neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-core/query_find_in_batches.rb

@@ -1,41 +1,41 @@
-module Neo4j::Core
-  module QueryFindInBatches
+module Neo4j
+  module Core
+    module QueryFindInBatches
+      def find_in_batches(node_var, prop_var, options = {})
+        invalid_keys = options.keys.map(&:to_sym) - [:batch_size]
+        fail ArgumentError, "Invalid keys: #{invalid_keys.join(', ')}" if not invalid_keys.empty?
 
-    def find_in_batches(node_var, prop_var, options = {})
-      invalid_keys = options.keys.map(&:to_sym) - [:batch_size]
-      raise ArgumentError, "Invalid keys: #{invalid_keys.join(', ')}" if not invalid_keys.empty?
+        batch_size = options.delete(:batch_size) || 1000
 
-      batch_size = options.delete(:batch_size) || 1000
+        query = reorder(node_var => prop_var).limit(batch_size)
 
-      query = self.reorder(node_var => prop_var).limit(batch_size)
+        records = query.to_a
 
-      records = query.to_a
-
-      while records.any?
-        records_size = records.size
-        primary_key_offset = begin
-                               records.last.send(node_var).send(prop_var)
-                             rescue NoMethodError
-                               begin
-                                 records.last.send(node_var)[prop_var.to_sym]
+        while records.any?
+          records_size = records.size
+          primary_key_offset = begin
+                                 records.last.send(node_var).send(prop_var)
                                rescue NoMethodError
-                                 records.last.send("#{node_var}.#{prop_var}") # In case we're explicitly returning it
+                                 begin
+                                   records.last.send(node_var)[prop_var.to_sym]
+                                 rescue NoMethodError
+                                   records.last.send("#{node_var}.#{prop_var}") # In case we're explicitly returning it
+                                 end
                                end
-                             end
 
-        yield records
+          yield records
 
-        break if records_size < batch_size
+          break if records_size < batch_size
 
-        records = query.where("#{node_var}.#{prop_var} > {primary_key_offset}").params(primary_key_offset: primary_key_offset).to_a
+          records = query.where("#{node_var}.#{prop_var} > {primary_key_offset}").params(primary_key_offset: primary_key_offset).to_a
+        end
       end
-    end
 
-    def find_each(*args)
-      find_in_batches(*args) do |batch|
-        batch.each { |result| yield result }
+      def find_each(*args)
+        find_in_batches(*args) do |batch|
+          batch.each { |result| yield result }
+        end
       end
     end
   end
 end
-

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.1.1"
+    VERSION = '4.0.0'
   end
 end

data/lib/neo4j-embedded.rb

@@ -11,5 +11,5 @@ require 'neo4j-embedded/embedded_label'
 require 'neo4j-embedded/embedded_transaction'
 require 'neo4j-embedded/cypher_response'
 
-# TODO replace this with https://github.com/intridea/hashie gem
-require 'neo4j-core/hash_with_indifferent_access'
+# TODO: replace this with https://github.com/intridea/hashie gem
+require 'neo4j-core/hash_with_indifferent_access'

data/lib/neo4j-embedded/cypher_response.rb

@@ -1,53 +1,52 @@
-module Neo4j::Embedded
-
-  # Wraps the Cypher query result.
-  # Loads the node and relationships wrapper if possible and use symbol as column keys.
-  # This is typically used in the native neo4j bindings since result does is not a Ruby enumerable with symbols as keys.
-  # @note The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
-  #
-  class ResultWrapper
-    class ResultsAlreadyConsumedException < Exception;
-    end
-
-    include Enumerable
+module Neo4j
+  module Embedded
+    # Wraps the Cypher query result.
+    # Loads the node and relationships wrapper if possible and use symbol as column keys.
+    # This is typically used in the native neo4j bindings since result does is not a Ruby enumerable with symbols as keys.
+    # @note The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
+    #
+    class ResultWrapper
+      class ResultsAlreadyConsumedException < Exception
+      end
 
-    # @return the original result from the Neo4j Cypher Engine, once forward read only !
-    attr_reader :source
+      include Enumerable
 
