activegraph 10.0.0.pre.alpha.9 → 10.0.0.pre.alpha.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 878888811097ecc00e00aec51dd01ca61244b0717cc4e562aa3a30aa3c4721db
-  data.tar.gz: 0f254663f8d1be115d4a728542f01984cb29f8bb40e501297afff27f19afd7de
+  metadata.gz: 39751bab802f72daa73a5fb59b5d356a26616b0547931021cdcc14130690ac3c
+  data.tar.gz: 347bbbd3f9e60fdff9dce58147e86ea8f959803a8e18b2788703964847cf285f
 SHA512:
-  metadata.gz: 764844043ffd84ace94e417db4bc1de961ddc61f0a503b42ab55c387533417c4cfd569367be7d928d993d2a15168be8d5a6dfa35fefbae6bd47a392098b02dd3
-  data.tar.gz: 7952ae963f7a7627422c773308e2b96615bcba97403ce4712d542cb62e568652019eb93d2336d5dfccf755a80c080325ac7d57f0144cc4207941707b27768db9
+  metadata.gz: 78fc78517a28af803822c2b5113ecd1db26cd03490e1f342d52c14af8bb15d740a3e4ea69fd7209a36eba7d69bb402cade0a374ba3c45c7da9d04b3b68b2e008
+  data.tar.gz: 38ade859a5ab61994676589a28484bea97da74d66d35cf0f8b3b6331eab28903bfd812e0162b7250b4f14a568d70db3b52e09c3fbf93a109a77a22f970b9b4a3

data/lib/neo4j.rb

@@ -14,6 +14,8 @@ require 'active_support/core_ext/class/subclasses.rb'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'json'
 
+require 'neo4j/lazy_attribute_hash'
+require 'neo4j/attribute_set'
 require 'neo4j/errors'
 require 'neo4j/config'
 require 'neo4j/wrapper'

data/lib/neo4j/active_base.rb

@@ -9,17 +9,17 @@ module Neo4j
     class << self
       # private?
       def current_driver
-        (@driver ||= establish_session).tap do |session|
-          fail 'No session defined!' if session.nil?
+        (@driver ||= establish_driver).tap do |driver|
+          fail 'No driver defined!' if driver.nil?
         end
       end
 
-      def on_establish_session(&block)
-        @establish_session_block = block
+      def on_establish_driver(&block)
+        @establish_driver_block = block
       end
 
-      def establish_session
-        @establish_session_block.call if @establish_session_block
+      def establish_driver
+        @establish_driver_block.call if @establish_driver_block
       end
 
       def new_driver(url, options = {})
@@ -55,7 +55,7 @@ module Neo4j
 
       def new_query(options = {})
         validate_model_schema!
-        Neo4j::Core::Query.new({session: current_driver}.merge(options))
+        Neo4j::Core::Query.new({driver: current_driver}.merge(options))
       end
 
       def magic_query(*args)

data/lib/neo4j/active_node/has_n.rb

