neo4j-core 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9b416de0287b913be5f84220b4c2d5fb6b8012a
-  data.tar.gz: 4751578b98692e10782620037c596cf983a8353b
+  metadata.gz: 66251bf61bb42f0f8f74378b2c6da243cc730172
+  data.tar.gz: 78bd05d535dea67264c20e5e72f3f46f7af7b84a
 SHA512:
-  metadata.gz: a7a595759c87818f75f869dcc6ce04250834236c5c13dce315f2aa1d7eace080b74443f6aa581d0732c089fcc7a5080858eeee0a6e4116bd077ccb6c3a05df06
-  data.tar.gz: 6764c3d207e04008f45e7912508f31464fc263772f3fc606bd955beb9ce160e8d54bb35a5f08d95645f5f8a8977a89597d75c66ef2eb0df89a7f50ff70763eee
+  metadata.gz: b4309cc95b32c1d44afb6bc92c558378d0d2acef61ee85312eb24678bb585167622e3f56ee1d0b1f77412d9aa42bd0bdca29df45d827871a6e1ce5d055cd09e4
+  data.tar.gz: 3b94371cd1cf479225030e5e359eb3d97dd4c834e13496e6626b12828e95063ffe7ea08e197a69fe3324adf507d6f71bc26b5ecb2b3bccd00ec99ab8c8e5794a

data/lib/neo4j-core/query_clauses.rb

@@ -134,7 +134,11 @@ module Neo4j::Core
 
       def attributes_string(attributes)
         attributes_string = attributes.map do |key, value|
-          v = value.to_s.match(/^{.+}$/) ? value : value.inspect
+          v = if value.nil?
+                'null'
+              else
+                value.to_s.match(/^{.+}$/) ? value : value.inspect
+              end
           "#{key}: #{v}"
         end.join(', ')
 

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.0.0"
+    VERSION = "3.0.1"
   end
 end

data/lib/neo4j-embedded/embedded_node.rb

@@ -113,6 +113,10 @@ module Neo4j::Embedded
             nil
           end
           tx_methods :del
+          tx_methods :delete
+
+          alias_method :destroy, :del
+          tx_methods :destroy
 
           def create_rel(type, other_node, props = nil)
             rel = create_relationship_to(other_node.neo4j_obj, ToJava.type_to_java(type))

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -47,6 +47,10 @@ module Neo4j::Embedded
             delete
           end
           tx_methods :del
+          tx_methods :delete
+
+          alias_method :destroy, :del
+          tx_methods :destroy
 
           def other_node(n)
             _other_node(n.neo4j_obj).wrapper

data/lib/neo4j-server/cypher_node.rb

@@ -33,7 +33,8 @@ module Neo4j::Server
     def create_rel(type, other_node, props = nil)
       q = "START a=node(#{neo_id}), b=node(#{other_node.neo_id}) CREATE (a)-[r:`#{type}` #{cypher_prop_list(props)}]->(b) RETURN ID(r)"
       id = @session._query_or_fail(q, true)
-      CypherRelationship.new(@session, id, type)
+      data_hash = { 'type' => type, 'data' => props, 'start' => self.neo_id.to_s, 'end' => other_node.neo_id.to_s, 'id' => id }
+      CypherRelationship.new(@session, data_hash)
     end
 
     # (see Neo4j::Node#props)
@@ -142,6 +143,9 @@ module Neo4j::Server
       @session._query_or_fail("START n = node(#{neo_id}) MATCH n-[r]-() DELETE r")
       @session._query_or_fail("START n = node(#{neo_id}) DELETE n")
     end
+    alias_method :delete, :del
+    alias_method :destroy, :del
+
 
     # (see Neo4j::Node#exist?)
     def exist?
@@ -158,33 +162,33 @@ module Neo4j::Server
 
     # (see Neo4j::Node#node)
     def node(match={})
-      result = match(CypherNode, "ID(p)", match)
+      result = match(CypherNode, "p as result LIMIT 2", match)
       raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
       result.first
     end
 
     # (see Neo4j::Node#rel)
     def rel(match={})
-      result = match(CypherRelationship, "ID(r), TYPE(r)", match)
+      result = match(CypherRelationship, "r as result LIMIT 2", match)
       raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
       result.first
     end
 
     # (see Neo4j::Node#rel?)
     def rel?(match={})
-      result = match(CypherRelationship, "ID(r), TYPE(r)", match)
+      result = match(CypherRelationship, "r as result", match)
       !!result.first
     end
 
     # (see Neo4j::Node#nodes)
     def nodes(match={})
-      match(CypherNode, "ID(p)", match)
+      match(CypherNode, "p as result", match)
     end
 
 
     # (see Neo4j::Node#rels)
     def rels(match = {dir: :both})