-    def initialize(source, query)
-      @source = source
-      @struct = Struct.new(*source.columns.to_a.map(&:to_sym))
-      @unread = true
-      @query = query
-    end
+      # @return the original result from the Neo4j Cypher Engine, once forward read only !
+      attr_reader :source
 
-    def to_s
-      @query
-    end
+      def initialize(source, query)
+        @source = source
+        @struct = Struct.new(*source.columns.to_a.map(&:to_sym))
+        @unread = true
+        @query = query
+      end
 
-    def inspect
-      "Enumerable query: '#{@query}'"
-    end
+      def to_s
+        @query
+      end
 
-    # @return [Array<Symbol>] the columns in the query result
-    def columns
-      @source.columns.map(&:to_sym)
-    end
+      def inspect
+        "Enumerable query: '#{@query}'"
+      end
 
-    def each
-      raise ResultsAlreadyConsumedException unless @unread
+      # @return [Array<Symbol>] the columns in the query result
+      def columns
+        @source.columns.map(&:to_sym)
+      end
 
-      if block_given?
-        @source.each do |row|
-          yield(row.each_with_object(@struct.new) do |(column, value), result|
-            result[column.to_sym] = (value.respond_to?(:wrapper) ? value.wrapper : value)
-          end)
+      def each
+        fail ResultsAlreadyConsumedException unless @unread
+
+        if block_given?
+          @source.each do |row|
+            yield(row.each_with_object(@struct.new) do |(column, value), result|
+              result[column.to_sym] = (value.respond_to?(:wrapper) ? value.wrapper : value)
+            end)
+          end
+        else
+          Enumerator.new(self)
         end
-      else
-        Enumerator.new(self)
       end
     end
-
   end
 end
-

data/lib/neo4j-embedded/embedded_database.rb

@@ -1,29 +1,28 @@
-module Neo4j::Embedded
-  class EmbeddedDatabase
-
-    class Error < StandardError
-    end
+module Neo4j
+  module Embedded
+    class EmbeddedDatabase
+      class Error < StandardError
+      end
 
-    class << self
-      def connect(db_location, config={})
-        if Neo4j::Session.current.respond_to?(:db_location) && Neo4j::Session.current.db_location == db_location
-          return Neo4j::Session.current
-        else
-          EmbeddedSession.new(db_location, config)
+      class << self
+        def connect(db_location, config = {})
+          if Neo4j::Session.current.respond_to?(:db_location) && Neo4j::Session.current.db_location == db_location
+            return Neo4j::Session.current
+          else
+            EmbeddedSession.new(db_location, config)
+          end
         end
-      end
 
-      def create_db(db_location)
-        puts "Start embedded Neo4j db at #{db_location}"
-        factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
-        factory.newEmbeddedDatabase(db_location)
-      end
+        def create_db(db_location)
+          puts "Start embedded Neo4j db at #{db_location}"
+          factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
+          factory.newEmbeddedDatabase(db_location)
+        end
 
-      def factory_class
-        Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
-        Java::OrgNeo4jTest::ImpermanentGraphDatabase
+        def factory_class
+          Java::OrgNeo4jTest::ImpermanentGraphDatabase
+        end
       end
-
     end
   end
-end
+end

data/lib/neo4j-embedded/embedded_ha_session.rb

@@ -4,18 +4,20 @@ Neo4j::Session.register_db(:ha_db) do |*args|
   Neo4j::Embedded::EmbeddedHaSession.new(*args)
 end
 
-module Neo4j::Embedded
-  class EmbeddedHaSession < EmbeddedSession
-    def start
-      raise Error.new("Embedded HA Neo4j db is already running") if running?
-      puts "Start embedded HA Neo4j db at #{db_location}"
-      factory    = Java::OrgNeo4jGraphdbFactory::HighlyAvailableGraphDatabaseFactory.new
-      db_service = factory.newHighlyAvailableDatabaseBuilder(db_location)
+module Neo4j
+  module Embedded
+    class EmbeddedHaSession < EmbeddedSession
+      def start
+        fail Error, 'Embedded HA Neo4j db is already running' if running?
+        puts "Start embedded HA Neo4j db at #{db_location}"
+        factory    = Java::OrgNeo4jGraphdbFactory::HighlyAvailableGraphDatabaseFactory.new
+        db_service = factory.newHighlyAvailableDatabaseBuilder(db_location)
 
