neo4j 6.1.12 → 7.0.0.rc.1

data/lib/neo4j/shared/type_converters.rb

@@ -4,7 +4,13 @@ require 'bigdecimal/util'
 require 'active_support/core_ext/big_decimal/conversions'
 
 module Neo4j::Shared
+  class Boolean; end
+
   module TypeConverters
+    CONVERTERS = {}
+
+    class Boolean; end
+
     class BaseConverter
       class << self
         def converted?(value)
@@ -102,7 +108,7 @@ module Neo4j::Shared
         end
 
         def db_type
-          ActiveAttr::Typecasting::Boolean
+          Neo4j::Shared::Boolean
         end
 
         alias_method :convert_type, :db_type
@@ -139,7 +145,7 @@ module Neo4j::Shared
         end
 
         def to_ruby(value)
-          Time.at(value).utc.to_date
+          value.respond_to?(:to_date) ? value.to_date : Time.at(value).utc.to_date
         end
       end
     end
@@ -168,7 +174,10 @@ module Neo4j::Shared
 
         DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %z'
         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
@@ -211,7 +220,6 @@ module Neo4j::Shared
         def to_ruby(value)
           Time.at(value).utc
         end
-        alias_method :call, :to_ruby
       end
     end
 
@@ -257,6 +265,47 @@ module Neo4j::Shared
       end
     end
 
+    class EnumConverter
+      def initialize(enum_keys)
+        @enum_keys = enum_keys
+      end
+
+      def converted?(value)
+        value.is_a?(db_type)
+      end
+
+      def db_type
+        Integer
+      end
+
+      def convert_type
+        Symbol
+      end
+
+      def to_ruby(value)
+        @enum_keys.key(value) unless value.nil?
+      end
+
+      alias_method :call, :to_ruby
+
+      def to_db(value)
+        @enum_keys[value.to_s.to_sym] || 0
+      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.
@@ -277,11 +326,19 @@ module Neo4j::Shared
       converted_property(primitive_type(key.to_sym), value, direction)
     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, converter)
+    def converted_property(type, value, direction)
       return nil if value.nil?
