neo4j-core 3.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb8493440e6f8164e499189ebc58e95998b5bad1
-  data.tar.gz: 02678788be0642f10aa6781bdcb82fd11ab5fe97
+  metadata.gz: 6e441fd4d968dfd3b6caf201fc60ce19c2698d29
+  data.tar.gz: d4e88b57b2ecd1a342eaa83c4c05faa1c4d3bdbe
 SHA512:
-  metadata.gz: 82882d368b6ff790c061653f0cb68a2af37e328ef2ea948c507671108976d0a7ee60fac78653b6e254ca4a5d00c6cedf1bcda3bce15e038b446665042363fe5d
-  data.tar.gz: 76be0d527c6d6710eb3753fd370b747341efd3f099654447d9297a18d29bb01c330764183d206ef48fa59aab78ecdfa600cdb55879e0ad106a177e0188970035
+  metadata.gz: 65292755970b43e9c31b886c1e3e52455094f7de61e44d483f88c15d9f4ec713a9ceeff2302b0918c02264ee957e08210850aa29ed3651905bcd5149165916dc
+  data.tar.gz: b3ef3555c5b6de4ef7527664b2133ecf0ca73de25245b41bf2f92817800e7403010155ef48d7be9f583d8380280fbb431016f7f239184a3782110ffc925845e6

data/Gemfile

@@ -4,22 +4,17 @@ gemspec
 
 gem 'zip'
 
-#gem 'neo4j-advanced',   '>= 1.8.1', '< 2.0', :require => false
-#gem 'neo4j-enterprise', '>= 1.8.1', '< 2.0', :require => false
-
-gem 'coveralls', require: false
-gem 'simplecov-html', require: false
+# gem 'neo4j-advanced',   '>= 1.8.1', '< 2.0', :require => false
+# gem 'neo4j-enterprise', '>= 1.8.1', '< 2.0', :require => false
 
 group 'development' do
-  gem 'yard'
-  gem 'simplecov'
-  gem 'pry'
-  gem 'pry-rescue'
-  gem 'pry-stack_explorer', platform: :ruby
+  gem 'guard-rspec', require: false
 end
 
 group 'test' do
-  gem "rake", ">= 0.8.7"
-  gem "rspec", "~> 3.0"
+  gem 'coveralls', require: false
+  gem 'simplecov-html', require: false
+  gem 'rake', '>= 0.8.7'
+  gem 'rspec', '~> 3.0'
   gem 'rspec-its'
 end

data/README.md

@@ -1,12 +1,12 @@
-# Neo4j-core v3.0 [![Code Climate](https://codeclimate.com/github/andreasronge/neo4j-core.png)](https://codeclimate.com/github/andreasronge/neo4j-core) [![Build Status](https://travis-ci.org/neo4jrb/neo4j-core.png)](https://travis-ci.org/andreasronge/neo4j-core) [![Coverage Status](https://coveralls.io/repos/neo4jrb/neo4j-core/badge.png?branch=master)](https://coveralls.io/r/neo4jrb/neo4j-core?branch=master)
+# Neo4j-core v3.0 [![Code Climate](https://codeclimate.com/github/neo4jrb/neo4j-core.png)](https://codeclimate.com/github/neo4jrb/neo4j-core) [![Build Status](https://travis-ci.org/neo4jrb/neo4j-core.png)](https://travis-ci.org/neo4jrb/neo4j-core) [![Coverage Status](https://coveralls.io/repos/neo4jrb/neo4j-core/badge.png?branch=master)](https://coveralls.io/r/neo4jrb/neo4j-core?branch=master) [![PullReview stats](https://www.pullreview.com/github/neo4jrb/neo4j-core/badges/master.svg?)](https://www.pullreview.com/github/neo4jrb/neo4j-core/reviews/master)
 
 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.
 
 ## Documentation
 
