neo4j 4.1.5 → 5.0.0.rc.1

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

@@ -9,13 +9,12 @@ module Neo4j
         # 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
+        def each(node = true, rel = nil, &block)
+          pluck_vars = []
+          pluck_vars << identity if node
+          pluck_vars << @rel_var if rel
+
+          pluck(*pluck_vars).each(&block)
         end
 
         # When called at the end of a QueryProxy chain, it will return the resultant relationship objects intead of nodes.
@@ -41,25 +40,16 @@ module Neo4j
 
         # 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?
+          transformable_attributes = (model ? model.attribute_names : []) + %w(uuid neo_id)
+          arg_list = args.map do |arg|
+            if transformable_attributes.include?(arg.to_s)
+              {identity => arg}
+            else
+              arg
+            end
           end
-          association_collection
+
+          self.query.pluck(*arg_list)
         end
       end
     end

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

@@ -0,0 +1,89 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      class QueryProxy
+        class Link
+          attr_reader :clause
+
+          def initialize(clause, arg, args = [])
+            @clause = clause
+            @arg = arg
+            @args = args
+          end
+
+          def args(var, rel_var)
+            @arg.respond_to?(:call) ? @arg.call(var, rel_var) : [@arg, @args].flatten
+          end
+
+          class << self
+            def for_clause(clause, arg, model, *args)
+              method_to_call = "for_#{clause}_clause"
+
+              send(method_to_call, arg, model, *args)
+            end
+
+            def for_where_clause(arg, model, *args)
+              node_num = 1
+              result = []
+              if arg.is_a?(Hash)
+                arg.each do |key, value|
+                  if model && model.association?(key)
+                    result += for_association(key, value, "n#{node_num}", model)
+
+                    node_num += 1
+                  else
+                    result << new(:where, ->(v, _) { {v => {key => value}} })
+                  end
+                end
+              elsif arg.is_a?(String)
+                result << new(:where, arg, args)
+              end
+              result
+            end
+            alias_method :for_node_where_clause, :for_where_clause
+
+            def for_association(name, value, n_string, model)
+              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 ? '-->' : '<--'
+              [
+                new(:match, ->(v, _) { "#{v}#{arrow}(#{n_string})" }),
+                new(: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 for_rel_where_clause(arg, _)
+              arg.each_with_object([]) do |(key, value), result|
+                result << new(:where, ->(_, rel_var) { {rel_var => {key => value}} })
+              end
+            end
+
+            def for_order_clause(arg, _)
+              [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => arg} })]
+            end
+
+            def for_args(model, clause, args)
+              if clause == :where && args[0].is_a?(String) # Better way?
+                [for_arg(model, :where, args[0], *args[1..-1])]
+              else
+                args.map { |arg| for_arg(model, clause, arg) }
+              end
+            end
+
+            def for_arg(model, clause, arg, *args)
+              default = [Link.new(clause, arg, *args)]
+
+              Link.for_clause(clause, arg, model, *args) || default
+            rescue NoMethodError
+              default
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,31 +3,56 @@ module Neo4j
     module Query
       module QueryProxyMethods
         class InvalidParameterError < StandardError; end
+        FIRST = 'HEAD'
+        LAST = 'LAST'
 
         def first(target = nil)
-          query_with_target(target) { |var| first_and_last("ID(#{var})", var) }
+          first_and_last(FIRST, target)
         end
 
         def last(target = nil)
-          query_with_target(target) { |var| first_and_last("ID(#{var}) DESC", var) }
+          first_and_last(LAST, target)
+        end
+
+        def first_and_last(func, target)
+          new_query, pluck_proc = if self.query.clause?(:order)
+                                    new_query = self.query.with(identity)
+                                    pluck_proc = proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }
+                                    [new_query, pluck_proc]
+                                  else
+                                    new_query = self.order(order).limit(1)
+                                    pluck_proc = proc { |var| var }
+                                    [new_query, pluck_proc]
+                                  end
+          result = query_with_target(target) do |var|
+            final_pluck = pluck_proc.call(var)
+            new_query.pluck(final_pluck)
+          end
+          result.first
         end
 
