neo4j 4.1.5 → 5.0.0.rc.1

data/lib/neo4j/shared/declared_property_manager.rb

@@ -0,0 +1,150 @@
+module Neo4j::Shared
+  # The DeclaredPropertyuManager holds details about objects created as a result of calling the #property
+  # class method on a class that includes Neo4j::ActiveNode or Neo4j::ActiveRel. There are many options
+  # that are referenced frequently, particularly during load and save, so this provides easy access and
+  # a way of separating behavior from the general Active{obj} modules.
+  #
+  # See Neo4j::Shared::DeclaredProperty for definitions of the property objects themselves.
+  class DeclaredPropertyManager
+    include Neo4j::Shared::TypeConverters
+
+    attr_reader :klass
+
+    # Each class that includes Neo4j::ActiveNode or Neo4j::ActiveRel gets one instance of this class.
+    # @param [#declared_property_manager] klass An object that has the #declared_property_manager method.
+    def initialize(klass)
+      @klass = klass
+    end
+
+    # @param [Neo4j::Shared::DeclaredProperty] property An instance of DeclaredProperty, created as the result of calling
+    # #property on an ActiveNode or ActiveRel class. The DeclaredProperty has specifics about the property, but registration
+    # makes the management object aware of it. This is necessary for type conversion, defaults, and inclusion in the nil and string hashes.
+    def register(property)
+      @_attributes_nil_hash = nil
+      @_attributes_string_map = nil
+      registered_properties[property.name] = property
+      register_magic_typecaster(property) if property.magic_typecaster
+      declared_property_defaults[property.name] = property.default_value if property.default_value
+    end
+
+    # The :default option in Neo4j::ActiveNode#property class method allows for setting a default value instead of
+    # nil on declared properties. This holds those values.
+    def declared_property_defaults
+      @_default_property_values ||= {}
+    end
+
+    def registered_properties
+      @_registered_properties ||= {}
+    end
+
+    # During object wrap, a hash is needed that contains each declared property with a nil value.
+    # The active_attr dependency is capable of providing this but it is expensive and calculated on the fly
+    # each time it is called. Rather than rely on that, we build this progressively as properties are registered.
+    # When the node or rel is loaded, this is used as a template.
+    def attributes_nil_hash
+      @_attributes_nil_hash ||= {}.tap do |attr_hash|
+        registered_properties.each_pair do |k, prop_obj|
+          val = prop_obj.default_value
+          attr_hash[k.to_s] = val
+        end
+      end.freeze
+    end
+
+    # During object wrapping, a props hash is built with string keys but Neo4j-core provides symbols.
+    # Rather than a `to_s` or `symbolize_keys` during every load, we build a map of symbol-to-string
+    # to speed up the process. This increases memory used by the gem but reduces object allocation and GC, so it is faster
+    # in practice.
+    def attributes_string_map
+      @_attributes_string_map ||= {}.tap do |attr_hash|
+        attributes_nil_hash.each_key { |k| attr_hash[k.to_sym] = k }
+      end.freeze
+    end
+
+    # @param [Symbol] k A symbol for which the String representation is sought. This might seem silly -- we could just call #to_s --
+    # but when this happens many times while loading many objects, it results in a surprisingly significant slowdown.
+    # The branching logic handles what happens if a property can't be found.
+    # The first option attempts to find it in the existing hash.
+    # The second option checks whether the key is the class's id property and, if it is, the string hash is rebuilt with it to prevent
+    # future lookups.
+    # The third calls `to_s`. This would happen if undeclared properties are found on the object. We could add them to the string map
+    # but that would result in unchecked, un-GCed memory consumption. In the event that someone is adding properties dynamically,
+    # maybe through user input, this would be bad.
+    def string_key(k)
+      attributes_string_map[k] || string_map_id_property(k) || k.to_s
+    end
+
+    def unregister(name)
+      # might need to be include?(name.to_s)
+      fail ArgumentError, "Argument `#{name}` not an attribute" if not registered_properties[name]
+      declared_prop = registered_properties[name]
+      registered_properties.delete(declared_prop)
+      unregister_magic_typecaster(name)
+      unregister_property_default(name)
+    end
+
+    def serialize(name, coder = JSON)
+      @serialize ||= {}
+      @serialize[name] = coder
+    end
+
+    def serialized_properties=(serialize_hash)
+      @serialized_property_keys = nil
+      @serialize = serialize_hash.clone
+    end
+
+    def serialized_properties
+      @serialize ||= {}
+    end
+
+    def serialized_properties_keys
+      @serialized_property_keys ||= serialized_properties.keys
+    end
+
+    def magic_typecast_properties_keys
+      @magic_typecast_properties_keys ||= magic_typecast_properties.keys
+    end
+
+    def magic_typecast_properties
+      @magic_typecast_properties ||= {}
+    end
+
+    # The known mappings of declared properties and their primitive types.
+    def upstream_primitives
+      @upstream_primitives ||= {}
+    end
+
+    protected
+
+    # Prevents repeated calls to :_attribute_type, which isn't free and never changes.
+    def fetch_upstream_primitive(attr)
+      upstream_primitives[attr] || upstream_primitives[attr] = klass._attribute_type(attr)
+    end
+
+    private
+
+    # @param [Symbol] key An undeclared property value found in the _persisted_obj.props hash.
+    # Typically, this is a node's id property, which will not be registered as other properties are.
+    # In the future, this should probably be reworked a bit. This class should either not know or care
+    # about the id property or it should be in charge of it. In the meantime, this improves
+    # node load performance.
+    def string_map_id_property(key)
+      return unless klass.id_property_name == key
+      @_attributes_string_map = attributes_string_map.dup.tap { |h| h[key] = key.to_s }.freeze
+    end
+
+    def unregister_magic_typecaster(property)
+      magic_typecast_properties.delete(property)
+      @magic_typecast_properties_keys = nil
+    end
+
+    def unregister_property_default(property)
+      declared_property_defaults.delete(property)
+      @_default_property_values = nil
+    end
+
+    def register_magic_typecaster(property)
+      magic_typecast_properties[property.name] = property.magic_typecaster
+      @magic_typecast_properties_keys = nil
+    end
+  end
+end

