neo4j-core 3.0.0.rc.1 → 3.0.0.rc.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d20898c080d0bca882d65f41646ef7e4067a5b9b
-  data.tar.gz: adc55730515f69c5b8df000ffdd661964520a1eb
+  metadata.gz: 6f4e034ba33270fdcb1cb5b5535d039fd9efde54
+  data.tar.gz: 532daaec0377fe3e610b2d76acd2b69a8f3c96e2
 SHA512:
-  metadata.gz: 45044b6d438c430d95ca67c70a2572479c2fcaaa5f4001b117f0096d2a497f119b1f9ea5212966ba4fff83266d7308d8c93aefc043a6a5eae2827e7a040fc0d1
-  data.tar.gz: c3812fad93af67cdde06336b870aa67a7de44e7052c2c24ad6e0d038ce23d788573b2791ef4cf00baf05758860bdd63811a3c3bb135e59309dde36cc2b7b0a47
+  metadata.gz: 733e818958cc4ae6ad35d5a8c6a6d9a86e7d12c8117f35734c15520974cabb40deff43b25761d971fe78e19aa5b742b7105b463d5d584d91027a3bccd1f076fc
+  data.tar.gz: 1d72fb9147c87fe03b6c9bc82aff383dad9fce34213da4020f5a7afbb840241e48006a16fb6d667725ba3c7a139fc80b396e671dfe6750d6ebaf9da512fbd83c

data/lib/neo4j-core.rb

@@ -25,7 +25,4 @@ else
   # just for the tests
   module Neo4j::Embedded
   end
-
-  require 'oj'
-  require 'oj_mimic_json'
 end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.0.0.rc.1"
+    VERSION = "3.0.0.rc.4"
   end
 end

data/neo4j-core.gemspec

@@ -30,15 +30,12 @@ It comes included with the Apache Lucene document database.
 
   # Not released yet
   s.add_dependency("httparty")
+  s.add_dependency("json")
   s.add_dependency("os")  # for Rake task
   s.add_dependency("zip") # for Rake task
   s.add_dependency("activesupport") # For ActiveSupport::Notifications
 
-  if RUBY_PLATFORM =~ /java/
-    s.add_dependency("json")
+  if RUBY_PLATFORM == 'java'
     s.add_dependency("neo4j-community", '~> 2.1.1')
-  else
-    s.add_dependency("oj")
-    s.add_dependency("oj_mimic_json")
   end
 end

metadata

@@ -1,99 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-core
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc.1
+  version: 3.0.0.rc.4
 platform: ruby
 authors:
 - Andreas Ronge
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: os
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
   prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: json
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: zip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
   prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: os
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
   prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: zip
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
   prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: activesupport
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: oj_mimic_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
   prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: neo4j-community
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.1.1
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  prerelease: false
+  type: :runtime
 description: |
   You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
   The programmer works with an object-oriented, flexible network structure rather than with strict and static tables
@@ -105,10 +105,19 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- Gemfile
-- README.md
 - lib/neo4j-core.rb
-- lib/neo4j-core.rb~
+- lib/neo4j-embedded.rb
+- lib/neo4j-server.rb
+- lib/neo4j/entity_equality.rb
+- lib/neo4j/label.rb
+- lib/neo4j/node.rb
+- lib/neo4j/property_container.rb
+- lib/neo4j/property_validator.rb
+- lib/neo4j/relationship.rb
+- lib/neo4j/session.rb
+- lib/neo4j/transaction.rb
+- lib/neo4j/tasks/config_server.rb
+- lib/neo4j/tasks/neo4j_server.rb
 - lib/neo4j-core/active_entity.rb
 - lib/neo4j-core/cypher_translator.rb
 - lib/neo4j-core/hash_with_indifferent_access.rb
@@ -117,74 +126,57 @@ files:
 - lib/neo4j-core/query.rb
 - lib/neo4j-core/query_clauses.rb
 - lib/neo4j-core/version.rb
-- lib/neo4j-core/version.rb~
-- lib/neo4j-embedded.rb
 - lib/neo4j-embedded/cypher_response.rb
