neo4j 5.0.15 → 5.1.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 614d5fb5803862fb5eabc3e58e19fa52dfd707eb
-  data.tar.gz: 5c5aab03b675ae7253552b07282132885454eb6d
+  metadata.gz: 7f1d7952f8318fc3525d1e1bfbf90729ddcd02f5
+  data.tar.gz: aaea4557f810905866707c6c19e480b3816efbd0
 SHA512:
-  metadata.gz: 357f69c5ae85ea3a29661c03ec8bee6ed04123256f1d147f771da7d36fbc224e82f3e403df76c93d2845f3fa8083d5bf73758d7b5ba573d89e638ec8cc34f09c
-  data.tar.gz: c82b2d8b33fd3ac9a32880dede8fe2d9cf4aaa726b421f6e2452fb06ff5db71479edaa21614f3c6693f3eb9108b52805d9c74c6508d26ca40a0d3e3dd45f92d3
+  metadata.gz: eed94e2d7d99f61592a341e233995b730c312ad8c71bc460f59a8d2b34a4c0cb63b918e803fd2fd13d18f5c221a82d890961fdaac8bf2ed5a122d82252ee044b
+  data.tar.gz: bf2c82d7b1c138964010b6bb80f01b0cc0341babc279adb8ee2a4cd3921d384e064a399927309b5a1114437cb2b86f7e74b2539b742372eec29ec6d55661e5f4

data/CHANGELOG.md

@@ -5,30 +5,83 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased][unreleased]
 
-### Changed
-- `ActiveNode#destroyed?` and `ActiveRel#destroyed?` now only consider the in-memory state of if an object is destroyed without checking the database
-
 ### Fixed
 - Added a `before_remove_const` method to clear cached models when Rails `reload!` is called. 5.0.1 included a workaround but this appears to cut to the core of the issue. See https://github.com/neo4jrb/neo4j/pull/855.
-- Fixed bug which caused `QueryProxy` context to repeat (showed up in query logging)
+- To prevent errors, changing an index to constraint or constraint to index will drop the existing index/constraint before adding the new.
+- Fixed `AssociationProxy#method_missing` so it properly raises errors.
 
 ### Added
 - Added ability to view `model_class` from `Association` class for `rails_admin` Neo4j adapter
 - QueryProxy `where` will now look for declared properties matching hash keys. When found, it will send the value through that property's type converter if the type matches the property's unconverted state.
 - Improved handling of unpersisted nodes with associations. You can now use `<<` to create associations between unpersisted nodes. A `save` will cascade through unpersisted objects, creating nodes and rels along the way. See https://github.com/neo4jrb/neo4j/pull/871
 - Support formatted cypher queries for easy reading by humans via the `pretty_logged_cypher_queries` configuration variable
+- Ability to query for just IDs on associations
 - On `QueryProxy` objects you can now use an `:id` key in `where` and `find_by` methods to refer to the property from `id_property` (`uuid` by default)
