neo4j 4.0.0 → 4.1.0

data/lib/neo4j/active_node/orm_adapter.rb

@@ -22,7 +22,7 @@ module Neo4j
       # Get an instance by id of the model
       def get!(id)
         klass.find(wrap_key(id)).tap do |node|
-          raise "No record found" if node.nil?
+          fail 'No record found' if node.nil?
         end
       end
 
@@ -68,7 +68,7 @@ module Neo4j
       private
 
       def hasherize_order(order)
-        (order || []).map {|clause| Hash[*clause] }
+        (order || []).map { |clause| Hash[*clause] }
       end
 
       def extract_id!(conditions)
@@ -76,8 +76,6 @@ module Neo4j
           conditions[klass.id_property_name.to_sym] = id
         end
       end
-
     end
   end
 end
-

data/lib/neo4j/active_node/persistence.rb

@@ -1,12 +1,11 @@
 module Neo4j::ActiveNode
   module Persistence
-
     class RecordInvalidError < RuntimeError
       attr_reader :record
 
       def initialize(record)
         @record = record
-        super(@record.errors.full_messages.join(", "))
+        super(@record.errors.full_messages.join(', '))
       end
     end
 
@@ -18,7 +17,7 @@ module Neo4j::ActiveNode
     # If the model is new a record gets created in the database, otherwise the existing record gets updated.
     # If perform_validation is true validations run.
     # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
-    # There’s a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
+    # There's a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
     def save(*)
       update_magic_properties
       clear_association_cache
@@ -36,9 +35,7 @@ module Neo4j::ActiveNode
     # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
     # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
     def save!(*args)
-      unless save(*args)
-        raise RecordInvalidError.new(self)
-      end
+      fail RecordInvalidError, self unless save(*args)
     end
 
     # Creates a model with values matching those of the instance attributes and returns its id.
@@ -70,7 +67,7 @@ module Neo4j::ActiveNode
     module ClassMethods
       # Creates and saves a new node
       # @param [Hash] props the properties the new node should have
-      def create(props = {}, &block)
+      def create(props = {})
         association_props = extract_association_attributes!(props)
 
         new(props).tap do |obj|
@@ -83,7 +80,7 @@ module Neo4j::ActiveNode
       end
 
       # Same as #create, but raises an error if there is a problem during save.
-      def create!(*args, &block)
+      def create!(*args)
         props = args[0] || {}
         association_props = extract_association_attributes!(props)
 
@@ -109,10 +106,8 @@ module Neo4j::ActiveNode
       def load_entity(id)
         Neo4j::Node.load(id)
       end
-
     end
 
     private
-
   end
 end

data/lib/neo4j/active_node/property.rb

@@ -3,19 +3,18 @@ module Neo4j::ActiveNode
     extend ActiveSupport::Concern
     include Neo4j::Shared::Property
 
-    def initialize(attributes={}, options={})
+    def initialize(attributes = {}, options = {})
       super(attributes, options)
 
-      send_props(@relationship_props) if persisted? and not @relationship_props.nil?
+      send_props(@relationship_props) if persisted? && !@relationship_props.nil?
     end
 
     module ClassMethods
-
       # Extracts keys from attributes hash which are relationships of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
         attributes.keys.each_with_object({}) do |key, association_props|
-          association_props[key] = attributes.delete(key) if self.has_association?(key)
+          association_props[key] = attributes.delete(key) if self.association?(key)
         end
       end
     end

data/lib/neo4j/active_node/query.rb

@@ -1,6 +1,5 @@
 module Neo4j
   module ActiveNode
-
     # Helper methods to return Neo4j::Core::Query objects.  A query object can be used to successively build a cypher query
     #
     #    person.query_as(:n).match('n-[:friend]-o').return(o: :name) # Return the names of all the person's friends
@@ -12,12 +11,25 @@ module Neo4j
       #
       # @example Return the names of all of Mike's friends
       #   # Generates: MATCH (mike:Person), mike-[:friend]-friend WHERE ID(mike) = 123 RETURN friend.name
