neo4j-core 6.1.6 → 7.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 131388b56fcbd32c29bb5408fb8474cdc8b78776
-  data.tar.gz: 8cd2bf7b5850b2bcac88575196c3174a80a1a47e
+  metadata.gz: d35477edf97f10ae13b42128f88351fd5823160f
+  data.tar.gz: ef4e066f6673584c3863f0a68a7c0f78034755eb
 SHA512:
-  metadata.gz: c9fb22452fdfe95e4c533445eeeccc7180657eba6332f03d0139372575b346db43e744caefa4d16004b426d85b030fe1253d5eb2e3e7a751b5385f7e6782ab2e
-  data.tar.gz: e58f76b625bd8db33c0e6814ff95c9cd0ef3b2c6b3ab90b7ece0eaa331af3bea722a20e8b7bf75f876e7c2ce469524d9472ab8b4e11a8f4daa98e8ce89630f3d
+  metadata.gz: 6855bc2443d440660c73c1f8d0270abf0ca18dca819cbae37f57a2a277e0ef9c49d166209f8377c87397d6ed1314eda0cba700e3b729c764f2b3077c38770476
+  data.tar.gz: 0887b3a29ca9c0ce06c1352df53824678f2c571a15fd0b89da9383374af3faab6add251f927079689695d323e412c1d00721e77eb23917331b78972014f72b80

data/Gemfile

@@ -5,23 +5,18 @@ gemspec
 # gem 'neo4j-advanced',   '>= 1.8.1', '< 2.0', :require => false
 # gem 'neo4j-enterprise', '>= 1.8.1', '< 2.0', :require => false
 
-gem 'activesupport', '~> 4.2' if RUBY_VERSION.to_f < 2.2
+gem 'tins', '< 1.7' if RUBY_VERSION.to_f < 2.0
 
 group 'development' do
-  gem 'listen', '< 3.1'
-  gem 'guard-rspec', require: false
-  if RUBY_VERSION.to_f < 2.0
-    gem 'overcommit', '< 0.35.0'
-  else
-    gem 'overcommit'
-  end
+  gem 'guard-rspec', require: false if RUBY_PLATFORM != 'java'
+  gem 'overcommit'
 end
 
 group 'test' do
   gem 'coveralls', require: false
   gem 'simplecov-html', require: false
-  gem 'tins', '< 1.7' if RUBY_VERSION.to_f < 2.0
   gem 'rspec', '~> 3.0'
   gem 'rspec-its'
   gem 'dotenv'
+  gem 'activesupport', '~> 4.0'
 end

data/README.md

@@ -3,6 +3,54 @@
 A simple Ruby wrapper around the Neo4j graph database that works with the server and embedded Neo4j API. This gem can be used both from JRuby and normal MRI.
 It can be used standalone without the neo4j gem.
 
