neo4j 6.1.12 → 7.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cdaac2ed51c1376e2fd9cfba0e3dd46065ce1ab
-  data.tar.gz: 4ae2e390db76490a98c42e2719d8416c7da0194c
+  metadata.gz: b6bcfe613b82f80a6f772cb99f0df6042882209f
+  data.tar.gz: 2d63ea0d2a44bc68cd69bb59977bab5b056c8ab1
 SHA512:
-  metadata.gz: ae1bded3ab39626e16264cefa89bd00f9ceafc64d9284a98b6a09403341abde2f09f3a5ef9105589199a1c36976d4994278a4ca3c01816c514e936d9f0df39d3
-  data.tar.gz: 9e2c5859d7e47eefc8135ca5bc54ae08047f07fca167da657631bbe05ad592e6b946f1d548f66ae79c88694ec9fd37a50ffde3857617842d488a7d6d69c64e3c
+  metadata.gz: 5e8ae42d5b5708112736c066c5d033ee964130ae3df87ef0a6b4686ae446936770114a38ef66c0a3e2e446a9f9d98f95f0f71b3fd77a932c46b39a0ddce401ec
+  data.tar.gz: f3fa6b6e2b81eeff82fe724cb6ac1f1491d3ea93754787a9c7089737ddf394d8b2e8f687c9fc60ac653120e12e5416418d046345d356d97733d10f71375297df

data/CHANGELOG.md

@@ -3,29 +3,34 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
-## [6.1.12] - 05-27-2016
+## [7.0.0.rc.1] - 03-08-2016
 