+- Added `ActiveRel.creates_unique` and deprecated `ActiveRel.creates_unique_rel`
+- Added #inspect method to ActiveRel to show Cypher-style representation of from node, to node, and relationship type
+
+### Changed
+
+- Methods related to ActiveNode's IdProperty module were refactored to improve performance and simplify the API. Existing `default_properties` methods were reworked to reflect their use as-implemented: storage for a single default property, not multiple.
+- Implementation adjustments that improve node and rel initialization speed, particularly when loading large numbers of objects from the database.
+
+## [5.0.15] - 08-12-2015
+
+### Fixed
+
+- `reload!` within Rails apps will work correctly. An earlier release included a workaround but this uses ActiveModel's system for clearing caches to provide a more thorough resolution.
+
+## [5.0.14] - 08-09-2015
+
+### Fixed
+
+- Calling `all` on a QueryProxy chain would cause the currently set node identity within Cypher to be lost.
+
+## [5.0.13] - 08-07-2015
+
+### Fixed
+- Backport AssociationProxy#method_missing fix to raise errors on invalid methods
+- Fix the count issue on depth two associations (#881)
+
+## [5.0.12] - ?
+
+### Fixed
+- Break between associations so that potential `where` clauses get applied to the correct `(OPTIONAL )MATCH` clause
+
+### Fixed
+- Delegate `first` and `last` from `AssociationProxy` to `QueryProxy`
+- Fix `order` behavior for `first` and `last` in `QueryProxy`
+
+## [5.0.11] - ?
+
+### Fixed
+- Delegate `first` and `last` from `AssociationProxy` to `QueryProxy`
+- Fix `order` behavior for `first` and `last` in `QueryProxy`
+
+## [5.0.10] - 2015-07-31
+
+### Fixed
+- Fix what should have been a very obvious bug in `_active_record_destroyed_behavior` behavior
+- Add eager loading to QueryProxy so that it works in all expected places
 
 ## [5.0.9] - 2015-07-29
-- Fix "NameError: uninitialized constant Class::Date" (https://github.com/neo4jrb/neo4j/issues/852)
+
+### Fixed
+- "NameError: uninitialized constant Class::Date" (https://github.com/neo4jrb/neo4j/issues/852)
 
 ## [5.0.8] - 2015-07-26
+
+### Changed
 - Copied QueryClauseMethods doc from master
 
 ## [5.0.7] - 2015-07-26
+
+### Changed
 - Copied `docs` folder from master because a lot of work had gone into the docs since 5.0.0 was released
 
 ## [5.0.6] - 2015-07-22
+
+### Fixed
 - Fix query logging so that by default it only outputs to the user in the console and development server.  Logger can be changed with `neo4j.config.logger` configuration option
 
 ## [5.0.5] - 2015-07-19
@@ -45,6 +98,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 - Moved `#with_associations` method from `AssociationProxy` to `QueryProxy` so that all `QueryProxy` chains can benefit from it.
+- Added `_active_record_destroyed_behavior` semi-hidden configuration variable so that behavior for `ActiveNode#destroyed?` and `ActiveRel#destroyed?` can be changed to upcoming 6.0.0 behavior (matching ActiveRecord) where the database is not accessed.
 
 ## [5.0.2] - 2015-06-30
 
@@ -52,6 +106,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 - Fix error when calling `#empty?` or `#blank?` on a query chain with on `order` specified
 - Make `#find_each` and `#find_in_batches` return the actual objects rather than the result objects
 - Query logging on console should be to STDOUT with `puts`.  Using `Rails.logger` outputs to the file in the `log` directory
+- Modified queryproxy include? to accept a uuid instead of full node
 
 ## [5.0.1] - 2015-06-23
 

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 gemspec
 
-# gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
+gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: '5.1.x'
 # gem 'neo4j-core', path: '../neo4j-core'
 
 # gem 'active_attr', github: 'neo4jrb/active_attr', branch: 'performance'

data/README.md

@@ -12,8 +12,16 @@
 
 ## Get Support
 
+### Documentation
+
+All new documentation will be done via our [readthedocs](http://neo4jrb.readthedocs.org) site, though some old documentation has yet to be moved from our [wiki](https://github.com/neo4jrb/neo4j/wiki) (also there is the [neo4j-core wiki](https://github.com/neo4jrb/neo4j-core/wiki))
+
+### Contact Us
+
   [![StackOverflow](https://img.shields.io/badge/StackOverflow-Ask%20a%20question!-blue.svg)](http://stackoverflow.com/questions/ask?tags=neo4j.rb+neo4j+ruby)  [![Gitter](https://img.shields.io/badge/Gitter-Join%20our%20chat!-blue.svg)](https://gitter.im/neo4jrb/neo4j?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)  [![Twitter](https://img.shields.io/badge/Twitter-Tweet%20with%20us!-blue.svg)](https://twitter.com/neo4jrb)  [![Mailing list](https://img.shields.io/badge/Mailing%20list-Mail%20us!-blue.svg)](https://groups.google.com/forum/#!forum/neo4jrb)
 
+
+
 # Introduction
 
 Neo4j.rb is an Active Model compliant Ruby/JRuby wrapper for [the Neo4j graph database](http://www.neo4j.org/). It uses the [neo4j-core](https://github.com/neo4jrb/neo4j-core) and [active_attr](https://github.com/cgriego/active_attr) gems.

data/lib/neo4j.rb

@@ -52,12 +52,14 @@ require 'neo4j/active_node/dependent'
 require 'neo4j/active_node/dependent/query_proxy_methods'
 require 'neo4j/active_node/dependent/association_methods'
 require 'neo4j/active_node/query_methods'
+require 'neo4j/active_node/query/query_proxy_unpersisted'
 require 'neo4j/active_node/query/query_proxy_methods'
 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'
 require 'neo4j/active_node/query/query_proxy_link'
 require 'neo4j/active_node/labels'
+require 'neo4j/active_node/id_property/accessor'
 require 'neo4j/active_node/id_property'
 require 'neo4j/active_node/callbacks'
 require 'neo4j/active_node/initialize'
@@ -66,7 +68,9 @@ require 'neo4j/active_node/persistence'
 require 'neo4j/active_node/validations'
 require 'neo4j/active_node/rels'
 require 'neo4j/active_node/reflection'
+require 'neo4j/active_node/unpersisted'
 require 'neo4j/active_node/has_n'
+require 'neo4j/active_node/has_n/association_cypher_methods'
 require 'neo4j/active_node/has_n/association'
 require 'neo4j/active_node/query/query_proxy'
 require 'neo4j/active_node/query'

data/lib/neo4j/active_node.rb

@@ -36,6 +36,7 @@ module Neo4j
     include Neo4j::ActiveNode::Query
     include Neo4j::ActiveNode::Labels
     include Neo4j::ActiveNode::Rels
+    include Neo4j::ActiveNode::Unpersisted
     include Neo4j::ActiveNode::HasN
     include Neo4j::ActiveNode::Scope
     include Neo4j::ActiveNode::Dependent
@@ -75,7 +76,7 @@ module Neo4j
 
       def self.inherit_id_property(other)
         Neo4j::Session.on_session_available do |_|
-          return unless self.id_property?
+          next if other.manual_id_property? || !self.id_property?
           id_prop = self.id_property_info
           conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
           other.id_property id_prop[:name], conf
@@ -83,6 +84,7 @@ module Neo4j
       end
 
       Neo4j::Session.on_session_available do |_|
+        next if manual_id_property?
         id_property :uuid, auto: :uuid unless self.id_property?
 
         name = Neo4j::Config[:id_property]

data/lib/neo4j/active_node/dependent/association_methods.rb

@@ -32,11 +32,13 @@ module Neo4j
         end
 
         def dependent_destroy_callback(object)
-          object.association_query_proxy(name).each_for_destruction(object, &:destroy)
+          unique_query = object.association_query_proxy(name)
+          unique_query.each_for_destruction(object, &:destroy) if unique_query
         end
 
         def dependent_destroy_orphans_callback(object)
-          object.as(:self).unique_nodes(self, :self, :n, :other_rel).each_for_destruction(object, &:destroy)
+          unique_query = object.as(:self).unique_nodes(self, :self, :n, :other_rel)
+          unique_query.each_for_destruction(object, &:destroy) if unique_query
         end
 
         # End callback methods

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

@@ -28,7 +28,7 @@ module Neo4j
         # @return [Neo4j::ActiveNode::Query::QueryProxy]
         def unique_nodes(association, self_identifer, other_node, other_rel)
           fail 'Only supported by in QueryProxy chains started by an instance' unless source_object
-
+          return false if send(association.name).empty?
           unique_nodes_query(association, self_identifer, other_node, other_rel)
             .proxy_as(association.target_class, other_node)
         end
@@ -40,9 +40,9 @@ module Neo4j
             .send(association.name, other_node, other_rel)
             .query
             .with(other_node)
-            .match("()#{association.arrow_cypher}(#{other_node})")
+            .match("()#{association.arrow_cypher(:orphan_rel)}(#{other_node})")
             .with(other_node, count: 'count(*)')
-            .where('count = 1')
+            .where('count = {one}', one: 1)
         end
       end
     end

data/lib/neo4j/active_node/has_n.rb

@@ -24,7 +24,7 @@ module Neo4j::ActiveNode
         if @cached_result
           @cached_result.inspect
         else
-          "<AssociationProxy @query_proxy=#{@query_proxy.inspect}>"
+          "#<AssociationProxy @query_proxy=#{@query_proxy.inspect}>"
         end
       end
 
@@ -121,7 +121,7 @@ module Neo4j::ActiveNode
 
     def association_proxy(name, options = {})
       name = name.to_sym
-      hash = [name, options.values_at(:node, :rel, :labels)].hash
+      hash = [name, options.values_at(:node, :rel, :labels, :rel_length)].hash
       association_proxy_cache_fetch(hash) do
         if result_cache = self.instance_variable_get('@source_query_proxy_result_cache')
           result_by_previous_id = previous_proxy_results_by_previous_id(result_cache, name)
@@ -152,27 +152,19 @@ module Neo4j::ActiveNode
       Hash[*query_proxy.pluck('ID(previous)', 'collect(next)').flatten(1)]
     end
 
-    def handle_non_persisted_node(other_node)
-      return unless Neo4j::Config[:autosave_on_assignment]
-      other_node.try(:save)
-      save
-    end
-
-    def validate_persisted_for_association!
-      fail(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self._persisted_obj
-    end
-
     module ClassMethods
-      # :nocov:
       # rubocop:disable Style/PredicateName
+
+      # :nocov:
       def has_association?(name)
         ActiveSupport::Deprecation.warn 'has_association? is deprecated and may be removed from future releases, use association? instead.', caller
 
         association?(name)
       end
-      # rubocop:enable Style/PredicateName
       # :nocov:
 
+      # rubocop:enable Style/PredicateName
+
       def association?(name)
         !!associations[name.to_sym]
       end
@@ -195,7 +187,10 @@ module Neo4j::ActiveNode
       # For defining an "has many" association on a model.  This defines a set of methods on
       # your model instances.  For instance, if you define the association on a Person model:
       #
-      # has_many :out, :vehicles, type: :has_vehicle
+      #
+      # .. code-block:: ruby
+      #
+      #   has_many :out, :vehicles, type: :has_vehicle
       #
       # This would define the following methods:
       #
@@ -213,7 +208,10 @@ module Neo4j::ActiveNode
       #   either all ``Person`` nodes (if ``Person.vehicles`` is called), or all ``Vehicle`` objects
       #   associated with the ``Person`` nodes thus far represented in the QueryProxy chain.
       #   For example:
-      #     ``company.people.where(age: 40).vehicles``
+      #
+      #   .. code-block:: ruby
+      #
+      #     company.people.where(age: 40).vehicles
       #
       # Arguments:
       #   **direction:**
@@ -222,18 +220,24 @@ module Neo4j::ActiveNode
       #     Refers to the relative to the model on which the association is being defined.
       #
       #     Example:
-      #       ``Person.has_many :out, :posts, type: :wrote``
       #
-      #         means that a `WROTE` relationship goes from a `Person` node to a `Post` node
+      #     .. code-block:: ruby
+      #
+      #       Person.has_many :out, :posts, type: :wrote
+      #
+      #     means that a `WROTE` relationship goes from a `Person` node to a `Post` node
       #
       #   **name:**
       #     The name of the association.  The affects the methods which are created (see above).
       #     The name is also used to form default assumptions about the model which is being referred to
       #
       #     Example:
-      #       ``Person.has_many :out, :posts, type: :wrote``
       #
-      #       will assume a `model_class` option of ``'Post'`` unless otherwise specified
+      #     .. code-block:: ruby
+      #
+      #       Person.has_many :out, :posts, type: :wrote
+      #
+      #     will assume a `model_class` option of ``'Post'`` unless otherwise specified
       #
       #   **options:** A ``Hash`` of options.  Allowed keys are:
       #     *type*: The Neo4j relationship type.  This option is required unless either the
@@ -243,17 +247,21 @@ module Neo4j::ActiveNode
       #       can be gathered.
       #
       #       Example:
-      #         ``Person.has_many :out, :posts, origin: :author`` (`model_class` of `Post` is assumed here)
       #
-      #         ``Post.has_one :in, :author, type: :has_author, model_class: 'Person'``
+      #       .. code-block:: ruby
+      #
+      #         # `model_class` of `Post` is assumed here
+      #         Person.has_many :out, :posts, origin: :author
+      #
+      #         Post.has_one :in, :author, type: :has_author, model_class: 'Person'
       #
       #     *model_class*: The model class to which the association is referring.  Can be either a
-      #       model object ``include`` ing ``ActiveNode`` or a string (or an ``Array`` of same).
-      #       **A string is recommended** to avoid load-time issues
+      #       model object ``include`` ing ``ActiveNode`` or a Symbol/String (or an ``Array`` of same).
+      #       **A Symbol or String is recommended** to avoid load-time issues
       #
       #     *rel_class*: The ``ActiveRel`` class to use for this association.  Can be either a
-      #       model object ``include`` ing ``ActiveRel`` or a string (or an ``Array`` of same).
-      #       **A string is recommended** to avoid load-time issues
+      #       model object ``include`` ing ``ActiveRel`` or a Symbol/String (or an ``Array`` of same).
+      #       **A Symbol or String is recommended** to avoid load-time issues
       #
       #     *dependent*: Enables deletion cascading.
       #       **Available values:** ``:delete``, ``:delete_orphans``, ``:destroy``, ``:destroy_orphans``
@@ -287,13 +295,20 @@ module Neo4j::ActiveNode
 
       def define_has_many_methods(name)
         define_method(name) do |node = nil, rel = nil, options = {}|
-          return [].freeze unless self._persisted_obj
+          # return [].freeze unless self._persisted_obj
+
+          if node.is_a?(Hash)
+            options = node
+            node = nil
+          end
 
           association_proxy(name, {node: node, rel: rel, source_object: self, labels: options[:labels]}.merge!(options))
         end
 
         define_has_many_setter(name)
 
+        define_has_many_id_methods(name)
+
         define_class_method(name) do |node = nil, rel = nil, options = {}|
           association_proxy(name, {node: node, rel: rel, labels: options[:labels]}.merge!(options))
         end
@@ -307,27 +322,79 @@ module Neo4j::ActiveNode
         end
       end
 
-      def define_has_one_methods(name)
-        define_method(name) do |node = nil, rel = nil|
-          return nil unless self._persisted_obj
+      def define_has_many_id_methods(name)
+        define_method_unless_defined("#{name.to_s.singularize}_ids") do
+          association_proxy(name).pluck(:uuid)
+        end
 
-          association_proxy(name, node: node, rel: rel).first
+        define_method_unless_defined("#{name.to_s.singularize}_ids=") do |ids|
+          association_proxy(name).replace_with(ids)
         end
 
+        define_method_unless_defined("#{name.to_s.singularize}_neo_ids") do
+          association_proxy(name).pluck(:neo_id)
+        end
+      end
+
+      def define_method_unless_defined(method_name, &block)
+        define_method(method_name, block) unless respond_to?(method_name)
+      end
+
+      def define_has_one_methods(name)
+        define_has_one_getter(name)
+
         define_has_one_setter(name)
 
+        define_has_one_id_methods(name)
+
         define_class_method(name) do |node = nil, rel = nil, options = {}|
           association_proxy(name, {node: node, rel: rel, labels: options[:labels]}.merge!(options))
         end
       end
 
+      def define_has_one_id_methods(name)
+        define_method("#{name}_id") do
+          association_proxy(name).pluck(:uuid).first
+        end
+
+        define_method_unless_defined("#{name}_id=") do |id|
+          association_proxy(name).replace_with(id)
+        end
+
+        define_method("#{name}_neo_id") do
+          association_proxy(name).pluck(:neo_id).first
+        end
+      end
+
+      def define_has_one_getter(name)
+        define_method(name) do |node = nil, rel = nil, options = {}|
+          return nil unless self._persisted_obj
+
+          if node.is_a?(Hash)
+            options = node
+            node = nil
+          end
+
+          # Return all results if a variable-length relationship length was given
+          results = association_proxy(name, {node: node, rel: rel}.merge!(options))
+          if options[:rel_length] && !options[:rel_length].is_a?(Fixnum)
+            results
+          else
+            results.first
+          end
+        end
+      end
+
       def define_has_one_setter(name)
         define_method("#{name}=") do |other_node|
-          handle_non_persisted_node(other_node)
-          validate_persisted_for_association!
-          association_proxy_cache.clear # TODO: Should probably just clear for this association...
-
-          Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
+          if persisted?
+            other_node.save if other_node.respond_to?(:persisted?) && !other_node.persisted?
+            association_proxy_cache.clear # TODO: Should probably just clear for this association...
+            Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
+            # handle_non_persisted_node(other_node)
+          else
+            association_proxy(name).defer_create(other_node, {}, :'=')
+          end
         end
       end