data/lib/neo4j/shared/persistence.rb

@@ -1,17 +1,16 @@
 module Neo4j::Shared
   module Persistence
     extend ActiveSupport::Concern
-    include Neo4j::Shared::TypeConverters
 
     USES_CLASSNAME = []
 
     def update_model
-      if changed_attributes && !changed_attributes.empty?
-        changed_props = attributes.select { |k, _| changed_attributes.include?(k) }
-        changed_props = convert_properties_to :db, changed_props
-        _persisted_obj.update_props(changed_props)
-        changed_attributes.clear
-      end
+      return if !changed_attributes || changed_attributes.empty?
+
+      changed_props = attributes.select { |k, _| changed_attributes.include?(k) }
+      changed_props = self.class.declared_property_manager.convert_properties_to(self, :db, changed_props)
+      _persisted_obj.update_props(changed_props)
+      changed_attributes.clear
     end
 
     # Convenience method to set attribute and #save at the same time
@@ -33,6 +32,7 @@ module Neo4j::Shared
     def create_or_update
       # since the same model can be created or updated twice from a relationship we have to have this guard
       @_create_or_updating = true
+      apply_default_values
       result = _persisted_obj ? update_model : create_model
       if result == false
         Neo4j::Transaction.current.failure if Neo4j::Transaction.current
@@ -47,6 +47,13 @@ module Neo4j::Shared
       @_create_or_updating = nil
     end
 
