neo4j 4.1.5 → 5.0.0.rc.1

data/lib/neo4j/active_node/has_n/association.rb

@@ -17,42 +17,51 @@ module Neo4j
           apply_vars_from_options(options)
         end
 
-        def target_class_option(options)
-          if options[:model_class].nil?
+        def target_class_option(model_class)
+          case model_class
+          when nil
             if @target_class_name_from_name
-              "::#{@target_class_name_from_name}"
+              "#{association_model_namespace}::#{@target_class_name_from_name}"
             else
               @target_class_name_from_name
             end
-          elsif options[:model_class] == false
+          when Array
+            model_class.map { |sub_model_class| target_class_option(sub_model_class) }
+          when false
             false
           else
-            "::#{options[:model_class]}"
+            "::#{model_class}"
           end
         end
 
         # Return cypher partial query string for the relationship part of a MATCH (arrow / relationship definition)
-        def arrow_cypher(var = nil, properties = {}, create = false)
+        def arrow_cypher(var = nil, properties = {}, create = false, reverse = false)
           validate_origin!
-          relationship_type = relationship_type(create)
-          relationship_name_cypher = ":`#{relationship_type}`" if relationship_type
-          properties_string = get_properties_string(properties)
-          relationship_cypher = get_relationship_cypher(var, relationship_name_cypher, properties_string)
-          get_direction(relationship_cypher, create)
+          direction_cypher(get_relationship_cypher(var, properties, create), create, reverse)
         end
 
-        def target_class_name
-          @target_class_name ||= @target_class_option.to_s if @target_class_option
+        def target_class_names
+          @target_class_names ||= if @target_class_option.is_a?(Array)
+                                    @target_class_option.map(&:to_s)
+                                  elsif @target_class_option
+                                    [@target_class_option.to_s]
+                                  end
         end
 
-        def target_class_name_or_nil
-          @target_class_name_or_nil ||= target_class_name || 'nil'
+        def target_classes_or_nil
+          @target_classes_or_nil ||= discovered_model if target_class_names
+        end
+
+        def discovered_model
+          target_class_names.map(&:constantize).select do |constant|
+            constant.ancestors.include?(::Neo4j::ActiveNode)
+          end
         end
 
         def target_class
           return @target_class if @target_class
 
-          @target_class = target_class_name.constantize if target_class_name
+          @target_class = target_class_names[0].constantize if target_class_names && target_class_names.size == 1
         rescue NameError
           raise ArgumentError, "Could not find `#{@target_class}` class and no :model_class specified"
         end
@@ -83,7 +92,7 @@ module Neo4j
 
         def relationship_class_type
           @relationship_class = @relationship_class.constantize if @relationship_class.class == String || @relationship_class == Symbol
-          @relationship_class._type
+          @relationship_class._type.to_sym
         end
 
         def relationship_class_name
@@ -110,11 +119,18 @@ module Neo4j
           @origin ? origin_association.unique? : !!@unique
         end
 
+        def create_method
+          unique? ? :create_unique : :create
+        end
+
         private
 
-        def get_direction(relationship_cypher, create)
-          dir = (create && @direction == :both) ? :out : @direction
-          case dir
+        def association_model_namespace
+          Neo4j::Config.association_model_namespace_string
+        end
+
+        def direction_cypher(relationship_cypher, create, reverse = false)
+          case get_direction(create, reverse)
           when :out
             "-#{relationship_cypher}->"
           when :in
@@ -124,7 +140,24 @@ module Neo4j
           end
         end
 
-        def get_relationship_cypher(var, relationship_name_cypher, properties_string)
+        def get_direction(create, reverse = false)
+          dir = (create && @direction == :both) ? :out : @direction
+          if reverse
+            case dir
+            when :in then :out
+            when :out then :in
+            else :both
+            end
+          else
+            dir
+          end
+        end
+
+        def get_relationship_cypher(var, properties, create)
+          relationship_type = relationship_type(create)
+          relationship_name_cypher = ":`#{relationship_type}`" if relationship_type
+          properties_string = get_properties_string(properties)
+
           "[#{var}#{relationship_name_cypher}#{properties_string}]"
         end
 
@@ -146,41 +179,41 @@ module Neo4j
         private
 
         def apply_vars_from_options(options)
-          @target_class_option = target_class_option(options)
+          @target_class_option = target_class_option(options[:model_class])
           @callbacks = {before: options[:before], after: options[:after]}
           @origin = options[:origin] && options[:origin].to_sym
           @relationship_class = options[:rel_class]
           @relationship_type  = options[:type] && options[:type].to_sym
-          @dependent = options[:dependent]
+          @dependent = options[:dependent].try(:to_sym)
           @unique = options[:unique]
         end
 
         # Return basic details about association as declared in the model
         # @example
