neo4j 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d902cb2867667c62e30b5a4c0ca2aa5341b06cc
-  data.tar.gz: 95ce7ebf16a229a510ab76aeb1e40b69275e1dc3
+  metadata.gz: bf2546cbe829d338babc703fcecdeff5650e8fd5
+  data.tar.gz: 094b2019bb62cb8e9f5e510eb54cf00f51c6131f
 SHA512:
-  metadata.gz: 265e6724e37c3a89d7af59dcc2484915cd0d39b60e1cf642bd22ed1f0a6d997aa09163186148e78803f7cec552be2c07f0ce9eb503f572208c116313da6db764
-  data.tar.gz: c84429373e502d634d4b29c6a0ab864af15e4def869260693bfba8789c4a610c2406f2dd611d6d84317ca2a55199c267d642342f1610966d5a210a351ae873eb
+  metadata.gz: b7552de25d876bd2b98038637c517ae77c47c04ae5d3fbd0a14852710998a3549d1ce981a9c35eea94e84cf1dcc04f469497ae7c7eb9be45a76b77f813900bd8
+  data.tar.gz: ba45f543a6cbce758ccfba472789cfb41ba78ce8ee6fe70db8e187371a1a638e83c86a6dae316a4ff786046a61b2ab3a984001993d4150b30e9eee57c4b89fcd

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 gemspec
 
-gem 'neo4j-core', github: 'neo4jrb/neo4j-core' if ENV["TRAVIS"]
+#gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
 #gem 'neo4j-core', git: 'https://github.com/neo4jrb/neo4j-core'
 #gem 'orm_adapter', :path => '../orm_adapter'
 

data/lib/neo4j/active_node/id_property.rb

@@ -27,25 +27,21 @@ module Neo4j::ActiveNode
 
     module TypeMethods
       def define_id_methods(clazz, name, conf)
-        validate_conf(conf)
+        raise "Expected a Hash, got #{conf.class} (#{conf.to_s}) for id_property" unless conf.is_a?(Hash)
         if conf[:on]
           define_custom_method(clazz, name, conf[:on])
         elsif conf[:auto]
           raise "only :uuid auto id_property allowed, got #{conf[:auto]}" unless conf[:auto] == :uuid
           define_uuid_method(clazz, name)
-        else conf.empty?
+        elsif conf.empty?
           define_property_method(clazz, name)
+        else
+          raise "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
         end
       end
 
       private
 
-      def validate_conf(conf)
-        return if conf.empty?
-        raise "Expected a Hash, got #{conf.class} (#{conf.to_s}) for id_property" unless conf.is_a?(Hash)
-        raise "Illegal value #{conf.inspect} for id_property, expected :on or :auto" unless conf.include?(:auto) || conf.include?(:on)
-      end
-
       def define_property_method(clazz, name)
         clear_methods(clazz, name)
 

data/lib/neo4j/active_node/node_wrapper.rb

@@ -1,4 +1,5 @@
 class Neo4j::Node
+  # The wrapping process is what transforms a raw CypherNode or EmbeddedNode from Neo4j::Core into a healthy ActiveNode (or ActiveRel) object.
   module Wrapper
 
     # this is a plugin in the neo4j-core so that the Ruby wrapper will be wrapped around the Neo4j::Node objects
@@ -23,6 +24,7 @@ class Neo4j::Node
       end
     end
 
+    # Makes the determination of whether to use <tt>_classname</tt> (or whatever is defined by config) or the node's labels.
     def sorted_wrapper_classes
       if self.props.is_a?(Hash) && self.props.has_key?(Neo4j::Config.class_name_property)
         self.props[Neo4j::Config.class_name_property].constantize

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

@@ -11,6 +11,27 @@ module Neo4j
         # Will be nil when using QueryProxy chains on class methods.
         attr_reader :caller
 
+        # 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.
+        # QueryProxy provides ActiveRecord-like methods for common patterns. When it's not handling CRUD for relationships and queries, it
+        # provides ActiveNode's association chaining (`student.lessons.teachers.where(age: 30).hobbies`) and enjoys long walks on the
+        # beach.
+        #
+        # It should not ever be necessary to instantiate a new QueryProxy object directly, it always happens as a result of
+        # calling a method that makes use of it.
+        #
+        # @param [Constant] model The class which included ActiveNode (typically a model, hence the name) from which the query
+        # originated.
+        # @param [Neo4j::ActiveNode::HasN::Association] association The ActiveNode association (an object created by a <tt>has_one</tt> or
+        # <tt>has_many</tt>) that created this object.
+        # @param [Hash] options Additional options pertaining to the QueryProxy object. These may include:
+        # * node_var: A string or symbol to be used by Cypher within its query string as an identifier
+        # * rel_var:  Same as above but pertaining to a relationship identifier
+        # * session: The session to be used for this query
+        # * caller:  The node instance at the start of the QueryProxy chain
+        # * query_proxy: An existing QueryProxy chain upon which this new object should be built
+        #
+        # QueryProxy objects are evaluated lazily.
         def initialize(model, association = nil, options = {})
           @model = model
           @association = association
@@ -24,10 +45,21 @@ module Neo4j
           @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
         end
 
+        # The relationship identifier most recently used by the QueryProxy chain.
+        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?
@@ -40,6 +72,10 @@ module Neo4j
           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 }
@@ -49,14 +85,23 @@ module Neo4j
           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 ==(value)
           self.to_a == value
         end
@@ -89,7 +134,10 @@ module Neo4j
           query_as(identity)
         end
 
