neo4j 4.0.0 → 4.1.0

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

@@ -0,0 +1,67 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      # Methods related to returning nodes and rels from QueryProxy
+      module QueryProxyEnumerable
+        include Enumerable
+
+        # Just like every other <tt>each</tt> but it allows for optional params to support the versions that also return relationships.
+        # The <tt>node</tt> and <tt>rel</tt> params are typically used by those other methods but there's nothing stopping you from
+        # using `your_node.each(true, true)` instead of `your_node.each_with_rel`.
+        # @return [Enumerable] An enumerable containing some combination of nodes and rels.
+        def each(node = true, rel = nil, &_block)
+          if node && rel
+            enumerable_query(identity, rel_var).each { |returned_node, returned_rel| yield returned_node, returned_rel }
+          else
+            pluck_this = !rel ? identity : @rel_var
+            enumerable_query(pluck_this).each { |returned_node| yield returned_node }
+          end
+        end
+
+        # When called at the end of a QueryProxy chain, it will return the resultant relationship objects intead of nodes.
+        # For example, to return the relationship between a given student and their lessons:
+        #   student.lessons.each_rel do |rel|
+        # @return [Enumerable] An enumerable containing any number of applicable relationship objects.
+        def each_rel(&block)
+          block_given? ? each(false, true, &block) : to_enum(:each, false, true)
+        end
+
+        # When called at the end of a QueryProxy chain, it will return the nodes and relationships of the last link.
+        # For example, to return a lesson and each relationship to a given student:
+        #   student.lessons.each_with_rel do |lesson, rel|
+        def each_with_rel(&block)
+          block_given? ? each(true, true, &block) : to_enum(:each, true, true)
+        end
+
+        # Does exactly what you would hope. Without it, comparing `bobby.lessons == sandy.lessons` would evaluate to false because it
+        # would be comparing the QueryProxy objects, not the lessons themselves.
+        def ==(other)
+          self.to_a == other
+        end
+
+        # For getting variables which have been defined as part of the association chain
+        def pluck(*args)
+          self.query.pluck(*args)
+        end
+
+        private
+
+        # Executes the query against the database if the results are not already present in a node's association cache. This method is
+        # shared by <tt>each</tt>, <tt>each_rel</tt>, and <tt>each_with_rel</tt>.
+        # @param [String,Symbol] node The string or symbol of the node to return from the database.
+        # @param [String,Symbol] rel The string or symbol of a relationship to return from the database.
+        def enumerable_query(node, rel = nil)
+          pluck_this = rel.nil? ? [node] : [node, rel]
+          return self.pluck(*pluck_this) if @association.nil? || caller.nil?
+          cypher_string = self.to_cypher_with_params(pluck_this)
+          association_collection = caller.association_instance_get(cypher_string, @association)
+          if association_collection.nil?
+            association_collection = self.pluck(*pluck_this)
+            caller.association_instance_set(cypher_string, association_collection, @association) unless association_collection.empty?
+          end
+          association_collection
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,6 @@ module Neo4j
             yield result
           end
         end
-
       end
     end
   end

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

@@ -4,12 +4,12 @@ module Neo4j
       module QueryProxyMethods
         class InvalidParameterError < StandardError; end
 
-        def first(target=nil)
-          query_with_target(target) { |target| first_and_last("ID(#{target})", target) }
+        def first(target = nil)
+          query_with_target(target) { |var| first_and_last("ID(#{var})", var) }
         end
 
-        def last(target=nil)
-          query_with_target(target) { |target| first_and_last("ID(#{target}) DESC", target) }
+        def last(target = nil)
+          query_with_target(target) { |var| first_and_last("ID(#{var}) DESC", var) }
         end
 
         def first_and_last(order, target)
@@ -17,35 +17,35 @@ module Neo4j
         end
 
         # @return [Fixnum] number of nodes of this class