@@ -545,7 +545,7 @@ module Neo4j::ActiveNode
         query_proxy = previous_query_proxy || default_association_query_proxy
         Neo4j::ActiveNode::Query::QueryProxy.new(association_target_class(name),
                                                  associations[name],
-                                                 {session: neo4j_session,
+                                                 {driver: neo4j_driver,
                                                   query_proxy: query_proxy,
                                                   context: "#{query_proxy.context || self.name}##{name}",
                                                   optional: query_proxy.optional?,
@@ -578,7 +578,7 @@ module Neo4j::ActiveNode
 
       def default_association_query_proxy
         Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize, nil,
-                                                 session: neo4j_session, query_proxy: nil, context: self.name.to_s)
+                                                 driver: neo4j_driver, query_proxy: nil, context: self.name.to_s)
       end
 
       def build_association(macro, direction, name, options)

data/lib/neo4j/active_node/property.rb

@@ -5,7 +5,7 @@ module Neo4j::ActiveNode
 
     def initialize(attributes = nil)
       super(attributes)
-      @attributes ||= Hash[self.class.attributes_nil_hash]
+      @attributes ||= Neo4j::AttributeSet.new(self.class.attributes_nil_hash, self.class.attributes.keys)
     end
 
     module ClassMethods

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -33,7 +33,7 @@ module Neo4j
         # @option options [String, Symbol] :rel_var Same as above but pertaining to a relationship identifier
         # @option options [Range, Integer, Symbol, Hash] :rel_length A Range, a Integer, a Hash or a Symbol to indicate the variable-length/fixed-length
         #   qualifier of the relationship. See http://neo4jrb.readthedocs.org/en/latest/Querying.html#variable-length-relationships.
-        # @option options [Neo4j::Session] :session The session to be used for this query
+        # @option options [Neo4j::Driver] :driver The driver to be used for this query
         # @option options [Neo4j::ActiveNode] :source_object The node instance at the start of the QueryProxy chain
         # @option options [QueryProxy] :query_proxy An existing QueryProxy chain upon which this new object should be built
         #
@@ -317,9 +317,9 @@ module Neo4j
           "result_#{(association || model).try(:name)}#{index}".downcase.tr(':', '').to_sym
         end
 
-        def _session
-          (@session || (@model && @model.neo4j_session)).tap do |session|
-            fail 'No session found!' if session.nil?
+        def _driver
+          (@driver || (@model && @model.neo4j_driver)).tap do |driver|
+            fail 'No driver found!' if driver.nil?
           end
         end
 
@@ -357,9 +357,9 @@ module Neo4j
         private
 
         def instance_vars_from_options!(options)
-          @node_var, @session, @source_object, @starting_query, @optional,
+          @node_var, @driver, @source_object, @starting_query, @optional,
               @start_object, @query_proxy, @chain_level, @association_labels,
-              @rel_length = options.values_at(:node, :session, :source_object, :starting_query, :optional,
+              @rel_length = options.values_at(:node, :driver, :source_object, :starting_query, :optional,
                                               :start_object, :query_proxy, :chain_level, :association_labels, :rel_length)
         end
 

data/lib/neo4j/active_rel/query.rb

@@ -7,15 +7,15 @@ module Neo4j::ActiveRel
     module ClassMethods
       # Returns the object with the specified neo4j id.
       # @param [String,Integer] id of node to find
-      # @param [Neo4j::Session] session optional
-      def find(id, session = self.neo4j_session)
+      # @param [Neo4j::Driver] driver optional
+      def find(id, driver = self.neo4j_driver)
         fail "Unknown argument #{id.class} in find method (expected String or Integer)" if !(id.is_a?(String) || id.is_a?(Integer))
-        find_by_id(id, session)
+        find_by_id(id, driver)
       end
 
       # Loads the relationship using its neo_id.
-      def find_by_id(key, session = nil)
-        options = session ? {session: session} : {}
+      def find_by_id(key, driver = nil)
+        options = driver ? {driver: driver} : {}
         query ||= Neo4j::ActiveBase.new_query(options)
         result = query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first
         fail RecordNotFound.new("Couldn't find #{name} with 'id'=#{key.inspect}", name, key) if result.blank?

data/lib/neo4j/attribute_set.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_model/attribute_set'
+
+module Neo4j
+  class AttributeSet < ActiveModel::AttributeSet
+    def initialize(attr_hash, attr_list)
+      hashmap = Neo4j::LazyAttributeHash.new(attr_hash, attr_list)
+      super(hashmap)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      if defined?(name)
+        attributes.send(:materialize).send(name, *args, **kwargs, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, *)
+      attributes.send(:materialize).respond_to?(method) || super
+    end
+
+    def keys
+      attributes.send(:materialize).keys
+    end
+
+    def ==(other)
+      other.is_a?(Neo4j::AttributeSet) ? super : to_hash == other
+    end
+  end
+end

data/lib/neo4j/core/label.rb

@@ -21,8 +21,8 @@ module Neo4j
       # Creates a neo4j constraint on a property
       # See http://docs.neo4j.org/chunked/stable/query-constraints.html
       # @example
-      #   label = Neo4j::Label.create(:person, session)
-      #   label.create_constraint(:name, {type: :unique}, session)
+      #   label = Neo4j::Label.create(:person, driver)
+      #   label.create_constraint(:name, {type: :unique}, driver)
       #
       def create_constraint(property, constraints)
         cypher = case constraints[:type]
@@ -41,9 +41,9 @@ module Neo4j
       # Drops a neo4j constraint on a property
       # See http://docs.neo4j.org/chunked/stable/query-constraints.html
       # @example
-      #   label = Neo4j::Label.create(:person, session)
-      #   label.create_constraint(:name, {type: :unique}, session)
-      #   label.drop_constraint(:name, {type: :unique}, session)
+      #   label = Neo4j::Label.create(:person, driver)
+      #   label.create_constraint(:name, {type: :unique}, driver)
+      #   label.drop_constraint(:name, {type: :unique}, driver)
       #
       def drop_constraint(property, constraint)
         cypher = case constraint[:type]
@@ -97,8 +97,8 @@ module Neo4j
 
       private
 
-      # Store schema threads on the session so that we can easily wait for all
-      # threads on a session regardless of label
+      # Store schema threads on the driver so that we can easily wait for all
+      # threads on a driver regardless of label
       def schema_threads
         self.class.schema_threads
       end
@@ -134,7 +134,7 @@ module Neo4j
 
         def wait_for_schema_changes
           schema_threads.map(&:join)
-          set_schema_threads(session, [])
+          set_schema_threads(driver, [])
         end
 
         def schema_threads

data/lib/neo4j/core/query.rb

@@ -68,7 +68,7 @@ module Neo4j
       end
 
       def initialize(options = {})
-        @session = options[:session]
+        @driver = options[:driver]
 
         @options = options
         @clauses = []
@@ -374,7 +374,7 @@ module Neo4j
       end
 
       def &(other)
-        self.class.new(session: @session).tap do |new_query|
+        self.class.new(driver: @driver).tap do |new_query|
           new_query.options = options.merge(other.options)
           new_query.clauses = clauses + other.clauses
         end.params(other._params)
@@ -396,7 +396,7 @@ module Neo4j
 
       protected
 
-      attr_accessor :session, :options, :_params
+      attr_accessor :driver, :options, :_params
 
       def add_clauses(clauses)
         @clauses += clauses

data/lib/neo4j/core/query_builder.rb

@@ -23,9 +23,9 @@ module Neo4j
       end
 
       def query
-        # `nil` sessions are just a workaround until
-        # we phase out `Query` objects containing sessions
-        Neo4j::Core::Query.new(session: nil)
+        # `nil` drivers are just a workaround until
+        # we phase out `Query` objects containing drivers
+        Neo4j::Core::Query.new(driver: nil)
       end
     end
   end

data/lib/neo4j/lazy_attribute_hash.rb

@@ -0,0 +1,38 @@
+require 'active_model/attribute_set'
+
+module Neo4j
+  class LazyAttributeHash < ActiveModel::LazyAttributeHash
+    def initialize(values, attr_list)
+      @types = {}
+      @values = {}
+      @additional_types = {}
+      @materialized = false
+      @delegate_hash = values
+
+      @default_attributes = process_default_attributes(attr_list)
+    end
+
+    private
+
+    def marshal_load(values)
+      initialize(values[4], values[3])
+    end
+
+    def process_default_attributes(attr_list)
+      if attr_list.is_a?(Hash)
+        attr_list
+      else
+        # initialize default attributes map with nil values
+        attr_list.each_with_object({}) do |name, map|
+          map[name] = nil
+        end
+      end
+    end
+
+    # we are using with_cast_value here because at the moment casting is being managed by
+    # Neo4j and not in ActiveModel
+    def assign_default_value(name)
+      delegate_hash[name] = ActiveModel::Attribute.with_cast_value(name, default_attributes[name].dup, nil)
+    end
+  end
+end

data/lib/neo4j/migrations/schema.rb

@@ -2,28 +2,28 @@ module Neo4j
   module Migrations
     module Schema
       class << self
-        def fetch_schema_data(session)
-          {constraints: fetch_constraint_descriptions(session).sort,
-           indexes: fetch_index_descriptions(session).sort}
+        def fetch_schema_data(driver)
+          {constraints: fetch_constraint_descriptions(driver).sort,
+           indexes: fetch_index_descriptions(driver).sort}
         end
 
-        def synchronize_schema_data(session, schema_data, remove_missing)
+        def synchronize_schema_data(driver, schema_data, remove_missing)
           queries = []
-          queries += drop_and_create_queries(fetch_constraint_descriptions(session), schema_data[:constraints], remove_missing)
-          queries += drop_and_create_queries(fetch_index_descriptions(session), schema_data[:indexes], remove_missing)
-          session.queries do
+          queries += drop_and_create_queries(fetch_constraint_descriptions(driver), schema_data[:constraints], remove_missing)
+          queries += drop_and_create_queries(fetch_index_descriptions(driver), schema_data[:indexes], remove_missing)
+          driver.queries do
             queries.each { |query| append query }
           end
         end
 
         private
 
-        def fetch_constraint_descriptions(session)
-          session.query('CALL db.constraints()').map(&:description)
+        def fetch_constraint_descriptions(driver)
+          driver.query('CALL db.constraints()').map(&:description)
         end
 
-        def fetch_index_descriptions(session)
-          result = session.query('CALL db.indexes()')
+        def fetch_index_descriptions(driver)
+          result = driver.query('CALL db.indexes()')
           if result.columns.include?(:description)
             v3_indexes(result)
           else

data/lib/neo4j/railtie.rb

@@ -7,7 +7,7 @@ require 'neo4j/core/driver'
 module Neo4j
   class Railtie < ::Rails::Railtie
     def empty_config
-      ActiveSupport::OrderedOptions.new.tap { |cfg| cfg.session = ActiveSupport::OrderedOptions.new }
+      ActiveSupport::OrderedOptions.new.tap { |cfg| cfg.driver = ActiveSupport::OrderedOptions.new }
     end
 
     config.neo4j = empty_config
@@ -48,7 +48,7 @@ module Neo4j
 
       Neo4j::Config.configuration.merge!(neo4j_config.to_h)
 
-      Neo4j::ActiveBase.on_establish_session { setup! neo4j_config }
+      Neo4j::ActiveBase.on_establish_driver { setup! neo4j_config }
 
       Neo4j::Config[:logger] ||= Rails.logger
 
@@ -58,18 +58,18 @@ module Neo4j
     end
 
     def setup!(neo4j_config = empty_config)
-      url, path, options = final_session_config!(neo4j_config).values_at(:url, :path, :options)
+      url, path, options = final_driver_config!(neo4j_config).values_at(:url, :path, :options)
       options ||= {}
       register_neo4j_cypher_logging
 
-      Neo4j::ActiveBase.new_driver( url || path || default_session_path_or_url, options)
+      Neo4j::ActiveBase.new_driver( url || path || default_driver_path_or_url, options)
     end
 
-    def final_session_config!(neo4j_config)
-      (neo4j_config[:session].empty? ? yaml_config_data : neo4j_config[:session]).dup
+    def final_driver_config!(neo4j_config)
+      (neo4j_config[:driver].empty? ? yaml_config_data : neo4j_config[:driver]).dup
     end
 
-    def default_session_path_or_url
+    def default_driver_path_or_url
       ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] || 'bolt://localhost:7474'
     end
 

data/lib/neo4j/shared.rb

@@ -10,10 +10,10 @@ module Neo4j
     include ActiveModel::Serializers::JSON
 
     module ClassMethods
-      # TODO: Deprecate neo4j_session_name(name)
+      # TODO: Deprecate neo4j_driver_name(name)
 
       # remove?
-      def neo4j_session
+      def neo4j_driver
         Neo4j::ActiveBase.current_driver
       end
 
@@ -23,7 +23,7 @@ module Neo4j
       end
 
       # This should be used everywhere.  Should make it easy
-      # to support a session-per-model system
+      # to support a driver-per-model system
       def neo4j_query(*args)
         Neo4j::ActiveBase.query(*args)
       end

data/lib/neo4j/shared/attributes.rb

@@ -77,14 +77,15 @@ module Neo4j::Shared
 
     # Read an attribute from the attributes hash
     def attribute(name)
-      @attributes ||= {}
-      @attributes[name]
+      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes.fetch_value(name.to_s)
     end
 
     # Write an attribute to the attributes hash
     def attribute=(name, value)
-      @attributes ||= {}
-      @attributes[name] = value
+      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes.write_cast_value(name, value)
+      value
     end
 
     # Maps all attributes using the given block

data/lib/neo4j/shared/initialize.rb

@@ -12,16 +12,17 @@ module Neo4j::Shared
     private
 
     def convert_and_assign_attributes(properties)
-      @attributes ||= Hash[self.class.attributes_nil_hash]
+      @attributes ||= Neo4j::AttributeSet.new(self.class.attributes_nil_hash, self.class.attributes.keys)
       stringify_attributes!(@attributes, properties)
       self.default_properties = properties if respond_to?(:default_properties=)
       self.class.declared_properties.convert_properties_to(self, :ruby, @attributes)
+      @attributes
     end
 
     def stringify_attributes!(attr, properties)
       properties.each_pair do |k, v|
         key = self.class.declared_properties.string_key(k)
-        attr[key.freeze] = v
+        attr.write_cast_value(key.freeze, v)
       end
     end
 

data/lib/neo4j/shared/property.rb

@@ -11,6 +11,9 @@ module Neo4j::Shared
 
     attr_reader :_persisted_obj
 
+    NEO4J_DRIVER_DATA_TYPES = [Date, Time, Hash, Neo4j::Driver::Types::Bytes, ActiveSupport::Duration, Neo4j::Driver::Types::Point,
+                               Neo4j::Driver::Types::OffsetTime, Neo4j::Driver::Types::LocalTime, Neo4j::Driver::Types::LocalDateTime]
+
     # 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
@@ -28,6 +31,7 @@ module Neo4j::Shared
     end
 
     def initialize(attributes = nil)
+      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
       attributes = process_attributes(attributes)
       modded_attributes = inject_defaults!(attributes)
       validate_attributes!(modded_attributes)
@@ -212,7 +216,11 @@ module Neo4j::Shared
         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)