-      match(CypherRelationship, "ID(r), TYPE(r)", match)
+      match(CypherRelationship, "r as result", match)
     end
 
     # @private
@@ -199,17 +203,11 @@ module Neo4j::Server
       cypher = "START n=node(#{neo_id}) #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
       r = @session._query(cypher)
       r.raise_error if r.error?
-      _map_result(r, clazz)
+      _map_result(r)
     end
 
-    # @private
-    def _map_result(r, clazz)
-      r.data.map do |rel|
-        next if r.uncommited? ? rel['row'].first.nil? : rel.first.nil?
-        row = r.uncommited? ? rel['row'] : rel
-        clazz.new(@session, *row).wrapper
-      end.compact
+    def _map_result(r)
+      r.to_node_enumeration.map { |rel| rel.result }
     end
-
   end
 end

data/lib/neo4j-server/cypher_relationship.rb

@@ -5,23 +5,14 @@ module Neo4j::Server
     include Neo4j::Core::CypherTranslator
     include Neo4j::Core::ActiveEntity
 
-    attr_reader :start_node_neo_id, :end_node_neo_id
-
-    def initialize(session, value, rel_type = nil)
+    def initialize(session, value)
       @session = session
-
-      @id = if value.is_a?(Hash)
-        @response_hash = value
-        @rel_type = @response_hash['type']
-        @props = @response_hash['data']
-        @start_node_neo_id = @response_hash['start'].match(/\d+$/)[0].to_i
-        @end_node_neo_id = @response_hash['end'].match(/\d+$/)[0].to_i
-        @response_hash['id']
-      else
-        @rel_type = rel_type
-
-        value
-      end
+      @response_hash = value
+      @rel_type = @response_hash['type']
+      @props = @response_hash['data']
+      @start_node_neo_id = @response_hash['start'].match(/\d+$/)[0].to_i
+      @end_node_neo_id = @response_hash['end'].match(/\d+$/)[0].to_i
+      @id = @response_hash['id']
     end
 
     def ==(o)
@@ -29,21 +20,32 @@ module Neo4j::Server
     end
     alias_method :eql?, :==
 
-    def neo_id
+    def id
       @id
     end
 
+    def neo_id
+      id
+    end
+
     def inspect
       "CypherRelationship #{neo_id}"
     end
 
     def load_resource
-      id = neo_id
-      unless @resource_data
+      if resource_data.nil? || resource_data.empty?
         @resource_data = @session._query_or_fail("START n=relationship(#{id}) RETURN n", true) # r.first_data
       end
     end
 
+    def start_node_neo_id
+      @start_node_neo_id
+    end
+
+    def end_node_neo_id
+      @end_node_neo_id
+    end
+
     def _start_node_id
       @start_node_neo_id ||= get_node_id(:start)
     end
@@ -53,15 +55,12 @@ module Neo4j::Server
     end
 
     def _start_node
-      load_resource
-      id = resource_url_id(resource_url(:start))
-      Neo4j::Node._load(id)
+      @_start_node ||= Neo4j::Node._load(start_node_neo_id)
     end
 
     def _end_node
       load_resource
-      id = resource_url_id(resource_url(:end))
-      Neo4j::Node._load(id)
+      @_end_node ||= Neo4j::Node._load(end_node_neo_id)
     end
 
     def get_node_id(direction)
@@ -70,17 +69,14 @@ module Neo4j::Server
     end
 
     def get_property(key)
-      id = neo_id
       @session._query_or_fail("START n=relationship(#{id}) RETURN n.`#{key}`", true)
     end
 
     def set_property(key,value)
-      id = neo_id
       @session._query_or_fail("START n=relationship(#{id}) SET n.`#{key}` = {value}", false, {value: value})
     end
 
     def remove_property(key)
-      id = neo_id
       @session._query_or_fail("START n=relationship(#{id}) REMOVE n.`#{key}`")
     end
 
@@ -118,6 +114,8 @@ module Neo4j::Server
       id = neo_id
       @session._query("START n=relationship(#{id}) DELETE n").raise_unless_response_code(200)
     end
+    alias_method :delete, :del
+    alias_method :destroy, :del
 
     def exist?
       id = neo_id

data/lib/neo4j-server/cypher_response.rb

@@ -50,25 +50,21 @@ module Neo4j::Server
 
     def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
       Enumerator.new do |yielder|
+        @result_index = 0
         self.to_struct_enumeration(cypher).each do |row|
+          @row_index = 0
           yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
             result[column] = map_row_value(value, session)
+            @row_index += 1
           end
+          @result_index += 1
         end
       end
     end
 
     def map_row_value(value, session)
       if value.is_a?(Hash)
-        if value['labels']
-          add_entity_id(value)
-          CypherNode.new(session, value).wrapper
-        elsif value['type']
-          add_entity_id(value)
-          CypherRelationship.new(session, value).wrapper
-        else
-          value
-        end
+        hash_value_as_object(value, session)
       elsif value.is_a?(Array)
         value.map {|v| map_row_value(v, session) }
       else