-      raise Error.new("Need properties file for HA configuration") unless properties_file
-      db_service.loadPropertiesFromFile(properties_file)
-      @graph_db = db_service.newGraphDatabase()
-      Neo4j::Session._notify_listeners(:session_available, self)
+        fail Error, 'Need properties file for HA configuration' unless properties_file
+        db_service.loadPropertiesFromFile(properties_file)
+        @graph_db = db_service.newGraphDatabase
+        Neo4j::Session._notify_listeners(:session_available, self)
+      end
     end
   end
 end

data/lib/neo4j-embedded/embedded_impermanent_session.rb

@@ -4,14 +4,15 @@ Neo4j::Session.register_db(:impermanent_db) do |*args|
   Neo4j::Embedded::EmbeddedImpermanentSession.new(*args)
 end
 
-module Neo4j::Embedded
-  class EmbeddedImpermanentSession < EmbeddedSession
-    def start
-      raise Error.new("Embedded Neo4j db is already running") if running?
-      #puts "Start test impermanent embedded Neo4j db at #{db_location}"
-      @graph_db = Java::OrgNeo4jTest::TestGraphDatabaseFactory.new.newImpermanentDatabase()
-      Neo4j::Session._notify_listeners(:session_available, self)
+module Neo4j
+  module Embedded
+    class EmbeddedImpermanentSession < EmbeddedSession
+      def start
+        fail Error, 'Embedded Neo4j db is already running' if running?
+        # puts "Start test impermanent embedded Neo4j db at #{db_location}"
+        @graph_db = Java::OrgNeo4jTest::TestGraphDatabaseFactory.new.newImpermanentDatabase
+        Neo4j::Session._notify_listeners(:session_available, self)
+      end
     end
   end
 end
-

data/lib/neo4j-embedded/embedded_label.rb

@@ -1,92 +1,86 @@
-module Neo4j::Embedded
-  class EmbeddedLabel < Neo4j::Label
-    extend Neo4j::Core::TxMethods
-    attr_reader :name
-    JAVA_CLASS = Java::OrgNeo4jGraphdb::DynamicLabel
-
-    def initialize(session, name)
-      @name = name.to_sym
-      @session = session
-    end
+module Neo4j
+  module Embedded
+    class EmbeddedLabel < Neo4j::Label
+      extend Neo4j::Core::TxMethods
+      attr_reader :name
+      JAVA_CLASS = Java::OrgNeo4jGraphdb::DynamicLabel
+
+      def initialize(session, name)
+        @name = name.to_sym
+        @session = session
+      end
 
-    def to_s
-      @name
-    end
+      def to_s
+        @name
+      end
 
-    def find_nodes(key=nil, value=nil)
-       begin
-        iterator = _find_nodes(key,value)
-        iterator.to_a.map{|n| n.wrapper}
+      def find_nodes(key = nil, value = nil)
+        iterator = _find_nodes(key, value)
+        iterator.to_a.map(&:wrapper)
       ensure
         iterator && iterator.close
       end
-    end
-    tx_methods :find_nodes
+      tx_methods :find_nodes
 
-    def _find_nodes(key=nil, value=nil)
-      if (key)
-        @session.graph_db.find_nodes_by_label_and_property(as_java, key, value).iterator
-      else
-        ggo = Java::OrgNeo4jTooling::GlobalGraphOperations.at(@session.graph_db)
-        ggo.getAllNodesWithLabel(as_java).iterator
+      def _find_nodes(key = nil, value = nil)
+        if key
+          @session.graph_db.find_nodes_by_label_and_property(as_java, key, value).iterator
+        else
+          ggo = Java::OrgNeo4jTooling::GlobalGraphOperations.at(@session.graph_db)
+          ggo.getAllNodesWithLabel(as_java).iterator
+        end
       end
 
-    end
-
-    def as_java
-      self.class.as_java(@name.to_s)
-    end
+      def as_java
+        self.class.as_java(@name.to_s)
+      end
 
-    def create_index(*properties)
+      def create_index(*properties)
         index_creator = @session.graph_db.schema.index_for(as_java)
