activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/shared/property.rb

@@ -0,0 +1,240 @@
+module Neo4j::Shared
+  module Property
+    extend ActiveSupport::Concern
+
+    include Neo4j::Shared::MassAssignment
+    include Neo4j::Shared::TypecastedAttributes
+    include ActiveModel::Dirty
+
+    class UndefinedPropertyError < Neo4j::Error; end
+    class MultiparameterAssignmentError < Neo4j::Error; end
+
+    attr_reader :_persisted_obj
+
+    # TODO: Set @attribute correctly using class ActiveModel::Attribute, and after that
+    # remove mutations_from_database and other ActiveModel::Dirty overrided methods
+    def mutations_from_database
+      @mutations_from_database ||=
+        defined?(ActiveModel::ForcedMutationTracker) ? ActiveModel::ForcedMutationTracker.new(self) : ActiveModel::NullMutationTracker.instance
+    end
+
+    def inspect
+      attribute_descriptions = inspect_attributes.map do |key, value|
+        "#{Neo4j::ANSI::CYAN}#{key}: #{Neo4j::ANSI::CLEAR}#{value.inspect}"
+      end.join(', ')
+
+      separator = ' ' unless attribute_descriptions.empty?
+      "#<#{Neo4j::ANSI::YELLOW}#{self.class.name}#{Neo4j::ANSI::CLEAR}#{separator}#{attribute_descriptions}>"
+    end
+
+    def initialize(attributes = nil)
+      attributes = process_attributes(attributes)
+      modded_attributes = inject_defaults!(attributes)
+      validate_attributes!(modded_attributes)
+      writer_method_props = extract_writer_methods!(modded_attributes)
+      send_props(writer_method_props)
+      self.undeclared_properties = attributes
+      @_persisted_obj = nil
+    end
+
+    def undeclared_properties=(_); end
+
+    def inject_defaults!(starting_props)
+      return starting_props if self.class.declared_properties.declared_property_defaults.empty?
+      self.class.declared_properties.inject_defaults!(self, starting_props || {})
+    end
+
+    def read_attribute(name)
+      respond_to?(name) ? send(name) : nil
+    end
+    alias [] read_attribute
+
+    def send_props(hash)
+      return hash if hash.blank?
+      hash.each { |key, value| send("#{key}=", value) }
+    end
+
+    def reload_properties!(properties)
+      @attributes = nil
+      convert_and_assign_attributes(properties)
+    end
+
+    private
+
+    # Changes attributes hash to remove relationship keys
+    # Raises an error if there are any keys left which haven't been defined as properties on the model
+    # TODO: use declared_properties instead of self.attributes
+    def validate_attributes!(attributes)
+      return attributes if attributes.blank?
+      invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
+      invalid_properties.reject! { |name| self.respond_to?("#{name}=") }
+      fail UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if !invalid_properties.empty?
+    end
+
+    def extract_writer_methods!(attributes)
+      return attributes if attributes.blank?
+      {}.tap do |writer_method_props|
+        attributes.each_key do |key|
+          writer_method_props[key] = attributes.delete(key) if self.respond_to?("#{key}=")
+        end
+      end
+    end
+
+    DATE_KEY_REGEX = /\A([^\(]+)\((\d+)([ifs])\)$/
+    # Gives support for Rails date_select, datetime_select, time_select helpers.
+    def process_attributes(attributes = nil)
+      return attributes if attributes.blank?
+      multi_parameter_attributes = {}
+      new_attributes = {}
+      attributes.each_pair do |key, value|
+        if key.match(DATE_KEY_REGEX)
+          match = key.to_s.match(DATE_KEY_REGEX)
+          found_key = match[1]
+          index = match[2].to_i
+          (multi_parameter_attributes[found_key] ||= {})[index] = value.empty? ? nil : value.send("to_#{$3}")
+        else
+          new_attributes[key] = value
+        end
+      end
+
+      multi_parameter_attributes.empty? ? new_attributes : process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
+    end
+
+    def process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
+      multi_parameter_attributes.each_with_object(new_attributes) do |(key, values), attributes|
+        values = (values.keys.min..values.keys.max).map { |i| values[i] }
+        if (field = self.class.attributes[key.to_sym]).nil?
+          fail MultiparameterAssignmentError, "error on assignment #{values.inspect} to #{key}"
+        end
+
+        attributes[key] = instantiate_object(field, values)
+      end
+    end
+
+    def instantiate_object(field, values_with_empty_parameters)
+      return nil if values_with_empty_parameters.all?(&:nil?)
+      values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
+      klass = field.type
+      klass ? klass.new(*values) : values
+    end
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :declared_properties, :serialized_properties, :serialized_properties=, :serialize, :declared_property_defaults
+
+      VALID_PROPERTY_OPTIONS = %w(type default index constraint serializer typecaster).map(&:to_sym)
+      # Defines a property on the class
+      #
+      # See active_attr gem for allowed options, e.g which type
+      # Notice, in Neo4j you don't have to declare properties before using them, see the neo4j-core api.
+      #
+      # @example Without type
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name
+      #    end
+      #
+      # @example With type and a default value
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :score, type: Integer, default: 0
+      #    end
+      #
+      # @example With an index
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name, index: :exact
+      #    end
+      #
+      # @example With a constraint
+      #    class Person
+      #      # declare a property which can have any value
+      #      property :name, constraint: :unique
+      #    end
+      def property(name, options = {})
+        invalid_option_keys = options.keys.map(&:to_sym) - VALID_PROPERTY_OPTIONS
+        fail ArgumentError, "Invalid options for property `#{name}` on `#{self.name}`: #{invalid_option_keys.join(', ')}" if invalid_option_keys.any?
+        build_property(name, options) do |prop|
+          attribute(prop)
+        end
+      end
+
+      # @param [Symbol] name The property name
+      # @param [Neo4j::Shared::AttributeDefinition] attr_def A cloned AttributeDefinition to reuse
+      # @param [Hash] options An options hash to use in the new property definition
+      def inherit_property(name, attr_def, options = {})
+        build_property(name, options) do |prop_name|
+          attributes[prop_name] = attr_def
+        end
+      end
+
+      def build_property(name, options)
+        decl_prop = DeclaredProperty.new(name, options).tap do |prop|
+          prop.register
+          declared_properties.register(prop)
+          yield name
+          constraint_or_index(name, options)
+        end
+
+        # If this class has already been inherited, make sure subclasses inherit property
+        subclasses.each do |klass|
+          klass.inherit_property name, decl_prop.clone, declared_properties[name].options
+        end
+
+        decl_prop
+      end
+
+      def undef_property(name)
+        undef_constraint_or_index(name)
+        declared_properties.unregister(name)
+        attribute_methods(name).each { |method| undef_method(method) }
+      end
+
+      def declared_properties
+        @_declared_properties ||= DeclaredProperties.new(self)
+      end
+
+      # @return [Hash] A frozen hash of all model properties with nil values. It is used during node loading and prevents
+      # an extra call to a slow dependency method.
+      def attributes_nil_hash
+        declared_properties.attributes_nil_hash
+      end
+
+      def extract_association_attributes!(props)
+        props
+      end
+
+      private
+
+      def attribute!(name)
+        remove_instance_variable('@attribute_methods_generated') if instance_variable_defined?('@attribute_methods_generated')
+        define_attribute_methods([name]) unless attribute_names.include?(name)
+        attributes[name.to_s] = declared_properties[name]
+        define_method("#{name}=") do |value|
+          typecast_value = typecast_attribute(_attribute_typecaster(name), value)
+          send("#{name}_will_change!") unless typecast_value == read_attribute(name)
+          super(value)
+        end
+      end
+
+      def constraint_or_index(name, options)
+        # either constraint or index, do not set both
+        if options[:constraint]
+          fail "unknown constraint type #{options[:constraint]}, only :unique supported" if options[:constraint] != :unique
+          constraint(name, type: :unique)
+        elsif options[:index]
+          fail "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
+          index(name) if options[:index] == :exact
+        end
+      end
+
+      def undef_constraint_or_index(name)
+        prop = declared_properties[name]
+        return unless prop.index_or_constraint?
+        type = prop.constraint? ? :constraint : :index
+        send(:"drop_#{type}", name)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/query_factory.rb

@@ -0,0 +1,102 @@
+module Neo4j::Shared
+  # Acts as a bridge between the node and rel models and Neo4j::Core::Query.
+  # If the object is persisted, it returns a query matching; otherwise, it returns a query creating it.
+  # This class does not execute queries, so it keeps no record of what identifiers have been set or what has happened in previous factories.
+  class QueryFactory
+    attr_reader :graph_object, :identifier
+
+    def initialize(graph_object, identifier)
+      @graph_object = graph_object
+      @identifier = identifier.to_sym
+    end
+
+    def self.create(graph_object, identifier)
+      factory_for(graph_object).new(graph_object, identifier)
+    end
+
+    def self.factory_for(graph_obj)
+      case
+      when graph_obj.respond_to?(:labels_for_create)
+        NodeQueryFactory
+      when graph_obj.respond_to?(:rel_type)
+        RelQueryFactory
+      else
+        fail "Unable to find factory for #{graph_obj}"
+      end
+    end
+
+    def query
+      graph_object.persisted? ? match_query : create_query
+    end
+
+    # @param [Neo4j::Core::Query] query An instance of Neo4j::Core::Query upon which methods will be chained.
+    def base_query=(query)
+      return if query.blank?
+      @base_query = query
+    end
+
+    def base_query
+      @base_query || Neo4j::ActiveBase.new_query
+    end
+
+    protected
+
+    def create_query
+      fail 'Abstract class, not implemented'
+    end
+
+    def match_query
+      base_query
+        .match(match_string).where("ID(#{identifier}) = {#{identifier_id}}")
+        .params(identifier_id.to_sym => graph_object.neo_id)
+    end
+
+    def identifier_id
+      @identifier_id ||= "#{identifier}_id"
+    end
+
+    def identifier_params
+      @identifier_params ||= "#{identifier}_params"
+    end
+  end
+
+  class NodeQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{identifier})"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      labels = graph_object.labels_for_create.map { |l| ":`#{l}`" }.join
+      base_query.create("(#{identifier}#{labels} {#{identifier}_params})").params(identifier_params => graph_object.props_for_create)
+    end
+  end
+
+  class RelQueryFactory < QueryFactory
+    protected
+
+    def match_string
+      "(#{graph_object.from_node_identifier})-[#{identifier}]->()"
+    end
+
+    def create_query
+      return match_query if graph_object.persisted?
+      create_props, set_props = filtered_props
+      base_query.send(graph_object.create_method, query_string).break
+                .set(identifier => set_props)
+                .params(:"#{identifier}_create_props" => create_props)
+    end
+
+    private
+
+    def filtered_props
+      Neo4j::Shared::FilteredHash.new(graph_object.props_for_create, graph_object.creates_unique_option).filtered_base
+    end
+
+    def query_string
+      "(#{graph_object.from_node_identifier})-[#{identifier}:`#{graph_object.type}` {#{identifier}_create_props}]->(#{graph_object.to_node_identifier})"
+    end
+  end
+end

