neo4j 6.1.12 → 7.0.0.rc.1

data/lib/neo4j/shared/declared_property.rb

@@ -1,7 +1,9 @@
 module Neo4j::Shared
   # Contains methods related to the management
   class DeclaredProperty
-    class IllegalPropertyError < StandardError; end
+    include Comparable
+
+    class IllegalPropertyError < Neo4j::Error; end
     include Neo4j::Shared::DeclaredProperty::Index
 
     ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
@@ -9,12 +11,46 @@ module Neo4j::Shared
 
     def initialize(name, options = {})
       fail IllegalPropertyError, "#{name} is an illegal property" if ILLEGAL_PROPS.include?(name.to_s)
-      @name = @name_sym = name
+      fail TypeError, "can't convert #{name.class} into Symbol" unless name.respond_to?(:to_sym)
+      @name = @name_sym = name.to_sym
       @name_string = name.to_s
       @options = options
       fail_invalid_options!
     end
 
+    # Compare attribute definitions
+    #
+    # @example
+    #   attribute_definition <=> other
+    #
+    # @param [Neo4j::Shared::DeclaredProperty, Object] other The other
+    #   attribute definition to compare with.
+    #
+    # @return [-1, 0, 1, nil]
+    def <=>(other)
+      return nil unless other.instance_of? self.class
+      return nil if name == other.name && options != other.options
+      self.to_s <=> other.to_s
+    end
+
+    def inspect
+      options_description = options.map { |key, value| "#{key.inspect} => #{value.inspect}" }.sort.join(', ')
+      inspected_options = ", #{options_description}" unless options_description.empty?
+      "attribute :#{name}#{inspected_options}"
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def to_sym
+      name
+    end
+
+    def [](key)
+      respond_to?(key) ? public_send(key) : nil
+    end
+
     def register
       register_magic_properties
     end
@@ -30,6 +66,7 @@ module Neo4j::Shared
     def default_value
       options[:default]
     end
+    alias_method :default, :default_value
 
     def fail_invalid_options!
       case
@@ -74,7 +111,7 @@ module Neo4j::Shared
       converter = options[:serializer]
       return unless converter
       options[:type]        = converter.convert_type
-      options[:typecaster]  = ActiveAttr::Typecasting::ObjectTypecaster.new
+      options[:typecaster]  = Neo4j::Shared::TypeConverters::ObjectConverter
       Neo4j::Shared::TypeConverters.register_converter(converter)
     end
   end

data/lib/neo4j/shared/enum.rb