@@ -76,6 +72,18 @@ module Neo4j::Server
       end
     end
 
+    def hash_value_as_object(value, session)
+      return value unless value['labels'] || value['type'] || is_transaction_response?
+      obj_type, data = if value['labels'] || value['type']
+                        add_entity_id(value)
+                        [(value['labels'] ? CypherNode : CypherRelationship), value]
+                      else
+                        add_transaction_entity_id
+                        [(mapped_rest_data['start'] ? CypherRelationship : CypherNode), mapped_rest_data]
+                      end
+      obj_type.new(session, data).wrapper
+    end
+
     attr_reader :struct
     
     def initialize(response, uncommited = false)
@@ -83,7 +91,6 @@ module Neo4j::Server
       @uncommited = uncommited
     end
 
-
     def entity_data(id=nil)
       if uncommited?
         data = @data.first['row'].first
@@ -108,6 +115,10 @@ module Neo4j::Server
       data.merge!({'id' => data['self'].split('/')[-1].to_i})
     end
 
+    def add_transaction_entity_id
+      mapped_rest_data.merge!({'id' => mapped_rest_data['self'].split('/').last.to_i})
+    end
+
     def error?
       !!@error
     end
@@ -116,6 +127,10 @@ module Neo4j::Server
       @uncommited
     end
 
+    def has_data?
+      !response.body['data'].nil?
+    end
+
     def raise_unless_response_code(code)
       raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.status == code
     end
@@ -179,5 +194,32 @@ module Neo4j::Server
       end
       cr
     end
+
+    def is_transaction_response?
+      !self.response.body['results'].nil?
+    end
+
+    def rest_data
+      @result_index = @row_index = 0
+      mapped_rest_data
+    end
+
+    def rest_data_with_id
+      rest_data.merge!({'id' => mapped_rest_data['self'].split('/').last.to_i})
+    end
+
+    private
+
+    def row_index
+      @row_index
+    end
+
+    def result_index
+      @result_index
+    end
+
+    def mapped_rest_data
+      self.response.body['results'][0]['data'][result_index]['rest'][row_index]
+    end
   end
-end
+end

data/lib/neo4j-server/cypher_session.rb

@@ -104,24 +104,28 @@ module Neo4j::Server
 
     def load_node(neo_id)
       cypher_response = _query("START n=node(#{neo_id}) RETURN n")
-      if (!cypher_response.error?)
-        result = cypher_response.entity_data(neo_id)
-        CypherNode.new(self, result)
-      elsif (cypher_response.error_status =~ /EntityNotFound/)
-        return nil
-      else
-        cypher_response.raise_error
-      end
+      load_entity(CypherNode, cypher_response)
     end
 
     def load_relationship(neo_id)
-      cypher_response = _query("START r=relationship(#{neo_id}) RETURN TYPE(r)")
-      if (!cypher_response.error?)
-        CypherRelationship.new(self, neo_id, cypher_response.first_data)
-      elsif (cypher_response.error_msg =~ /not found/)  # Ugly that the Neo4j API gives us this error message
+      cypher_response = _query("START r=relationship(#{neo_id}) RETURN r")
+      load_entity(CypherRelationship, cypher_response)
+    end
+
+    def load_entity(clazz, cypher_response)
+      return nil if cypher_response.data.nil? || cypher_response.data[0].nil?
+      data  = if cypher_response.is_transaction_response?
+                cypher_response.rest_data_with_id
+              else
+                cypher_response.first_data
+              end
+
+      if cypher_response.error?
+        cypher_response.raise_error
+      elsif cypher_response.error_msg =~ /not found/  # Ugly that the Neo4j API gives us this error message
         return nil
       else
-        cypher_response.raise_error
+        clazz.new(self, data)
       end
     end
 
@@ -254,27 +258,27 @@ module Neo4j::Server
     end
 
 
-    def search_result_to_enumerable(response, ret, map)
-      return [] unless response.data
-
-      if (ret.size == 1)
-        Enumerator.new do |yielder|
-          response.data.each do |data|
-            yielder << map_column(key, map, data[0])
-          end
-        end
-
-      else
-        Enumerator.new do |yielder|
-          response.data.each do |data|
-            hash = {}
-            ret.each_with_index do |key, i|
-              hash[key] = map_column(key, map, data[i])
-            end
-            yielder << hash
-          end
-        end
-      end
-    end
+    # def search_result_to_enumerable(response, ret, map)
+    #   return [] unless response.data
+
+    #   if (ret.size == 1)
+    #     Enumerator.new do |yielder|
+    #       response.data.each do |data|
+    #         yielder << map_column(key, map, data[0])
+    #       end
+    #     end
+
+    #   else
+    #     Enumerator.new do |yielder|
+    #       response.data.each do |data|
+    #         hash = {}
+    #         ret.each_with_index do |key, i|
+    #           hash[key] = map_column(key, map, data[i])
+    #         end
+    #         yielder << hash
+    #       end
+    #     end
+    #   end
+    # end
   end
 end