-        def first_and_last(order, target)
-          self.order(order).limit(1).pluck(target).first
-        end
+        private :first_and_last
 
         # @return [Integer] number of nodes of this class
         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
+            limited_query = self.query.clause?(:limit) ? self.query.with(var) : self.query.reorder
+            limited_query.pluck("count(#{q}) AS #{var}").first
           end
         end
 
         alias_method :size,   :count
         alias_method :length, :count
 
+        # TODO: update this with public API methods if/when they are exposed
+        def limit_value
+          return unless self.query.clause?(:limit)
+          limit_clause = self.query.send(:clauses).select { |clause| clause.is_a?(Neo4j::Core::QueryClauses::LimitClause) }.first
+          limit_clause.instance_variable_get(:@arg)
+        end
+
         def empty?(target = nil)
           query_with_target(target) { |var| !self.exists?(nil, var) }
         end
@@ -59,7 +84,7 @@ module Neo4j
             rescue Neo4j::Session::CypherError
               self.query.delete(target).exec
             end
-            clear_caller_cache
+            clear_source_object_cache
           end
         end
 
@@ -71,12 +96,11 @@ module Neo4j
         # @param [#neo_id, String, Enumerable] node A node, a string representing a node's ID, or an enumerable of nodes or IDs.
         # @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}
+          first_node = node.is_a?(Array) ? node.first : node
+          where_arg = if first_node.respond_to?(:neo_id)
+                        {neo_id: node.is_a?(Array) ? node.map(&:neo_id) : node}
                       elsif !node.nil?
-                        id_key = association_id_key
-                        node = ids_array(node) if node.is_a?(Array)
-                        {id_key => node}
+                        {association_id_key => node.is_a?(Array) ? ids_array(node) : node}
                       else
                         # support for null object pattern
                         '1 = 2'
@@ -84,6 +108,7 @@ module Neo4j
           self.where(where_arg)
         end
 
+
         # Gives you the first relationship between the last link of a QueryProxy chain and a given node
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id} RETURN r`
         # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
@@ -103,25 +128,53 @@ module Neo4j
         # 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_var).exec
-          clear_caller_cache
+          clear_source_object_cache
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain.  Executed in the database, callbacks will not be run.
+        def delete_all_rels
+          self.query.delete(rel_var).exec
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain and replaces them with relationships to the given nodes.
+        # Executed in the database, callbacks will not be run.
+        def replace_with(node_or_nodes)
+          nodes = Array(node_or_nodes)
+
+          self.delete_all_rels
+          nodes.each { |node| self << node }
         end
 
         # Returns all relationships between a node and its last link in the QueryProxy chain, destroys them in Ruby. Callbacks will be run.
         def destroy(node)
           self.rels_to(node).map!(&:destroy)
-          clear_caller_cache
+          clear_source_object_cache
         end
 
         # A shortcut for attaching a new, optional match to the end of a QueryProxy chain.
-        # TODO: It's silly that we have to call constantize here. There should be a better way of finding the target class of the destination.
         def optional(association, node_var = nil, rel_var = nil)
-          self.send(association, node_var, rel_var, nil, optional: true)
+          self.send(association, node_var, rel_var, optional: true)
+        end
+
+        # Takes an Array of ActiveNode models and applies the appropriate WHERE clause
+        # So for a `Teacher` model inheriting from a `Person` model and an `Article` model
+        # if you called .as_models([Teacher, Article])
+        # The where clause would look something like:
+        #   WHERE (node_var:Teacher:Person OR node_var:Article)
+        def as_models(models)
+          where_clause = models.map do |model|
+            "`#{identity}`:" + model.mapped_label_names.map do |mapped_label_name|
+              "`#{mapped_label_name}`"
+            end.join(':')
+          end.join(' OR ')
+
+          where("(#{where_clause})")
         end
 
         private
 
-        def clear_caller_cache
-          self.caller.clear_association_cache if self.caller.respond_to?(:clear_association_cache)
+        def clear_source_object_cache
+          self.source_object.clear_association_cache if self.source_object.respond_to?(:clear_association_cache)
         end
 
         # @return [String] The primary key of a the current QueryProxy's model or target class
@@ -132,7 +185,7 @@ module Neo4j
         # @param [Enumerable] node An enumerable of nodes or ids.
         # @return [Array] An array after having `id` called on each object
         def ids_array(node)
