neography 1.0.10 → 1.0.11

data/lib/neography/rest/node_relationships.rb

@@ -37,17 +37,6 @@ module Neography
         node_relationships
       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/other_node_relationships.rb

@@ -36,24 +36,13 @@ module Neography
                     }.merge(relationships).to_json,
           :headers => json_content_type
         }
-        #puts options.inspect
+
         node_relationships = @connection.post(base_path(:id => get_id(id)), options) || []
 
         return nil if node_relationships.empty?
         node_relationships
       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/relationship_types.rb

@@ -0,0 +1,18 @@
+module Neography
+  class Rest
+    class RelationshipTypes
+      extend Neography::Rest::Paths
+
+      add_path :all,    "/relationship/types"
+      
+      def initialize(connection)
+        @connection = connection
+      end
+            
+      def list
+        @connection.get(all_path)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/schema_indexes.rb

@@ -0,0 +1,34 @@
+module Neography
+  class Rest
+    class SchemaIndexes
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,      "/schema/index/:label"
+      add_path :drop,      "/schema/index/:label/:index"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def list(label)
+        @connection.get(base_path(:label => label))
+      end
+
+      def drop(label, index)
+        @connection.delete(drop_path(:label => label, :index => index))
+      end
+
+      def create(label, keys = [])
+        options = {
+          :body => (
+            { :property_keys => keys
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(base_path(:label => label), options)
+      end
+    end
+  end
+end

data/lib/neography/rest/transactions.rb

@@ -0,0 +1,83 @@
+module Neography
+  class Rest
+    class Transactions
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,   "/transaction"
+      add_path :tx,    "/transaction/:id"
+      add_path :commit, "/transaction/:id/commit"
+      
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def begin(statements = [], commit = "")
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(base_path + commit, options)
+      end
+
+      def add(tx, statements = [])
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(tx_path(:id => get_id(tx)), options)
+      end
+
+      def commit(tx, statements = [])
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(commit_path(:id => get_id(tx)), options)
+      end
+      
+      def rollback(tx)
+        @connection.delete(tx_path(:id => get_id(tx)))
+      end
+
+      private
+      
+      def get_id(tx)
+        return tx if tx.is_a?(Integer)
+        return tx.split("/")[-2] if tx.is_a?(String)
+        return tx["commit"].split("/")[-2] if tx["commit"]
+        raise NeographyError.new("Could not determine transaction id", nil, tx)
+      end
+      
+      def convert_cypher(statements)
+        array = []
+        query = nil
+        parameters = nil
+        Array(statements).each do |statement|
+          if query & parameters
+            array << {:statement => query, :parameters => {:props => parameters}}
+            query = statement
+            parameters = nil            
+          elsif query & statement.is_a?(String)
+            array << {:statement => query}
+            query = statement
+            parameters = nil 
+          elsif query & statement.is_a?(Hash)
+            array << {:statement => query, :parameters => {:props => parameters}}
+            query = nil
+            parameters = nil            
+          end
+          query = statement
+        end
+        array << {:statement => query} if query
+        { :statements => array }
+      end
+    end
+  end
+end

data/lib/neography/tasks.rb

@@ -6,7 +6,7 @@ require 'zip/zip'
 namespace :neo4j do
   desc "Install Neo4j"
   task :install, :edition, :version do |t, args|
-    args.with_defaults(:edition => "community", :version => "1.8.2")
+    args.with_defaults(:edition => "community", :version => "1.9")
     puts "Installing Neo4j-#{args[:edition]}-#{args[:version]}"
     
     if OS::Underlying.windows?

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "1.0.10"
+  VERSION = "1.0.11"
 end

data/spec/integration/node_spec.rb

@@ -68,6 +68,19 @@ describe Neography::Node do
         existing_node = Neography::Node.load(@neo, new_node)
       }.to raise_error(ArgumentError)
     end
+
+    it "can get a node that exists via cypher" do
+      new_node = Neography::Node.create("age" => 31, "name" => "Max")
+      cypher = "START n = node({id}) return n"
+      @neo = Neography::Rest.new
+      results = @neo.execute_query(cypher, {:id => new_node.neo_id.to_i})
+      existing_node = Neography::Node.load(results)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+    end
+
+
   end
 
   describe "del" do

data/spec/integration/rest_batch_spec.rb

@@ -255,14 +255,14 @@ describe Neography::Rest do
       batch_result.first["body"].first["end"].split('/').last.should == node2["self"].split('/').last
     end
 
-    it "can batch gremlin" do
+    it "can batch gremlin", :gremlin => true  do
       batch_result = @neo.batch [:execute_script, "g.v(0)"]
       batch_result.first.should have_key("id")
       batch_result.first.should have_key("from")
       batch_result.first["body"]["self"].split('/').last.should == "0"
     end
 
-    it "can batch gremlin with parameters" do
+    it "can batch gremlin with parameters", :gremlin => true  do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       batch_result = @neo.batch [:execute_script, "g.v(id)", {:id => id.to_i}]
@@ -445,38 +445,34 @@ describe Neography::Rest do
       # See https://github.com/neo4j/community/issues/697
 
       expect {
-        batch_result = @neo.batch [:create_unique_node, "person", "ssn", "000-00-0001", {:first_name=>"Jane", :last_name=>"Doe", :ssn=>"000-00-0001", :_type=>"Person", :created_at=>1335269478}],
-                                  [:add_node_to_index, "person_ssn", "ssn", "000-00-0001", "{0}"],
-                                  [:create_node, {:street1=>"94437 Kemmer Crossing", :street2=>"Apt. 333", :city=>"Abshireton", :state=>"AA", :zip=>"65820", :_type=>"Address", :created_at=>1335269478}],
-                                  [:create_relationship, "has", "{0}", "{2}", {}]
-      }.to raise_error(Neography::BadInputException)
+              batch_result = @neo.batch [:create_unique_node, "person", "ssn", "000-00-0001", {:first_name=>"Jane", :last_name=>"Doe", :ssn=>"000-00-0001", :_type=>"Person", :created_at=>1335269478}],
+                                        [:add_node_to_index, "person_ssn", "ssn", "000-00-0001", "{0}"],
+                                        [:create_node, {:street1=>"94437 Kemmer Crossing", :street2=>"Apt. 333", :city=>"Abshireton", :state=>"AA", :zip=>"65820", :_type=>"Address", :created_at=>1335269478}],
+                                        [:create_relationship, "has", "{0}", "{2}", {}]
+            }.to raise_error(Neography::NeographyError)                               
     end
 
   end
 
   describe "broken queries" do
     it "should return errors when bad syntax is passed in batch" do
-
       batch_commands = []
-      # batch_commands << [ :create_unique_node, "person", "ssn", "000-00-0002", {:foo => "bar"} ]
     
-      # this doesn't raise error
       batch_commands << [ :execute_query, "start person_n=node:person(ssn = '000-00-0002')
-                                         set bar1 = {foo}",
+                                           set bar1 = {foo}",
                         { :other => "what" }
                       ]
 
+      expect { 
+        batch_result = @neo.batch *batch_commands
+      }.to raise_exception Neography::SyntaxException          
 
-      # this does raise error
       expect { 
           @neo.execute_query("start person_n=node:person(ssn = '000-00-0001')
                               set bar = {foo}",
                         { :other => "what" })
       }.to raise_exception Neography::SyntaxException
                       
-      expect { 
-        batch_result = @neo.batch *batch_commands
-      }.to raise_exception Neography::SyntaxException          
       
     end    
   end

data/spec/integration/rest_batch_streaming_spec.rb

@@ -17,9 +17,9 @@ describe Neography::Rest do
       batch_result.last["body"]["data"]["name"].should == "Max 999"
     end  
 
-    it "can send a 10000 item batch" do
+    it "can send a 5000 item batch" do
       commands = []
-      10000.times do |x|
+      5000.times do |x|
         commands << [:get_node, 0]
       end
       batch_result = @neo.batch *commands

data/spec/integration/rest_gremlin_fail_spec.rb

@@ -6,7 +6,7 @@ describe Neography::Rest do
   end
 
   describe "don't break gremlin" do
-    it "can handle node and relationship indexes" do
+    it "can handle node and relationship indexes", :gremlin => true  do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
@@ -16,7 +16,7 @@ describe Neography::Rest do
       @neo.add_relationship_to_index("test_index2", key, value, new_relationship) 
     end
 
-    it "gremlin works" do
+    it "gremlin works", :gremlin => true  do
       root_node = @neo.execute_script("g.v(0)")
       root_node.should have_key("self")
       root_node["self"].split('/').last.should == "0"
@@ -25,7 +25,7 @@ describe Neography::Rest do
 
 
   describe "break gremlin" do
-    it "can can't handle node and relationship indexes with the same name", :break_gremlin => true do
+    it "can can't handle node and relationship indexes with the same name", :gremlin => true do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
@@ -35,7 +35,7 @@ describe Neography::Rest do
       @neo.add_relationship_to_index("test_index3", key, value, new_relationship) 
     end
 
-    it "gremlin works" do
+    it "gremlin works", :gremlin => true  do
       root_node = @neo.execute_script("g.v(0)")
       root_node.should have_key("self")
       root_node["self"].split('/').last.should == "0"

data/spec/integration/rest_header_spec.rb

@@ -8,7 +8,7 @@ describe Neography::Connection do
 
   it "should add a content type if there's existing headers" do
     subject.merge_options({:headers => {'Content-Type' => 'foo/bar'}})[:headers].should ==
-      {'Content-Type' => "foo/bar",  "User-Agent"   => "Neography/#{Neography::VERSION}"}
+      {'Content-Type' => "foo/bar",  "User-Agent"   => "Neography/#{Neography::VERSION}" , "X-Stream"=>true}
   end
 
 end

data/spec/integration/rest_labels_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "list_labels" do
+    it "can get the labels of the database" do
+      @neo.set_label(0, "Person")
+      labels = @neo.list_labels
+      labels.should include("Person")
+    end
+  end
+
+  describe "add_label" do
+    it "can add a label to a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.add_label(new_node_id, "Person")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Person"]
+    end
+
+    it "can add another label to a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.add_label(new_node_id, "Actor")
+      @neo.add_label(new_node_id, "Director")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Actor", "Director"]
+    end
+
+    it "can add multiple labels to a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.add_label(new_node_id, ["Actor", "Director"])
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Actor", "Director"]
+    end
+  end
+  
+  describe "set_label" do
+    it "can set a label to a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, "Person")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Person"]
+    end  
+
+    it "can set a label to a node that already had a label" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.add_label(new_node_id, "Actor")
+      @neo.set_label(new_node_id, "Director")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Director"]
+    end  
+    
+    it "can set multiple labels to a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, ["Actor", "Director"])
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Actor", "Director"]
+    end
+  end
+
+  describe "delete_label" do
+    it "can delete a label from a node" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, ["Actor", "Director"])
+      @neo.delete_label(new_node_id, "Actor")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == ["Director"]
+    end  
+
+    it "can delete a label from a node that doesn't have one" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.delete_label(new_node_id, "Actor")
+      labels = @neo.get_node_labels(new_node_id)
+      labels.should == []
+    end  
+
+    it "cannot delete a label from a node that doesn't exist" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      expect {      
+        @neo.delete_label(new_node_id.to_i + 1, "Actor")
+      }.to raise_error Neography::NodeNotFoundException
+    end  
+  end
+
+  describe "get_nodes_labeled" do
+    it "can get a node with a label" do
+      new_node = @neo.create_node
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, ["Actor", "Director"])
+      nodes = @neo.get_nodes_labeled("Actor")
+      nodes.last["self"].split('/').last.should == new_node_id
+    end  
+
+    it "returns an empty array on non-existing label" do
+      nodes = @neo.get_nodes_labeled("do_not_exist")
+      nodes.should == []
+    end  
+  end
+  
+  describe "find_nodes_labeled" do
+    it "can find a node with a label and a property" do
+      new_node = @neo.create_node(:name => "max")
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, "clown")
+      nodes = @neo.find_nodes_labeled("clown", { :name => "max" })
+      nodes.last["self"].split('/').last.should == new_node_id
+    end  
+
+    it "returns an empty array on non-existing label property" do
+      new_node = @neo.create_node(:name => "max")
+      new_node_id = new_node["self"].split('/').last
+      @neo.set_label(new_node_id, "clown")
+      nodes = @neo.find_nodes_labeled("clown", { :name => "does_not_exist" })
+      nodes.should == []
+    end  
+
+  end  
+  
+end