-        # Build a Neo4j::Core::Query object for the QueryProxy
+        # Build a Neo4j::Core::Query object for the QueryProxy. This is necessary when you want to take an existing QueryProxy chain
+        # and work with it from the more powerful (but less friendly) Neo4j::Core::Query.
+        # @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)
           var = @node_var if @node_var
           query = if @association
@@ -106,7 +154,7 @@ module Neo4j
           end
         end
 
-        # Cypher string for the QueryProxy's query
+        # 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
           query.to_cypher
         end

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

@@ -49,11 +49,36 @@ module Neo4j
           end
         end
 
+        # Deletes a group of nodes and relationships within a QP chain. When identifier is omitted, it will remove the last link in the chain.
+        # The optional argument must be a node identifier. A relationship identifier will result in a Cypher Error
+        # @param [String,Symbol] the optional identifier of the link in the chain to delete.
+        def delete_all(identifier = nil)
+          query_with_target(identifier) do |target|
+            begin
+              self.query.with(target).match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
+            rescue Neo4j::Session::CypherError
+              self.query.delete(target).exec
+            end
+            self.caller.clear_association_cache if self.caller.respond_to?(:clear_association_cache)
+          end
+        end
+
+        # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
+        # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object upon which you can build.
+        def match_to(node)
+          self.where(neo_id: node.neo_id)
+        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`
+        def first_rel_to(node)
+          self.where(neo_id: node.neo_id).limit(1).pluck(rel_identity).first
+        end
+
         private
 
         def query_with_target(target, &block)
-          target = target.nil? ? identity : target
-          block.yield(target)
+          block.yield(target || identity)
         end
 
         def exists_query_start(origin, condition, target)

data/lib/neo4j/active_node/query_methods.rb

@@ -36,11 +36,6 @@ module Neo4j
 
       alias_method :blank?, :empty?
 
-      def include?(other)
-        raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
-        self.query_as(:n).where(n: {primary_key => other.id}).return("count(n) AS count").first.count > 0
-      end
-
       def find_in_batches(options = {})
         self.query_as(:n).return(:n).find_in_batches(:n, primary_key, options) do |batch|
           yield batch.map(&:n)

data/lib/neo4j/active_node/reflection.rb

@@ -1,5 +1,5 @@
 module Neo4j::ActiveNode
-  # A reflection contains information about an association. 
+  # A reflection contains information about an association.
   # They are often used in connection with form builders to determine associated classes.
   # This module contains methods related to the creation and retrieval of reflections.
   module Reflection

data/lib/neo4j/active_rel/persistence.rb

@@ -4,8 +4,8 @@ module Neo4j::ActiveRel
     include Neo4j::Shared::Persistence
 
     class RelInvalidError < RuntimeError; end
-
     class ModelClassInvalidError < RuntimeError; end
+    class RelCreateFailedError < RuntimeError; end
 
     def clear_association_cache; end
 
@@ -86,12 +86,16 @@ module Neo4j::ActiveRel
     def _rel_creation_query(from_node, to_node, props)
       from_class = from_node.class
       to_class = to_node.class
-      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)
-        .create("(n1)-[r:`#{type}`]->(n2)")
-        .with('r').set(r: props).return(:r).first.r
+      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)
+          .create("(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}"
+      end
     end
 
   end

data/lib/neo4j/config.rb

@@ -113,7 +113,10 @@ module Neo4j
         Neo4j::Config[:class_name_property] || :_classname
       end
 
+      def include_root_in_json
+        # we use ternary because a simple || will always evaluate true
+        Neo4j::Config[:include_root_in_json].nil? ? true : Neo4j::Config[:include_root_in_json]
+      end
     end
   end
-
-end
+end

data/lib/neo4j/paginated.rb

@@ -8,9 +8,8 @@ module Neo4j
     end
 
     def self.create_from(source, page, per_page, order = nil)
-      #partial = source.drop((page-1) * per_page).first(per_page)
       target = source.node_var
-      partial = source.skip(page-1).limit(per_page)
+      partial = source.skip((page - 1) * per_page).limit(per_page)
       ordered_partial, ordered_source = if order
                                           [partial.order_by(order), source.query.with("#{target} as #{target}").pluck("COUNT(#{target})").first]
                                         else

data/lib/neo4j/shared.rb

@@ -22,7 +22,7 @@ module Neo4j
     end
 
     included do
-      self.include_root_in_json = true
+      self.include_root_in_json = Neo4j::Config.include_root_in_json
 
       def self.i18n_scope
         :neo4j

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "3.0.3"
+  VERSION = "3.0.4"
 end

data/neo4j.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.summary = "A graph database for Ruby"
   s.license = 'MIT'
   s.description = <<-EOF
-A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks, intended as a complete replacement for ActiveRecord.
+A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks heavily inspired by ActiveRecord.
   EOF
 
   s.require_path = 'lib'
@@ -31,7 +31,7 @@ A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks,
   s.add_dependency("activesupport", "~> 4")
   s.add_dependency("railties", "~> 4")
   s.add_dependency('active_attr', "~> 0.8")
-  s.add_dependency("neo4j-core", "~> 3.0.5")
+  s.add_dependency("neo4j-core", "~> 3.0.8")
 
   if RUBY_PLATFORM =~ /java/
     s.add_dependency("neo4j-community", '~> 2.0')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-03 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -86,16 +86,16 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        version: 3.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        version: 3.0.8
 description: |
-  A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks, intended as a complete replacement for ActiveRecord.
+  A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks heavily inspired by ActiveRecord.
 email: andreas.ronge@gmail.com
 executables:
 - neo4j-jars