data/lib/neo4j-server/cypher_transaction.rb

@@ -26,41 +26,25 @@ module Neo4j::Server
     end
 
     def _query(cypher_query, params=nil)
-      statement = {statement: cypher_query}
-      body = {statements: [statement]}
-
-      if params
-        # TODO can't get this working for some reason using parameters
-        #props = params.keys.inject({}) do|ack, k|
-        #  ack[k] = {name: params[k]}
-        #  ack
-        #end
-        #statement[:parameters] = props
-
-        # So we have to do this workaround
-        params.each_pair do |k,v|
-          statement[:statement].gsub!("{ #{k} }", "#{escape_value(v)}")
-        end
-      end
+      statement = { statement: cypher_query, parameters: params, resultDataContents: ['row', 'REST'] }
+      body = { statements: [statement] }
       response = @connection.post(@exec_url, body)
       _create_cypher_response(response)
     end
 
     def _create_cypher_response(response)
       first_result = response.body['results'][0]
-      cr = CypherResponse.new(response, true)
 
-      if (response.body['errors'].empty?)
-        cr.set_data(first_result['data'], first_result['columns'])
-      else
+      cr = CypherResponse.new(response, true)
+      if !response.body['errors'].empty?
         first_error = response.body['errors'].first
         cr.set_error(first_error['message'], first_error['code'], first_error['code'])
+      else
+        cr.set_data(first_result['data'], first_result['columns'])
       end
       cr
     end
 
-
-
     def _delete_tx
       response = @connection.delete(@exec_url, headers: resource_headers)
       expect_response_code(response,200)
@@ -74,4 +58,4 @@ module Neo4j::Server
       response
     end
   end
-end
+end

data/lib/neo4j-server/resource.rb

@@ -16,8 +16,9 @@ module Neo4j
       end
 
 
-      def wrap_resource(db, rel, resource_class, verb=:get, payload={}, connection)
+      def wrap_resource(db, rel, resource_class, verb = :get, statement = {}, connection)
         url = resource_url(rel)
+        payload = statement.empty? ? nil : statement
         response = case verb
           when :get then connection.get(url, payload)
           when :post then connection.post(url, payload)
@@ -26,9 +27,9 @@ module Neo4j
         response.status == 404 ? nil : resource_class.new(db, response, url, connection)
       end
 
-      def resource_url(rel=nil)
-        return @resource_url unless rel
-        url = @resource_data[rel.to_s]
+      def resource_url(rel = nil)
+        return @resource_url if rel.nil?
+        url = resource_data[rel.to_s]
         raise "No resource rel '#{rel}', available #{@resource_data.keys.inspect}" unless url
         url
       end
@@ -51,7 +52,7 @@ module Neo4j
         {'Content-Type' => 'application/json', 'Accept' => 'application/json'}
       end
 
-      def resource_url_id(url = @resource_url)
+      def resource_url_id(url = resource_url)
         url.match(/\/(\d+)$/)[1].to_i
       end
 

data/neo4j-core.gemspec

@@ -10,16 +10,13 @@ Gem::Specification.new do |s|
 
   s.authors  = "Andreas Ronge"
   s.email    = 'andreas.ronge@gmail.com'
-  s.homepage = "http://github.com/andreasronge/neo4j-core/tree"
+  s.homepage = "https://github.com/neo4jrb/neo4j-core"
   s.rubyforge_project = 'neo4j-core'
   s.summary = "A graph database for Ruby"
   s.license = 'MIT'
 
   s.description = <<-EOF
-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
-yet enjoys all the benefits of a fully transactional, enterprise-strength database.
-It comes included with the Apache Lucene document database.
+Neo4j-core provides classes and methods to work with the graph database Neo4j.
   EOF
 
   s.require_path = 'lib'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-core
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-26 00:00:00.000000000 Z
+date: 2014-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -137,10 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 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
-  yet enjoys all the benefits of a fully transactional, enterprise-strength database.
-  It comes included with the Apache Lucene document database.
+  Neo4j-core provides classes and methods to work with the graph database Neo4j.
 email: andreas.ronge@gmail.com
 executables: []
 extensions: []
@@ -190,7 +187,7 @@ files:
 - lib/neo4j/tasks/neo4j_server.rake
 - lib/neo4j/transaction.rb
 - neo4j-core.gemspec
-homepage: http://github.com/andreasronge/neo4j-core/tree
+homepage: https://github.com/neo4jrb/neo4j-core
 licenses:
 - MIT
 metadata: {}