-      # we can also use the PropertyConstraintCreator here
-      properties.inject(index_creator) {|creator, key| creator.on(key.to_s)}.create
-    end
-    tx_methods :create_index
+        # we can also use the PropertyConstraintCreator here
+        properties.inject(index_creator) { |creator, key| creator.on(key.to_s) }.create
+      end
+      tx_methods :create_index
 
-    def indexes()
-      {
+      def indexes
+        {
           property_keys: @session.graph_db.schema.indexes(as_java).map do |index_def|
-            index_def.property_keys.map{|x| x.to_sym}
+            index_def.property_keys.map(&:to_sym)
           end
-      }
-    end
-    tx_methods :indexes
-
-    def uniqueness_constraints()
-      {
-          property_keys: @session.graph_db.schema.constraints(as_java).select do |index_def|
-            index_def.is_a?(Java::OrgNeo4jKernelImplCoreapiSchema::PropertyUniqueConstraintDefinition)
-          end.map do |index_def|
-            index_def.property_keys.map{|x| x.to_sym}
-          end
-      }
-    end
-    tx_methods :uniqueness_constraints
-
-
-    def drop_index(*properties)
-      @session.graph_db.schema.indexes(as_java).each do |index_def|
-        # at least one match, TODO
-        keys = index_def.property_keys.map{|x| x.to_sym}
-        index_def.drop if (properties - keys).count < properties.count
+        }
       end
+      tx_methods :indexes
 
-    end
-    tx_methods :drop_index
+      def uniqueness_constraints
+        definitions = @session.graph_db.schema.constraints(as_java).select do |index_def|
+          index_def.is_a?(Java::OrgNeo4jKernelImplCoreapiSchema::PropertyUniqueConstraintDefinition)
+        end
+        {
+          property_keys: definitions.map { |index_def| index_def.property_keys.map(&:to_sym) }
+        }
+      end
+      tx_methods :uniqueness_constraints
 
-    class << self
 
-      def as_java(labels)
-        if labels.is_a?(Array)
-          return nil if labels.empty?
-          labels.inject([]) { |result, label| result << JAVA_CLASS.label(label.to_s) }.to_java(JAVA_CLASS)
-        else
-          JAVA_CLASS.label(labels.to_s)
+      def drop_index(*properties)
+        @session.graph_db.schema.indexes(as_java).each do |index_def|
+          # at least one match, TODO
+          keys = index_def.property_keys.map(&:to_sym)
+          index_def.drop if (properties - keys).count < properties.count
+        end
+      end
+      tx_methods :drop_index
+
+      class << self
+        def as_java(labels)
+          if labels.is_a?(Array)
+            return nil if labels.empty?
+            labels.inject([]) { |result, label| result << JAVA_CLASS.label(label.to_s) }.to_java(JAVA_CLASS)
+          else
+            JAVA_CLASS.label(labels.to_s)
+          end
         end
       end
     end
   end
-
 end
-

data/lib/neo4j-embedded/embedded_node.rb

@@ -1,57 +1,55 @@
-module Neo4j::Embedded
-  class RelsIterator
-    include Enumerable
-    extend Neo4j::Core::TxMethods
-
-    def initialize(node, match)
-      @node = node
-      @match = match
-    end
+module Neo4j
+  module Embedded
+    class RelsIterator
+      include Enumerable
+      extend Neo4j::Core::TxMethods
+
+      def initialize(node, match)
+        @node = node
+        @match = match
+      end
 
-    def inspect
-      "Enumerable<Neo4j::Relationship>"
-    end
+      def inspect
+        'Enumerable<Neo4j::Relationship>'
+      end
 
-    def each(&block)
-      @node._rels(@match).each {|r| block.call(r.wrapper)}
-    end
-    tx_methods :each
+      def each(&block)
+        @node._rels(@match).each { |r| block.call(r.wrapper) }
+      end
+      tx_methods :each
 
-    def empty?
-      first == nil
+      def empty?
+        first.nil?
+      end
     end
 
-  end
-
-  class NodesIterator
-    include Enumerable
-    extend Neo4j::Core::TxMethods
+    class NodesIterator
+      include Enumerable
+      extend Neo4j::Core::TxMethods
 