+          typecast_value = if NEO4J_DRIVER_DATA_TYPES.include?(_attribute_type(name))
+                             value
+                           else
+                             typecast_attribute(_attribute_typecaster(name), value)
+                           end
           send("#{name}_will_change!") unless typecast_value == read_attribute(name)
           super(value)
         end

data/lib/neo4j/shared/type_converters.rb

@@ -25,7 +25,14 @@ module Neo4j::Shared
     end
 
     class IntegerConverter < BaseConverter
+      NEO4J_LARGEST_INT = 9223372036854775807
+      NEO4J_SMALLEST_INT = -9223372036854775808
       class << self
+        
+        def converted?(value)
+          false
+        end
+
         def convert_type
           Integer
         end
@@ -35,55 +42,31 @@ module Neo4j::Shared
         end
 
         def to_db(value)
-          value.to_i
+          val = value.to_i
+          val > NEO4J_LARGEST_INT || val < NEO4J_SMALLEST_INT ? val.to_s : val
         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
+        def to_ruby(value)
+          value.to_i
         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
+    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 StringConverter < BaseConverter
@@ -103,62 +86,6 @@ module Neo4j::Shared
       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
@@ -167,7 +94,7 @@ module Neo4j::Shared
 
         def db_type
           Integer
-        end
+        end 
 
         # Converts the given DateTime (UTC) value to an Integer.
         # DateTime values are automatically converted to UTC.