-      #   mike.query_as(:mike).match('mike-[:friend]-friend').return(friend: :name) 
+      #   mike.query_as(:mike).match('mike-[:friend]-friend').return(friend: :name)
       #
       # @param var [Symbol, String] The variable name to specify in the query
       # @return [Neo4j::Core::Query]
-      def query_as(var)
-        self.class.query_as(var).where("ID(#{var})" => self.neo_id)
+      def query_as(node_var)
+        self.class.query_as(node_var).where("ID(#{node_var})" => self.neo_id)
+      end
+
+      # Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy caller set to the node instance.
+      # This method does not exist within QueryProxy and can only be used to start a new chain.
+      #
+      # @example Start a new QueryProxy chain with the first identifier set manually
+      #   # Generates: MATCH (s:`Student`), (l:`Lesson`), s-[rel1:`ENROLLED_IN`]->(l:`Lesson`) WHERE ID(s) = {neo_id_17963}
+      #   student.as(:s).lessons(:l)
+      #
+      # @param [String, Symbol] node_var The identifier to use within the QueryProxy object
+      # @return [Neo4j::ActiveNode::Query::QueryProxy]
+      def as(node_var)
+        self.class.query_proxy(node: node_var, caller: self).match_to(self)
       end
 
       module ClassMethods
@@ -34,7 +46,7 @@ module Neo4j
         end
 
         Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
