neo4j-core 3.0.0.alpha.17 → 3.0.0.alpha.18

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