neo4j 4.0.0.rc.1 → 4.0.0.rc.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 122872ebd58702ee7d868124092285e8907cfbfd
-  data.tar.gz: 11989c0af301ccb1305df5deb26e9c55a20313f6
+  metadata.gz: 28fe8a8c4370fbe08721a8ebd9f88665439a71f2
+  data.tar.gz: 802a04febb895b8a561e4c82b9324b159c4eb68a
 SHA512:
-  metadata.gz: e9433059f7d5dd25d4bd22be97af295f98cbd1340f5bdf1c1869c01111b22d61bf8cf6e260d08de528c3cb90735984d069234fafe32556cd6b200c415b0d7243
-  data.tar.gz: c894497b7e00362c8145bdbf61bdd8b50f772f108b839ae068971bd32e888f502897ecfc03c4284bfd1f838815b75fe8dc41d3222ea61b0d1157d371a3ff325e
+  metadata.gz: 37cbe5595a4991d3f13f44411c71e2c2ec4e3587489cdaec51f639668d94e3819dae84d4fc1213573fb76bac3e6f592ca3919617ea5fa1b9be840b767bf2fd41
+  data.tar.gz: 61781492746a92e307d2bc5769ce7d0db389c06a16864c750cec5981067594fc553d0cd0330984b9fd009b76817380cf9f6cd4224334f4c8b60572472d67b241

data/CHANGELOG

@@ -1,3 +1,16 @@
+== 4.0.0.rc.3
+Released minutes after rc.2 to catch one late addition!
+* Adds serialization support for QueryProxy.
+
+== 4.0.0.rc.2
+This release builds on features introduced in the first RC. We are releasing this as another RC because the API may be tweaked before release.
+* New `proxy_as` for Core::Query to build QueryProxy chains onto Core::Query objects! 
+* Using `proxy_as`, new `optional` method in QueryProxy to use the `OPTIONAL MATCH` Cypher function.  
+* `match_to` and methods that depend on it now support arrays of nodes or IDs.
+* New `rels_to`/`all_rels_to` methods.
+* New `delete` and `destroy` methods in QueryProxy to easily remove relationships.
+* Serialized objects will include IDs by default.
+
 == 4.0.0.rc.1
 This release introduces API changes that may be considered breaking under certain conditions. See See https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v4-Introduction.
 Please use https://github.com/neo4jrb/neo4j/issues for support regarding this update! You can also reach us on Twitter: @neo4jrb (Brian) and @subvertallmedia (Chris).

data/lib/neo4j.rb

@@ -10,6 +10,7 @@ require 'neo4j/version'
 #require "active_support/time_with_zone"
 
 require "neo4j-core"
+require 'neo4j/core/query'
 require "active_model"
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'

data/lib/neo4j/active_node/has_n.rb

@@ -119,7 +119,7 @@ module HasN
 
         instance_eval(%Q{
           def #{name}(node = nil, rel = nil, proxy_obj = nil)
-            query_proxy = proxy_obj || Neo4j::ActiveNode::Query::QueryProxy.new(#{self.name}, nil, { 
+            query_proxy = proxy_obj || Neo4j::ActiveNode::Query::QueryProxy.new(#{self.name}, nil, {
                   session: self.neo4j_session, query_proxy: nil, context: '#{self.name}' + '##{name}'
                 })
             context = (query_proxy && query_proxy.context ? query_proxy.context : '#{self.name}') + '##{name}'
@@ -131,6 +131,7 @@ module HasN
                                                        node: node,
                                                        rel: rel,
                                                        context: context,
+                                                       optional: query_proxy.optional?,
                                                        caller: query_proxy.caller
                                                      })
           end}, __FILE__, __LINE__)
@@ -167,11 +168,7 @@ module HasN
             result = #{name}_query_proxy(node: node, rel: rel, context: '#{self.name}##{name}')
             association = self.class.reflect_on_association(__method__)
             query_return = association_instance_get(result.to_cypher_with_params, association)