-          node.first.respond_to?(:id) ? node.map!(&:id) : node
+          node.first.respond_to?(:id) ? node.map(&:id) : node
         end
 
         def query_with_target(target)

data/lib/neo4j/active_node/query_methods.rb

@@ -4,7 +4,9 @@ module Neo4j
       class InvalidParameterError < StandardError; end
 
       def exists?(node_condition = nil)
-        fail(InvalidParameterError, ':exists? only accepts ids or conditions') unless node_condition.is_a?(Integer) || node_condition.is_a?(Hash) || node_condition.nil?
+        unless node_condition.is_a?(Integer) || node_condition.is_a?(Hash) || node_condition.nil?
+          fail(InvalidParameterError, ':exists? only accepts ids or conditions')
+        end
         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

data/lib/neo4j/active_node/scope.rb

@@ -12,7 +12,7 @@ module Neo4j::ActiveNode
       #     include Neo4j::ActiveNode
       #     property :name
       #     property :score
-      #     has_many :out, :friends, model_class: self
+      #     has_many :out, :friends, type: :has_friend, model_class: self
       #     scope :top_students, -> { where(score: 42)}") }
       #   end
       #   Person.top_students.to_a
@@ -28,7 +28,7 @@ module Neo4j::ActiveNode
       #     include Neo4j::ActiveNode
       #     property :name
       #     property :score
-      #     has_many :out, :friends, model_class: self
+      #     has_many :out, :friends, type: :has_friend, model_class: self
       #     scope :great_students, ->(identifier) { where("#{identifier}.score > 41") }
       #   end
       #   Person.as(:all_people).great_students(:all_people).to_a
@@ -37,21 +37,18 @@ module Neo4j::ActiveNode
       def scope(name, proc)
         _scope[name.to_sym] = proc
 
-        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}"]
-            self.class._call_scope_context(eval_context, query_params, proc)
-          end
-        }, __FILE__, __LINE__)
+        define_method(name) do |query_params = nil, some_var = nil|
+          self.class.send(name, query_params, some_var, current_scope)
+        end
 
-        instance_eval(%{
-          def #{name}(query_params=nil, _=nil, query_proxy=nil)
-            eval_context = ScopeEvalContext.new(self, query_proxy || self.query_proxy)
-            proc = _scope[:"#{name}"]
+        klass = class << self; self; end
+        klass.instance_eval do
+          define_method(name) do |query_params = nil, _ = nil|
+            eval_context = ScopeEvalContext.new(self, current_scope || self.query_proxy)
+            proc = _scope[name.to_sym]
             _call_scope_context(eval_context, query_params, proc)
           end
-        }, __FILE__, __LINE__)
+        end
       end
 
       # rubocop:disable Style/PredicateName
@@ -87,12 +84,11 @@ module Neo4j::ActiveNode
         ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
       end
 
-
-      def all
+      def all(var = :n)
         if current_scope
-          current_scope.clone
+          current_scope.new_link(var)
         else
-          self.as(:n)
+          self.as(var)
         end
       end
     end
@@ -140,9 +136,9 @@ module Neo4j::ActiveNode
       private
 
       def raise_invalid_scope_type!(scope_type)
-        if !VALID_SCOPE_TYPES.include?(scope_type)
-          fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
-        end
+        return if VALID_SCOPE_TYPES.include?(scope_type)
+
+        fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
       end
     end
   end

data/lib/neo4j/active_node/validations.rb

@@ -26,6 +26,12 @@ module Neo4j
         end
 
         def validate_each(record, attribute, value)
+          return unless found(record, attribute, value).exists?
+
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value))
+        end
+
+        def found(record, attribute, value)
           conditions = scope_conditions(record)
 
           # TODO: Added as find(:name => nil) throws error
@@ -34,8 +40,8 @@ module Neo4j
           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('ID(result) <> {record_neo_id}').params(record_neo_id: record.neo_id) if record.persisted?
+          found
         end
 
         def message(instance)

data/lib/neo4j/active_rel/initialize.rb

@@ -1,7 +1,6 @@
 module Neo4j::ActiveRel
   module Initialize
     extend ActiveSupport::Concern