@@ -198,29 +125,37 @@ module Neo4j::Shared
       end
     end
 
-    class TimeConverter < BaseConverter
+    class BooleanConverter < BaseConverter
+      FALSE_VALUES = %w(n N no No NO false False FALSE off Off OFF f F).to_set
+
       class << self
-        def convert_type
-          Time
+        def converted?(value)
+          converted_values.include?(value)
+        end
+
+        def converted_values
+          [true, false]
         end
 
         def db_type
-          Integer
+          Neo4j::Shared::Boolean
         end
 
-        # Converts the given DateTime (UTC) value to an Integer.
-        # Only utc times are supported !
+        alias convert_type db_type
+
         def to_db(value)
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          return false if FALSE_VALUES.include?(value)
+          case value
+          when TrueClass, FalseClass
+            value
+          when Numeric, /^\-?[0-9]/
+            !value.to_f.zero?
           else
-            value.utc.to_i
+            value.present?
           end
         end
 
-        def to_ruby(value)
-          Time.at(value).utc
-        end
+        alias to_ruby to_db
       end
     end
 
@@ -240,7 +175,7 @@ module Neo4j::Shared
         end
 
         def to_ruby(value)
-          Psych.load(value)
+          value.is_a?(Hash) ? value : Psych.load(value)
         end
       end
     end
