neo4j 8.1.5 → 8.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13d58b195820ff94f9899f26eb281f1621b1ea64
-  data.tar.gz: a49c32fd9ef2a70e2b825d6de8cbf169a61fe88f
+  metadata.gz: 895f04165de18db60874c876b6be4a1118f8622a
+  data.tar.gz: 031cde1a701badd8ebe273c1abc6b753df0d14c3
 SHA512:
-  metadata.gz: 740c3277e7d4a5ec4c34965adf2e4fa871cbe59f3658d89f396861ca0d12d8129426dddc186aab2c940d35134bd077e92650fc2b355d87e5370afd907395ff00
-  data.tar.gz: f4e8ba8d4d366202a803b8bc035d31868ca8aa2cd546807021a1ad0e3df220a999b5520add6dd9e7c1c9a874f061d4b6cfd3aa9f63c7debc20b1fbd7d54eda57
+  metadata.gz: 4bccc04892a44df3dae9bd29858b771e6e8c98c7e00a59e31b88df1cd4835476044f57dd76376e92c17d3973e1e2f77a1ed256be8808109a38fe188a8300b935
+  data.tar.gz: 751d813901d03a86174ea3b6677bb643668987dbb385b278a042f1d64cf3fbd51ad02723fe73f2b5c14c8d81bd7ba1279ae39fe9c82963fdc96caad1ffefe247

data/CHANGELOG.md

@@ -3,6 +3,16 @@ 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/).
 