-            if query_return.nil?
-              association_instance_set(result.to_cypher_with_params, result.first, association)
-            else
-              query_return
-            end
+            query_return || association_instance_set(result.to_cypher_with_params, result.first, association)
           end}, __FILE__, __LINE__)
 
         instance_eval(%Q{

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

@@ -9,7 +9,7 @@ module Neo4j
 
         # The most recent node to start a QueryProxy chain.
         # Will be nil when using QueryProxy chains on class methods.
-        attr_reader :caller, :association, :model
+        attr_reader :caller, :association, :model, :starting_query
 
         # QueryProxy is ActiveNode's Cypher DSL. While the name might imply that it creates queries in a general sense,
         # it is actually referring to <tt>Neo4j::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
@@ -42,13 +42,15 @@ module Neo4j
           @session = options[:session]
           @caller = options[:caller]
           @chain = []
+          @starting_query = options[:starting_query]
+          @optional = options[:optional]
           @params = options[:query_proxy] ? options[:query_proxy].instance_variable_get('@params') : {}
         end
 
         # 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.
         def identity
-          @node_var || :result
+          @node_var || _result_string
         end
         alias_method :node_identity, :identity
 
@@ -142,20 +144,18 @@ module Neo4j
         #   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)).match("#{chain_var}#{_association_arrow}(#{var}#{label_string})")
-          else
-            _query_model_as(var)
-          end
-
+                    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)|
             query.send(method, arg.respond_to?(:call) ? arg.call(var) : arg)
           end
         end
 
-
         # Scope all queries to the current scope.
         #
         #   Comment.where(post_id: 1).scoping do
@@ -182,7 +182,7 @@ module Neo4j
         # Returns a string of the cypher query with return objects and params
         # @param [Array] columns array containing symbols of identifiers used in the query
         # @return [String]
-        def to_cypher_with_params(columns = [:result])
+        def to_cypher_with_params(columns = [self.identity])
           final_query = query.return_query(columns)
           "#{final_query.to_cypher} | params: #{final_query.send(:merge_params)}"
         end
@@ -232,6 +232,10 @@ module Neo4j
           end
         end
 
+        def 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)
@@ -243,6 +247,10 @@ module Neo4j
           end
         end
 
+        def optional?
+          @optional == true
+        end
+
         attr_reader :context
         attr_reader :node_var
 
@@ -259,12 +267,23 @@ 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}
+                        label = @model.respond_to?(:mapped_label_name) ? @model.mapped_label_name : @model
+                        { var => label }
+                      else
+                        var
+                      end
+          _session.query(context: @context).send(_match_type, match_arg)
+        end
+
+        # TODO: Refactor this. Too much happening here.
+        def _result_string
+          if self.association
+            "result_#{self.association.name}".to_sym
+          elsif self.model
+            "result_#{self.model.name.tr!(':', '')}".to_sym
           else
-            var
+            :result
           end
-          _session.query(context: @context).match(match_arg)
         end
 
         def _session
@@ -276,9 +295,7 @@ module Neo4j
         end
 
         def _chain_level
-          if @options[:start_object]
-            1
-          elsif query_proxy = @options[:query_proxy]
+          if query_proxy = @options[:query_proxy]
             query_proxy._chain_level + 1
           else
             1
@@ -309,6 +326,10 @@ module Neo4j
           :"rel#{_chain_level - 1}"
         end
 
+        def _match_type
+          @optional ? :optional_match : :match
+        end
+
         attr_writer :context
 
         private

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

@@ -59,7 +59,7 @@ module Neo4j
             rescue Neo4j::Session::CypherError
               self.query.delete(target).exec
             end
-            self.caller.clear_association_cache if self.caller.respond_to?(:clear_association_cache)
+            clear_caller_cache
           end
         end
 