-        #   has_many :in, :bands
+        #   has_many :in, :bands, type: :has_band
         def base_declaration
           "#{type} #{direction.inspect}, #{name.inspect}"
         end
 
         def validate_init_arguments(type, direction, options)
           validate_option_combinations(options)
+          validate_dependent(options[:dependent].try(:to_sym))
           check_valid_type_and_dir(type, direction)
         end
 
         def check_valid_type_and_dir(type, direction)
-          fail ArgumentError, "Invalid association type: #{type.inspect} (valid value: :has_many and :has_one)" if not [:has_many, :has_one].include?(type.to_sym)
-          fail ArgumentError, "Invalid direction: #{direction.inspect} (valid value: :out, :in, and :both)" if not [:out, :in, :both].include?(direction.to_sym)
+          fail ArgumentError, "Invalid association type: #{type.inspect} (valid value: :has_many and :has_one)" if ![:has_many, :has_one].include?(type.to_sym)
+          fail ArgumentError, "Invalid direction: #{direction.inspect} (valid value: :out, :in, and :both)" if ![:out, :in, :both].include?(direction.to_sym)
         end
 
         def validate_option_combinations(options)
-          fail ArgumentError, "Cannot specify both :type and :origin (#{base_declaration})" if options[:type] && options[:origin]
-          fail ArgumentError, "Cannot specify both :type and :rel_class (#{base_declaration})" if options[:type] && options[:rel_class]
-          fail ArgumentError, "Cannot specify both :origin and :rel_class (#{base_declaration}" if options[:origin] && options[:rel_class]
-        end
-
-        VALID_DEPENDENT_TYPES = [:delete, :delete_orphans, :destroy_orphans, :destroy, nil]
-        def validate_dependent(value)
-          fail ArgumentError, "Invalid dependent value: #{value.inspect}" if not VALID_DEPENDENT_TYPES.include?(value)
+          [[:type, :origin],
+           [:type, :rel_class],
+           [:origin, :rel_class]].each do |key1, key2|
+            if options[key1] && options[key2]
+              fail ArgumentError, "Cannot specify both :#{key1} and :#{key2} (#{base_declaration})"
+            end
+          end
         end
 
         # Determine if model class as derived from the association name would be different than the one specified via the model_class key
@@ -197,12 +230,18 @@ module Neo4j
         def validate_origin!
           return if not @origin
 
-          fail ArgumentError, 'Cannot use :origin without a model_class (implied or explicit)' if not target_class
-
           association = origin_association
-          fail ArgumentError, "Origin `#{@origin.inspect}` association not found for #{target_class} (specified in #{base_declaration})" if not association
 
-          fail ArgumentError, "Origin `#{@origin.inspect}` (specified in #{base_declaration}) has same direction `#{@direction}`)" if @direction == association.direction
+          message = case
+                    when !target_class
+                      'Cannot use :origin without a model_class (implied or explicit)'
+                    when !association
+                      "Origin `#{@origin.inspect}` association not found for #{target_class} (specified in #{base_declaration})"
+                    when @direction == association.direction
+                      "Origin `#{@origin.inspect}` (specified in #{base_declaration}) has same direction `#{@direction}`)"
+                    end
+
+          fail ArgumentError, message if message
         end
       end
     end

data/lib/neo4j/active_node/id_property.rb

@@ -20,27 +20,52 @@ module Neo4j::ActiveNode
   #     end
   #   end
   #
+  # @example using already exsting ids that you don't want a constraint added to
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     property :title
+  #     validates :title, :presence => true
+  #     id_property :id, on: :id_builder, constraint: false
+  #
+  #     def id_builder
+  #       # only need to fill this out if you're gonna write to the db
+  #     end
+  #   end
+  #
   module IdProperty
     extend ActiveSupport::Concern
 
 
     module TypeMethods
       def define_id_methods(clazz, name, conf)
-        fail "Expected a Hash, got #{conf.class} (#{conf}) for id_property" unless conf.is_a?(Hash)
+        validate_conf!(conf)
+
         if conf[:on]
           define_custom_method(clazz, name, conf[:on])
         elsif conf[:auto]
-          fail "only :uuid auto id_property allowed, got #{conf[:auto]}" unless conf[:auto] == :uuid
           define_uuid_method(clazz, name)
         elsif conf.empty?
           define_property_method(clazz, name)
-        else
-          fail "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
         end
       end
 
       private
 
+      def validate_conf!(conf)
+        fail "Expected a Hash, got #{conf.class} (#{conf}) for id_property" if !conf.is_a?(Hash)
+
+        return if conf[:on]
+
+        if conf[:auto]
+          fail "only :uuid auto id_property allowed, got #{conf[:auto]}" if conf[:auto] != :uuid
+          return
+        end
+
+        return if conf.empty?
+
+        fail "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
+      end
+
       def define_property_method(clazz, name)
         clear_methods(clazz, name)
 