+    def apply_default_values
+      return if self.class.declared_property_defaults.empty?
+      self.class.declared_property_defaults.each_pair do |key, value|
+        self.send("#{key}=", value) if self.send(key).nil?
+      end
+    end
+
     # Returns +true+ if the record is persisted, i.e. it's not a new record and it was not destroyed
     def persisted?
       !new_record? && !destroyed?
@@ -92,7 +99,7 @@ module Neo4j::Shared
 
     def reload
       return self if new_record?
-      clear_association_cache
+      association_proxy_cache.clear
       changed_attributes && changed_attributes.clear
       unless reload_from_database
         @_deleted = true

data/lib/neo4j/shared/property.rb

@@ -11,22 +11,21 @@ module Neo4j::Shared
 
     class UndefinedPropertyError < RuntimeError; end
     class MultiparameterAssignmentError < StandardError; end
-    class IllegalPropertyError < StandardError; end
-
-    ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
+    # @_declared_property_manager = DeclaredPropertyManager.new
 
     attr_reader :_persisted_obj
 
-    def initialize(attributes = {}, options = {})
-      attributes = process_attributes(attributes)
+    # TODO: Remove the commented :super entirely once this code is part of a release.
+    # It calls an init method in active_attr that has a very negative impact on performance.
+    def initialize(attributes = {}, _options = nil)
+      attributes = process_attributes(attributes) unless attributes.empty?
       @relationship_props = self.class.extract_association_attributes!(attributes)
       writer_method_props = extract_writer_methods!(attributes)
       validate_attributes!(attributes)
-      send_props(writer_method_props) unless writer_method_props.nil?
+      send_props(writer_method_props) unless writer_method_props.empty?
 
       @_persisted_obj = nil
-
-      super(attributes, options)
+      # super(attributes, options)
     end
 
     # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
@@ -38,8 +37,8 @@ module Neo4j::Shared
     alias_method :[], :read_attribute
 
     def default_properties=(properties)
-      keys = self.class.default_properties.keys
-      @default_properties = properties.select { |key| keys.include?(key) }
+      default_property_keys = self.class.default_properties_keys
+      @default_properties = properties.select { |key| default_property_keys.include?(key) }
     end
 
     def default_property(key)
@@ -53,9 +52,17 @@ module Neo4j::Shared
     end
 
     def send_props(hash)
-      hash.each do |key, value|
-        self.send("#{key}=", value)
-      end
+      hash.each { |key, value| self.send("#{key}=", value) }
+    end
+
+    protected
+
+    # This method is defined in ActiveModel.
+    # When each node is loaded, it is called once in pursuit of 'sanitize_for_mass_assignment', which this gem does not implement.
+    # In the course of doing that, it calls :attributes, which is quite expensive, so we return immediately.
+    def attribute_method?(attr_name) #:nodoc:
+      return false if attr_name == 'sanitize_for_mass_assignment'
+      super(attr_name)
     end
 
     private
@@ -63,13 +70,17 @@ module Neo4j::Shared
     # 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
     def validate_attributes!(attributes)
+      return attributes if attributes.empty?
       invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
       fail UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
     end
 
     def extract_writer_methods!(attributes)
-      attributes.keys.each_with_object({}) do |key, writer_method_props|
-        writer_method_props[key] = attributes.delete(key) if self.respond_to?("#{key}=")
+      return attributes if attributes.empty?
+      {}.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
 
@@ -78,8 +89,9 @@ module Neo4j::Shared
       multi_parameter_attributes = {}
       new_attributes = {}
       attributes.each_pair do |key, value|