+## Basic usage
+
+### Executing Cypher queries
+
+To make a basic connection to Neo4j to execute Cypher queries, first choose an adaptor.  Adaptors for HTTP and Embedded mode (jRuby only) are available (support for Neo4j 3.0's [Bolt protocol](http://alpha.neohq.net/docs/server-manual/bolt.html) is planned).  You can create an adaptor like:
+
+    http_adaptor = Neo4j::Core::CypherSession::Adaptors::HTTP.new('http://neo4j:pass@localhost:7474')
+
+    # or
+
+    neo4j_adaptor = Neo4j::Core::CypherSession::Adaptors::Embedded.new('/file/path/to/graph.db')
+
+Once you have an adaptor you can create a session like so:
+
+    neo4j_session = Neo4j::Core::CypherSession.new(http_adaptor)
+
+From there you can make queries with a Cypher string:
+
+    # Basic query
+    neo4j_session.query('MATCH (n) RETURN n LIMIT 10')
+
+    # Query with parameters
+    neo4j_session.query('MATCH (n) RETURN n LIMIT {limit}', limit: 10)
+
+Or via the `Neo4j::Core::Query` class
+
+    query_obj = Neo4j::Core::Query.new.match(:n).return(:n).limit(10)
+
+    neo4j_session.query(query_obj)
+
+Making multiple queries with one request is support with the HTTP Adaptor:
+
+    results = neo4j_session.queries do
+      append 'MATCH (n:Foo) RETURN n LIMIT 10'
+      append 'MATCH (n:Bar) RETURN n LIMIT 5'
+    end
+
+    results[0] # results of first query
+    results[1] # results of second query
+
+When doing batched queries, there is also a shortcut for getting a new `Neo4j::Core::Query`:
+
+    results = neo4j_session.queries do
+      append query.match(:n).return(:n).limit(10)
+    end
+
+    results[0] # result
+
 ## Documentation
 
 ### 3.0+ Documentation:

data/lib/neo4j-core.rb

@@ -24,3 +24,26 @@ require 'neo4j/transaction'
 
 require 'rake'
 require 'neo4j/rake_tasks'
+
+require 'logger'
+
+module Neo4j
+  module Core
+    ORIGINAL_FORMATTER = ::Logger::Formatter.new
+
+    def self.logger(stream = STDOUT)
+      @logger ||= Logger.new(stream).tap do |logger|
+        logger.formatter = method(:formatter)
+      end
+    end
+
+    def self.formatter(severity, datetime, progname, msg)
+      output = ''
+      if Thread.current != Thread.main
+        output += "#{ANSI::YELLOW}Thread: #{Thread.current.object_id}: #{ANSI::CLEAR}"
+      end
+      output += msg
+      ORIGINAL_FORMATTER.call(severity, datetime, progname, output)
+    end
+  end
+end

data/lib/neo4j-core/helpers.rb

@@ -18,6 +18,14 @@ module Neo4j
       def self.using_new_session?
         ENV.key?('NEW_NEO4J_SESSIONS')
       end
+
+      def self.wrapping_level(level = nil)
+        if level.nil?
+          @wrapping_level || :core_entity
+        else
+          @wrapping_level = level
+        end
+      end
     end
   end
 end

data/lib/neo4j-core/query.rb

@@ -158,10 +158,11 @@ module Neo4j
       # DETACH DELETE clause
       # @return [Query]
 
-      METHODS = %w(start match optional_match call using where create create_unique merge set on_create_set on_match_set remove unwind delete detach_delete with return order skip limit) # rubocop:disable Metrics/LineLength
-      BREAK_METHODS = %(with call)
+      METHODS = %w(start match optional_match using where create create_unique merge set on_create_set on_match_set remove unwind delete detach_delete with return order skip limit)
+      BREAK_METHODS = %(with)
 
       CLAUSIFY_CLAUSE = proc { |method| const_get(method.to_s.split('_').map(&:capitalize).join + 'Clause') }
+
       CLAUSES = METHODS.map(&CLAUSIFY_CLAUSE)
 
       METHODS.each_with_index do |clause, i|
@@ -175,8 +176,8 @@ module Neo4j
         end
       end
 
-      alias_method :offset, :skip
-      alias_method :order_by, :order
+      alias offset skip
+      alias order_by order
 
       # Clears out previous order clauses and allows only for those specified by args
       def reorder(*args)
@@ -235,16 +236,16 @@ module Neo4j
       def response
         return @response if @response
 
-        cypher = to_cypher
-        pretty_cypher = to_cypher(pretty: true) if self.class.pretty_cypher
-
         @response = if session_is_new_api?
-                      @session.query(self)
+                      @session.query(self, transaction: Transaction.current_for(@session), wrap_level: (:core_entity if unwrapped?))
                     else
-                      @session._query(cypher, merge_params, context: @options[:context], pretty_cypher: pretty_cypher)
+                      @session._query(to_cypher, merge_params,
+                                      context: @options[:context], pretty_cypher: (pretty_cypher if self.class.pretty_cypher)).tap(&method(:raise_if_cypher_error!))
                     end
+      end
 
-        (!@response.respond_to?(:error?) || !response.error?) ? @response : @response.raise_cypher_error
+      def raise_if_cypher_error!(response)
+        response.raise_cypher_error if response.respond_to?(:error?) && response.error?
       end
 
       def match_nodes(hash, optional_match = false)
@@ -269,9 +270,11 @@ module Neo4j
 
       def each
         response = self.response
-        if response.is_a?(Neo4j::Server::CypherResponse)
+        if defined?(Neo4j::Server::CypherResponse) && response.is_a?(Neo4j::Server::CypherResponse)
           response.unwrapped! if unwrapped?
           response.to_node_enumeration
+        elsif defined?(Neo4j::Core::CypherSession::Result) && response.is_a?(Neo4j::Core::CypherSession::Result)
+          response.to_a
         else
           Neo4j::Embedded::ResultWrapper.new(response, to_cypher, unwrapped?)
         end.each { |object| yield object }
@@ -307,8 +310,7 @@ module Neo4j
         query = return_query(columns)
         columns = query.response.columns
 
-        case columns.size
-        when 1
+        if columns.size == 1
           column = columns[0]
           query.map { |row| row[column] }
         else
@@ -346,7 +348,7 @@ module Neo4j
         cypher_string = "CYPHER #{@options[:parser]} #{cypher_string}" if @options[:parser]
         cypher_string.tap(&:strip!)
       end
-      alias_method :cypher, :to_cypher
+      alias cypher to_cypher
 
       def pretty_cypher
         to_cypher(pretty: true)
@@ -481,17 +483,18 @@ module Neo4j
             @partitioning[-2] && @partitioning[-2].any? { |c| self.class.clause_is_order_or_limit?(c) }
         end
 
-        def self.clause_is_order_or_limit?(clause)
-          clause.is_a?(::Neo4j::Core::QueryClauses::OrderClause) ||
-            clause.is_a?(::Neo4j::Core::QueryClauses::LimitClause)
+        class << self
+          def clause_is_order_or_limit?(clause)
+            clause.is_a?(::Neo4j::Core::QueryClauses::OrderClause) ||
+              clause.is_a?(::Neo4j::Core::QueryClauses::LimitClause)
+          end
         end
       end
 
       # SHOULD BE DEPRECATED
       def merge_params
-        @clauses.compact!
-        @merge_params ||= @clauses.inject(@params.to_hash) { |params, clause| params.merge!(clause.params) }
-        @params.to_hash
+        @merge_params_base ||= @clauses.compact.inject({}) { |params, clause| params.merge!(clause.params) }
+        @params.to_hash.merge(@merge_params_base)
       end
     end
   end

data/lib/neo4j-core/query_clauses.rb

@@ -90,8 +90,8 @@ module Neo4j
           when Hash
             if value.values.map(&:class) == [Hash]
               value.first.first
-            else
-              key if !_use_key_for_var?(value, prefer)
+            elsif !_use_key_for_var?(value, prefer)
+              key
             end
           else
             fail ArgError, value
@@ -144,7 +144,7 @@ module Neo4j
                               keyword
                             end
 
-            "#{final_keyword} #{string}" if string.size > 0
+            "#{final_keyword} #{string}" if !string.empty?
           end
 
           def clause_string(clauses, pretty)
@@ -162,6 +162,14 @@ module Neo4j
           def clause_color
             ANSI::CYAN
           end
+
+          def from_key_and_single_value(key, value)
+            if value.to_sym == :neo_id
+              "ID(#{key})"
+            else
+              "#{key}.#{value}"
+            end
+          end
         end
 
         def self.paramaterize_key!(key)
@@ -211,7 +219,7 @@ module Neo4j
           label_arg = label_arg.to_s
           label_arg.strip!
           if !label_arg.empty? && label_arg[0] != ':'
-            label_arg = "`#{label_arg}`" unless label_arg.match(' ')
+            label_arg = "`#{label_arg}`" unless label_arg[' ']
             label_arg = ":#{label_arg}"
           end
           label_arg
@@ -221,10 +229,10 @@ module Neo4j
           return '' if not attributes
 
           attributes_string = attributes.map do |key, value|
-            if value.to_s.match(/^{.+}$/)
+            if value.to_s =~ /^{.+}$/
               "#{key}: #{value}"
             else
-              param_key = "#{prefix}#{key}".gsub('::', '_')
+              param_key = "#{prefix}#{key}".gsub(/:+/, '_')
               param_key = add_param(param_key, value)
               "#{key}: {#{param_key}}"
             end
@@ -337,24 +345,6 @@ module Neo4j
         end
       end
 
-      class CallClause < Clause
-        KEYWORD = 'CALL'
-
-        def from_string(value)
-          value
-        end
-
-        class << self
-          def clause_strings(clauses)
-            clauses.map!(&:value)
-          end
-
-          def clause_join
-            " #{KEYWORD} "
-          end
-        end
-      end
-
       class MatchClause < Clause
         KEYWORD = 'MATCH'
 
@@ -511,13 +501,13 @@ module Neo4j
         def from_key_and_value(key, value)
           case value
           when String, Symbol
-            "#{key}.#{value}"
+            self.class.from_key_and_single_value(key, value)
           when Array
             value.map do |v|
-              v.is_a?(Hash) ? from_key_and_value(key, v) : "#{key}.#{v}"
+              v.is_a?(Hash) ? from_key_and_value(key, v) : self.class.from_key_and_single_value(key, v)
             end
           when Hash
-            value.map { |k, v| "#{key}.#{k} #{v.upcase}" }
+            value.map { |k, v| "#{self.class.from_key_and_single_value(key, k)} #{v.upcase}" }
           end
         end
 
@@ -708,11 +698,7 @@ module Neo4j
               from_key_and_value(key, v)
             end.join(Clause::COMMA_SPACE)
           when String, Symbol
-            if value.to_sym == :neo_id
-              "ID(#{key})"
-            else
-              "#{key}.#{value}"
-            end
+            self.class.from_key_and_single_value(key, value)
           else
             fail ArgError, value
           end

data/lib/neo4j-core/query_find_in_batches.rb

@@ -18,7 +18,9 @@ module Neo4j
 
           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
+          primary_key_var = Neo4j::Core::QueryClauses::Clause.from_key_and_single_value(node_var, prop_var)
+          records = query.where("#{primary_key_var} > {primary_key_offset}")
+                         .params(primary_key_offset: primary_key_offset).to_a
         end
       end
 

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = '6.1.6'
+    VERSION = '7.0.0.alpha.1'
   end
 end

data/lib/neo4j-embedded/cypher_response.rb

@@ -39,6 +39,10 @@ module Neo4j
         @source.columns.map!(&:to_sym)
       end
 
+      def error?
+        false
+      end
+
       def each
         fail ResultsAlreadyConsumedException unless @unread
 

data/lib/neo4j-embedded/embedded_database.rb

@@ -6,11 +6,9 @@ module Neo4j
 
       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
+          return Neo4j::Session.current if Neo4j::Session.current.respond_to?(:db_location) && Neo4j::Session.current.db_location == db_location
+
+          EmbeddedSession.new(db_location, config)
         end
 
         def create_db(db_location)

data/lib/neo4j-embedded/embedded_node.rb

@@ -16,8 +16,8 @@ module Neo4j
         'Enumerable<Neo4j::Relationship>'
       end
 
-      def each(&block)
-        @node._rels(@match).each { |r| block.call(r.wrapper) }
+      def each
+        @node._rels(@match).each { |r| yield(r.wrapper) }
       end
       tx_methods :each
 
@@ -39,8 +39,8 @@ module Neo4j
         'Enumerable<Neo4j::Node>'
       end
 
-      def each(&block)
-        @node._rels(@match).each { |r| block.call(r.other_node(@node)) }
+      def each
+        @node._rels(@match).each { |r| yield(r.other_node(@node)) }
       end
       tx_methods :each
 

data/lib/neo4j-embedded/embedded_session.rb

@@ -68,21 +68,32 @@ module Neo4j
         Java::OrgNeo4jTest::ImpermanentGraphDatabase
       end
 
-      def begin_tx
-        if Neo4j::Transaction.current
-          # Handle nested transaction "placebo transaction"
-          Neo4j::Transaction.current.push_nested!
-        else
-          Neo4j::Embedded::EmbeddedTransaction.new(@graph_db.begin_tx)
-        end
-        Neo4j::Transaction.current
-      end
-
       def close
         super
         shutdown
       end
 
+      def self.transaction_class
+        Neo4j::Embedded::EmbeddedTransaction
+      end
+
+      # Duplicate of CypherSession::Adaptor::Base#transaction
+      def transaction
+        return self.class.transaction_class.new(self) if !block_given?
+
+        begin
+          tx = transaction
+
+          yield tx
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          tx.mark_failed
+
+          raise e
+        ensure
+          tx.close
+        end
+      end
+
       def shutdown
         @graph_db && @graph_db.shutdown