-- lib/neo4j-embedded/cypher_response.rb~
 - lib/neo4j-embedded/embedded_database.rb
 - lib/neo4j-embedded/embedded_impermanent_session.rb
 - lib/neo4j-embedded/embedded_label.rb
 - lib/neo4j-embedded/embedded_node.rb
-- lib/neo4j-embedded/embedded_node.rb~
 - lib/neo4j-embedded/embedded_relationship.rb
-- lib/neo4j-embedded/embedded_relationship.rb~
 - lib/neo4j-embedded/embedded_session.rb
-- lib/neo4j-embedded/embedded_session.rb~
 - lib/neo4j-embedded/embedded_transaction.rb
 - lib/neo4j-embedded/property.rb
 - lib/neo4j-embedded/to_java.rb
-- lib/neo4j-server.rb
 - lib/neo4j-server/cypher_label.rb
 - lib/neo4j-server/cypher_node.rb
 - lib/neo4j-server/cypher_node_uncommited.rb
 - lib/neo4j-server/cypher_relationship.rb
 - lib/neo4j-server/cypher_response.rb
-- lib/neo4j-server/cypher_response.rb~
 - lib/neo4j-server/cypher_session.rb
 - lib/neo4j-server/cypher_transaction.rb
 - lib/neo4j-server/neo4j_server_endpoint.rb
 - lib/neo4j-server/resource.rb
-- lib/neo4j/entity_equality.rb
-- lib/neo4j/label.rb
-- lib/neo4j/node.rb
-- lib/neo4j/property_container.rb
-- lib/neo4j/property_validator.rb
-- lib/neo4j/relationship.rb
-- lib/neo4j/session.rb
-- lib/neo4j/session.rb~
-- lib/neo4j/tasks/config_server.rb
-- lib/neo4j/tasks/neo4j_server.rb
-- lib/neo4j/transaction.rb
+- README.md
+- Gemfile
 - neo4j-core.gemspec
 homepage: http://github.com/andreasronge/neo4j-core/tree
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
-- "--quiet"
-- "--title"
+- --quiet
+- --title
 - Neo4j::Core
-- "--line-numbers"
-- "--main"
+- --line-numbers
+- --main
 - README.rdoc
-- "--inline-source"
+- --inline-source
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: neo4j-core
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 2.1.9
+signing_key:
 specification_version: 4
 summary: A graph database for Ruby
 test_files: []

data/lib/neo4j-core.rb~

@@ -1,26 +0,0 @@
-require 'forwardable'
-require 'fileutils'
-
-require 'neo4j/property_validator'
-require 'neo4j/property_container'
-require 'neo4j-core/helpers'
-require 'neo4j-core/cypher_translator'
-require 'neo4j-core/query'
-
-require 'neo4j/entity_equality'
-require 'neo4j/node'
-require 'neo4j/label'
-require 'neo4j/session'
-
-require 'neo4j/relationship'
-require 'neo4j/transaction'
-
-require 'neo4j-server'
-
-if RUBY_PLATFORM == 'java'
-  require 'neo4j-embedded'
-else
-  # just for the tests
-  module Neo4j::Embedded
-  end
-end

data/lib/neo4j-core/version.rb~

@@ -1,5 +0,0 @@
-module Neo4j
-  module Core
-    VERSION = "3.0.0.rc1"
-  end
-end

data/lib/neo4j-embedded/cypher_response.rb~

@@ -1,85 +0,0 @@
-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
-
-    # @return the original result from the Neo4j Cypher Engine, once forward read only !
-    attr_reader :source
-
-    def initialize(source, map_return_procs, query)
-      @source = source
-      @unread = true
-      @map_return_procs = map_return_procs
-      @query = query
-    end
-
-    def to_s
-      @query
-    end
-
-    # @return [Array<Symbol>] the columns in the query result
-    def columns
-      @source.columns.map { |x| x.to_sym }
-    end
-
-    # for the Enumerable contract
-    def each(&block)
-      raise ResultsAlreadyConsumedException unless @unread
-
-      if (block)
-        case @map_return_procs
-          when NilClass then
-            each_no_mapping &block
-          when Hash then
-            each_multi_column_mapping &block
-          else
-            each_single_column_mapping &block
-        end
-      else
-        Enumerator.new(self)
-      end
-    end
-
-
-    private
-
-    def each_no_mapping
-      @source.each do |row|
-        hash = {}
-        row.each do |key, value|
-          out[key.to_sym] = value
-        end
-        yield hash
-      end
-    end
-
-    def each_multi_column_mapping
-      @source.each do |row|
-        hash = {}
-        row.each do |key, value|
-          k = key.to_sym
-          proc = @map_return_procs[k]
-          hash[k] = proc ? proc.call(value) : value
-        end
-        yield hash
-      end
-    end
-
-    def each_single_column_mapping
-      @source.each do |row|
-        result = @map_return_procs.call(row.values.first)
-        yield result
-      end
-    end
-
-  end
-end
-

