neography 1.0.10 → 1.0.11

data/.travis.yml

@@ -1,4 +1,4 @@
-script: "bundle exec rake neo4j:install['enterprise','1.8.2'] neo4j:start spec --trace"
+script: "bundle exec rake neo4j:install['enterprise','2.0.0-M03'] neo4j:start spec --trace"
 language: ruby
 rvm:
   - 1.9.3

data/README.md

@@ -99,6 +99,7 @@ Some of this functionality is shown here, but all of it is explained in the foll
 * [Node relationships](https://github.com/maxdemarzi/neography/wiki/Node-relationships) - Create and get relationships between nodes.
 * [Relationship](https://github.com/maxdemarzi/neography/wiki/Relationships) - Get and delete relationships.
 * [Relationship properties](https://github.com/maxdemarzi/neography/wiki/Relationship-properties) - Create, get and delete relationship properties.
+* [Relationship types](https://github.com/maxdemarzi/neography/wiki/Relationship-types) - List relationship types.
 * [Node indexes](https://github.com/maxdemarzi/neography/wiki/Node-indexes) - List and create node indexes. Add, remove, get and search nodes in indexes.
 * [Relationship indexes](https://github.com/maxdemarzi/neography/wiki/Relationship-indexes) - List and create relationships indexes. Add, remove, get and search relationships in indexes.
 * [Auto indexes](https://github.com/maxdemarzi/neography/wiki/Auto-indexes) - Get, set and remove auto indexes.

data/lib/neography/connection.rb

@@ -16,6 +16,7 @@ module Neography
       save_local_configuration(config)
       @client = HTTPClient.new
       @client.send_timeout = 1200 # 10 minutes
+      @client.receive_timeout = 1200
     end
 
     def configure(protocol, server, port, directory)
@@ -30,8 +31,9 @@ module Neography
     end
 
     def merge_options(options)
-      merged_options = options.merge!(@authentication)#.merge!(@parser)
+      merged_options = options.merge!(@authentication)
       merged_options[:headers].merge!(@user_agent) if merged_options[:headers]
+      merged_options[:headers].merge!('X-Stream' => true) if merged_options[:headers]
       merged_options
     end
 
@@ -45,23 +47,6 @@ module Neography
       evaluate_response(@client.post(configuration + path, merge_options(options)[:body], merge_options(options)[:headers]))
     end
 
-    def post_chunked(path, options={})
-      authenticate(configuration + path)
-      result = ""
-
-      response = @client.post(configuration + path, merge_options(options)[:body], merge_options(options)[:headers]) do |chunk|
-        result << chunk
-      end
-
-      r = evaluate_chunk_response(response, result)
-
-      if r.last["status"] > 399
-        handle_4xx_500_response(r.last["status"], r.last["body"] || r.last )
-      end
-      
-      r
-    end
-
     def put(path, options={})
       authenticate(configuration + path)
       evaluate_response(@client.put(configuration + path, merge_options(options)[:body], merge_options(options)[:headers]))
@@ -121,19 +106,36 @@ module Neography
     end
 
     def evaluate_response(response)
-      code = response.code
-      body = response.body
-      return_result(code, body)
+      if response.http_header.request_uri.request_uri == "/db/data/batch"
+        code, body, parsed = handle_batch(response)
+      else
+        code = response.code
+        body = response.body
+        parsed = false
+      end
+      return_result(code, body, parsed)
+    end
+
+    def handle_batch(response)
+      code = 200
+      body = @parser.json(response.body)
+      body.each do |result|
+        if result["status"] >= 400
+          code = result["status"] 
+          break
+        end
+      end
+      return code, body, true
     end
     
-    def return_result(code, body)
+    def return_result(code, body, parsed)
       case code
       when 200
-        @logger.debug "OK" if @log_enabled
-        @parser.json(body) #response.parsed_response
+        @logger.debug "OK, created #{body}" if @log_enabled
+        parsed ? body : @parser.json(body)
       when 201
         @logger.debug "OK, created #{body}" if @log_enabled
-        r = @parser.json(body) #response.parsed_response
+        r = parsed ? body : @parser.json(body)
         r.extend(WasCreated)
         r
       when 204
@@ -147,24 +149,32 @@ module Neography
 
     def handle_4xx_500_response(code, body)
       if body.nil? or body == ""
-        parsed_body = {}
-        message = "No error message returned from server."
-        stacktrace = ""
+        parsed_body = {"message" => "No error message returned from server.",
+                       "stacktrace" => "No stacktrace returned from server." }
       elsif body.is_a? Hash
         parsed_body = body
-        message = parsed_body["message"]
-        stacktrace = parsed_body["stacktrace"]
+      elsif body.is_a? Array
+        body.each do |result|
+          if result["status"] >= 400
+            parsed_body = result["body"] || result
+            break
+          end
+        end        
       else
         parsed_body = @parser.json(body)
-        message = parsed_body["message"]
-        stacktrace = parsed_body["stacktrace"]
       end
 
-      @logger.error "#{code} error: #{body}" if @log_enabled
+      message = parsed_body["message"]
+      stacktrace = parsed_body["stacktrace"]
 
+      @logger.error "#{code} error: #{body}" if @log_enabled
+      raise_errors(code, parsed_body["exception"], message, stacktrace)
+    end
+    
+    def raise_errors(code, exception, message, stacktrace)
       case code
       when 400, 404
-        case parsed_body["exception"]
+        case exception
         when /SyntaxException/               ; raise SyntaxException.new(message, code, stacktrace)
         when /this is not a query/           ; raise SyntaxException.new(message, code, stacktrace)
         when /PropertyValueException/        ; raise PropertyValueException.new(message, code, stacktrace)
@@ -184,6 +194,7 @@ module Neography
       else
         raise NeographyError.new(message, code, stacktrace)
       end
+      
     end
 
     def parse_string_options(options)

data/lib/neography/node.rb

@@ -20,7 +20,7 @@ module Neography
       def load(node, db = Neography::Rest.new)
         raise ArgumentError.new("syntax deprecated") if node.is_a?(Neography::Rest)
 
-        node = db.get_node(node)
+        node = db.get_node(node) if (node.to_s.match(/^\d+$/) or node.to_s.split("/").last.match(/^\d+$/))
         if node
           node = self.new(node)
           node.neo_server = db

data/lib/neography/path_traverser.rb

@@ -63,15 +63,15 @@ module Neography
 
         if @get.include?("node")
           path["nodes"].each_with_index do |n, i|
-            @loaded_nodes[n.split('/').last.to_i] = Neography::Node.load(n) if @loaded_nodes.at(n.split('/').last.to_i).nil?
-            paths[i * 2] =  @loaded_nodes[n.split('/').last.to_i]
+            @loaded_nodes[get_id(n)] = Neography::Node.load(n) if @loaded_nodes.at(get_id(n)).nil?
+            paths[i * 2] =  @loaded_nodes[get_id(n)]
           end
         end
 
         if @get.include?("rel") 
           path["relationships"].each_with_index do |r, i|
-            @loaded_rels[r.split('/').last.to_i] = Neography::Relationship.load(r)  if @loaded_rels.at(r.split('/').last.to_i).nil?
-            paths[i * 2 + 1] =  @loaded_rels[r.split('/').last.to_i]
+            @loaded_rels[get_id(r)] = Neography::Relationship.load(r)  if @loaded_rels.at(get_id(r)).nil?
+            paths[i * 2 + 1] =  @loaded_rels[get_id(r)]
           end
         end
  
@@ -90,6 +90,11 @@ module Neography
         @from.neo_server.get_paths(@from, @to, @relationships, @depth, @algorithm)
       end
     end
+    
+    private 
+    def get_id(object)
+      object.split('/').last.to_i
+    end
 
   end
 end

data/lib/neography/property_container.rb

@@ -5,11 +5,23 @@ module Neography
     def initialize(hash=nil)
       @table = {}
       if hash
-        @neo_id = hash["self"].split('/').last
-        for k,v in hash["data"]
-          @table[k.to_sym] = v
-          new_ostruct_member(k)
+        if hash["self"] # coming from REST API
+          @neo_id = hash["self"].split('/').last
+          data = hash["data"]
+        elsif hash.is_a? Neography::Node # is already a Neography::Node
+          @neo_id = hash.neo_id
+          data = Hash[*hash.attributes.collect{|x| [x.to_sym, hash.send(x)]}.flatten]
+        elsif hash["data"] # coming from CYPHER
+          @neo_id = hash["data"].first.first["self"].split('/').last  
+          data = hash["data"].first.first["data"]
         end
+      else
+        data = []
+      end      
+      
+      for k,v in data
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
       end
     end
 

data/lib/neography/rest.rb

@@ -6,6 +6,7 @@ require 'neography/rest/paths'
 require 'neography/rest/properties'
 require 'neography/rest/indexes'
 require 'neography/rest/auto_indexes'
+require 'neography/rest/schema_indexes'
 
 require 'neography/rest/nodes'
 require 'neography/rest/node_properties'
@@ -15,15 +16,18 @@ require 'neography/rest/node_indexes'
 require 'neography/rest/node_auto_indexes'
 require 'neography/rest/node_traversal'
 require 'neography/rest/node_paths'
+require 'neography/rest/node_labels'
 require 'neography/rest/relationships'
 require 'neography/rest/relationship_properties'
 require 'neography/rest/relationship_indexes'
 require 'neography/rest/relationship_auto_indexes'
+require 'neography/rest/relationship_types'
 require 'neography/rest/cypher'
 require 'neography/rest/gremlin'
 require 'neography/rest/extensions'
 require 'neography/rest/batch'
 require 'neography/rest/clean'
+require 'neography/rest/transactions'
 
 require 'neography/errors'
 
@@ -48,21 +52,101 @@ module Neography
       @other_node_relationships  = OtherNodeRelationships.new(@connection)
       @node_indexes              = NodeIndexes.new(@connection)
       @node_auto_indexes         = NodeAutoIndexes.new(@connection)
+      @schema_indexes            = SchemaIndexes.new(@connection)
       @node_traversal            = NodeTraversal.new(@connection)
       @node_paths                = NodePaths.new(@connection)
+      @node_labels               = NodeLabels.new(@connection)
 
       @relationships             = Relationships.new(@connection)
       @relationship_properties   = RelationshipProperties.new(@connection)
       @relationship_indexes      = RelationshipIndexes.new(@connection)
       @relationship_auto_indexes = RelationshipAutoIndexes.new(@connection)
+      @relationship_types        = RelationshipTypes.new(@connection)
 
       @cypher                    = Cypher.new(@connection)
       @gremlin                   = Gremlin.new(@connection)
       @extensions                = Extensions.new(@connection)
       @batch                     = Batch.new(@connection)
       @clean                     = Clean.new(@connection)
+      @transactions              = Transactions.new(@connection)
     end
 
+    # meta-data
+
+    def list_relationship_types
+      @relationship_types.list
+    end
+    
+    # labels
+    
+    def list_labels
+      @node_labels.list
+    end
+    
+    def add_label(id, label)
+      @node_labels.add(id, label)
+    end
+
+    def set_label(id, label)
+      @node_labels.set(id, label)
+    end
+
+    def delete_label(id, label)
+      @node_labels.delete(id, label)
+    end
+    
+    def get_node_labels(id)
+      @node_labels.get(id)
+    end
+    
+    def get_nodes_labeled(label)
+      @node_labels.get_nodes(label)
+    end
+
+    def find_nodes_labeled(label, hash)
+      @node_labels.find_nodes(label, hash)
+    end
+
+    # schema indexes
+ 
+    def get_schema_index(label)
+      @schema_indexes.list(label)
+    end
+    
+    def create_schema_index(label, properties)
+      @schema_indexes.create(label, properties)
+    end
+    
+    def delete_schema_index(label, property)
+      @schema_indexes.drop(label, property)
+    end
+
+    # transactions
+    
+    def begin_transaction(statements=nil)
+      @transactions.begin(statements)
+    end
+    
+    def in_transaction(tx, statements)
+      @transactions.add(tx, statements)    
+    end
+    
+    def keep_transaction(tx)
+      @transactions.add(tx)    
+    end
+
+    def commit_transaction(tx, statements=[])
+      if tx.is_a?(Array)
+        @transactions.begin(tx, "commit")
+      else
+        @transactions.commit(tx, statements)    
+      end
+    end
+    
+    def rollback_transaction(tx)
+      @transactions.add(tx)    
+    end    
+    
     # nodes
 
     def get_root
@@ -331,8 +415,8 @@ module Neography
 
     # cypher query
 
-    def execute_query(query, params = {})
-      @cypher.query(query, params)
+    def execute_query(query, params = {}, cypher_options = nil)
+      @cypher.query(query, params, cypher_options)
     end
 
     # gremlin script

data/lib/neography/rest/batch.rb

@@ -11,29 +11,21 @@ module Neography
       end
 
       def execute(*args)
-        batch({'Accept' => 'application/json;stream=true'}, *args)
-      end
-
-      def not_streaming(*args)
-        batch({}, *args)
+        batch(*args)
       end
 
       private
 
-      def batch(accept_header, *args)
+      def batch(*args)
         batch = []
         Array(args).each_with_index do |c, i|
           batch << {:id => i }.merge(get_batch(c))
         end
         options = {
           :body => batch.to_json,
-          :headers => json_content_type.merge(accept_header)
+          :headers => json_content_type
         }
-        if accept_header.empty?
-          @connection.post(batch_path, options)
-        else
-          @connection.post_chunked(batch_path, options)
-        end
+        @connection.post(batch_path, options)
       end
 
       def get_batch(args)

data/lib/neography/rest/cypher.rb

@@ -7,7 +7,7 @@ module Neography
         @connection = connection
       end
 
-      def query(query, parameters = {})
+      def query(query, parameters = {}, cypher_options = nil)
         options = {
           :body => {
             :query => query,
@@ -15,8 +15,17 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;stream=true'})
         }
-
-        @connection.post(@connection.cypher_path, options)
+        
+        @connection.post(optioned_path(cypher_options), options)
+      end
+      
+      private
+      def optioned_path(cypher_options = nil)
+        return @connection.cypher_path unless cypher_options
+        options = []
+        options << "includeStats=true" if cypher_options[:stats]
+        options << "profile=true" if cypher_options[:profile]
+        @connection.cypher_path + "?" + options.join("&")
       end
 
     end

data/lib/neography/rest/helpers.rb

@@ -21,6 +21,18 @@ module Neography
         {'Content-Type' => 'application/json'}
       end
 
+      def parse_direction(direction)
+        case direction
+          when :incoming, "incoming", :in, "in"
+            "in"
+          when :outgoing, "outgoing", :out, "out"
+            "out"
+          else
+            "all"
+        end
+      end
+
+
     end
   end
 end

data/lib/neography/rest/node_labels.rb

@@ -0,0 +1,60 @@
+module Neography
+  class Rest
+    class NodeLabels
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,      "/labels"
+      add_path :node,      "/node/:id/labels"
+      add_path :nodes,     "/label/:label/nodes"
+      add_path :find,      "/label/:label/nodes?:property=%22:value%22"
+      add_path :delete,    "/node/:id/labels/:label"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def list
+        @connection.get(base_path)
+      end
+      
+      def get(id)
+        @connection.get(node_path(:id => id))
+      end
+      
+      def get_nodes(label)
+        @connection.get(nodes_path(:label => label))
+      end
+
+      def find_nodes(label, hash)
+        @connection.get(find_path(:label => label, :property => hash.keys.first, :value => hash.values.first))
+      end
+
+      def add(id, label)
+        options = {
+          :body => (
+            label
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(node_path(:id => id), options)
+      end
+      
+      def set(id, label)
+        options = {
+          :body => (
+            Array(label)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.put(node_path(:id => id), options)
+      end      
+
+      def delete(id, label)
+        @connection.delete(delete_path(:id => id, :label => label))
+      end
+
+
+    end
+  end
+end