-        def count(distinct=nil, target=nil)
-          raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
-          query_with_target(target) do |target|
-            q = distinct.nil? ? target : "DISTINCT #{target}"
-            self.query.reorder.pluck("count(#{q}) AS #{target}").first
+        def count(distinct = nil, target = nil)
+          fail(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+          query_with_target(target) do |var|
+            q = distinct.nil? ? var : "DISTINCT #{var}"
+            self.query.reorder.pluck("count(#{q}) AS #{var}").first
           end
         end
 
         alias_method :size,   :count
         alias_method :length, :count
 
-        def empty?(target=nil)
-          query_with_target(target) { |target| !self.exists?(nil, target) }
+        def empty?(target = nil)
+          query_with_target(target) { |var| !self.exists?(nil, var) }
         end
 
         alias_method :blank?, :empty?
 
-        def include?(other, target=nil)
-          raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
-          query_with_target(target) do |target|
-            self.where("ID(#{target}) = {other_node_id}").params(other_node_id: other.neo_id).query.return("count(#{target}) as count").first.count > 0
+        def include?(other, target = nil)
+          fail(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
+          query_with_target(target) do |var|
+            self.where("ID(#{var}) = {other_node_id}").params(other_node_id: other.neo_id).query.return("count(#{var}) as count").first.count > 0
           end
         end
 
-        def exists?(node_condition=nil, target=nil)
-          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
-          query_with_target(target) do |target|
-            start_q = exists_query_start(self, node_condition, target)
-            start_q.query.return("COUNT(#{target}) AS count").first.count > 0
+        def exists?(node_condition = nil, target = nil)
+          fail(InvalidParameterError, ':exists? only accepts neo_ids') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
+          query_with_target(target) do |var|
+            start_q = exists_query_start(node_condition, var)
+            start_q.query.return("COUNT(#{var}) AS count").first.count > 0
           end
         end
 
@@ -72,11 +72,11 @@ module Neo4j
         # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object upon which you can build.
         def match_to(node)
           where_arg = if node.respond_to?(:neo_id)
-                        { neo_id: node.neo_id }
+                        {neo_id: node.neo_id}
                       elsif !node.nil?
                         id_key = association_id_key
                         node = ids_array(node) if node.is_a?(Array)
-                        { id_key => node }
+                        {id_key => node}
                       else
                         # support for null object pattern
                         '1 = 2'
@@ -89,20 +89,20 @@ module Neo4j
         # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
         # @return A relationship (ActiveRel, CypherRelationship, EmbeddedRelationship) or nil.
         def first_rel_to(node)
-          self.match_to(node).limit(1).pluck(rel_identity).first
+          self.match_to(node).limit(1).pluck(rel_var).first
         end
 
         # Returns all relationships across a QueryProxy chain between a given node or array of nodes and the preceeding link.
         # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
         # @return An enumerable of relationship objects.
         def rels_to(node)
-          self.match_to(node).pluck(rel_identity)
+          self.match_to(node).pluck(rel_var)
         end
         alias_method :all_rels_to, :rels_to
 
         # Deletes the relationship between a node and its last link in the QueryProxy chain. Executed in the database, callbacks will not run.
         def delete(node)
-          self.match_to(node).query.delete(rel_identity).exec
+          self.match_to(node).query.delete(rel_var).exec
           clear_caller_cache
         end
 
@@ -142,10 +142,11 @@ module Neo4j
           yield(target || identity)
         end
 
-        def exists_query_start(origin, condition, target)
-          if condition.class == Fixnum
+        def exists_query_start(condition, target)
+          case condition
+          when Fixnum
             self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
-          elsif condition.class == Hash
+          when Hash
             self.where(condition.keys.first => condition.values.first)
           else
             self

data/lib/neo4j/active_node/query_methods.rb

@@ -3,11 +3,11 @@ module Neo4j
     module QueryMethods
       class InvalidParameterError < StandardError; end
 
-      def exists?(node_condition=nil)
-        raise(InvalidParameterError, ':exists? only accepts ids or conditions') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
+      def exists?(node_condition = nil)
+        fail(InvalidParameterError, ':exists? only accepts ids or conditions') unless node_condition.is_a?(Fixnum) || node_condition.is_a?(Hash) || node_condition.nil?
         query_start = exists_query_start(node_condition)
         start_q = query_start.respond_to?(:query_as) ? query_start.query_as(:n) : query_start
-        start_q.return("COUNT(n) AS count").first.count > 0
+        start_q.return('COUNT(n) AS count').first.count > 0
       end
 
       # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
@@ -22,8 +22,8 @@ module Neo4j
 
       # @return [Fixnum] number of nodes of this class
       def count(distinct = nil)
-        raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
-        q = distinct.nil? ? "n" : "DISTINCT n"
+        fail(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+        q = distinct.nil? ? 'n' : 'DISTINCT n'
         self.query_as(:n).return("count(#{q}) AS count").first.count
       end
 
@@ -53,7 +53,7 @@ module Neo4j
       def exists_query_start(node_condition)
         case node_condition
         when Fixnum
-          self.query_as(:n).where("ID(n)" => node_condition)
+          self.query_as(:n).where('ID(n)' => node_condition)
         when Hash
           self.where(node_condition.keys.first => node_condition.values.first)
         else

data/lib/neo4j/active_node/reflection.rb

@@ -15,8 +15,9 @@ module Neo4j::ActiveNode
       # @param macro [Symbol] the association type, :has_many or :has_one
       # @param name [Symbol] the association name
       # @param association_object [Neo4j::ActiveNode::HasN::Association] the association object created in the course of creating this reflection
-      def create_reflection(macro, name, association_object)
+      def create_reflection(macro, name, association_object, model)
         self.reflections = self.reflections.merge(name => AssociationReflection.new(macro, name, association_object))
+        association_object.add_destroy_callbacks(model)
       end
 
       private :create_reflection
@@ -82,4 +83,4 @@ module Neo4j::ActiveNode
       end
     end
   end
-end
+end

data/lib/neo4j/active_node/rels.rb

@@ -4,7 +4,7 @@ module Neo4j::ActiveNode
     def_delegators :_rels_delegator, :rel?, :rel, :rels, :node, :nodes, :create_rel
 
     def _rels_delegator
-      raise "Can't access relationship on a non persisted node" unless _persisted_obj
+      fail "Can't access relationship on a non persisted node" unless _persisted_obj
       _persisted_obj
     end
   end

data/lib/neo4j/active_node/scope.rb

@@ -5,7 +5,6 @@ module Neo4j::ActiveNode
     extend ActiveSupport::Concern
 
     module ClassMethods
-
       # Similar to ActiveRecord scope
       #
       # @example without argument
@@ -38,7 +37,7 @@ module Neo4j::ActiveNode
       def scope(name, proc)
         _scope[name.to_sym] = proc
 
-        module_eval(%Q{
+        module_eval(%{
           def #{name}(query_params=nil, _=nil, query_proxy=nil)
             eval_context = ScopeEvalContext.new(self, query_proxy || self.class.query_proxy)
             proc = self.class._scope[:"#{name}"]
@@ -46,7 +45,7 @@ module Neo4j::ActiveNode
           end
         }, __FILE__, __LINE__)
 
-        instance_eval(%Q{
+        instance_eval(%{
           def #{name}(query_params=nil, _=nil, query_proxy=nil)
             eval_context = ScopeEvalContext.new(self, query_proxy || self.query_proxy)
             proc = _scope[:"#{name}"]
@@ -55,8 +54,16 @@ module Neo4j::ActiveNode
         }, __FILE__, __LINE__)
       end
 
+      # rubocop:disable Style/PredicateName
       def has_scope?(name)
-        _scope.has_key?(name.to_sym)
+        ActiveSupport::Deprecation.warn 'has_scope? is deprecated and may be removed from future releases, use scope? instead.', caller
+
+        scope?(name)
+      end
+      # rubocop:enable Style/PredicateName
+
+      def scope?(name)
+        _scope.key?(name.to_sym)
       end
 
       def _scope
@@ -88,7 +95,6 @@ module Neo4j::ActiveNode
           self.as(:n)
         end
       end
-
     end
 
     class ScopeEvalContext
@@ -98,7 +104,7 @@ module Neo4j::ActiveNode
       end
 
       Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
-        module_eval(%Q{
+        module_eval(%{
             def #{method}(params={})
               @target.all.scoping do
                 (@query_proxy || @target).#{method}(params)
@@ -135,10 +141,9 @@ module Neo4j::ActiveNode
 
       def raise_invalid_scope_type!(scope_type)
         if !VALID_SCOPE_TYPES.include?(scope_type)
-          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+          fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
         end
       end
     end
-
   end
 end

data/lib/neo4j/active_node/validations.rb

@@ -22,24 +22,24 @@ module Neo4j
 
       class UniquenessValidator < ::ActiveModel::EachValidator
         def initialize(options)
-          super(options.reverse_merge(:case_sensitive => true))
+          super(options.reverse_merge(case_sensitive: true))
         end
 
         def validate_each(record, attribute, value)
           conditions = scope_conditions(record)
 
           # TODO: Added as find(:name => nil) throws error
-          value = "" if value == nil
+          value = '' if value.nil?
 
           conditions[attribute] = options[:case_sensitive] ? value : /^#{Regexp.escape(value.to_s)}$/i
 
           found = record.class.as(:result).where(conditions)
-          found = found.where("NOT ID(result) = {record_neo_id}").params(record_neo_id: record.neo_id) if record.persisted?
-          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value)) if found.exists?
+          found = found.where('NOT ID(result) = {record_neo_id}').params(record_neo_id: record.neo_id) if record.persisted?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value)) if found.exists?
         end
 
         def message(instance)
-          super || "has already been taken"
+          super || 'has already been taken'
         end
 
         def scope_conditions(instance)
@@ -48,7 +48,6 @@ module Neo4j
           end
         end
       end
-
     end
   end
 end

data/lib/neo4j/active_rel.rb

@@ -1,5 +1,4 @@
 module Neo4j
-
   # Makes Neo4j Relationships more or less act like ActiveRecord objects.
   # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
   module ActiveRel
@@ -24,7 +23,7 @@ module Neo4j
     end
 
     def neo4j_obj
-      _persisted_obj || raise("Tried to access native neo4j object on a non persisted object")
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
     end
 
     included do

data/lib/neo4j/active_rel/callbacks.rb

@@ -6,10 +6,10 @@ module Neo4j
 
       def save(*args)
         unless self.persisted? || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
-          raise Neo4j::ActiveRel::Persistence::RelInvalidError, 'from_node and to_node must be node objects'
-        end 
+          fail Neo4j::ActiveRel::Persistence::RelInvalidError, 'from_node and to_node must be node objects'
+        end
         super(*args)
       end
     end
   end
-end
+end

data/lib/neo4j/active_rel/persistence.rb

@@ -15,7 +15,7 @@ module Neo4j::ActiveRel
     end
 
     def save!(*args)
-      raise RelInvalidError.new(self) unless save(*args)
+      fail RelInvalidError, self unless save(*args)
     end
 
     def create_model(*)
@@ -30,7 +30,6 @@ module Neo4j::ActiveRel
     end
 
     module ClassMethods
-
       # Creates a new relationship between objects
       # @param [Hash] props the properties the new relationship should have
       def create(props = {})
@@ -45,7 +44,7 @@ module Neo4j::ActiveRel
 
       # Same as #create, but raises an error if there is a problem during save.
       def create!(*args)
-        raise RelInvalidError.new(self) unless create(*args)
+        fail RelInvalidError, self unless create(*args)
       end
     end
 
@@ -55,7 +54,7 @@ module Neo4j::ActiveRel
       [from_node, to_node].each do |node|
         type = from_node == node ? :_from_class : :_to_class
         next if allows_any_class?(type)
-        raise ModelClassInvalidError, "Node class was #{node.class}, expected #{self.class.send(type)}" unless class_as_constant(type) == node.class || node.class.ancestors.include?(class_as_constant(type))
+        fail ModelClassInvalidError, "Node class was #{node.class}, expected #{self.class.send(type)}" unless class_as_constant(type) == node.class || node.class.ancestors.include?(class_as_constant(type))
       end
     end
 
@@ -92,12 +91,15 @@ module Neo4j::ActiveRel
           .where("n1.#{from_class.primary_key} = {from_node_id}")
           .where("n2.#{to_class.primary_key} = {to_node_id}")
           .params(from_node_id: from_node.id, to_node_id: to_node.id)
-          .create("(n1)-[r:`#{type}`]->(n2)")
+          .send(create_method, ("(n1)-[r:`#{type}`]->(n2)"))
           .with('r').set(r: props).return(:r).first.r
-      rescue NoMethodError
-        raise RelCreateFailedError, "Unable to create relationship. from_node: #{from_node}, to_node: #{to_node}"
+      rescue NoMethodError => e
+        raise RelCreateFailedError, "Unable to create relationship. from_node: #{from_node}, to_node: #{to_node}, error: #{e}"
       end
     end
 
+    def create_method
+      self.class.unique? ? :create_unique : :create
+    end
   end
 end