@@ -327,16 +262,21 @@ module Neo4j::Shared
       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|
+      properties.to_h.each_pair do |key, value|
         next if skip_conversion?(obj, key, value)
-        properties[key] = convert_property(key, value, direction)
+
+        converted_value = convert_property(key, value, direction)
+        if properties.is_a?(Neo4j::AttributeSet)
+          properties.write_cast_value(key, converted_value)
+        else
+          properties[key] = converted_value
+        end
       end
     end
 

data/lib/neo4j/shared/typecasted_attributes.rb

@@ -39,15 +39,15 @@ module Neo4j::Shared
     #
     # @return [Object, nil] The attribute value before typecasting
     def attribute_before_type_cast(name)
-      @attributes ||= {}
-      @attributes[name.to_s]
+      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes.fetch_value(name.to_s)
     end
 
     private
 
     # Reads the attribute and typecasts the result
     def attribute(name)
-      typecast_attribute(_attribute_typecaster(name), super)
+      Property::NEO4J_DRIVER_DATA_TYPES.include?(_attribute_type(name)) ? super : typecast_attribute(_attribute_typecaster(name), super)
     end
 
     def typecast_attribute(typecaster, value)
@@ -66,7 +66,8 @@ module Neo4j::Shared
     # @private
     def _attribute_typecaster(attribute_name)
       type = _attribute_type(attribute_name)