-* [3.0 Documentation](https://github.com/andreasronge/neo4j-core/wiki)
-* [2.x Documentation](https://github.com/andreasronge/neo4j-core/tree/v2.x)
+* [3.0 Documentation](https://github.com/neo4jrb/neo4j-core/wiki)
+* [2.x Documentation](https://github.com/neo4jrb/neo4j-core/tree/v2.x)
 
 
 ## Support
@@ -16,20 +16,20 @@ It can be used standalone without the neo4j gem.
 
 ## Developers
 
-* [Andreas Ronge](https://github.com/andreasronge)
+* [Andreas Ronge](https://github.com/neo4jrb)
 * [Brian Underwood](https://github.com/cheerfulstoic)
 * [Chris Grigg](https://github.com/subvertallchris)
 
 
 ## Contributing
 
-Pull request with high test coverage and good [code climate](https://codeclimate.com/github/andreasronge/neo4j-core) values will be accepted faster.
+Pull request with high test coverage and good [code climate](https://codeclimate.com/github/neo4jrb/neo4j-core) values will be accepted faster.
 Notice, only JRuby can run all the tests (embedded and server db). To run tests with coverage: `rake coverage`.
 
 ## License
-* Neo4j.rb - MIT, see the LICENSE file http://github.com/andreasronge/neo4j-core/tree/master/LICENSE.
+* Neo4j.rb - MIT, see the LICENSE file http://github.com/neo4jrb/neo4j-core/tree/master/LICENSE.
 * Lucene -  Apache, see http://lucene.apache.org/java/docs/features.html
-* \Neo4j - Dual free software/commercial license, see http://neo4j.org/
+* Neo4j - Dual free software/commercial license, see http://neo4j.org/
 
 Notice there are different license for the neo4j-community, neo4j-advanced and neo4j-enterprise jar gems.
 Only the neo4j-community gem is by default required.

data/lib/neo4j-core.rb

@@ -24,7 +24,8 @@ if RUBY_PLATFORM == 'java'
   require 'neo4j-embedded'
 else
   # just for the tests
-  module Neo4j::Embedded
+  module Neo4j
+    module Embedded
+    end
   end
 end
-

data/lib/neo4j-core/active_entity.rb

@@ -1,13 +1,11 @@
-module Neo4j::Core
-
-  # A module to make Neo4j::Node and Neo4j::Relationship work better together with neo4j.rb's Neo4j::ActiveNode and Neo4j::ActiveRel
-  module ActiveEntity
-    # @return true
-    def persisted?
-      true
+module Neo4j
+  module Core
+    # A module to make Neo4j::Node and Neo4j::Relationship work better together with neo4j.rb's Neo4j::ActiveNode and Neo4j::ActiveRel
+    module ActiveEntity
+      # @return true
+      def persisted?
+        true
+      end
     end
-
   end
 end
-
-

data/lib/neo4j-core/cypher_translator.rb

@@ -1,74 +1,76 @@
-module Neo4j::Core
-  module CypherTranslator
-    # Cypher Helper
-    def escape_value(value)
-      if value.is_a?(String) || value.is_a?(Symbol)
-        "'#{escape_quotes(sanitize_escape_sequences(value.to_s))}'"
-      else
-        value
+module Neo4j
+  module Core
+    module CypherTranslator
+      # Cypher Helper
+      def escape_value(value)
+        if value.is_a?(String) || value.is_a?(Symbol)
+          "'#{escape_quotes(sanitize_escape_sequences(value.to_s))}'"
+        else
+          value
+        end
       end
-    end
 
-    # Like escape_value but it does not wrap the value in quotes
-    def create_escape_value(value)
-      if value.is_a?(String) || value.is_a?(Symbol)
-        "#{sanitize_escape_sequences(value.to_s)}"
-      else
-        value
+      # Like escape_value but it does not wrap the value in quotes
+      def create_escape_value(value)
+        if value.is_a?(String) || value.is_a?(Symbol)
+          "#{sanitize_escape_sequences(value.to_s)}"
+        else
+          value
+        end
       end
-    end
 
-    # Only following escape sequence characters are allowed in Cypher:
-    #
-    # \t Tab
-    # \b Backspace
-    # \n Newline
-    # \r Carriage return
-    # \f Form feed
-    # \' Single quote
-    # \" Double quote
-    # \\ Backslash
-    #
-    # From:
-    # http://docs.neo4j.org/chunked/stable/cypher-expressions.html#_note_on_string_literals
-    SANITIZE_ESCAPED_REGEXP = /(?<!\\)\\(\\\\)*(?![futbnr'"\\])/
-    EMPTY_PROPS = ''
+      # Only following escape sequence characters are allowed in Cypher:
+      #
+      # \t Tab
+      # \b Backspace
+      # \n Newline
+      # \r Carriage return
+      # \f Form feed
+      # \' Single quote
+      # \" Double quote
+      # \\ Backslash
+      #
+      # From:
+      # http://docs.neo4j.org/chunked/stable/cypher-expressions.html#_note_on_string_literals
+      SANITIZE_ESCAPED_REGEXP = /(?<!\\)\\(\\\\)*(?![futbnr'"\\])/
+      EMPTY_PROPS = ''
 
-    def sanitize_escape_sequences(s)
-     s.gsub SANITIZE_ESCAPED_REGEXP, EMPTY_PROPS
-    end
+      def sanitize_escape_sequences(s)
+        s.gsub SANITIZE_ESCAPED_REGEXP, EMPTY_PROPS
+      end
 
-    def escape_quotes(s)
-     s.gsub("'", %q(\\\'))
-    end
+      def escape_quotes(s)
+        s.gsub("'", %q(\\\'))
+      end
 
-    # Cypher Helper
-    def cypher_prop_list(props)
-      return nil unless props
-      props.reject! {|k,v| v.nil? }
-      { props: props.each { |k, v|  props[k] = create_escape_value(v) } }
-    end
+      # Cypher Helper
+      def cypher_prop_list(props)
+        return nil unless props
+        props.reject! { |_, v| v.nil? }
+        {props: props.each { |k, v|  props[k] = create_escape_value(v) }}
+      end
 
-    # Stolen from keymaker
-    # https://github.com/therubymug/keymaker/blob/master/lib/keymaker/parsers/cypher_response_parser.rb
-    def self.translate_response(response_body, result)
-      Hashie::Mash.new(Hash[sanitized_column_names(response_body).zip(result)])
-    end
+      # Stolen from keymaker
+      # https://github.com/therubymug/keymaker/blob/master/lib/keymaker/parsers/cypher_response_parser.rb
+      def self.translate_response(response_body, result)
+        Hashie::Mash.new(Hash[sanitized_column_names(response_body).zip(result)])
+      end
 
-    def self.sanitized_column_names(response_body)
-      response_body.columns.map { |column| column[/[^\.]+$/] }
-    end
+      def self.sanitized_column_names(response_body)
+        response_body.columns.map { |column| column[/[^\.]+$/] }
+      end
 
-    def cypher_string(labels, props)
-      "CREATE (n#{label_string(labels)} #{prop_identifier(props)}) RETURN ID(n)"
-    end
+      def cypher_string(labels, props)
+        "CREATE (n#{label_string(labels)} #{prop_identifier(props)}) RETURN ID(n)"
+      end
 
-    def label_string(labels)
-      labels.empty? ? '' : ":#{labels.map{|k| "`#{k}`"}.join(':')}"
-    end
+      def label_string(labels)
+        labels.empty? ? '' : ":#{labels.map { |k| "`#{k}`" }.join(':')}"
+      end
 
-    def prop_identifier(props)
-      '{props}' unless props.nil?
+      def prop_identifier(props)
+        '{props}' unless props.nil?
+      end
     end
   end
 end

data/lib/neo4j-core/hash_with_indifferent_access.rb

@@ -3,7 +3,6 @@ module Neo4j
     # Stolen from http://as.rubyonrails.org/classes/HashWithIndifferentAccess.html
     # We don't want to depend on active support
     class HashWithIndifferentAccess < Hash
-
       # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
       def extractable_options?
         true
@@ -103,7 +102,7 @@ module Neo4j
       #   hash.values_at("a", "b") # => ["x", "y"]
       #
       def values_at(*indices)
-        indices.collect {|key| self[convert_key(key)]}
+        indices.collect { |key| self[convert_key(key)] }
       end
 
       # Returns an exact copy of the hash.
@@ -116,7 +115,7 @@ module Neo4j
       # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
       # Does not overwrite the existing hash.
       def merge(hash)
-        self.dup.update(hash)
+        dup.update(hash)
       end
 
       # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
@@ -126,7 +125,7 @@ module Neo4j
       end
 
       def reverse_merge!(other_hash)
-        replace(reverse_merge( other_hash ))
+        replace(reverse_merge(other_hash))
       end
 
       # Removes a specified key from the hash.
@@ -134,11 +133,21 @@ module Neo4j
         super(convert_key(key))
       end
 
-      def stringify_keys!; self end
-      def stringify_keys; dup end
-#      undef :symbolize_keys!
-      def symbolize_keys; to_hash.symbolize_keys end
-      def to_options!; self end
+      def stringify_keys!
+        self
+      end
+
+      def stringify_keys
+        dup
+      end
+      #      undef :symbolize_keys!
+      def symbolize_keys
+        to_hash.symbolize_keys
+      end
+
+      def to_options!
+        self
+      end
 
       # Convert to a Hash with String keys.
       def to_hash
@@ -146,20 +155,20 @@ module Neo4j
       end
 
       protected
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
 
-        def convert_value(value)
-          if value.is_a? Hash
-            value #.nested_under_indifferent_access
-          elsif value.is_a?(Array)
-            value.dup.replace(value.map { |e| convert_value(e) })
-          else
-            value
-          end
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        if value.is_a? Hash
+          value # .nested_under_indifferent_access
+        elsif value.is_a?(Array)
+          value.dup.replace(value.map { |e| convert_value(e) })
+        else
+          value
         end
+      end
     end
-
   end
-end
+end

data/lib/neo4j-core/helpers.rb

@@ -1,24 +1,22 @@
-module Neo4j::Core
-
-  module ArgumentHelper
-
-    def self.session(args)
-      args.last.kind_of?(Neo4j::Session) ? args.pop : Neo4j::Session.current!
+module Neo4j
+  module Core
+    module ArgumentHelper
+      def self.session(args)
+        args.last.is_a?(Neo4j::Session) ? args.pop : Neo4j::Session.current!
+      end
     end
-  end
 
-  module TxMethods
-    def tx_methods(*methods)
-      methods.each do |method|
-        tx_method = "#{method}_in_tx"
-        send(:alias_method, tx_method, method)
-        send(:define_method, method) do |*args, &block|
-          session = ArgumentHelper.session(args)
-          Neo4j::Transaction.run(session.auto_commit?) { send(tx_method, *args, &block) }
+    module TxMethods
+      def tx_methods(*methods)
+        methods.each do |method|
+          tx_method = "#{method}_in_tx"
+          send(:alias_method, tx_method, method)
+          send(:define_method, method) do |*args, &block|
+            session = ArgumentHelper.session(args)
+            Neo4j::Transaction.run(session.auto_commit?) { send(tx_method, *args, &block) }
+          end
         end
       end
     end
   end
-
-
 end

data/lib/neo4j-core/label.rb

@@ -1,8 +1,9 @@
-module Neo4j::Core
-  class Label
-    def labels
-      get_labels.map{|x| Label.new(x.name) }
+module Neo4j
+  module Core
+    class Label
+      def labels
+        get_labels.map { |x| Label.new(x.name) }
+      end
     end
   end
-
-end
+end

data/lib/neo4j-core/query.rb

@@ -1,344 +1,347 @@
 require 'neo4j-core/query_clauses'
 require 'active_support/notifications'
 
-module Neo4j::Core
-  # Allows for generation of cypher queries via ruby method calls (inspired by ActiveRecord / arel syntax)
-  #
-  # Can be used to express cypher queries in ruby nicely, or to more easily generate queries programatically.
-  #
-  # Also, queries can be passed around an application to progressively build a query across different concerns
-  #
-  # See also the following link for full cypher language documentation:
-  # http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html
-  class Query
-    include Neo4j::Core::QueryClauses
-    include Neo4j::Core::QueryFindInBatches
-
-    def initialize(options = {})
-      @session = options[:session] || Neo4j::Session.current
-
-      @options = options
-      @clauses = []
-      @_params = {}
-    end
-
-    # @method start *args
-    # START clause
-    # @return [Query]
-
-    # @method match *args
-    # MATCH clause
-    # @return [Query]
+module Neo4j
+  module Core
+    # Allows for generation of cypher queries via ruby method calls (inspired by ActiveRecord / arel syntax)
+    #
+    # Can be used to express cypher queries in ruby nicely, or to more easily generate queries programatically.
+    #
+    # Also, queries can be passed around an application to progressively build a query across different concerns
+    #
+    # See also the following link for full cypher language documentation:
+    # http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html
+    class Query
+      include Neo4j::Core::QueryClauses
+      include Neo4j::Core::QueryFindInBatches
+
+      def initialize(options = {})
+        @session = options[:session] || Neo4j::Session.current
+
+        @options = options
+        @clauses = []
+        @_params = {}
+      end
 
-    # @method optional_match *args
-    # OPTIONAL MATCH clause
-    # @return [Query]
+      # @method start *args
+      # START clause
+      # @return [Query]
 
-    # @method using *args
-    # USING clause
-    # @return [Query]
+      # @method match *args
+      # MATCH clause
+      # @return [Query]
 
-    # @method where *args
-    # WHERE clause
-    # @return [Query]
+      # @method optional_match *args
+      # OPTIONAL MATCH clause
+      # @return [Query]
 
-    # @method with *args
-    # WITH clause
-    # @return [Query]
+      # @method using *args
+      # USING clause
+      # @return [Query]
 
-    # @method order *args
-    # ORDER BY clause
-    # @return [Query]
+      # @method where *args
+      # WHERE clause
+      # @return [Query]
 
-    # @method limit *args
-    # LIMIT clause
-    # @return [Query]
+      # @method with *args
+      # WITH clause
+      # @return [Query]
 
-    # @method skip *args
-    # SKIP clause
-    # @return [Query]
+      # @method order *args
+      # ORDER BY clause
+      # @return [Query]
 
-    # @method set *args
-    # SET clause
-    # @return [Query]
+      # @method limit *args
+      # LIMIT clause
+      # @return [Query]
 
-    # @method remove *args
-    # REMOVE clause
-    # @return [Query]
+      # @method skip *args
+      # SKIP clause
+      # @return [Query]
 
-    # @method unwind *args
-    # UNWIND clause
-    # @return [Query]
+      # @method set *args
+      # SET clause
+      # @return [Query]
 
-    # @method return *args
-    # RETURN clause
-    # @return [Query]
+      # @method remove *args
+      # REMOVE clause
+      # @return [Query]
 
-    # @method create *args
-    # CREATE clause
-    # @return [Query]
+      # @method unwind *args
+      # UNWIND clause
+      # @return [Query]
 
-    # @method create_unique *args
-    # CREATE UNIQUE clause
-    # @return [Query]
+      # @method return *args
+      # RETURN clause
+      # @return [Query]
 
-    # @method merge *args
-    # MERGE clause
-    # @return [Query]
+      # @method create *args
+      # CREATE clause
+      # @return [Query]
 
-    # @method on_create_set *args
-    # ON CREATE SET clause
-    # @return [Query]
+      # @method create_unique *args
+      # CREATE UNIQUE clause
+      # @return [Query]
 
-    # @method on_match_set *args
-    # ON MATCH SET clause
-    # @return [Query]
+      # @method merge *args
+      # MERGE clause
+      # @return [Query]
 
-    # @method delete *args
-    # DELETE clause
-    # @return [Query]
+      # @method on_create_set *args
+      # ON CREATE SET clause
+      # @return [Query]
 
-    METHODS = %w[with start match optional_match using where set create create_unique merge on_create_set on_match_set remove unwind delete return order skip limit]
+      # @method on_match_set *args
+      # ON MATCH SET clause
+      # @return [Query]
 
-    CLAUSES = METHODS.map { |method| const_get(method.split('_').map { |c| c.capitalize }.join + 'Clause') }
+      # @method delete *args
+      # DELETE clause
+      # @return [Query]
 
-    METHODS.each_with_index do |clause, i|
-      clause_class = CLAUSES[i]
+      METHODS = %w(with start match optional_match using where set create create_unique merge on_create_set on_match_set remove unwind delete return order skip limit)
 
-      module_eval(%Q{
-        def #{clause}(*args)
-          build_deeper_query(#{clause_class}, args)
-        end}, __FILE__, __LINE__)
-    end
+      CLAUSES = METHODS.map { |method| const_get(method.split('_').map(&:capitalize).join + 'Clause') }
 
-    alias_method :offset, :skip
-    alias_method :order_by, :order
+      METHODS.each_with_index do |clause, i|
+        clause_class = CLAUSES[i]
 
-    # Clears out previous order clauses and allows only for those specified by args
-    def reorder(*args)
-      query = self.copy
+        module_eval(%{
+          def #{clause}(*args)
+            build_deeper_query(#{clause_class}, args)
+          end}, __FILE__, __LINE__)
+      end
 
-      query.remove_clause_class(OrderClause)
-      query.order(*args)
-    end
+      alias_method :offset, :skip
+      alias_method :order_by, :order
 
-    # Works the same as the #set method, but when given a nested array it will set properties rather than setting entire objects
-    # @example
-    #    # Creates a query representing the cypher: MATCH (n:Person) SET n.age = 19
-    #    Query.new.match(n: :Person).set_props(n: {age: 19})
-    def set_props(*args)
-      build_deeper_query(SetClause, args, set_props: true)
-    end
+      # Clears out previous order clauses and allows only for those specified by args
+      def reorder(*args)
+        query = copy
 
-    # Allows what's been built of the query so far to be frozen and the rest built anew.  Can be called multiple times in a string of method calls
-    # @example
-    #   # Creates a query representing the cypher: MATCH (q:Person), r:Car MATCH (p: Person)-->q
-    #   Query.new.match(q: Person).match('r:Car').break.match('(p: Person)-->q')
-    def break
-      build_deeper_query(nil)
-    end
+        query.remove_clause_class(OrderClause)
+        query.order(*args)
+      end
 
-    # Allows for the specification of values for params specified in query
-    # @example
-    #   # Creates a query representing the cypher: MATCH (q: Person {id: {id}})
-    #   # Calls to params don't affect the cypher query generated, but the params will be
-    #   # Passed down when the query is made
-    #   Query.new.match('(q: Person {id: {id}})').params(id: 12)
-    #
-    def params(args)
-      @_params = @_params.merge(args)
+      # Works the same as the #set method, but when given a nested array it will set properties rather than setting entire objects
+      # @example
+      #    # Creates a query representing the cypher: MATCH (n:Person) SET n.age = 19
+      #    Query.new.match(n: :Person).set_props(n: {age: 19})
+      def set_props(*args)
+        build_deeper_query(SetClause, args, set_props: true)
+      end
 
-      self
-    end
+      # Allows what's been built of the query so far to be frozen and the rest built anew.  Can be called multiple times in a string of method calls
+      # @example
+      #   # Creates a query representing the cypher: MATCH (q:Person), r:Car MATCH (p: Person)-->q
+      #   Query.new.match(q: Person).match('r:Car').break.match('(p: Person)-->q')
+      def break
+        build_deeper_query(nil)
+      end
 
-    def response
-      return @response if @response
-      cypher = self.to_cypher
-      @response = ActiveSupport::Notifications.instrument('neo4j.cypher_query', context: @options[:context] || 'CYPHER', cypher: cypher, params: merge_params) do
-        @session._query(cypher, merge_params)
+      # Allows for the specification of values for params specified in query
+      # @example
+      #   # Creates a query representing the cypher: MATCH (q: Person {id: {id}})
+      #   # Calls to params don't affect the cypher query generated, but the params will be
+      #   # Passed down when the query is made
+      #   Query.new.match('(q: Person {id: {id}})').params(id: 12)
+      #
+      def params(args)
+        @_params = @_params.merge(args)
+
+        self
       end
-      if !response.respond_to?(:error?) || !response.error?
-        response
-      else
-        response.raise_cypher_error
+
+      def response
+        return @response if @response
+        cypher = to_cypher
+        @response = ActiveSupport::Notifications.instrument('neo4j.cypher_query', context: @options[:context] || 'CYPHER', cypher: cypher, params: merge_params) do
+          @session._query(cypher, merge_params)
+        end
+        if !response.respond_to?(:error?) || !response.error?
+          response
+        else
+          response.raise_cypher_error
+        end
       end
-    end
 
-    include Enumerable
+      include Enumerable
 
-    def each
-      response = self.response
-      if response.is_a?(Neo4j::Server::CypherResponse)
-        response.to_node_enumeration
-      else
-        Neo4j::Embedded::ResultWrapper.new(response, self.to_cypher)
-      end.each { |object| yield object }
-    end
+      def each
+        response = self.response
+        if response.is_a?(Neo4j::Server::CypherResponse)
+          response.to_node_enumeration
+        else
+          Neo4j::Embedded::ResultWrapper.new(response, to_cypher)
+        end.each { |object| yield object }
+      end
 
-    # @method to_a
-    # Class is Enumerable.  Each yield is a Hash with the key matching the variable returned and the value being the value for that key from the response
-    # @return [Array]
-    # @raise [Neo4j::Server::CypherResponse::ResponseError] Raises errors from neo4j server
+      # @method to_a
+      # Class is Enumerable.  Each yield is a Hash with the key matching the variable returned and the value being the value for that key from the response
+      # @return [Array]
+      # @raise [Neo4j::Server::CypherResponse::ResponseError] Raises errors from neo4j server
 
 
-    # Executes a query without returning the result
-    # @return [Boolean] true if successful
-    # @raise [Neo4j::Server::CypherResponse::ResponseError] Raises errors from neo4j server
-    def exec
-      self.response
+      # Executes a query without returning the result
+      # @return [Boolean] true if successful
+      # @raise [Neo4j::Server::CypherResponse::ResponseError] Raises errors from neo4j server
+      def exec
+        response
 
-      true
-    end
+        true
+      end
 
-    # Return the specified columns as an array.
-    # If one column is specified, a one-dimensional array is returned with the values of that column
-    # If two columns are specified, a n-dimensional array is returned with the values of those columns
-    #
-    # @example
-    #    Query.new.match(n: :Person).return(p: :name}.pluck(p: :name) # => Array of names
-    # @example
-    #    Query.new.match(n: :Person).return(p: :name}.pluck('p, DISTINCT p.name') # => Array of [node, name] pairs
-    #
-    def pluck(*columns)
-      query = return_query(columns)
-      columns = query.response.columns
-
-      case columns.size
-      when 0
-        raise ArgumentError, 'No columns specified for Query#pluck'
-      when 1
-        column = columns[0]
-        query.map { |row| row[column] }
-      else
-        query.map do |row|
-          columns.map do |column|
-            row[column]
+      # Return the specified columns as an array.
+      # If one column is specified, a one-dimensional array is returned with the values of that column
+      # If two columns are specified, a n-dimensional array is returned with the values of those columns
+      #
+      # @example
+      #    Query.new.match(n: :Person).return(p: :name}.pluck(p: :name) # => Array of names
+      # @example
+      #    Query.new.match(n: :Person).return(p: :name}.pluck('p, DISTINCT p.name') # => Array of [node, name] pairs
+      #
+      def pluck(*columns)
+        query = return_query(columns)
+        columns = query.response.columns
+
+        case columns.size
+        when 0
+          fail ArgumentError, 'No columns specified for Query#pluck'
+        when 1
+          column = columns[0]
+          query.map { |row| row[column] }
+        else
+          query.map do |row|
+            columns.map do |column|
+              row[column]
+            end
           end
         end
       end
-    end
 
-    def return_query(columns)
-      query = self.copy
-      query.remove_clause_class(ReturnClause)
+      def return_query(columns)
+        query = copy
+        query.remove_clause_class(ReturnClause)
 
-      columns = columns.map do |column_definition|
-        if column_definition.is_a?(Hash)
-          column_definition.map { |k, v| "#{k}.#{v}" }
-        else
-          column_definition
-        end
-      end.flatten.map(&:to_sym)
+        columns = columns.map do |column_definition|
+          if column_definition.is_a?(Hash)
+            column_definition.map { |k, v| "#{k}.#{v}" }
+          else
+            column_definition
+          end
+        end.flatten.map(&:to_sym)
 
-      query.return(columns)
-    end
+        query.return(columns)
+      end
 
-    # Returns a CYPHER query string from the object query representation
-    # @example
-    #    Query.new.match(p: :Person).where(p: {age: 30})  # => "MATCH (p:Person) WHERE p.age = 30
-    #
-    # @return [String] Resulting cypher query string
-    def to_cypher
-      cypher_string = partitioned_clauses.map do |clauses|
-        clauses_by_class = clauses.group_by(&:class)
+      # Returns a CYPHER query string from the object query representation
+      # @example
+      #    Query.new.match(p: :Person).where(p: {age: 30})  # => "MATCH (p:Person) WHERE p.age = 30
+      #
+      # @return [String] Resulting cypher query string
+      def to_cypher
+        cypher_string = partitioned_clauses.map do |clauses|
+          clauses_by_class = clauses.group_by(&:class)
 
-        cypher_parts = CLAUSES.map do |clause_class|
-          clauses = clauses_by_class[clause_class]
+          cypher_parts = CLAUSES.map do |clause_class|
+            clauses = clauses_by_class[clause_class]
 
-          clause_class.to_cypher(clauses) if clauses
-        end
+            clause_class.to_cypher(clauses) if clauses
+          end
 
-        cypher_string = cypher_parts.compact.join(' ')
-        cypher_string.strip
-      end.join ' '
+          cypher_string = cypher_parts.compact.join(' ')
+          cypher_string.strip
+        end.join ' '
 
-      cypher_string = "CYPHER #{@options[:parser]} #{cypher_string}" if @options[:parser]
-      cypher_string.strip
-    end
+        cypher_string = "CYPHER #{@options[:parser]} #{cypher_string}" if @options[:parser]
+        cypher_string.strip
+      end
 
-    # Returns a CYPHER query specifying the union of the callee object's query and the argument's query
-    #
-    # @example
-    #    # Generates cypher: MATCH (n:Person) UNION MATCH (o:Person) WHERE o.age = 10
-    #    q = Neo4j::Core::Query.new.match(o: :Person).where(o: {age: 10})
-    #    result = Neo4j::Core::Query.new.match(n: :Person).union_cypher(q)
-    #
-    # @param other_query [Query] Second half of UNION
-    # @param options [Hash] Specify {all: true} to use UNION ALL
-    # @return [String] Resulting UNION cypher query string
-    def union_cypher(other_query, options = {})
-      "#{self.to_cypher} UNION#{options[:all] ? ' ALL' : ''} #{other_query.to_cypher}"
-    end
+      # Returns a CYPHER query specifying the union of the callee object's query and the argument's query
+      #
+      # @example
+      #    # Generates cypher: MATCH (n:Person) UNION MATCH (o:Person) WHERE o.age = 10
+      #    q = Neo4j::Core::Query.new.match(o: :Person).where(o: {age: 10})
+      #    result = Neo4j::Core::Query.new.match(n: :Person).union_cypher(q)
+      #
+      # @param other [Query] Second half of UNION
+      # @param options [Hash] Specify {all: true} to use UNION ALL
+      # @return [String] Resulting UNION cypher query string
+      def union_cypher(other, options = {})
+        "#{to_cypher} UNION#{options[:all] ? ' ALL' : ''} #{other.to_cypher}"
+      end
 
-    def &(other_query)
-      raise "Sessions don't match!" if @session != other_query.session
+      def &(other)
+        fail "Sessions don't match!" if @session != other.session
 
-      self.class.new(session: @session).tap do |new_query|
-        new_query.options = self.options.merge(other_query.options)
-        new_query.clauses = self.clauses + other_query.clauses
-      end.params(other_query._params)
-    end
+        self.class.new(session: @session).tap do |new_query|
+          new_query.options = options.merge(other.options)
+          new_query.clauses = clauses + other.clauses
+        end.params(other._params)
+      end
 
-    MEMOIZED_INSTANCE_VARIABLES = [:response, :merge_params]
-    def copy
-      self.dup.tap do |query|
-        MEMOIZED_INSTANCE_VARIABLES.each do |var|
-          query.instance_variable_set("@#{var}", nil)
+      MEMOIZED_INSTANCE_VARIABLES = [:response, :merge_params]
+      def copy
+        dup.tap do |query|
+          MEMOIZED_INSTANCE_VARIABLES.each do |var|
+            query.instance_variable_set("@#{var}", nil)
+          end
         end
       end
-    end
 
-    protected
-    attr_accessor :session, :options, :clauses, :_params
+      protected
 
-    def add_clauses(clauses)
-      @clauses += clauses
-    end
+      attr_accessor :session, :options, :clauses, :_params
 
-    def remove_clause_class(clause_class)
-      @clauses = @clauses.reject do |clause|
-        clause.is_a?(clause_class)
+      def add_clauses(clauses)
+        @clauses += clauses
       end
-    end
-    private
 
-    def build_deeper_query(clause_class, args = {}, options = {})
-      self.copy.tap do |new_query|
-        new_query.add_clauses [nil] if [nil, WithClause].include?(clause_class)
-        new_query.add_clauses clause_class.from_args(args, options) if clause_class
+      def remove_clause_class(clause_class)
+        @clauses = @clauses.reject do |clause|
+          clause.is_a?(clause_class)
+        end
       end
-    end
 
-    def break_deeper_query
-      self.copy.tap do |new_query|
-        new_query.add_clauses [nil]
-      end
-    end
+      private
 
-    def partitioned_clauses
-      partitioning = [[]]
+      def build_deeper_query(clause_class, args = {}, options = {})
+        copy.tap do |new_query|
+          new_query.add_clauses [nil] if [nil, WithClause].include?(clause_class)
+          new_query.add_clauses clause_class.from_args(args, options) if clause_class
+        end
+      end
 
-      @clauses.each do |clause|
-        if clause.nil? && partitioning.last != []
-          partitioning << []
-        else
-          partitioning.last << clause
+      def break_deeper_query
+        copy.tap do |new_query|
+          new_query.add_clauses [nil]
         end
       end
 
-      partitioning
-    end
+      def partitioned_clauses
+        partitioning = [[]]
 
-    def merge_params
-      @merge_params ||= @clauses.compact.inject(@_params) { |params, clause| params.merge(clause.params) }
-    end
+        @clauses.each do |clause|
+          if clause.nil? && partitioning.last != []
+            partitioning << []
+          else
+            partitioning.last << clause
+          end
+        end
 
-    def sanitize_params(params)
-      passthrough_classes = [String, Numeric, Array, Regexp]
-      params.each do |key, value|
-        params[key] = value.to_s if not passthrough_classes.any? {|klass| value.is_a?(klass) }
+        partitioning
       end
-    end
 
+      def merge_params
+        @merge_params ||= @clauses.compact.inject(@_params) { |params, clause| params.merge(clause.params) }
+      end
+
+      def sanitize_params(params)
+        passthrough_classes = [String, Numeric, Array, Regexp]
+        params.each do |key, value|
+          params[key] = value.to_s if not passthrough_classes.any? { |klass| value.is_a?(klass) }
+        end
+      end
+    end
   end
 end