-### Fixed
-
-- Fix to `find_in_batches` (thanks to ProGM / see #1208)
-
-## [6.1.11] - 05-25-2016
+### Changed
 
-### Fixed
+- All explicit dependencies on `ActiveAttr` code that was not removed outright can now be found in the `Neo4j::Shared` namespace.
+- All type conversion uses Neo4j.rb-owned converters in the `Neo4j::Shared::TypeConverters` namespace. This is of particular importance where `Boolean` is concerned. Where explicitly using `ActiveAttr::Typecasting::Boolean`, use `Neo4j::Shared::Boolean`.
+- `Neo4j::Shared::TypeConverters.converters` was replaced with `Neo4j::Shared::TypeConverters::CONVERTERS`.
+- Error classes refactor: All errors now inherits from `Neo4j::Error`. All specific `InvalidParameterError` were replaced with a more generic `Neo4j::InvalidParameterError`.
+- When calling `Node.find(...)` with missing ids, `Neo4j::RecordNotFound` now returns a better error message and some informations about the query.
 
-- Allow models to use their superclass' scopes (thanks to veetow for the heads-up / see #1205)
+#### Internal
 
-## [6.1.10] - 03-14-2016
+- Ran transpec and fixed error warning (thanks brucek / #1132)
 
-### Fixed
-
-- Fixed issue where backticks weren't being added to where clauses for `with_associations`
+### Added
 
-## [6.1.9] - 2016-03-08
+- A number of modules and unit tests were moved directly from the ActiveAttr gem, which is no longer being maintained.
+- `ActiveNode` models now respond to `update_all` (thanks ProGM / #1113)
+- Association chains now respond to `update_all` and `update_all_rels` (thanks ProGM / #1113)
+- Rails will now rescue all `Neo4j::RecordNotFound` errors with a 404 status code by default
+- A clone of [ActiveRecord::Enum](http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html) API. See docs for details. (thanks ProGM / #1129)
+- Added #branch method to `QueryProxy` to allow for easy branching of matches in association chains (thanks ProGM / #1147 / #1143)
 
-### Fixed
+### Removed
 
-- Issue where creating relationships via `has_one` association created two relationships (forward ported from 6.0.7)
+- All external [ActiveAttr](https://github.com/cgriego/active_attr) dependencies.
+- All `call` class methods from Type Converters. Use `to_ruby` instead.
+- `Neo4j::ActiveNode::Labels::InvalidQueryError`, since it's unused.
 
 ## [6.1.8] - 2016-03-02
 
@@ -94,24 +99,6 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 - `config/neo4j.yml` now renders with an ERB step (thanks to mrstif via #1060)
 - `#increment`, `#increment!` and `#concurrent_increment!` methods added to instances of ActiveNode and ActiveRel (thanks to ProGM in #1074)
 
-## [6.0.9] - 05-27-2016
-
-### Fixed
-
-- Fix to `find_in_batches` (thanks to ProGM / see #1208)
-
-## [6.0.8] - 03-14-2016
-
-### Fixed
-
-- Fixed issue where backticks weren't being added to where clauses for `with_associations`
-
-## [6.0.7] - 03-08-2016
-
-### Fixed
-
-- Issue where creating relationships via `has_one` association created two relationships
-
 ## [6.0.6] - 01-20-2016
 
 ### Fixed

data/lib/neo4j.rb

@@ -1,14 +1,5 @@
 require 'neo4j/version'
 
-# require "delegate"
-# require "time"
-# require "set"
-#
-# require "active_support/core_ext"
-# require "active_support/json"
-# require "active_support/inflector"
-# require "active_support/time_with_zone"
-
 require 'neo4j-core'
 require 'neo4j/core/cypher_session'
 require 'neo4j/core/query'
@@ -16,7 +7,6 @@ require 'active_model'
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'
 
-require 'active_attr'
 require 'neo4j/errors'
 require 'neo4j/config'
 require 'neo4j/wrapper'
@@ -36,6 +26,10 @@ require 'neo4j/shared/filtered_hash'
 require 'neo4j/shared/declared_property/index'
 require 'neo4j/shared/declared_property'
 require 'neo4j/shared/declared_properties'
+require 'neo4j/shared/enum'
+require 'neo4j/shared/mass_assignment'
+require 'neo4j/shared/attributes'
+require 'neo4j/shared/typecasted_attributes'
 require 'neo4j/shared/property'
 require 'neo4j/shared/persistence'
 require 'neo4j/shared/validations'
@@ -61,8 +55,10 @@ require 'neo4j/active_rel'
 require 'neo4j/active_node/dependent'
 require 'neo4j/active_node/dependent/query_proxy_methods'
 require 'neo4j/active_node/dependent/association_methods'
+require 'neo4j/active_node/enum'
 require 'neo4j/active_node/query_methods'
 require 'neo4j/active_node/query/query_proxy_methods'
+require 'neo4j/active_node/query/query_proxy_methods_of_mass_updating'
 require 'neo4j/active_node/query/query_proxy_enumerable'
 require 'neo4j/active_node/query/query_proxy_find_in_batches'
 require 'neo4j/active_node/query/query_proxy_eager_loading'

data/lib/neo4j/active_node.rb

@@ -43,6 +43,7 @@ module Neo4j
     include Neo4j::ActiveNode::HasN
     include Neo4j::ActiveNode::Scope
     include Neo4j::ActiveNode::Dependent
+    include Neo4j::ActiveNode::Enum
 
     def initialize(args = nil)
       symbol_args = args.is_a?(Hash) ? args.symbolize_keys : args

data/lib/neo4j/active_node/enum.rb

@@ -0,0 +1,29 @@
+module Neo4j::ActiveNode
+  module Enum
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Enum
+
+    module ClassMethods
+      protected
+
+      def build_property_options(enum_keys, options = {})
+        if options[:_index]
+          super.merge!(index: :exact)
+        else
+          super
+        end
+      end
+
+      def define_enum_methods(property_name, enum_keys, options)
+        super
+        define_enum_scopes(property_name, enum_keys)
+      end
+
+      def define_enum_scopes(property_name, enum_keys)
+        enum_keys.keys.each do |name|
+          scope name, -> { where(property_name => name) }
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/has_n.rb

@@ -2,7 +2,7 @@ module Neo4j::ActiveNode
   module HasN
     extend ActiveSupport::Concern
 
-    class NonPersistedNodeError < StandardError; end
+    class NonPersistedNodeError < Neo4j::Error; end
 
     # Return this object from associations
     # It uses a QueryProxy to get results

data/lib/neo4j/active_node/has_n/association.rb

@@ -79,7 +79,7 @@ module Neo4j
           return if model_class == false
 
           Array.new(target_classes).map do |target_class|
-            "#{name}:`#{target_class.mapped_label_name}`"
+            "#{name}:#{target_class.mapped_label_name}"
           end.join(' OR ')
         end
 

data/lib/neo4j/active_node/labels.rb

@@ -20,8 +20,7 @@ module Neo4j
         Neo4j::ActiveNode::Labels.add_wrapped_class(model) unless Neo4j::ActiveNode::Labels._wrapped_classes.include?(model)
       end
 
-      class InvalidQueryError < StandardError; end
-      class RecordNotFound < StandardError; end
+      class RecordNotFound < Neo4j::RecordNotFound; end
 
       # @return the labels
       # @see Neo4j-core
@@ -78,17 +77,18 @@ module Neo4j
       module ClassMethods
         include Neo4j::ActiveNode::QueryMethods
 
+        delegate :update_all, to: :all
+
         # Returns the object with the specified neo4j id.
         # @param [String,Integer] id of node to find
         def find(id)
           map_id = proc { |object| object.respond_to?(:id) ? object.send(:id) : object }
 
-          result = if id.is_a?(Array)
-                     find_by_ids(id.map { |o| map_id.call(o) })
-                   else
-                     find_by_id(map_id.call(id))
-                   end
-          fail Neo4j::RecordNotFound if result.blank?
+          result = find_by_id_or_ids(map_id, id)
+
+          fail RecordNotFound.new(
+            "Couldn't find #{name} with '#{id_property_name}'=#{id}",
+            name, id_property_name, id) if result.blank?
           result.tap { |r| find_callbacks!(r) }
         end
 
@@ -162,6 +162,14 @@ module Neo4j
 
         private
 
+        def find_by_id_or_ids(map_id, id)
+          if id.is_a?(Array)
+            find_by_ids(id.map(&map_id))
+          else
+            find_by_id(map_id.call(id))
+          end
+        end
+
         def find_callbacks!(result)
           case result
           when Neo4j::ActiveNode

data/lib/neo4j/active_node/persistence.rb

@@ -128,15 +128,23 @@ module Neo4j::ActiveNode
         end
       end
 
-      def merge(attributes)
-        neo4j_session.query.merge(n: {self.mapped_label_names => attributes})
-          .on_create_set(n: on_create_props(attributes))
-          .on_match_set(n: on_match_props)
+      def merge(match_attributes, optional_attrs = {})
+        options = [:on_create, :on_match, :set]
+        optional_attrs.assert_valid_keys(*options)
+
+        optional_attrs.default = {}
+        on_create_attrs, on_match_attrs, set_attrs = optional_attrs.values_at(*options)
+
+        neo4j_session.query.merge(n: {self.mapped_label_names => match_attributes})
+          .on_create_set(n: on_create_props(on_create_attrs))
+          .on_match_set(n: on_match_props(on_match_attrs))
+          .break.set(n: set_attrs)
           .pluck(:n).first
       end
 
       def find_or_create(find_attributes, set_attributes = {})
         on_create_attributes = set_attributes.reverse_merge(on_create_props(find_attributes))
+
         neo4j_session.query.merge(n: {self.mapped_label_names => find_attributes})
           .on_create_set(n: on_create_attributes)
           .pluck(:n).first
@@ -162,8 +170,8 @@ module Neo4j::ActiveNode
         find_attributes.merge(self.new(find_attributes).props_for_create)
       end
 
-      def on_match_props
-        {}.tap { |props| props[:updated_at] = DateTime.now.to_i if attributes_nil_hash.key?('updated_at'.freeze) }
+      def on_match_props(match_attributes)
+        match_attributes.tap { |props| props[:updated_at] = DateTime.now.to_i if attributes_nil_hash.key?('updated_at') }
       end
     end
   end

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

@@ -4,6 +4,7 @@ module Neo4j
       class QueryProxy
         include Neo4j::ActiveNode::Query::QueryProxyEnumerable
         include Neo4j::ActiveNode::Query::QueryProxyMethods
+        include Neo4j::ActiveNode::Query::QueryProxyMethodsOfMassUpdating
         include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
         include Neo4j::ActiveNode::Query::QueryProxyEagerLoading
         include Neo4j::ActiveNode::Dependent::QueryProxyMethods
@@ -173,6 +174,25 @@ module Neo4j
           self
         end
 
+        # Executes the relation chain specified in the block, while keeping the current scope
+        #
+        # @example Load all people that have friends
+        #   Person.all.branch { friends }.to_a # => Returns a list of `Person`
+        #
+        # @example Load all people that has old friends
+        #   Person.all.branch { friends.where('age > 70') }.to_a # => Returns a list of `Person`
+        #
+        # @yield the block that will be evaluated starting from the current scope
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def branch(&block)
+          if block
+            instance_eval(&block).query.proxy_as(self.model, identity)
+          else
+            fail LocalJumpError, 'no block given'
+          end
+        end
+
         def [](index)
           # TODO: Maybe for this and other methods, use array if already loaded, otherwise
           # use OFFSET and LIMIT 1?

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

@@ -4,7 +4,7 @@ module Neo4j
       module QueryProxyFindInBatches
         def find_in_batches(options = {})
           query.return(identity).find_in_batches(identity, @model.primary_key, options) do |batch|
-            yield batch.map(&identity)
+            yield batch.map(&:identity)
           end
         end
 

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

@@ -2,7 +2,6 @@ module Neo4j
   module ActiveNode
     module Query
       module QueryProxyMethods
-        class InvalidParameterError < StandardError; end
         FIRST = 'HEAD'
         LAST = 'LAST'
 
@@ -30,32 +29,15 @@ module Neo4j
           first_and_last(LAST, target)
         end
 
-        def first_and_last(func, target)
-          new_query, pluck_proc = if self.query.clause?(:order)
-                                    [self.query.with(identity),
-                                     proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }]
-                                  else
-                                    [self.order(order_property).limit(1),
-                                     proc { |var| var }]
-                                  end
-          result = query_with_target(target) do |var|
-            final_pluck = pluck_proc.call(var)
-            new_query.pluck(final_pluck)
-          end
-          result.first
-        end
-
         def order_property
           # This should maybe be based on a setting in the association
           # rather than a hardcoded `nil`
           model ? model.id_property_name : nil
         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
+          fail(Neo4j::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}"
             limited_query = self.query.clause?(:limit) ? self.query.break.with(var) : self.query.reorder
@@ -93,32 +75,20 @@ module Neo4j
                              "#{var}.#{association_id_key} = {other_node_id}"
                            end
             node_id = other.respond_to?(:neo_id) ? other.neo_id : other
-            self.where(where_filter).params(other_node_id: node_id).query.reorder.return("count(#{var}) as count").first.count > 0
+            self.where(where_filter).params(other_node_id: node_id).query.return("count(#{var}) as count").first.count > 0
           end
         end
 
         def exists?(node_condition = nil, target = nil)
-          fail(InvalidParameterError, ':exists? only accepts neo_ids') 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(Neo4j::InvalidParameterError, ':exists? only accepts neo_ids')
+          end
           query_with_target(target) do |var|
             start_q = exists_query_start(node_condition, var)
             start_q.query.reorder.return("COUNT(#{var}) AS count").first.count > 0
           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 identifier [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).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
-            rescue Neo4j::Session::CypherError
-              self.query.delete(target).exec
-            end
-            clear_source_object_cache
-          end
-        end
-
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
         # The `node` param can be a persisted ActiveNode instance, any string or integer, or nil.
         # When it's a node, it'll use the object's neo_id, which is fastest. When not nil, it'll figure out the
@@ -157,27 +127,6 @@ module Neo4j
         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_var).exec
-          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
-          return unless start_object && start_object._persisted_obj
-          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
-
         # When called, this method returns a single node that satisfies the match specified in the params hash.
         # If no existing node is found to satisfy the match, one is created or associated as expected.
         def find_or_create_by(params)
@@ -191,12 +140,6 @@ module Neo4j
           end
         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_source_object_cache
-        end
-
         # A shortcut for attaching a new, optional match to the end of a QueryProxy chain.
         def optional(association, node_var = nil, rel_var = nil)
           self.send(association, node_var, rel_var, optional: true)
@@ -222,8 +165,18 @@ module Neo4j
 
         private
 
-        def clear_source_object_cache
-          self.source_object.clear_association_cache if self.source_object.respond_to?(:clear_association_cache)
+        def first_and_last(func, target)
+          new_query, pluck_proc = if self.query.clause?(:order)
+                                    [self.query.with(identity),
+                                     proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }]
+                                  else
+                                    [self.order(order_property).limit(1),
+                                     proc { |var| var }]
+                                  end
+          query_with_target(target) do |var|
+            final_pluck = pluck_proc.call(var)
+            new_query.pluck(final_pluck)
+          end.first
         end
 
         # @return [String] The primary key of a the current QueryProxy's model or target class
@@ -243,8 +196,10 @@ module Neo4j
 
         def exists_query_start(condition, target)
           case condition
-          when Integer then self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
-          when Hash then self.where(condition.keys.first => condition.values.first)
+          when Integer
+            self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
+          when Hash
+            self.where(condition.keys.first => condition.values.first)
           else
             self
           end