@@ -68,36 +68,84 @@ module Neo4j
         # When it's a node, it'll use the object's neo_id, which is fastest. When not nil, it'll figure out the
         # primary key of that model. When nil, it uses `1 = 2` to prevent matching all records, which is the default
         # behavior when nil is passed to `where` in QueryProxy.
+        # @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)
-          if node.respond_to?(:neo_id)
-            self.where(neo_id: node.neo_id)
-          elsif !node.nil?
-            id_key = self.association.nil? ? model.primary_key : self.association.target_class.primary_key
-            self.where(id_key => node)
-          else
-            # support for null object pattern
-            self.where('1 = 2')
-          end
+          where_arg = if node.respond_to?(: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 }
+                      else
+                        # support for null object pattern
+                        '1 = 2'
+                      end
+          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.
+        # @return A relationship (ActiveRel, CypherRelationship, EmbeddedRelationship) or nil.
         def first_rel_to(node)
           self.match_to(node).limit(1).pluck(rel_identity).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)
+        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
+          clear_caller_cache
+        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
+        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_id = nil)
+          target_qp = self.send(association)
+          model = target_qp.name.constantize
+          var = node_id || target_qp.identity
+          self.query.proxy_as(model, var, true)
+        end
+
         private
 
-        def query_with_target(target, &block)
-          block.yield(target || identity)
+        def clear_caller_cache
+          self.caller.clear_association_cache if self.caller.respond_to?(:clear_association_cache)
+        end
+
+        # @return [String] The primary key of a the current QueryProxy's model or target class
+        def association_id_key
+          self.association.nil? ? model.primary_key : self.association.target_class.primary_key
+        end
+
+        # @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
+        end
+
+        def query_with_target(target)
+          yield(target || identity)
         end
 
         def exists_query_start(origin, condition, target)
-          case
-          when condition.class == Fixnum
+          if condition.class == Fixnum
             self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
-          when condition.class == Hash
+          elsif condition.class == Hash
             self.where(condition.keys.first => condition.values.first)
           else
             self

data/lib/neo4j/core/query.rb

@@ -0,0 +1,19 @@
+module Neo4j::Core
+  class Query
+    # Creates a Neo4j::ActiveNode::Query::QueryProxy object that builds off of a Core::Query object.
+    #
+    # @param [Class] model An ActiveNode model to be used as the start of a new QueryuProxy chain
+    # @param [Symbol] var The variable to be used to refer to the object from within the new QueryProxy
+    # @param [Boolean] optional Indicate whether the new QueryProxy will use MATCH or OPTIONAL MATCH.
+    # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object.
+    def proxy_as(model, var, optional = false)
+      # TODO: Discuss whether it's necessary to call `break` on the query or if this should be left to the user.
+      Neo4j::ActiveNode::Query::QueryProxy.new(model, nil, { starting_query: self.break, node: var, optional: optional })
+    end
+
+    # Calls proxy_as with `optional` set true. This doesn't offer anything different from calling `proxy_as` directly but it may be more readable.
+    def proxy_as_optional(model, var)
+      proxy_as(model, var, true)
+    end
+  end
+end

data/lib/neo4j/shared/serialized_properties.rb

@@ -11,6 +11,10 @@ module Neo4j::Shared
       self.class.serialized_properties
     end
 
+    def serializable_hash(*args)
+      super.merge(id: id)
+    end
+
     module ClassMethods
       def serialized_properties
         @serialize || {}

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "4.0.0.rc.1"
+  VERSION = "4.0.0.rc.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 4.0.0.rc.1
+  version: 4.0.0.rc.3
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2014-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -143,6 +143,7 @@ files:
 - lib/neo4j/active_rel/types.rb
 - lib/neo4j/active_rel/validations.rb
 - lib/neo4j/config.rb
+- lib/neo4j/core/query.rb
 - lib/neo4j/migration.rb
 - lib/neo4j/paginated.rb
 - lib/neo4j/railtie.rb