@@ -0,0 +1,148 @@
+module Neo4j::Shared
+  module Enum
+    extend ActiveSupport::Concern
+
+    class ConflictingEnumMethodError < Neo4j::Error; end
+
+    module ClassMethods
+      attr_reader :neo4j_enum_data
+
+      # Similar to ActiveRecord enum, maps an integer value on the database to
+      # a set of enum keys.
+      #
+      # @example Base example
+      #   class Media
+      #     include Neo4j::ActiveNode
+      #     enum type: [:image, :video, :unknown]
+      #   end
+      #   Media.types # => { :images => 0, :video => 1, :unknown => 2 }
+      #
+      #   media.video!
+      #   media.image? # => false
+      #   media.type # => :video
+      #
+      #   Media.videos # => All medias with type = 1 (:video)
+      #   Media.where(type: :video) # => All medias with type = 1 (:video)
+      #
+      # @example Prefix-ing an enum
+      #   Media.enum type: [:image, :video, :unknown], _prefix: :enum
+      #
+      #   media.enum_video!
+      #   media.enum_video? # => true
+      #
+      # @example Suffix-ing an enum
+      #   Media.enum type: [:image, :video, :unknown], _suffix: true
+      #
+      #   media.video_type!
+      #   media.video_type? # => true
+      #
+      # @example Disable index: :exact for enum elements
+      #   Media.enum type: [:image, :video, :unknown], _index: false
+      #
+      # @example Define a custom mapping for keys-numbers
+      #   Media.enum type: { image: 1, video: 2, unknown: 3 }
+      #
+      # @see http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html
+      def enum(parameters = {})
+        options, parameters = *split_options_and_parameters(parameters)
+        parameters.each do |property_name, enum_keys|
+          enum_keys = normalize_key_list enum_keys
+          @neo4j_enum_data ||= {}
+          @neo4j_enum_data[property_name] = enum_keys
+          define_property(property_name, enum_keys, options)
+          define_enum_methods(property_name, enum_keys, options)
+        end
+      end
+
+      protected
+
+      def normalize_key_list(enum_keys)
+        case enum_keys
+        when Hash
+          enum_keys
+        when Array
+          Hash[enum_keys.each_with_index.to_a]
+        else
+          fail ArgumentError, 'Invalid parameter for enum. Please provide an Array or an Hash.'
+        end
+      end
+
+      VALID_OPTIONS_FOR_ENUMS = [:_index, :_prefix, :_suffix]
+      DEFAULT_OPTIONS_FOR_ENUMS = {
+        _index: true
+      }
+
+      def split_options_and_parameters(parameters)
+        options = DEFAULT_OPTIONS_FOR_ENUMS.clone
+        new_parameters = {}
+        parameters.each do |k, v|
+          if VALID_OPTIONS_FOR_ENUMS.include? k
+            options[k] = v
+          else
+            new_parameters[k] = v
+          end
+        end
+        [options, new_parameters]
+      end
+
+      def define_property(property_name, enum_keys, options)
+        property_options = build_property_options(enum_keys, options)
+        property property_name, property_options
+        serialize property_name, Neo4j::Shared::TypeConverters::EnumConverter.new(enum_keys)
+      end
+
+      def build_property_options(enum_keys, _options = {})
+        {
+          default: enum_keys.keys.first
+        }
+      end
+
+      def define_enum_methods(property_name, enum_keys, options)
+        define_enum_methods_?(property_name, enum_keys, options)
+        define_enum_methods_!(property_name, enum_keys, options)
+        define_class_methods(property_name, enum_keys)
+      end
+
+      def define_class_methods(property_name, enum_keys)
+        plural_property_name = property_name.to_s.pluralize.to_sym
+        define_singleton_method(plural_property_name) do
+          enum_keys
+        end
+      end
+
+      def define_enum_methods_?(property_name, enum_keys, options)
+        enum_keys.keys.each do |enum_value|
+          method_name = build_method_name(enum_value, property_name, options)
+          check_enum_method_conflicts! property_name, :"#{method_name}?"
+          define_method("#{method_name}?") do
+            __send__(property_name).to_s.to_sym == enum_value
+          end
+        end
+      end
+
+      def define_enum_methods_!(property_name, enum_keys, options)
+        enum_keys.keys.each do |enum_value|
+          method_name = build_method_name(enum_value, property_name, options)
+          check_enum_method_conflicts! property_name, :"#{method_name}!"
+          define_method("#{method_name}!") do
+            __send__("#{property_name}=", enum_value)
+          end
+        end
+      end
+
+      def build_method_name(base_name, property_name, options)
+        method_name = base_name
+        method_name = "#{method_name}_#{property_name}" if options[:_suffix]
+        method_name = "#{options[:_prefix]}_#{method_name}" if options[:_prefix]
+        method_name
+      end
+
+      def check_enum_method_conflicts!(property_name, method_name)
+        fail ConflictingEnumMethodError,
+             "The enum `#{property_name}` is trying to define a `#{method_name}` method, "\
+             'that is already defined. Try to use options `:prefix` or `:suffix` '\
+             'to avoid conflicts.' if instance_methods(false).include?(method_name)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/filtered_hash.rb

@@ -1,6 +1,6 @@
 module Neo4j::Shared
   class FilteredHash
-    class InvalidHashFilterType < Neo4j::Neo4jrbError; end
+    class InvalidHashFilterType < Neo4j::Error; end
     VALID_SYMBOL_INSTRUCTIONS = [:all, :none]
     VALID_HASH_INSTRUCTIONS = [:on]
     VALID_INSTRUCTIONS_TYPES = [Hash, Symbol]

data/lib/neo4j/shared/mass_assignment.rb