+## [8.2.1] 2017-09-01
+
+- Bringing forward changes from 8.1.x
+
+## [8.2.0] 2017-09-01
+
+### Added
+
+- Ability to load nested associations with one query using `with_associations` (big thanks to @klobuczek / see #1398)
+
 ## [8.1.4] 2017-08-17
 
 ### Fixed

data/Gemfile

@@ -4,9 +4,11 @@ gemspec
 
 # gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master' if ENV['CI']
 
-if branch = ENV['TRAVIS_BRANCH']
-  if `curl --head https://github.com/#{ENV['TRAVIS_REPO_SLUG']}-core/tree/#{branch} | head -1` =~ /200 OK/
-    gem 'neo4j-core', github: "#{ENV['TRAVIS_REPO_SLUG']}-core", branch:  branch
+branch = ENV['TRAVIS_PULL_REQUEST_BRANCH'] || ENV['TRAVIS_BRANCH']
+slug = ENV['TRAVIS_PULL_REQUEST_SLUG'] || ENV['TRAVIS_REPO_SLUG']
+if branch
+  if `curl --head https://github.com/#{slug}-core/tree/#{branch} | head -1` =~ /200 OK/
+    gem 'neo4j-core', github: "#{slug}-core", branch: branch
   else
     gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
   end

data/lib/neo4j/active_node/has_n.rb

@@ -38,6 +38,10 @@ module Neo4j::ActiveNode
         result_nodes.each(&block)
       end
 
+      def each_rel(&block)
+        rels.each(&block)
+      end
+
       # .count always hits the database
       def_delegator :@query_proxy, :count
 
@@ -92,9 +96,18 @@ module Neo4j::ActiveNode
         @enumerable = (@cached_result || @query_proxy)
       end
 
-      def add_to_cache(object)
+      def init_cache
+        @cached_rels ||= []
         @cached_result ||= []
-        @cached_result << object
+      end
+
+      def add_to_cache(object, rel = nil)
+        @cached_rels << rel if rel
+        (@cached_result ||= []) << object
+      end
+
+      def rels
+        @cached_rels || super
       end
 
       def cache_query_proxy_result

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

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

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

@@ -2,58 +2,173 @@ module Neo4j
   module ActiveNode
     module Query
       module QueryProxyEagerLoading
-        def each(node = true, rel = nil, &block)
-          return super if with_associations_spec.size.zero?
+        class IdentityMap < Hash
+          def add(node)
+            self[node.neo_id] ||= node
+          end
+        end
+
+        class AssociationTree < Hash
+          attr_accessor :model, :name, :association, :path
+
+          def initialize(model, name = nil)
+            super()
+            self.model = name ? target_class(model, name) : model
+            self.name = name
+            self.association = name ? model.associations[name] : nil
+          end
+
+          def clone
+            super.tap { |copy| copy.each { |key, value| copy[key] = value.clone } }
+          end
 
-          query_from_association_spec.pluck(identity, "[#{with_associations_return_clause}]").map do |record, eager_data|
-            eager_data.each_with_index do |eager_records, index|
-              record.association_proxy(with_associations_spec[index]).cache_result(eager_records)
+          def add_spec(spec)
+            if spec.is_a?(Array)
+              spec.each { |s| add_spec(s) }
+            elsif spec.is_a?(Hash)
+              spec.each { |k, v| (self[k] ||= AssociationTree.new(model, k)).add_spec(v) }
+            else
+              self[spec] ||= AssociationTree.new(model, spec)
             end
+          end
+
+          def paths(*prefix)
+            values.flat_map { |v| [[*prefix, v]] + v.paths(*prefix, v) }
+          end
+
+          private
 
-            yield(record)
+          def target_class(model, key)
+            association = model.associations[key]
+            fail "Invalid association: #{[*path, key].join('.')}" unless association
+            model.associations[key].target_class
           end
         end
 
-        def with_associations_spec
-          @with_associations_spec ||= []
+        def pluck_vars(node, rel)
+          return super if with_associations_tree.size.zero?
+
+          perform_query
         end
 
-        def with_associations(*spec)
-          invalid_association_names = spec.reject do |association_name|
-            model.associations[association_name]
-          end
+        def perform_query
+          @_cache = IdentityMap.new
+          query_from_association_tree
+            .map do |record, eager_data|
+            cache_and_init(record, with_associations_tree)
+            eager_data.zip(with_associations_tree.paths.map(&:last)).each do |eager_records, element|
+              eager_records.first.zip(eager_records.last).each do |eager_record|
+                add_to_cache(*eager_record, element)
+              end
+            end
 
-          if !invalid_association_names.empty?
-            fail "Invalid associations: #{invalid_association_names.join(', ')}"
+            record
           end
+        end
 
+        def with_associations(*spec)
           new_link.tap do |new_query_proxy|
-            new_spec = new_query_proxy.with_associations_spec + spec
-            new_query_proxy.with_associations_spec.replace(new_spec)
+            new_query_proxy.with_associations_tree = with_associations_tree.clone
+            new_query_proxy.with_associations_tree.add_spec(spec)
           end
         end
 
+        def with_associations_tree
+          @with_associations_tree ||= AssociationTree.new(model)
+        end
+
+        def with_associations_tree=(tree)
+          @with_associations_tree = tree
+        end
+
+        def first
+          (query.clause?(:order) ? self : order(order_property)).limit(1).to_a.first
+        end
+
         private
 
-        def with_associations_return_clause(variables = with_associations_spec)
-          variables.map { |n| "#{n}_collection" }.join(',')
+        def add_to_cache(rel, node, element)
+          direction = element.association.direction
+          node = cache_and_init(node, element)
+          if rel.is_a?(Neo4j::ActiveRel)
+            rel.instance_variable_set(direction == :in ? '@from_node' : '@to_node', node)
+          end
+          @_cache[direction == :out ? rel.start_node_neo_id : rel.end_node_neo_id]
+            .association_proxy(element.name).add_to_cache(node, rel)
+        end
+
+        def init_associations(node, element)
+          element.keys.each { |key| node.association_proxy(key).init_cache }
+        end
+
+        def cache_and_init(node, element)
+          @_cache.add(node).tap { |n| init_associations(n, element) }
+        end
+
+        def with_associations_return_clause(variables = path_names)
+          var_list(variables, &:itself)
+        end
+
+        def var_list(variables)
+          variables.map { |n| yield(escape("#{n}_collection")) }.join(',')
         end
 
-        def query_from_association_spec
+        # In neo4j version 2.1.8 this fails due to a bug:
+        # MATCH (`n`) WITH `n` RETURN `n`
+        # but this
+        # MATCH (`n`) WITH n RETURN `n`
+        # and this
+        # MATCH (`n`) WITH `n` AS `n` RETURN `n`
+        # does not
+        def var_list_fixing_neo4j_2_1_8_bug(variables)
+          var_list(variables) { |var| "#{var} AS #{var}" }
+        end
+
+        def escape(s)
+          "`#{s}`"
+        end
+
+        def path_name(path)
+          path.map(&:name).join('.')
+        end
+
+        def path_names
+          with_associations_tree.paths.map { |path| path_name(path) }
+        end
+
+        def query_from_association_tree
           previous_with_variables = []
-          with_associations_spec.inject(query_as(identity).with(identity)) do |query, association_name|
-            with_association_query_part(query, association_name, previous_with_variables).tap do
-              previous_with_variables << association_name
+          with_associations_tree.paths.inject(query_as(identity).with(identity)) do |query, path|
+            with_association_query_part(query, path, previous_with_variables).tap do
+              previous_with_variables << path_name(path)
             end
-          end.return(identity)
+          end.pluck(identity, "[#{with_associations_return_clause}]")
         end
 
-        def with_association_query_part(base_query, association_name, previous_with_variables)
-          association = model.associations[association_name]
+        def with_association_query_part(base_query, path, previous_with_variables)
+          optional_match_with_where(base_query, path)
+            .with(identity,
+                  "[collect(#{escape("#{path_name(path)}_rel")}), collect(#{escape path_name(path)})] AS #{escape("#{path_name(path)}_collection")}",
+                  *var_list_fixing_neo4j_2_1_8_bug(previous_with_variables))
+        end
+
+        def optional_match_with_where(base_query, path)
+          path
+            .each_with_index.map { |_, index| path[0..index] }
+            .inject(optional_match(base_query, path)) do |query, path_prefix|
+            query.where(path_prefix.last.association.target_where_clause(escape(path_name(path_prefix))))
+          end
+        end
+
+        def optional_match(base_query, path)
+          base_query.optional_match(
+            "(#{identity})#{path.each_with_index.map do |element, index|
+              relationship_part(element.association, path_name(path[0..index]))
+            end.join}")
+        end
 
-          base_query.optional_match("(#{identity})#{association.arrow_cypher}(#{association_name})")
-                    .where(association.target_where_clause)
-                    .with(identity, "collect(#{association_name}) AS #{association_name}_collection", *with_associations_return_clause(previous_with_variables))
+        def relationship_part(association, path_name)
+          "#{association.arrow_cypher(escape("#{path_name}_rel"))}(#{escape(path_name)})"
         end
       end
     end

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -11,8 +11,9 @@ module Neo4j
       def wrapper(rel)
         rel.props.symbolize_keys!
         begin
-          most_concrete_class = class_from_type(rel.rel_type)
-          most_concrete_class.constantize.new
+          most_concrete_class = class_from_type(rel.rel_type).constantize
+          return rel unless most_concrete_class < Neo4j::ActiveRel
+          most_concrete_class.new
         rescue NameError => e
           raise e unless e.message =~ /(uninitialized|wrong) constant/
 

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '8.1.5'
+  VERSION = '8.2.1'
 end

data/neo4j.gemspec

@@ -30,7 +30,7 @@ A Neo4j OGM (Object-Graph-Mapper) for Ruby heavily inspired by ActiveRecord.
   s.add_dependency('orm_adapter', '~> 0.5.0')
   s.add_dependency('activemodel', '>= 4.0')
   s.add_dependency('activesupport', '>= 4.0')
-  s.add_dependency('neo4j-core', '>= 7.0.0')
+  s.add_dependency('neo4j-core', '>= 7.2.2')
   s.add_dependency('neo4j-community', '~> 2.0') if RUBY_PLATFORM =~ /java/
   s.add_development_dependency('railties', '>= 4.0')
   s.add_development_dependency('pry')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 8.1.5
+  version: 8.2.1
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.2.2
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -349,7 +349,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: neo4j
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: A graph database for Ruby