-      caster = self.class.attributes[attribute_name].typecaster || Neo4j::Shared::TypeConverters.typecaster_for(type)
+      default_typecaster = self.class.attributes[attribute_name].typecaster
+      caster = default_typecaster || Neo4j::Shared::TypeConverters.typecaster_for(type)
       caster || fail(Neo4j::UnknownTypeConverterError, "Unable to cast to type #{type}")
     end
 

data/lib/neo4j/transaction.rb

@@ -16,7 +16,7 @@ module Neo4j
       # Runs the given block in a new transaction.
       # @param [Boolean] run_in_tx if true a new transaction will not be created, instead if will simply yield to the given block
       # @@yield [Neo4j::Transaction::Instance]
-      def run(driver, run_in_tx)
+      def run(_driver, run_in_tx)
         return yield(nil) unless run_in_tx
 
         tx = Neo4j::Transaction.new

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '10.0.0-alpha.9'
+  VERSION = '10.0.0-alpha.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activegraph
 version: !ruby/object:Gem::Version
-  version: 10.0.0.pre.alpha.9
+  version: 10.0.0.pre.alpha.10
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg, Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-12 00:00:00.000000000 Z
+date: 2020-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -304,6 +304,7 @@ files:
 - lib/neo4j/active_rel/types.rb
 - lib/neo4j/active_rel/validations.rb
 - lib/neo4j/ansi.rb
+- lib/neo4j/attribute_set.rb
 - lib/neo4j/class_arguments.rb
 - lib/neo4j/config.rb
 - lib/neo4j/core.rb
@@ -328,6 +329,7 @@ files:
 - lib/neo4j/core/schema_errors.rb
 - lib/neo4j/core/wrappable.rb
 - lib/neo4j/errors.rb
+- lib/neo4j/lazy_attribute_hash.rb
 - lib/neo4j/migration.rb
 - lib/neo4j/migrations.rb
 - lib/neo4j/migrations/base.rb
@@ -415,7 +417,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A graph database for Ruby