-      TypeConverters.converters[type].nil? ? value : TypeConverters.to_other(converter, value, type)
+      type.respond_to?(:db_type) || TypeConverters::CONVERTERS[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.
@@ -302,45 +359,47 @@ module Neo4j::Shared
     end
 
     class << self
-      attr_reader :converters
-
       def included(_)
-        return if @converters
-        @converters = {}
         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.key?(primitive_type) ? converters[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 = converters[type]
+        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)
-        if found_converter.respond_to?(:converted)
-          found_converter.converted?(value)
-        else
-          value.is_a?(found_converter.db_type)
-        end
+        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
+        CONVERTERS[converter.convert_type] = converter
       end
     end
   end

data/lib/neo4j/shared/typecasted_attributes.rb

@@ -0,0 +1,98 @@
+module Neo4j::Shared
+  # TypecastedAttributes allows types to be declared for your attributes
+  #
+  # Types are declared by passing the :type option to the attribute class
+  # method. After a type is declared, attribute readers will convert any
+  # assigned attribute value to the declared type. If the assigned value
+  # cannot be cast, nil will be returned instead. You can access the original
+  # assigned value using the before_type_cast methods.
+  #
+  # See {Typecasting} for the currently supported types.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::TypecastedAttributes
+  #     attribute :age, :type => Integer
+  #   end
+  #
+  #   person = Person.new
+  #   person.age = "29"
+  #   person.age #=> 29
+  #   person.age_before_type_cast #=> "29"
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module TypecastedAttributes
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Attributes
+
+    included do
+      attribute_method_suffix '_before_type_cast'
+    end
+
+    # Read the raw attribute value
+    #
+    # @example Reading a raw age value
+    #   person.age = "29"
+    #   person.attribute_before_type_cast(:age) #=> "29"
+    #
+    # @param [String, Symbol, #to_s] name Attribute name
+    #
+    # @return [Object, nil] The attribute value before typecasting
+    def attribute_before_type_cast(name)
+      @attributes ||= {}
+      @attributes[name.to_s]
+    end
+
+    private
+
+    # Reads the attribute and typecasts the result
+    def attribute(name)
+      typecast_attribute(_attribute_typecaster(name), super)
+    end
+
+    def typecast_attribute(typecaster, value)
+      self.class.typecast_attribute(typecaster, value)
+    end
+
+    # Calculates an attribute type
+    #
+    # @private
+    def _attribute_type(attribute_name)
+      self.class._attribute_type(attribute_name)
+    end
+
+    # Resolve an attribute typecaster
+    #
+    # @private
+    def _attribute_typecaster(attribute_name)
+      type = _attribute_type(attribute_name)
+      caster = self.class.attributes[attribute_name].typecaster || Neo4j::Shared::TypeConverters.typecaster_for(type)
+      caster || fail(Neo4j::UnknownTypeConverterError, "Unable to cast to type #{type}")
+    end
+
+    module ClassMethods
+      # Returns the class name plus its attribute names and types
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      def inspect
+        inspected_attributes = attribute_names.sort.map { |name| "#{name}: #{_attribute_type(name)}" }
+        attributes_list = "(#{inspected_attributes.join(', ')})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+      # Calculates an attribute type
+      #
+      # @private
+      def _attribute_type(attribute_name)
+        attributes[attribute_name].type || Object
+      end
+
+      def typecast_attribute(typecaster, value)
+        Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
+      end
+    end
+  end
+end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '6.1.12'
+  VERSION = '7.0.0.rc.1'
 end

data/neo4j.gemspec

@@ -29,7 +29,6 @@ A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks h
   s.add_dependency('orm_adapter', '~> 0.5.0')
   s.add_dependency('activemodel', '~> 4')
   s.add_dependency('activesupport', '~> 4')
-  s.add_dependency('active_attr', '~> 0.8')
   s.add_dependency('neo4j-core', '>= 6.0.0')
   s.add_dependency('neo4j-community', '~> 2.0') if RUBY_PLATFORM =~ /java/
   s.add_development_dependency('railties', '~> 4')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 6.1.12
+  version: 7.0.0.rc.1
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-27 00:00:00.000000000 Z
+date: 2016-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
-- !ruby/object:Gem::Dependency
-  name: active_attr
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: neo4j-core
   requirement: !ruby/object:Gem::Requirement
@@ -229,6 +215,7 @@ files:
 - lib/neo4j/active_node/dependent.rb
 - lib/neo4j/active_node/dependent/association_methods.rb
 - lib/neo4j/active_node/dependent/query_proxy_methods.rb
+- lib/neo4j/active_node/enum.rb
 - lib/neo4j/active_node/has_n.rb
 - lib/neo4j/active_node/has_n/association.rb
 - lib/neo4j/active_node/has_n/association/rel_factory.rb
@@ -251,6 +238,7 @@ files:
 - lib/neo4j/active_node/query/query_proxy_find_in_batches.rb
 - lib/neo4j/active_node/query/query_proxy_link.rb
 - lib/neo4j/active_node/query/query_proxy_methods.rb
+- lib/neo4j/active_node/query/query_proxy_methods_of_mass_updating.rb
 - lib/neo4j/active_node/query_methods.rb
 - lib/neo4j/active_node/reflection.rb
 - lib/neo4j/active_node/rels.rb
@@ -277,22 +265,25 @@ files:
 - lib/neo4j/railtie.rb
 - lib/neo4j/schema/operation.rb
 - lib/neo4j/shared.rb
+- lib/neo4j/shared/attributes.rb
 - lib/neo4j/shared/callbacks.rb
 - lib/neo4j/shared/cypher.rb
 - lib/neo4j/shared/declared_properties.rb
 - lib/neo4j/shared/declared_property.rb
 - lib/neo4j/shared/declared_property/index.rb
+- lib/neo4j/shared/enum.rb
 - lib/neo4j/shared/filtered_hash.rb
 - lib/neo4j/shared/identity.rb
 - lib/neo4j/shared/initialize.rb
 - lib/neo4j/shared/marshal.rb
+- lib/neo4j/shared/mass_assignment.rb
 - lib/neo4j/shared/persistence.rb
 - lib/neo4j/shared/property.rb
-- lib/neo4j/shared/property/default_property.rb
 - lib/neo4j/shared/query_factory.rb
 - lib/neo4j/shared/rel_type_converters.rb
 - lib/neo4j/shared/serialized_properties.rb
 - lib/neo4j/shared/type_converters.rb
+- lib/neo4j/shared/typecasted_attributes.rb
 - lib/neo4j/shared/typecaster.rb
 - lib/neo4j/shared/validations.rb
 - lib/neo4j/tasks/migration.rake
@@ -328,9 +319,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: neo4j
 rubygems_version: 2.4.5.1