data/lib/neo4j/shared/rel_type_converters.rb

@@ -0,0 +1,43 @@
+module Neo4j::Shared
+  # This module controls changes to relationship type based on Neo4j::Config.transform_rel_type.
+  # It's used whenever a rel type is automatically determined based on ActiveRel model name or
+  # association type.
+  module RelTypeConverters
+    def decorated_rel_type(type)
+      @decorated_rel_type ||= Neo4j::Shared::RelTypeConverters.decorated_rel_type(type)
+    end
+
+    class << self
+      # Determines how relationship types should look when inferred based on association or ActiveRel model name.
+      # With the exception of `:none`, all options will call `underscore`, so `ThisClass` becomes `this_class`, with capitalization
+      # determined by the specific option passed.
+      # Valid options:
+      # * :upcase - `:this_class`, `ThisClass`, `thiS_claSs` (if you don't like yourself) becomes `THIS_CLASS`
+      # * :downcase - same as above, only... downcased.
+      # * :legacy - downcases and prepends `#`, so ThisClass becomes `#this_class`
+      # * :none - uses the string version of whatever is passed with no modifications
+      def rel_transformer
+        @rel_transformer ||= Neo4j::Config[:transform_rel_type].nil? ? :upcase : Neo4j::Config[:transform_rel_type]
+      end
+
+      # @param [String,Symbol] type The raw string or symbol to be used as the basis of the relationship type
+      # @return [String] A string that conforms to the set rel type conversion setting.
+      def decorated_rel_type(type)
+        type = type.to_s
+        decorated_type =  case rel_transformer
+                          when :upcase
+                            type.underscore.upcase
+                          when :downcase
+                            type.underscore.downcase
+                          when :legacy
+                            "##{type.underscore.downcase}"
+                          when :none
+                            type
+                          else
+                            type.underscore.upcase
+                          end
+        decorated_type.tap { |s| s.gsub!('/', '::') if type.include?('::') }
+      end
+    end
+  end
+end