-          module_eval(%Q{
+          module_eval(%{
             def #{method}(*args)
               self.query_proxy.#{method}(*args)
             end}, __FILE__, __LINE__)
@@ -44,10 +56,19 @@ module Neo4j
           Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
         end
 
+        # Start a new QueryProxy with the starting identifier set to the given argument.
+        # This method does not exist within QueryProxy, it can only be called at the class level to create a new QP object.
+        # To set an identifier within a QueryProxy chain, give it as the first argument to a chained association.
+        #
+        # @example Start a new QueryProxy where the first identifier is set manually.
+        #   # Generates: MATCH (s:`Student`), (result_lessons:`Lesson`), s-[rel1:`ENROLLED_IN`]->(result_lessons:`Lesson`)
+        #   Student.as(:s).lessons
+        #
+        # @param [String, Symbol] node_var A string or symbol to use as the starting identifier.
+        # @return [Neo4j::ActiveNode::Query::QueryProxy]
         def as(node_var)
           query_proxy(node: node_var)
         end
-
       end
     end
   end

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

@@ -2,10 +2,10 @@ module Neo4j
   module ActiveNode
     module Query
       class QueryProxy
-
-        include Enumerable
+        include Neo4j::ActiveNode::Query::QueryProxyEnumerable
         include Neo4j::ActiveNode::Query::QueryProxyMethods
         include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
+        include Neo4j::ActiveNode::Dependent::QueryProxyMethods
 
         # The most recent node to start a QueryProxy chain.
         # Will be nil when using QueryProxy chains on class methods.
@@ -49,82 +49,18 @@ module Neo4j
 
         # The current node identifier on deck, so to speak. It is the object that will be returned by calling `each` and the last node link
         # in the QueryProxy chain.
+        attr_reader :node_var
         def identity
           @node_var || _result_string
         end
         alias_method :node_identity, :identity
 
         # The relationship identifier most recently used by the QueryProxy chain.
+        attr_reader :rel_var
         def rel_identity
-          @rel_var
-        end
-
-        # 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
-
-        # 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 { |obj, rel| yield obj, rel }
-          else
-            pluck_this = !rel ? identity : @rel_var
-            enumerable_query(pluck_this).each { |obj| yield obj }
-          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
+          ActiveSupport::Deprecation.warn 'rel_identity is deprecated and may be removed from future releases, use rel_var instead.', caller
 
-        # 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 ==(value)
-          self.to_a == value
-        end
-
-        METHODS = %w[where rel_where order skip limit]
-
-        METHODS.each do |method|
-          module_eval(%Q{
-            def #{method}(*args)
-              build_deeper_query_proxy(:#{method}, args)
-            end}, __FILE__, __LINE__)
-        end
-        # Since there is a rel_where method, it seems only natural for there to be node_where
-        alias_method :node_where, :where
-        alias_method :offset, :skip
-        alias_method :order_by, :order
-
-        # For getting variables which have been defined as part of the association chain
-        def pluck(*args)
-          self.query.pluck(*args)
+          @rel_var
         end
 
         def params(params)
@@ -143,15 +79,15 @@ module Neo4j
         # @param [String,Symbol] var The identifier to use for node at this link of the QueryProxy chain.
         #   student.lessons.query_as(:l).with('your cypher here...')
         def query_as(var)
-          query = if @association
-                    chain_var = _association_chain_var
-                    label_string = @model && ":`#{@model.mapped_label_name}`"
-                    (_association_query_start(chain_var) & _query_model_as(var)).send(_match_type, "#{chain_var}#{_association_arrow}(#{var}#{label_string})")
-                  else
-                    starting_query ? (starting_query & _query_model_as(var)) : _query_model_as(var)
-                  end
+          base_query = if @association
+                         chain_var = _association_chain_var
+                         label_string = @model && ":`#{@model.mapped_label_name}`"
+                         (_association_query_start(chain_var) & _query_model_as(var)).send(_match_type, "#{chain_var}#{_association_arrow}(#{var}#{label_string})")
+                       else
+                         starting_query ? (starting_query & _query_model_as(var)) : _query_model_as(var)
+                       end
           # Build a query chain via the chain, return the result
-          @chain.inject(query.params(@params)) do |query, (method, arg)|
+          @chain.inject(base_query.params(@params)) do |query, (method, arg)|
             query.send(method, arg.respond_to?(:call) ? arg.call(var) : arg)
           end
         end
@@ -172,7 +108,18 @@ module Neo4j
           @model.current_scope = previous
         end
 
+        METHODS = %w(where rel_where order skip limit)
 
+        METHODS.each do |method|
+          module_eval(%{
+            def #{method}(*args)
+              build_deeper_query_proxy(:#{method}, args)
+            end}, __FILE__, __LINE__)
+        end
+        # Since there is a rel_where method, it seems only natural for there to be node_where
+        alias_method :node_where, :where
+        alias_method :offset, :skip
+        alias_method :order_by, :order
 
         # Cypher string for the QueryProxy's query. This will not include params. For the full output, see <tt>to_cypher_with_params</tt>.
         def to_cypher
@@ -201,7 +148,7 @@ module Neo4j
         end
 
         def create(other_nodes, properties)
-          raise "Can only create associations on associations" unless @association
+          fail 'Can only create associations on associations' unless @association
           other_nodes = [other_nodes].flatten
           properties = @association.inject_classname(properties)
           other_nodes = other_nodes.map do |other_node|
@@ -213,34 +160,34 @@ module Neo4j
             end
           end.compact
 
-          raise ArgumentError, "Node must be of the association's class when model is specified" if @model && other_nodes.any? {|other_node| !other_node.is_a?(@model) }
+          fail ArgumentError, "Node must be of the association's class when model is specified" if @model && other_nodes.any? { |other_node| !other_node.is_a?(@model) }
           other_nodes.each do |other_node|
-            #Neo4j::Transaction.run do
-              other_node.save if not other_node.persisted?
+            # Neo4j::Transaction.run do
+            other_node.save unless other_node.neo_id
 
-              return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
+            return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
 
-              start_object = @options[:start_object]
-              start_object.clear_association_cache
-              _session.query(context: @options[:context])
-                .match("(start#{match_string(start_object)}), (end#{match_string(other_node)})").where("ID(start) = {start_id} AND ID(end) = {end_id}")
-                .params(start_id: start_object.neo_id, end_id: other_node.neo_id)
-                .create("start#{_association_arrow(properties, true)}end").exec
+            start_object = @options[:start_object]
+            start_object.clear_association_cache
+            _session.query(context: @options[:context])
+              .match("(start#{match_string(start_object)}), (end#{match_string(other_node)})").where('ID(start) = {start_id} AND ID(end) = {end_id}')
+              .params(start_id: start_object.neo_id, end_id: other_node.neo_id)
+              .send(create_method, "start#{_association_arrow(properties, true)}end").exec
 
-              @association.perform_callback(@options[:start_object], other_node, :after)
-            #end
+            @association.perform_callback(@options[:start_object], other_node, :after)
+            # end
           end
         end
 
         def read_attribute_for_serialization(*args)
-          to_a.map {|o| o.read_attribute_for_serialization(*args) }
+          to_a.map { |o| o.read_attribute_for_serialization(*args) }
         end
 
         # QueryProxy objects act as a representation of a model at the class level so we pass through calls
         # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
         def method_missing(method_name, *args, &block)
           if @model && @model.respond_to?(method_name)
-            args[2] = self if @model.has_association?(method_name) || @model.has_scope?(method_name)
+            args[2] = self if @model.association?(method_name) || @model.scope?(method_name)
             scoping { @model.public_send(method_name, *args, &block) }
           else
             super
@@ -252,9 +199,9 @@ module Neo4j
         end
 
         attr_reader :context
-        attr_reader :node_var
 
         protected
+
         # Methods are underscored to prevent conflict with user class methods
 
         def _add_params(params)
@@ -268,7 +215,7 @@ module Neo4j
         def _query_model_as(var)
           match_arg = if @model
                         label = @model.respond_to?(:mapped_label_name) ? @model.mapped_label_name : @model
-                        { var => label }
+                        {var => label}
                       else
                         var
                       end
@@ -310,7 +257,7 @@ module Neo4j
           elsif query_proxy = @options[:query_proxy]
             query_proxy.node_var || :"node#{_chain_level}"
           else
-            raise "Crazy error" # TODO: Better error
+            fail 'Crazy error' # TODO: Better error
           end
         end
 
@@ -320,7 +267,7 @@ module Neo4j
           elsif query_proxy = @options[:query_proxy]
             query_proxy.query_as(var)
           else
-            raise "Crazy error" # TODO: Better error
+            fail 'Crazy error' # TODO: Better error
           end
         end
 
@@ -336,6 +283,10 @@ module Neo4j
 
         private
 
+        def create_method
+          association.unique? ? :create_unique : :create
+        end
+
         def build_deeper_query_proxy(method, args)
           self.dup.tap do |new_query|
             args.each do |arg|
@@ -359,20 +310,12 @@ module Neo4j
           result = []
           if arg.is_a?(Hash)
             arg.each do |key, value|
-              if @model && @model.has_association?(key)
-
-                neo_id = value.try(:neo_id) || value
-                raise ArgumentError, "Invalid value for '#{key}' condition" if not neo_id.is_a?(Integer)
+              if @model && @model.association?(key)
+                result += links_for_association(key, value, "n#{node_num}")
 
-                n_string = "n#{node_num}"
-                dir = @model.associations[key].direction
-
-                arrow = dir == :out ? '-->' : '<--'
-                result << [:match, ->(v) { "#{v}#{arrow}(#{n_string})" }]
-                result << [:where, ->(v) { {"ID(#{n_string})" => neo_id.to_i} }]
                 node_num += 1
               else
-                result << [:where, ->(v) { {v => {key => value}}}]
+                result << [:where, ->(v) { {v => {key => value}} }]
               end
             end
           elsif arg.is_a?(String)
@@ -382,10 +325,23 @@ module Neo4j
         end
         alias_method :links_for_node_where_arg, :links_for_where_arg
 
+        def links_for_association(name, value, n_string)
+          neo_id = value.try(:neo_id) || value
+          fail ArgumentError, "Invalid value for '#{name}' condition" if not neo_id.is_a?(Integer)
+
+          dir = @model.associations[name].direction
+
+          arrow = dir == :out ? '-->' : '<--'
+          [
+            [:match, ->(v) { "#{v}#{arrow}(#{n_string})" }],
+            [:where, ->(_) { {"ID(#{n_string})" => neo_id.to_i} }]
+          ]
+        end
+
         # We don't accept strings here. If you want to use a string, just use where.
         def links_for_rel_where_arg(arg)
           arg.each_with_object([]) do |(key, value), result|
-            result << [:where, ->(v) {{ rel_identity => { key => value }}}]
+            result << [:where, ->(_) { {rel_var => {key => value}} }]
           end
         end
 
@@ -400,4 +356,3 @@ module Neo4j
     end
   end
 end
-