-        if key =~ /\A([^\(]+)\((\d+)([if])\)$/
-          found_key, index = $1, $2.to_i
+        if match = key.match(/\A([^\(]+)\((\d+)([if])\)$/)
+          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
@@ -90,16 +102,15 @@ module Neo4j::Shared
     end
 
     def process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
-      multi_parameter_attributes.each_pair do |key, values|
-        begin
-          values = (values.keys.min..values.keys.max).map { |i| values[i] }
-          field = self.class.attributes[key.to_sym]
-          new_attributes[key] = instantiate_object(field, values)
-        rescue
-          raise MultiparameterAssignmentError, "error on assignment #{values.inspect} to #{key}"
+      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
-      new_attributes
     end
 
     def instantiate_object(field, values_with_empty_parameters)
@@ -110,6 +121,10 @@ module Neo4j::Shared
     end
 
     module ClassMethods
+      extend Forwardable
+
+      def_delegators :declared_property_manager, :serialized_properties, :serialized_properties=, :serialize, :declared_property_defaults
+
       # Defines a property on the class
       #
       # See active_attr gem for allowed options, e.g which type
@@ -139,22 +154,25 @@ module Neo4j::Shared
       #      property :name, constraint: :unique
       #    end
       def property(name, options = {})
-        check_illegal_prop(name)
-        magic_properties(name, options)
-        attribute(name, options)
+        prop = DeclaredProperty.new(name, options)
+        prop.register
+        declared_property_manager.register(prop)
+
+        attribute(name, prop.options)
         constraint_or_index(name, options)
       end
 
       def undef_property(name)
-        fail ArgumentError, "Argument `#{name}` not an attribute" if not attribute_names.include?(name.to_s)
-
-        attribute_methods(name).each do |method|
-          undef_method(method)
-        end
-
+        declared_property_manager.unregister(name)
+        attribute_methods(name).each { |method| undef_method(method) }
         undef_constraint_or_index(name)
       end
 
+      def declared_property_manager
+        @_declared_property_manager ||= DeclaredPropertyManager.new(self)
+      end
+
+      # TODO: Move this to the DeclaredPropertyManager
       def default_property(name, &block)
         reset_default_properties(name) if default_properties.respond_to?(:size)
         default_properties[name] = block
@@ -165,10 +183,16 @@ module Neo4j::Shared
         @default_property ||= {}
       end
 
+      def default_properties_keys
+        @default_properties_keys ||= default_properties.keys
+      end
+
       def reset_default_properties(name_to_keep)
         default_properties.each_key do |property|
+          @default_properties_keys = nil
           undef_method(property) unless property == name_to_keep
         end
+        @default_properties_keys = nil
         @default_property = {}
       end
 
@@ -187,6 +211,12 @@ module Neo4j::Shared
         end
       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_property_manager.attributes_nil_hash
+      end
+
       private
 
       def constraint_or_index(name, options)
@@ -199,21 +229,6 @@ module Neo4j::Shared
           index(name, options) if options[:index] == :exact
         end
       end
-
-      def check_illegal_prop(name)
-        if ILLEGAL_PROPS.include?(name.to_s)
-          fail IllegalPropertyError, "#{name} is an illegal property"
-        end
-      end
-
-      # Tweaks properties
-      def magic_properties(name, options)
-        options[:type] ||= DateTime if name.to_sym == :created_at || name.to_sym == :updated_at
-
-        # ActiveAttr does not handle "Time", Rails and Neo4j.rb 2.3 did
-        # Convert it to DateTime in the interest of consistency
-        options[:type] = DateTime if options[:type] == Time
-      end
     end
   end
 end

data/lib/neo4j/shared/rel_type_converters.rb

@@ -24,18 +24,19 @@ module Neo4j::Shared
       # @return [String] A string that conforms to the set rel type conversion setting.
       def decorated_rel_type(type)
         type = type.to_s
-        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 =  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

data/lib/neo4j/shared/serialized_properties.rb

@@ -14,20 +14,5 @@ module Neo4j::Shared
     def serializable_hash(*args)
       super.merge(id: id)
     end
-
-    module ClassMethods
-      def serialized_properties
-        @serialize || {}
-      end
-
-      def serialized_properties=(serialize_hash)
-        @serialize = serialize_hash.clone
-      end
-
-      def serialize(name, coder = JSON)
-        @serialize ||= {}
-        @serialize[name] = coder
-      end
-    end
   end
 end