data/lib/neo4j-embedded/embedded_node.rb~

@@ -1,201 +0,0 @@
-module Neo4j::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 each(&block)
-      @node._rels(@match).each {|r| block.call(r.wrapper)}
-    end
-    tx_methods :each
-
-    def empty?
-      first == nil
-    end
-
-  end
-
-  class NodesIterator
-    include Enumerable
-    extend Neo4j::Core::TxMethods
-
-    def initialize(node, match)
-      @node = node
-      @match = match
-    end
-
-    def each(&block)
-      @node._rels(@match).each {|r| block.call(r.other_node(@node))}
-    end
-    tx_methods :each
-
-    def empty?
-      first == nil
-    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
-          include Neo4j::Embedded::Property
-          include Neo4j::EntityEquality
-          extend Neo4j::Core::TxMethods
-
-          def inspect
-            "EmbeddedNode neo_id: #{neo_id}"
-          end
-
-          def exist?
-            !!graph_database.get_node_by_id(neo_id)
-          rescue Java::OrgNeo4jGraphdb.NotFoundException
-            nil
-          end
-          tx_methods :exist?
-
-          def labels
-            _labels.iterator.map{|x| x.name.to_sym}
-          end
-          tx_methods :labels
-
-          alias_method :_labels, :getLabels
-
-          def _java_label(label_name)
-            Java::OrgNeo4jGraphdb.DynamicLabel.label(label_name)
-          end
-
-
-          def _add_label(*label_name)
-            label_name.each do |name|
-              addLabel(_java_label(name))
-            end
-          end
-
-          alias_method :add_label, :_add_label
-          tx_methods :add_label
-
-          def _remove_label(*label_name)
-            label_name.each do |name|
-              removeLabel(_java_label(name))
-            end
-          end
-
-          alias_method :remove_label, :_remove_label
-          tx_methods :remove_label
-
-          def set_label(*label_names)
-            label_as_symbols = label_names.map(&:to_sym)
-            to_keep = labels & label_as_symbols
-            to_remove = labels - to_keep
-            _remove_label(*to_remove)
-            to_add = label_as_symbols - to_keep
-            _add_label(*to_add)
-          end
-          tx_methods :set_label
-
-          def del
-            _rels.each { |r| r.del }
-            delete
-            nil
-          end
-          tx_methods :del
-
-          def create_rel(type, other_node, props = nil)
-            rel = create_relationship_to(other_node.neo4j_obj, ToJava.type_to_java(type))
-            props.each_pair { |k, v| rel[k] = v } if props
-            rel
-          end
-          tx_methods :create_rel
-
-
-          def rels(match={})
-            RelsIterator.new(self, match)
-          end
-
-          def nodes(match={})
-            NodesIterator.new(self, match)
-          end
-
-          def node(match={})
-            rel = _rel(match)
-            rel && rel.other_node(self).wrapper
-          end
-          tx_methods :node
-
-          def rel?(match={})
-            _rels(match).has_next
-          end
-          tx_methods :rel?
-
-          def rel(match={})
-            _rel(match)
-          end
-          tx_methods :rel
-
-          def _rel(match={})
-            dir = 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))
-                  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
-
-            between_id = match[:between] && match[:between].neo_id
-
-            if (rel && between_id)
-              rel.other_node(self).neo_id == between_id ? rel : nil
-            else
-              rel
-            end
-          end
-
-          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
-
-            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}
-            else
-              rels
-            end
-
-          end
-
-          def class
-            Neo4j::Node
-          end
-
-          include Neo4j::Node::Wrapper
-        end
-      end
-    end
-
-    extend_java_class(Java::OrgNeo4jKernelImplCore::NodeProxy)
-  end
-
-end