@@ -90,17 +115,8 @@ module Neo4j::ActiveNode
       end
 
       def clear_methods(clazz, name)
-        if clazz.method_defined?(name)
-          clazz.module_eval(%(
-            undef_method :#{name}
-                    ), __FILE__, __LINE__)
-        end
-
-        if clazz.attribute_names.include?(name.to_s)
-          clazz.module_eval(%(
-            undef_property :#{name}
-                    ), __FILE__, __LINE__)
-        end
+        clazz.module_eval(%(undef_method :#{name}), __FILE__, __LINE__) if clazz.method_defined?(name)
+        clazz.module_eval(%(undef_property :#{name}), __FILE__, __LINE__) if clazz.attribute_names.include?(name.to_s)
       end
 
       extend self
@@ -121,22 +137,12 @@ module Neo4j::ActiveNode
       end
 
       def id_property(name, conf = {})
-        begin
-          if id_property?
-            unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
-              drop_constraint(id_property_name, type: :unique)
-            end
-          end
-        rescue Neo4j::Server::CypherResponse::ResponseError
-        end
-
+        id_property_constraint(name)
         @id_property_info = {name: name, type: conf}
         TypeMethods.define_id_methods(self, name, conf)
-        constraint name, type: :unique
+        constraint name, type: :unique unless conf[:constraint] == false
 
-        self.define_singleton_method(:find_by_id) do |key|
-          self.where(name => key).first
-        end
+        self.define_singleton_method(:find_by_id) { |key| self.where(name => key).first }
       end
 
       # rubocop:disable Style/PredicateName
@@ -160,6 +166,18 @@ module Neo4j::ActiveNode
       end
 
       alias_method :primary_key, :id_property_name
+
+      private
+
+      def id_property_constraint(name)
+        if id_property?
+          unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
+            # Neo4j Embedded throws a crazy error when a constraint can't be dropped
+            drop_constraint(id_property_name, type: :unique)
+          end
+        end
+      rescue Neo4j::Server::CypherResponse::ResponseError, Java::OrgNeo4jCypher::CypherExecutionException
+      end
     end
   end
 end

data/lib/neo4j/active_node/initialize.rb

@@ -1,19 +1,15 @@
 module Neo4j::ActiveNode::Initialize
   extend ActiveSupport::Concern
-  include Neo4j::Shared::TypeConverters
   attr_reader :called_by
 
   # called when loading the node from the database
   # @param [Neo4j::Node] persisted_node the node this class wraps
   # @param [Hash] properties of the persisted node.
   def init_on_load(persisted_node, properties)
-    @_association_attributes = self.class.extract_association_attributes!(properties)
+    self.class.extract_association_attributes!(properties)
     @_persisted_obj = persisted_node
-    @association_cache = {}
     changed_attributes && changed_attributes.clear
-    @attributes = attributes.merge(properties.stringify_keys)
-    self.default_properties = properties
-    @attributes = convert_properties_to :ruby, @attributes
+    @attributes = convert_and_assign_attributes(properties)
   end
 
   # Implements the Neo4j::Node#wrapper and Neo4j::Relationship#wrapper method
@@ -22,4 +18,20 @@ module Neo4j::ActiveNode::Initialize
   def wrapper
     self
   end
+
+  private
+
+  def convert_and_assign_attributes(properties)
+    @attributes ||= self.class.attributes_nil_hash.dup
+    stringify_attributes!(@attributes, properties)
+    self.default_properties = properties
+    self.class.declared_property_manager.convert_properties_to(self, :ruby, @attributes)
+  end
+
+  def stringify_attributes!(attr, properties)
+    properties.each_pair do |k, v|
+      key = self.class.declared_property_manager.string_key(k)
+      attr[key] = v
+    end
+  end
 end

data/lib/neo4j/active_node/labels.rb

@@ -5,6 +5,19 @@ module Neo4j
       extend ActiveSupport::Concern
 
       WRAPPED_CLASSES = []
+      MODELS_FOR_LABELS_CACHE = {}
+      MODELS_FOR_LABELS_CACHE.clear
+
+      included do |model|
+        def self.inherited(model)
+          add_wrapped_class(model)
+
+          super
+        end
+
+        Neo4j::ActiveNode::Labels.add_wrapped_class(model) unless Neo4j::ActiveNode::Labels._wrapped_classes.include?(model)
+      end
+
       class InvalidQueryError < StandardError; end
       class RecordNotFound < StandardError; end
 
@@ -32,59 +45,59 @@ module Neo4j
         @_persisted_obj.remove_label(*label)
       end
 
-      def self.included(klass)
-        add_wrapped_class(klass)
-      end
-
-      def self.add_wrapped_class(klass)
-        _wrapped_classes << klass
-        @_wrapped_labels = nil
+      def self.add_wrapped_class(model)
+        _wrapped_classes << model
       end
 
       def self._wrapped_classes
         Neo4j::ActiveNode::Labels::WRAPPED_CLASSES
       end
 
-      protected
-
-      # Only for testing purpose
-      # @private
-      def self._wrapped_labels=(wl)
-        @_wrapped_labels = (wl)
+      def self.model_for_labels(labels)
+        MODELS_FOR_LABELS_CACHE[labels] || model_cache(labels)
       end
 
-      def self._wrapped_labels
-        @_wrapped_labels ||=  _wrapped_classes.inject({}) do |ack, clazz|
-          ack.tap do |a|
-            a[clazz.mapped_label_name.to_sym] = clazz if clazz.respond_to?(:mapped_label_name)
-          end
+      def self.model_cache(labels)
+        models = WRAPPED_CLASSES.select do |model|
+          (model.mapped_label_names - labels).size == 0
         end
+
+        MODELS_FOR_LABELS_CACHE[labels] = models.max do |model|
+          (model.mapped_label_names & labels).size
+        end
+      end
+
+      def self.clear_model_for_label_cache
+        MODELS_FOR_LABELS_CACHE.clear
       end
 
+      def self.clear_wrapped_models
+        WRAPPED_CLASSES.clear
+      end
+
+      protected
+
       module ClassMethods
         include Neo4j::ActiveNode::QueryMethods
 
-        # Find all nodes/objects of this class
-        def all
-          Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, {})
-        end
-
         # Returns the object with the specified neo4j id.
         # @param [String,Integer] id of node to find
         def find(id)
           map_id = proc { |object| object.respond_to?(:id) ? object.send(:id) : object }
 
-          if id.is_a?(Array)
-            find_by_ids(id.map { |o| map_id.call(o) })
-          else
-            find_by_id(map_id.call(id))
-          end
+          result =  if id.is_a?(Array)
+                      find_by_ids(id.map { |o| map_id.call(o) })
+                    else
+                      find_by_id(map_id.call(id))
+                    end
+          fail Neo4j::RecordNotFound if result.blank?
+          result
         end
 
         # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
         # @param Hash args of arguments to find
         def find_by(values)
-          self.query_as(:n).where(n: values).limit(1).pluck(:n).first
+          all.query_as(:n).where(n: values).limit(1).pluck(:n).first
         end
 
         # Like find_by, except that if no record is found, raises a RecordNotFound error.
@@ -94,14 +107,14 @@ module Neo4j
 
         # Deletes all nodes and connected relationships from Cypher.
         def delete_all
-          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`)-[r]-() DELETE n,r")
+          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH n-[r]-() DELETE n,r")
           self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
         end
 
         # Returns each node to Ruby and calls `destroy`. Be careful, as this can be a very slow operation if you have many nodes. It will generate at least
         # one database query per node in the database, more if callbacks require them.
         def destroy_all
-          self.all.each(&:destroy)
+          all.each(&:destroy)
         end
 
         # Creates a Neo4j index on given property
@@ -140,8 +153,10 @@ module Neo4j
         #
         def constraint(property, constraints)
           Neo4j::Session.on_session_available do |session|
-            label = Neo4j::Label.create(mapped_label_name)
-            label.create_constraint(property, constraints, session)
+            unless Neo4j::Label.constraint?(mapped_label_name, property)
+              label = Neo4j::Label.create(mapped_label_name)
+              label.create_constraint(property, constraints, session)
+            end
           end
         end
 
@@ -163,7 +178,7 @@ module Neo4j
 
         # @return [Symbol] the label that this class has which corresponds to a Ruby class
         def mapped_label_name
-          @mapped_label_name || (self.name.nil? ? object_id.to_s.to_sym : self.name.to_sym)
+          @mapped_label_name || label_for_model
         end
 
         # @return [Neo4j::Label] the label for this class
@@ -214,11 +229,30 @@ module Neo4j
 
         # rubocop:disable Style/AccessorMethodName
         def set_mapped_label_name(name)
-          ActiveSupport::Deprecation.warn 'set_mapped_label_name is deprecated and may be removed from future releases, use self.mapped_label_name= instead.', caller
+          ActiveSupport::Deprecation.warn 'set_mapped_label_name is deprecated, use self.mapped_label_name= instead.', caller
 
           self.mapped_label_name = name
         end
         # rubocop:enable Style/AccessorMethodName
+
+        private
+
+        def label_for_model
+          (self.name.nil? ? object_id.to_s.to_sym : decorated_label_name)
+        end
+
+        def decorated_label_name
+          name =  case Neo4j::Config[:module_handling]
+                  when :demodulize
+                    self.name.demodulize
+                  when Proc
+                    Neo4j::Config[:module_handling].call self.name
+                  else
+                    self.name
+                  end
+
+          name.to_sym
+        end
       end
     end
   end