@@ -0,0 +1,58 @@
+module Neo4j::Shared
+  # MassAssignment allows you to bulk set and update attributes
+  #
+  # Including MassAssignment into your model gives it a set of mass assignment
+  # methods, similar to those found in ActiveRecord.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::MassAssignment
+  #   end
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module MassAssignment
+    extend ActiveSupport::Concern
+    # Mass update a model's attributes
+    #
+    # @example Assigning a hash
+    #   person.assign_attributes(:first_name => "Chris", :last_name => "Griego")
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param [Hash{#to_s => Object}, #each] attributes Attributes used to
+    #   populate the model
+    # @param [Hash, #[]] options Options that affect mass assignment
+    def assign_attributes(new_attributes = nil)
+      return unless new_attributes.present?
+      new_attributes.each do |name, value|
+        writer = :"#{name}="
+        send(writer, value) if respond_to?(writer)
+      end
+    end
+
+    # Mass update a model's attributes
+    #
+    # @example Assigning a hash
+    #   person.attributes = { :first_name => "Chris", :last_name => "Griego" }
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param (see #assign_attributes)
+    def attributes=(new_attributes)
+      assign_attributes(new_attributes)
+    end
+
+    # Initialize a model with a set of attributes
+    #
+    # @example Initializing with a hash
+    #   person = Person.new(:first_name => "Chris", :last_name => "Griego")
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param (see #assign_attributes)
+    def initialize(attributes = nil)
+      assign_attributes(attributes)
+      super()
+    end
+  end
+end

data/lib/neo4j/shared/property.rb

@@ -2,15 +2,12 @@ module Neo4j::Shared
   module Property
     extend ActiveSupport::Concern
 
-    include ActiveAttr::Attributes
-    include ActiveAttr::MassAssignment
-    include ActiveAttr::TypecastedAttributes
-    include ActiveAttr::AttributeDefaults
-    include ActiveAttr::QueryAttributes
+    include Neo4j::Shared::MassAssignment
+    include Neo4j::Shared::TypecastedAttributes
     include ActiveModel::Dirty
 
-    class UndefinedPropertyError < RuntimeError; end
-    class MultiparameterAssignmentError < StandardError; end
+    class UndefinedPropertyError < Neo4j::Error; end
+    class MultiparameterAssignmentError < Neo4j::Error; end
 
     attr_reader :_persisted_obj
 
@@ -23,11 +20,9 @@ module Neo4j::Shared
       "#<#{Neo4j::ANSI::YELLOW}#{self.class.name}#{Neo4j::ANSI::CLEAR}#{separator}#{attribute_descriptions}>"
     end
 
-    # 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 = nil)
       attributes = process_attributes(attributes)
-      @relationship_props = {} # self.class.extract_association_attributes!(attributes)
+      @relationship_props = self.class.extract_association_attributes!(attributes)
       modded_attributes = inject_defaults!(attributes)
       validate_attributes!(modded_attributes)
       writer_method_props = extract_writer_methods!(modded_attributes)
@@ -40,11 +35,8 @@ module Neo4j::Shared
       self.class.declared_properties.inject_defaults!(self, starting_props || {})
     end
 
-    # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
     def read_attribute(name)
-      super(name)
-    rescue ActiveAttr::UnknownAttributeError
-      nil
+      respond_to?(name) ? send(name) : nil
     end
     alias_method :[], :read_attribute
 
@@ -58,16 +50,6 @@ module Neo4j::Shared
       convert_and_assign_attributes(properties)
     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
 
     # Changes attributes hash to remove relationship keys
@@ -123,7 +105,7 @@ module Neo4j::Shared
     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 = field.type
       klass ? klass.new(*values) : values
     end
 
@@ -162,54 +144,61 @@ module Neo4j::Shared
       #    end
       def property(name, options = {})
         build_property(name, options) do |prop|
-          attribute(name, prop.options)
+          attribute(prop)
         end
       end
 
       # @param [Symbol] name The property name
-      # @param [ActiveAttr::AttributeDefinition] active_attr A cloned AttributeDefinition to reuse
+      # @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, active_attr, options = {})
-        build_property(name, options) do |prop|
-          attributes[prop.name.to_s] = active_attr
+      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)
-        prop = DeclaredProperty.new(name, options)
-        prop.register
-        declared_properties.register(prop)
-        yield prop
-        constraint_or_index(name, options)
+        DeclaredProperty.new(name, options).tap do |prop|
+          prop.register
+          declared_properties.register(prop)
+          yield name
+          constraint_or_index(name, options)
+        end
       end
 
       def undef_property(name)
+        undef_constraint_or_index(name)
         declared_properties.unregister(name)
         attribute_methods(name).each { |method| undef_method(method) }
-        undef_constraint_or_index(name)
       end
 
       def declared_properties
         @_declared_properties ||= DeclaredProperties.new(self)
       end
 
-      def attribute!(name, options = {})
-        super(name, options)
-        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
-
       # @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]
@@ -220,6 +209,13 @@ module Neo4j::Shared
           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