data/lib/neo4j/shared/serialized_properties.rb

@@ -0,0 +1,30 @@
+module Neo4j::Shared
+  # This module adds the `serialize` class method. It lets you store hashes and arrays in Neo4j properties.
+  # Be aware that you won't be able to search within serialized properties and stuff use indexes. If you do a regex search for portion of a string
+  # property, the search happens in Cypher and you may take a performance hit.
+  #
+  # See type_converters.rb for the serialization process.
+  module SerializedProperties
+    extend ActiveSupport::Concern
+
+    def serialized_properties
+      self.class.serialized_properties
+    end
+
+    def serializable_hash(*args)
+      super.merge(id: id)
+    end
+
+
+    module ClassMethods
+      def inherited(other)
+        inherit_serialized_properties(other) if self.respond_to?(:serialized_properties)
+        super
+      end
+
+      def inherit_serialized_properties(other)
+        other.serialized_properties = self.serialized_properties
+      end
+    end
+  end
+end

data/lib/neo4j/shared/type_converters.rb

@@ -0,0 +1,433 @@
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'active_support/core_ext/big_decimal/conversions'
+require 'active_support/core_ext/string/conversions'
+
+module Neo4j::Shared
+  class Boolean; end
+
+  module TypeConverters
+    CONVERTERS = {}
+
+    class Boolean; end
+
+    class BaseConverter
+      class << self
+        def converted?(value)
+          value.is_a?(db_type)
+        end
+      end
+
+      def supports_array?
+        false
+      end
+    end
+
+    class IntegerConverter < BaseConverter
+      class << self
+        def convert_type
+          Integer
+        end
+
+        def db_type
+          Integer
+        end
+
+        def to_db(value)
+          value.to_i
+        end
+
+        alias to_ruby to_db
+      end
+    end
+
+    class FloatConverter < BaseConverter
+      class << self
+        def convert_type
+          Float
+        end
+
+        def db_type
+          Float
+        end
+
+        def to_db(value)
+          value.to_f
+        end
+        alias to_ruby to_db
+      end
+    end
+
+    class BigDecimalConverter < BaseConverter
+      class << self
+        def convert_type
+          BigDecimal
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          case value
+          when Rational
+            value.to_f.to_d
+          when respond_to?(:to_d)
+            value.to_d
+          else
+            BigDecimal(value.to_s)
+          end.to_s
+        end
+
+        def to_ruby(value)
+          value.to_d
+        end
+      end
+    end
+
+    class StringConverter < BaseConverter
+      class << self
+        def convert_type
+          String
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          value.to_s
+        end
+        alias to_ruby to_db
+      end
+    end
+
+    class BooleanConverter < BaseConverter
+      FALSE_VALUES = %w(n N no No NO false False FALSE off Off OFF f F).to_set
+
+      class << self
+        def converted?(value)
+          converted_values.include?(value)
+        end
+
+        def converted_values
+          [true, false]
+        end
+
+        def db_type
+          Neo4j::Shared::Boolean
+        end
+
+        alias convert_type db_type
+
+        def to_db(value)
+          return false if FALSE_VALUES.include?(value)
+          case value
+          when TrueClass, FalseClass
+            value
+          when Numeric, /^\-?[0-9]/
+            !value.to_f.zero?
+          else
+            value.present?
+          end
+        end
+
+        alias to_ruby to_db
+      end
+    end
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter < BaseConverter
+      class << self
+        def convert_type
+          Date
+        end
+
+        def db_type
+          Integer
+        end
+
+        def to_db(value)
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          value.respond_to?(:to_date) ? value.to_date : Time.at(value).utc.to_date
+        end
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter < BaseConverter
+      class << self
+        def convert_type
+          DateTime
+        end
+
+        def db_type
+          Integer
+        end
+
+        # Converts the given DateTime (UTC) value to an Integer.
+        # DateTime values are automatically converted to UTC.
+        def to_db(value)
+          value = value.new_offset(0) if value.respond_to?(:new_offset)
+
+          args = [value.year, value.month, value.day]
+          args += (value.class == Date ? [0, 0, 0] : [value.hour, value.min, value.sec])
+
+          Time.utc(*args).to_i
+        end
+
+        def to_ruby(value)
+          return value if value.is_a?(DateTime)
+          t = case value
+              when Time
+                return value.to_datetime.utc
+              when Integer
+                Time.at(value).utc
+              when String
+                return value.to_datetime
+              else
+                fail ArgumentError, "Invalid value type for DateType property: #{value.inspect}"
+              end
+
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+      end
+    end
+
+    class TimeConverter < BaseConverter
+      class << self
+        def convert_type
+          Time
+        end
+
+        def db_type
+          Integer
+        end
+
+        # Converts the given DateTime (UTC) value to an Integer.
+        # Only utc times are supported !
+        def to_db(value)
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            value.utc.to_i
+          end
+        end
+
+        def to_ruby(value)
+          Time.at(value).utc
+        end
+      end
+    end
+
+    # Converts hash to/from YAML
+    class YAMLConverter < BaseConverter
+      class << self
+        def convert_type
+          Hash
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          Psych.dump(value)
+        end
+
+        def to_ruby(value)
+          Psych.load(value)
+        end
+      end
+    end
+
+    # Converts hash to/from JSON
+    class JSONConverter < BaseConverter
+      class << self
+        def converted?(_value)
+          false
+        end
+
+        def convert_type
+          JSON
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          value.to_json
+        end
+
+        def to_ruby(value)
+          JSON.parse(value, quirks_mode: true)
+        end
+      end
+    end
+
+    class EnumConverter
+      def initialize(enum_keys, options)
+        @enum_keys = enum_keys
+        @options = options
+
+        return unless @options[:case_sensitive].nil?
+
+        @options[:case_sensitive] = Neo4j::Config.enums_case_sensitive
+      end
+
+      def converted?(value)
+        value.is_a?(db_type)
+      end
+
+      def supports_array?
+        true
+      end
+
+      def db_type
+        Integer
+      end
+
+      def convert_type
+        Symbol
+      end
+
+      def to_ruby(value)
+        @enum_keys.key(value) unless value.nil?
+      end
+
+      alias call to_ruby
+
+      def to_db(value)
+        if value.is_a?(Array)
+          value.map(&method(:to_db))
+        elsif @options[:case_sensitive]
+          @enum_keys[value.to_s.to_sym] ||
+            fail(Neo4j::Shared::Enum::InvalidEnumValueError, 'Value passed to an enum property must match one of the enum keys')
+        else
+          @enum_keys[value.to_s.downcase.to_sym] ||
+            fail(Neo4j::Shared::Enum::InvalidEnumValueError, 'Case-insensitive (downcased) value passed to an enum property must match one of the enum keys')
+        end
+      end
+    end
+
+    class ObjectConverter < BaseConverter
+      class << self
+        def convert_type
+          Object
+        end
+
+        def to_ruby(value)
+          value
+        end
+      end
+    end
+
+
+    # Modifies a hash's values to be of types acceptable to Neo4j or matching what the user defined using `type` in property definitions.
+    # @param [Neo4j::Shared::Property] obj A node or rel that mixes in the Property module
+    # @param [Symbol] medium Indicates the type of conversion to perform.
+    # @param [Hash] properties A hash of symbol-keyed properties for conversion.
+    def convert_properties_to(obj, medium, properties)
+      direction = medium == :ruby ? :to_ruby : :to_db
+      properties.each_pair do |key, value|
+        next if skip_conversion?(obj, key, value)
+        properties[key] = convert_property(key, value, direction)
+      end
+    end
+
+    # Converts a single property from its current format to its db- or Ruby-expected output type.
+    # @param [Symbol] key A property declared on the model
+    # @param value The value intended for conversion
+    # @param [Symbol] direction Either :to_ruby or :to_db, indicates the type of conversion to perform
+    def convert_property(key, value, direction)
+      converted_property(primitive_type(key.to_sym), value, direction)
+    end
+
+    def supports_array?(key)
+      type = primitive_type(key.to_sym)
+      type.respond_to?(:supports_array?) && type.supports_array?
+    end
+
+    def typecaster_for(value)
+      Neo4j::Shared::TypeConverters.typecaster_for(value)
+    end
+
+    def typecast_attribute(typecaster, value)
+      Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
+    end
+
+    private
+
+    def converted_property(type, value, direction)
+      return nil if value.nil?
+      CONVERTERS[type] || type.respond_to?(:db_type) ? TypeConverters.to_other(direction, value, type) : value
+    end
+
+    # If the attribute is to be typecast using a custom converter, which converter should it use? If no, returns the type to find a native serializer.
+    def primitive_type(attr)
+      case
+      when serialized_properties.include?(attr)
+        serialized_properties[attr]
+      when magic_typecast_properties.include?(attr)
+        magic_typecast_properties[attr]
+      else
+        fetch_upstream_primitive(attr)
+      end
+    end
+
+    # Returns true if the property isn't defined in the model or if it is nil
+    def skip_conversion?(obj, attr, value)
+      value.nil? || !obj.class.attributes.key?(attr)
+    end
+
+    class << self
+      def included(_)
+        Neo4j::Shared::TypeConverters.constants.each do |constant_name|
+          constant = Neo4j::Shared::TypeConverters.const_get(constant_name)
+          register_converter(constant) if constant.respond_to?(:convert_type)
+        end
+      end
+
+      def typecast_attribute(typecaster, value)
+        fail ArgumentError, "A typecaster must be given, #{typecaster} is invalid" unless typecaster.respond_to?(:to_ruby)
+        return value if value.nil?
+        typecaster.to_ruby(value)
+      end
+
+      def typecaster_for(primitive_type)
+        return nil if primitive_type.nil?
+        CONVERTERS[primitive_type]
+      end
+
+      # @param [Symbol] direction either :to_ruby or :to_other
+      def to_other(direction, value, type)
+        fail "Unknown direction given: #{direction}" unless direction == :to_ruby || direction == :to_db
+        found_converter = converter_for(type)
+        return value unless found_converter
+        return value if direction == :to_db && formatted_for_db?(found_converter, value)
+        found_converter.send(direction, value)
+      end
+
+      def converter_for(type)
+        type.respond_to?(:db_type) ? type : CONVERTERS[type]
+      end
+
+      # Attempts to determine whether conversion should be skipped because the object is already of the anticipated output type.
+      # @param [#convert_type] found_converter An object that responds to #convert_type, hinting that it is a type converter.
+      # @param value The value for conversion.
+      def formatted_for_db?(found_converter, value)
+        return false unless found_converter.respond_to?(:db_type)
+        found_converter.respond_to?(:converted?) ? found_converter.converted?(value) : value.is_a?(found_converter.db_type)
+      end
+
+      def register_converter(converter)
+        CONVERTERS[converter.convert_type] = converter
+      end
+    end
+  end
+end