-    def initialize(node, match)
-      @node = node
-      @match = match
-    end
+      def initialize(node, match)
+        @node = node
+        @match = match
+      end
 
-    def inspect
-      "Enumerable<Neo4j::Node>"
-    end
+      def inspect
+        'Enumerable<Neo4j::Node>'
+      end
 
-    def each(&block)
-      @node._rels(@match).each {|r| block.call(r.other_node(@node))}
-    end
-    tx_methods :each
+      def each(&block)
+        @node._rels(@match).each { |r| block.call(r.other_node(@node)) }
+      end
+      tx_methods :each
 
-    def empty?
-      first == nil
+      def empty?
+        first.nil?
+      end
     end
 
-  end
-
-  class EmbeddedNode
-    class << self
-      # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
-      def extend_java_class(java_clazz)
-        java_clazz.class_eval do
+    class EmbeddedNode
+      class << self
+        # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
+        Java::OrgNeo4jKernelImplCore::NodeProxy.class_eval do
           include Neo4j::Embedded::Property
           include Neo4j::EntityEquality
           include Neo4j::Core::ActiveEntity
@@ -69,7 +67,7 @@ module Neo4j::Embedded
           tx_methods :exist?
 
           def labels
-            _labels.iterator.map{|x| x.name.to_sym}
+            _labels.iterator.map { |x| x.name.to_sym }
           end
           tx_methods :labels
 
@@ -108,7 +106,7 @@ module Neo4j::Embedded
           tx_methods :set_label
 
           def del
-            _rels.each { |r| r.del }
+            _rels.each(&:del)
             delete
             nil
           end
@@ -126,72 +124,72 @@ module Neo4j::Embedded
           tx_methods :create_rel
 
 
-          def rels(match={})
+          def rels(match = {})
             RelsIterator.new(self, match)
           end
 
-          def nodes(match={})
+          def nodes(match = {})
             NodesIterator.new(self, match)
           end
 
-          def node(match={})
+          def node(match = {})
             rel = _rel(match)
             rel && rel.other_node(self).wrapper
           end
           tx_methods :node
 
-          def rel?(match={})
+          def rel?(match = {})
             _rels(match).has_next
           end
           tx_methods :rel?
 
-          def rel(match={})
+          def rel(match = {})
             _rel(match)
           end
           tx_methods :rel
 
-          def _rel(match={})
-            dir = match[:dir] || :both
+          def _rel(match = {})
+            dir = ToJava.dir_to_java(match[:dir] || :both)
             rel_type = match[:type]
 
             rel = if rel_type
-                     get_single_relationship(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir))
+                    get_single_relationship(ToJava.type_to_java(rel_type), dir)
                   else
-                     iter = get_relationships(ToJava.dir_to_java(dir)).iterator
-                     if (iter.has_next)
-                       first = iter.next
-                       raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
-                       first
-                     end
-                   end
+                    iter = get_relationships(dir).iterator
+
+                    if iter.has_next
+                      first = iter.next
+                      fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
+                      first
+                    end
+                  end
 
             between_id = match[:between] && match[:between].neo_id
 
-            if (rel && between_id)
-              rel.other_node(self).neo_id == between_id ? rel : nil
+            if rel && between_id
+              rel if rel.other_node(self).neo_id == between_id
             else
               rel
             end
           end
 
-          def _rels(match={})
+          def _rels(match = {})
             dir = match[:dir] || :both
             rel_type = match[:type]
 
             rels = if rel_type
-              get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
-            else
-              get_relationships(ToJava.dir_to_java(dir)).iterator
-            end
+                     get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
+                   else
+                     get_relationships(ToJava.dir_to_java(dir)).iterator
+                   end
 
             between_id = match[:between] && match[:between].neo_id
 
-            if (between_id)
-              rels.find_all{|r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id}
+            if between_id
+              rels.find_all { |r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id }
             else
               rels
             end
-
           end
 
           def class
@@ -202,8 +200,5 @@ module Neo4j::Embedded
         end
       end
     end
-
-    extend_java_class(Java::OrgNeo4jKernelImplCore::NodeProxy)
   end
-
 end