-    include Neo4j::Shared::TypeConverters
 
     attr_reader :_persisted_obj
 
@@ -17,7 +16,7 @@ module Neo4j::ActiveRel
       @attributes = attributes.merge(persisted_rel.props.stringify_keys)
       load_nodes(from_node_id, to_node_id)
       self.default_properties = persisted_rel.props
-      @attributes = convert_properties_to :ruby, @attributes
+      @attributes = self.class.declared_property_manager.convert_properties_to(self, :ruby, @attributes)
     end
 
     # Implements the Neo4j::Node#wrapper and Neo4j::Relationship#wrapper method

data/lib/neo4j/active_rel/persistence.rb

@@ -7,7 +7,10 @@ module Neo4j::ActiveRel
     class ModelClassInvalidError < RuntimeError; end
     class RelCreateFailedError < RuntimeError; end
 
-    def clear_association_cache; end
+    # Should probably find a way to not need this
+    def association_proxy_cache
+      {}
+    end
 
     def save(*)
       update_magic_properties
@@ -19,10 +22,10 @@ module Neo4j::ActiveRel
     end
 
     def create_model(*)
-      confirm_node_classes
+      validate_node_classes!
       create_magic_properties
       set_timestamps
-      properties = convert_properties_to :db, props
+      properties = self.class.declared_property_manager.convert_properties_to(self, :db, props)
       rel = _create_rel(from_node, to_node, properties)
       return self unless rel.respond_to?(:_persisted_obj)
       init_on_load(rel._persisted_obj, from_node, to_node, @rel_type)
@@ -50,11 +53,14 @@ module Neo4j::ActiveRel
 
     private
 
-    def confirm_node_classes
+    def validate_node_classes!
       [from_node, to_node].each do |node|
         type = from_node == node ? :_from_class : :_to_class
-        next if allows_any_class?(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))
+        type_class = self.class.send(type)
+
+        next if [:any, false].include?(type_class)
+
+        fail ModelClassInvalidError, "Node class was #{node.class}, expected #{type_class}" unless node.is_a?(type_class.to_s.constantize)
       end
     end
 
@@ -62,40 +68,22 @@ module Neo4j::ActiveRel
       props = self.class.default_property_values(self)
       props.merge!(args[0]) if args[0].is_a?(Hash)
       set_classname(props, true)
-      _rel_creation_query(from_node, to_node, props)
-    end
 
-    def class_as_constant(type)
-      given_class = self.class.send(type)
-      case given_class
-      when String
-        given_class.constantize
-      when Symbol
-        given_class.to_s.constantize
-      else
-        given_class
+      if from_node.id.nil? || to_node.id.nil?
+        fail RelCreateFailedError, "Unable to create relationship (id is nil). from_node: #{from_node}, to_node: #{to_node}"
       end
-    end
-
-    def allows_any_class?(type)
-      self.class.send(type) == :any || self.class.send(type) == false
+      _rel_creation_query(from_node, to_node, props)
     end
 
     private
 
+    N1_N2_STRING = 'n1, n2'
+    ACTIVEREL_NODE_MATCH_STRING = 'ID(n1) = {n1_neo_id} AND ID(n2) = {n2_neo_id}'
     def _rel_creation_query(from_node, to_node, props)
-      from_class = from_node.class
-      to_class = to_node.class
-      begin
-        Neo4j::Session.query.match(n1: from_class.mapped_label_name, n2: to_class.mapped_label_name)
-          .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)
-          .send(create_method, ("(n1)-[r:`#{type}`]->(n2)"))
-          .with('r').set(r: props).return(:r).first.r
-      rescue NoMethodError => e
-        raise RelCreateFailedError, "Unable to create relationship. from_node: #{from_node}, to_node: #{to_node}, error: #{e}"
-      end
+      Neo4j::Session.query.match(N1_N2_STRING)
+        .where(ACTIVEREL_NODE_MATCH_STRING).params(n1_neo_id: from_node.neo_id, n2_neo_id: to_node.neo_id).break
+        .send(create_method, "n1-[r:`#{type}`]->n2")
+        .with('r').set(r: props).pluck(:r).first
     end
 
     def create_method