data/lib/neo4j-embedded/embedded_relationship.rb~

@@ -1,62 +0,0 @@
-module Neo4j::Embedded
-  class EmbeddedRelationship
-    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
-          include Neo4j::Embedded::Property
-          include Neo4j::EntityEquality
-          include Neo4j::Relationship::Wrapper
-          extend Neo4j::Core::TxMethods
-
-          alias_method :_other_node, :getOtherNode
-
-          def exist?
-            !!graph_database.get_relationship_by_id(neo_id)
-          rescue Java::OrgNeo4jGraphdb.NotFoundException
-            nil
-          end
-          tx_methods :exist?
-
-          def start_node
-            _start_node.wrapper
-          end
-          tx_methods :start_node
-
-          def _start_node
-            getStartNode
-          end
-
-          def rel_type
-            getType().name().to_sym
-          end
-
-          def del
-            delete
-          end
-          tx_methods :del
-
-          def other_node(n)
-            _other_node(n.neo4j_obj).wrapper
-          end
-          tx_methods :other_node
-
-          def end_node
-            _end_node.wrapper
-          end
-          tx_methods :end_node
-
-          def _end_node
-            getEndNode
-          end
-
-        end
-      end
-    end
-
-    extend_java_class(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
-
-  end
-
-
-end

data/lib/neo4j-embedded/embedded_session.rb~

@@ -1,145 +0,0 @@
-# Plugin
-
-Neo4j::Session.register_db(:embedded_db) do |*args|
-  Neo4j::Embedded::EmbeddedSession.new(*args)
-end
-
-
-module Neo4j::Embedded
-  class EmbeddedSession < Neo4j::Session
-
-    class Error < StandardError
-    end
-
-    attr_reader :graph_db, :db_location
-    extend Forwardable
-    extend Neo4j::Core::TxMethods
-    def_delegator :@graph_db, :begin_tx
-
-
-    def initialize(db_location, config={})
-      @db_location = db_location
-      @auto_commit = !!config[:auto_commit]
-      Neo4j::Session.register(self)
-      @query_builder = Neo4j::Core::QueryBuilder.new
-    end
-
-    def start
-      raise Error.new("Embedded Neo4j db is already running") if running?
-      puts "Start embedded Neo4j db at #{db_location}"
-      factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
-      @graph_db = factory.newEmbeddedDatabase(db_location)
-      Neo4j::Session._notify_listeners(:session_available, self)
-    end
-
-    def factory_class
-      Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
-      Java::OrgNeo4jTest::ImpermanentGraphDatabase
-    end
-
-    def close
-      super
-      shutdown
-    end
-
-    def shutdown
-      graph_db && graph_db.shutdown
-      @graph_db = nil
-    end
-
-    def running?
-      !!graph_db
-    end
-
-    def create_label(name)
-      EmbeddedLabel.new(self, name)
-    end
-
-    def load_node(neo_id)
-      _load_node(neo_id)
-    end
-    tx_methods :load_node
-
-    # Same as load but does not return the node as a wrapped Ruby object.
-    #
-    def _load_node(neo_id)
-      return nil if neo_id.nil?
-      @graph_db.get_node_by_id(neo_id.to_i)
-    rescue Java::OrgNeo4jGraphdb.NotFoundException
-      nil
-    end
-
-    def load_relationship(neo_id)
-      _load_relationship(neo_id)
-    end
-    tx_methods :load_relationship
-
-    def _load_relationship(neo_id)
-      return nil if neo_id.nil?
-      @graph_db.get_relationship_by_id(neo_id.to_i)
-    rescue Java::OrgNeo4jGraphdb.NotFoundException
-      nil
-    end
-
-    def query(*params)
-      query_hash = @query_builder.to_query_hash(params, :to_node)
-      cypher = @query_builder.to_cypher(query_hash)
-
-      result = _query(cypher, query_hash[:params])
-      if result.respond_to?(:error?) && result.error?
-        raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
-      end
-
-      map_return_procs = @query_builder.to_map_return_procs(query_hash)
-      ResultWrapper.new(result, map_return_procs, cypher)
-    end
-
-    def find_all_nodes(label)
-      EmbeddedLabel.new(self, label).find_nodes
-    end
-
-    def find_nodes(label, key, value)
-      EmbeddedLabel.new(self, label).find_nodes(key,value)
-    end
-
-    # Performs a cypher query with given string.
-    # Remember that you should close the resource iterator.
-    # @param [String] q the cypher query as a String
-    # @return (see #query)
-    def _query(q, params={})
-      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
-    rescue Exception => e
-        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
-    end
-
-    def query_default_return(as)
-      " RETURN #{as}"
-    end
-
-    def _query_or_fail(q)
-      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      engine.execute(q)
-    end
-
-    def search_result_to_enumerable(result)
-      result.map {|column| column['n'].wrapper}
-    end
-
-    def create_node(properties = nil, labels=[])
-      if labels.empty?
-        _java_node = graph_db.create_node
-      else
-        labels = EmbeddedLabel.as_java(labels)
-        _java_node = graph_db.create_node(labels)
-      end
-      properties.each_pair { |k, v| _java_node[k]=v } if properties
-      _java_node
-    end
-    tx_methods :create_node
-
-  end
-
-
-
-end

data/lib/neo4j-server/cypher_response.rb~

@@ -1,155 +0,0 @@
-module Neo4j::Server
-  class CypherResponse
-    attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
-
-    class ResponseError < StandardError
-      attr_reader :status, :code
-
-      def initialize(msg, status, code)
-        super(msg)
-        @status = status
-        @code = code
-      end
-    end
-
-
-    class HashEnumeration
-      include Enumerable
-      extend Forwardable
-      def_delegator :@response, :error_msg
-      def_delegator :@response, :error_status
-      def_delegator :@response, :error_code
-      def_delegator :@response, :data
-      def_delegator :@response, :columns
-
-      def initialize(response, map_return_procs, query)
-        @response = response
-        @map_return_procs = map_return_procs
-        @query = query
-      end
-
-      def to_s
-        @query
-      end
-
-puts "RELOADED"
-      def inspect
-        #"Enumerable query: '#{@query}' map_return: [#{@map_return_procs.keys.join(', ')}]"
-        "Enumerable query: '#{@query}' map_return: [#{@map_return_procs.keys.inspect}]"
-      end
-
-      def each_no_mapping
-        data.each do |row|
-          hash = {}
-          row.each_with_index do |row, i|
-            key = columns[i].to_sym
-            hash[key] = row
-          end
-          yield hash
-        end
-      end
-
-      def each_multi_column_mapping
-        data.each do |row|
-          hash = {}
-          row.each_with_index do |row, i|
-            key = columns[i].to_sym
-            proc = @map_return_procs[key]
-            hash[key] = proc ? proc.call(row) : row
-          end
-          yield hash
-        end
-      end
-
-      def each_single_column_mapping
-        data.each do |row|
-          result = @map_return_procs.call(row.first)
-          yield result
-        end
-      end
-
-      def each(&block)
-        case @map_return_procs
-          when NilClass then each_no_mapping &block
-          when Hash then each_multi_column_mapping &block
-          else each_single_column_mapping &block
-        end
-      end
-    end
-
-    def to_hash_enumeration(map_return_procs={}, cypher='')
-      HashEnumeration.new(self, map_return_procs, cypher)
-    end
-
-    def initialize(response, uncommited = false)
-      @response = response
-      @uncommited = uncommited
-    end
-
-
-    def first_data
-      if uncommited?
-        @data.first['row'].first
-      else
-        @data[0][0]
-      end
-    end
-
-    def error?
-      !!@error
-    end
-
-    def uncommited?
-      @uncommited
-    end
-
-    def raise_unless_response_code(code)
-      raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.code == code
-    end
-
-    def set_data(data, columns)
-      @data = data
-      @columns = columns
-      self
-    end
-
-    def set_error(error_msg, error_status, error_core)
-      @error = true
-      @error_msg = error_msg
-      @error_status = error_status
-      @error_code = error_core
-      self
-    end
-
-    def raise_error
-      raise "Tried to raise error without an error" unless @error
-      raise ResponseError.new(@error_msg, @error_status, @error_code)
-    end
-
-    def self.create_with_no_tx(response)
-      case response.code
-        when 200
-          CypherResponse.new(response).set_data(response['data'], response['columns'])
-        when 400
-          CypherResponse.new(response).set_error(response['message'], response['exception'], response['fullname'])
-        else
-          raise "Unknown response code #{response.code} for #{response.request.path.to_s}"
-      end
-    end
-
-    def self.create_with_tx(response)
-      raise "Unknown response code #{response.code} for #{response.request.path.to_s}" unless response.code == 200
-
-      first_result = response['results'][0]
-      cr = CypherResponse.new(response, true)
-
-      if (response['errors'].empty?)
-        cr.set_data(first_result['data'], first_result['columns'])
-      else
-        first_error = response['errors'].first
-        cr.set_error(first_error['message'], first_error['status'], first_error['code'])
-      end
-      cr
-    end
-  end
-end

data/lib/neo4j/session.rb~

@@ -1,202 +0,0 @@
-module Neo4j
-  class Session
-
-    @@current_session = nil
-    @@all_sessions = {}
-    @@factories = {}
-
-    # @abstract
-    def close
-      self.class.unregister(self)
-    end
-
-    # Only for embedded database
-    # @abstract
-    def start
-      raise "not impl."
-    end
-
-    # Only for embedded database
-    # @abstract
-    def shutdown
-      raise "not impl."
-    end
-
-    # Only for embedded database
-    # @abstract
-    def running
-      raise "not impl."
-    end
-
-    def auto_commit?
-      true # TODO
-    end
-
-    # @abstract
-    def begin_tx
-      raise "not impl."
-    end
-
-    class CypherError < StandardError
-      attr_reader :error_msg, :error_status, :error_code
-      def initialize(error_msg, error_code, error_status)
-        super(error_msg)
-        @error_msg = error_msg
-        @error_status = error_status
-      end
-    end
-
-    # Executes a Cypher Query.
-    # Returns an enumerable of hash values where each hash corresponds to a row unless +return+ or +map_return+
-    # is not an array. The search result can be mapped to Neo4j::Node or Neo4j::Relationship is your own Ruby wrapper class
-    # by specifying a map_return parameter.
-    #
-    # @param [Hash, String] q the cypher query, as a pure string query or a hash which will generate a cypher string.
-    # @option q [Hash] :params cypher parameters
-    # @option q [Symbol,Hash] :label the label to match. You can specify several labels by using a hash of variable names and labels.
-    # @option q [Symbol] :conditions key and value of properties which the label nodes must match
-    # @option q [Hash] :conditions key and value of properties which the label nodes must match
-    # @option q [String, Array] :match the cypher match clause
-    # @option q [String, Array] :where the cypher where clause
-    # @option q [String, Array, Symbol] :return the cypher where clause
-    # @option q [String, Hash, Symbol] :map_return mapping of the returned values, e.g. :id_to_node, :id_to_rel, or :value
-    # @option q [Hash<Symbol, Proc>] :map_return_procs custom mapping functions of :map_return types
-    # @option q [String,Symbol,Array<Hash>] :order the order
-    # @option q [Fixnum] :limit enables the return of only subsets of the total result.
-    # @option q [Fixnum] :skip enables the return of only subsets of the total result.
-    # @return [Enumerable] the result, an enumerable of Neo4j::Node objects unless a pure cypher string is given or return/map_returns is specified, see examples.
-    # @raise CypherError if invalid cypher
-    # @example Cypher String and parameters
-    #   Neo4j::Session.query("START n=node({p}) RETURN ID(n)", params: {p: 42})
-    #
-    # @example label
-    #   # If there is no :return parameter it will try to return Neo4j::Node objects
-    #   # Default parameter is :n in the generated cypher
-    #   Neo4j::Session.query(label: :person) # => MATCH (n:`person`) RETURN ID(n) # or RETURN n for embedded
-    #
-    # @example to_s
-    #   # What Cypher is returned ? check with to_s
-    #   Neo4j::Session.query(label: :person).to_s # =>
-    #
-    # @example return
-    #   Neo4j::Session.query(label: :person, return: :age)  # returns age properties
-    #   Neo4j::Session.query(label: :person, return: [:name, :age]) # returns a hash of name and age properties
-    #   Neo4j::Session.query(label: :person, return: 'count(n) AS c')
-    #
-    # @example map_return - an Enumerable of names (String)
-    #   Neo4j::Session.query("START n=node(42) RETURN n.name", map_return: :value)
-    #
-    # @example map_return - Enumerable of an Hash with name property, Neo4j::Relationship and Neo4j::Node as values
-    #   Neo4j::Session.query("START n=node(42) MATCH n-[r]->[x] RETURN n.name as N, ID(r) as R, ID(x) as X",
-    #      map_return: {N: :value, R: :id_to_rel, X: :id_to_node})
-    #
-    # @example map_return, only for embedded_db, to_rel, and to_node allows direct mapping to Neo4j::Node and Neo4j::Relationship without ID(n)
-    #   Neo4j::Session.query("START n=node(42) MATCH n-[r]->[x] RETURN n.name as N, r, x", map_return: {N: :value, r: :to_rel, x: :to_node})
-    #
-    # @example map_return_procs, custom mapping function
-    #   Neo4j::Session.query(label: :person, map_return: :age_times_two, map_return_procs: {age_times_two: ->(row){(row[:age] || 0) * 2}})
-    #
-    # @example match
-    #   Neo4j::Session.query(label: :person, match: 'n--m')
-    #
-    # @example where
-    #   Neo4j::Session.query(label: :person, where: 'n.age > 40')
-    #   Neo4j::Session.query(label: :person, where: 'n.age > {age}', params: {age: 40})
-    #
-    # @example condition
-    #   Neo4j::Session.query(label: :person, conditions: {age: 42})
-    #   Neo4j::Session.query(label: :person, conditions: {name: /foo?bar.*/})
-    #
-    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
-    # @note Returns a read-once only forward iterable for the embedded database.
-    #
-    def query(q)
-      raise 'not implemented, abstract'
-    end
-
-    # Same as #query but does not accept an DSL and returns the raw result from the database.
-    # Notice, it might return different values depending on which database is used, embedded or server.
-    # @abstract
-    def _query(*params)
-      raise 'not implemented'
-    end
-
-    class << self
-      # Creates a new session to Neo4j
-      # @see also Neo4j::Server::CypherSession#open for :server_db params
-      # @param db_type the type of database, e.g. :embedded_db, or :server_db
-      def open(db_type=:server_db, *params)
-        register(create_session(db_type, params))
-      end
-
-      def open_named(db_type, name, default = nil, *params)
-        raise "Multiple sessions is currently only supported for Neo4j Server connections." unless db_type == :server_db
-        register(create_session(db_type, params), name, default)
-      end
-
-      def create_session(db_type, params = {})
-        unless (@@factories[db_type])
-          raise "Can't connect to database '#{db_type}', available #{@@factories.keys.join(',')}"
-        end
-        @@factories[db_type].call(*params)
-      end
-
-      def current
-        @@current_session
-      end
-
-      # @see Neo4j::Session#query
-      def query(*params)
-        current.query(*params)
-      end
-
-      def named(name)
-        @@all_sessions[name] || raise("No session named #{name}.")
-      end
-
-      def set_current(session)
-        @@current_session = session
-      end
-
-      def add_listener(&listener)
-        self._listeners << listener
-      end
-
-      def _listeners
-        @@listeners ||= []
-        @@listeners
-      end
-
-      def _notify_listeners(event, data)
-        _listeners.each {|li| li.call(event, data)}
-      end
-
-      def register(session, name = nil, default = nil)
-        if default == true
-          set_current(session)
-        elsif default.nil?
-          set_current(session) unless @@current_session
-        end
-        @@all_sessions[name] = session if name
-        @@current_session
-      end
-
-      def unregister(session)
-        @@current_session = nil if @@current_session == session
-      end
-
-      def all_sessions
-        @@all_sessions
-      end
-
-      def inspect
-         "Neo4j::Session available: #{@@factories && @@factories.keys}"
-      end
-
-      def register_db(db, &session_factory)
-        puts "replace factory for #{db}" if @@factories[db]
-        @@factories[db] = session_factory
-      end
-    end
-  end
-end