neography-calamitates 1.2.3.1

data/lib/neography/tasks.rb

@@ -0,0 +1,158 @@
+# borrowed from architect4r
+require 'os'
+require 'httpclient'
+require 'zip'
+require 'net/http'
+
+namespace :neo4j do
+  desc "Install Neo4j"
+  task :install, :edition, :version do |t, args|
+    args.with_defaults(:edition => "community", :version => "1.9.4")
+    puts "Installing Neo4j-#{args[:edition]}-#{args[:version]}"
+    
+    if OS::Underlying.windows?
+      # Download Neo4j    
+      unless File.exist?('neo4j.zip')
+        df = File.open('neo4j.zip', 'wb')
+        begin
+          Net::HTTP.start("dist.neo4j.org") do |http|
+            http.request_get("/neo4j-#{args[:edition]}-#{args[:version]}-windows.zip") do |resp|
+                resp.read_body do |segment|
+                    df.write(segment)
+                end
+            end
+          end
+        ensure
+          df.close()
+        end
+      end
+
+      # Extract and move to neo4j directory
+      unless File.exist?('neo4j')
+        Zip::File.open('neo4j.zip') do |zip_file|
+          zip_file.each do |f|
+           f_path=File.join(".", f.name)
+           FileUtils.mkdir_p(File.dirname(f_path))
+           begin
+             zip_file.extract(f, f_path) unless File.exist?(f_path)
+           rescue
+             puts f.name + " failed to extract."
+           end
+          end
+        end
+        FileUtils.mv "neo4j-#{args[:edition]}-#{args[:version]}", "neo4j"
+     end
+
+      # Install if running with Admin Privileges
+      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+        %x[neo4j/bin/neo4j install]
+        puts "Neo4j Installed as a service."
+      end
+
+    else    
+      %x[curl -O http://dist.neo4j.org/neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[tar -xvzf neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[mv neo4j-#{args[:edition]}-#{args[:version]} neo4j]
+      %x[rm neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      puts "Neo4j Installed in to neo4j directory."
+    end
+    puts "Type 'rake neo4j:start' to start it"
+  end
+  
+  desc "Start the Neo4j Server"
+  task :start do
+    puts "Starting Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+        value = %x[neo4j/bin/Neo4j.bat start]  #start service
+      else
+        puts "Starting Neo4j directly, not as a service."
+        value = %x[neo4j/bin/Neo4j.bat]
+      end      
+    else
+     value = %x[neo4j/bin/neo4j start]       
+    end
+     puts value
+  end
+
+  desc "Start the Neo4j Server in the background"
+  task :start_no_wait do
+    puts "Starting Neo4j in the background..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+        value = %x[neo4j/bin/Neo4j.bat start-no-wait]  #start service
+      else
+        puts "Starting Neo4j directly, not as a service."
+        value = %x[neo4j/bin/Neo4j.bat start-no-wait]
+      end      
+    else
+     value = %x[neo4j/bin/neo4j start-no-wait]       
+    end
+     puts value
+  end
+  
+  desc "Stop the Neo4j Server"
+  task :stop do
+    puts "Stopping Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+        value = %x[neo4j/bin/Neo4j.bat stop]  #stop service
+      else
+        puts "You do not have administrative rights to stop the Neo4j Service"   
+      end
+    else  
+      value = %x[neo4j/bin/neo4j stop]
+    end
+    puts value
+  end
+
+  desc "Restart the Neo4j Server"
+  task :restart do
+    puts "Restarting Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+         %x[neo4j/bin/Neo4j.bat restart] 
+      else
+        puts "You do not have administrative rights to restart the Neo4j Service"   
+      end
+    else  
+      %x[neo4j/bin/neo4j restart]
+    end
+  end
+
+  desc "Reset the Neo4j Server"
+  task :reset_yes_i_am_sure do
+    # Stop the server
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+         %x[neo4j/bin/Neo4j.bat stop]
+         
+        # Reset the database
+        FileUtils.rm_rf("neo4j/data/graph.db")
+        FileUtils.mkdir("neo4j/data/graph.db")
+        
+        # Remove log files
+        FileUtils.rm_rf("neo4j/data/log")
+        FileUtils.mkdir("neo4j/data/log")
+
+        %x[neo4j/bin/Neo4j.bat start]
+      else
+        puts "You do not have administrative rights to reset the Neo4j Service"   
+      end
+    else  
+      %x[neo4j/bin/neo4j stop]
+      
+      # Reset the database
+      FileUtils.rm_rf("neo4j/data/graph.db")
+      FileUtils.mkdir("neo4j/data/graph.db")
+      
+      # Remove log files
+      FileUtils.rm_rf("neo4j/data/log")
+      FileUtils.mkdir("neo4j/data/log")
+      
+      # Start the server
+      %x[neo4j/bin/neo4j start]
+    end
+  end
+
+end  

data/lib/neography/version.rb

@@ -0,0 +1,3 @@
+module Neography
+  VERSION = "1.2.3.1"
+end

data/neography.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "neography/version"
+
+Gem::Specification.new do |s|
+  s.name        = "neography-calamitates"
+  s.version     = Neography::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = "Max De Marzi"
+  s.email       = "maxdemarzi@gmail.com"
+  s.homepage    = "http://rubygems.org/gems/neography"
+  s.summary     = "ruby wrapper to Neo4j Rest API"
+  s.description = "A Ruby wrapper to the Neo4j Rest API see http://docs.neo4j.org/chunked/stable/rest-api.html for more details."
+
+  s.rubyforge_project = "neography"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", ">= 2.11"
+  s.add_development_dependency "net-http-spy", "0.2.1"
+  s.add_development_dependency "rake", ">= 0.8.7"
+  s.add_development_dependency "coveralls"
+  s.add_dependency "httpclient", ">= 2.3.3"
+  s.add_dependency "rake", ">= 0.8.7"
+  s.add_dependency "json", ">= 1.7.7"
+  s.add_dependency "os", ">= 0.9.6"
+  s.add_dependency "rubyzip", "~> 1.0.0"
+  s.add_dependency "multi_json", ">= 1.3.2"
+end

data/spec/integration/authorization_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Neography::Rest, :slow => true do
+  describe "basic authentication"  do
+    describe "get_root" do
+      it "can get the root node"do
+        @neo = Neography::Rest.new({:server => '4c36b641.neo4j.atns.de', :port => 7474, :directory => '/9dc1fda5be8b5cde29621e21cae5adece3de0f37', :authentication => 'basic', :username => "abbe3c012", :password => "34d7b22eb"})
+        root_node = @neo.get_root
+        root_node.should have_key("reference_node")
+      end
+    end
+
+    describe "create_node" do
+      it "can create an empty node" do
+        @neo = Neography::Rest.new({:server => '4c36b641.neo4j.atns.de', :port => 7474, :directory => '/9dc1fda5be8b5cde29621e21cae5adece3de0f37', :authentication => 'basic', :username => "abbe3c012", :password => "34d7b22eb"})
+        new_node = @neo.create_node
+        new_node.should_not be_nil
+      end
+    end
+
+    describe "quick initializer" do
+      it "can get the root node" do
+        @neo = Neography::Rest.new("http://abbe3c012:34d7b22eb@4c36b641.neo4j.atns.de:7474/9dc1fda5be8b5cde29621e21cae5adece3de0f37")
+        root_node = @neo.get_root
+        root_node.should have_key("reference_node")
+      end
+    end
+  end
+
+  describe "digest authentication"  do
+    describe "get_root" do
+      it "can get the root node" do
+        @neo = Neography::Rest.new({:server => '4c36b641.neo4j.atns.de', :port => 7474, :directory => '/9dc1fda5be8b5cde29621e21cae5adece3de0f37', :authentication => 'digest', :username => "abbe3c012", :password => "34d7b22eb"})
+        root_node = @neo.get_root
+        root_node.should have_key("reference_node")
+      end
+    end
+
+    describe "create_node" do
+      it "can create an empty node" do
+        @neo = Neography::Rest.new({:server => '4c36b641.neo4j.atns.de', :port => 7474, :directory => '/9dc1fda5be8b5cde29621e21cae5adece3de0f37', :authentication => 'digest', :username => "abbe3c012", :password => "34d7b22eb"})
+        new_node = @neo.create_node
+        new_node.should_not be_nil
+      end
+    end
+  end
+
+end

data/spec/integration/index_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Neography::Index do
+
+  it "can add a node to an index" do
+    new_node = Neography::Node.create
+    key = generate_text(6)
+    value = generate_text
+    new_node.add_to_index("node_test_index", key, value)
+  end
+
+  it "can add a node to an index uniquely" do
+    new_node = Neography::Node.create
+    key = generate_text(6)
+    value = generate_text
+    new_node.add_to_index("node_test_index", key, value, true)
+  end
+
+  it "can add a relationship to an index" do
+    node1 = Neography::Node.create
+    node2 = Neography::Node.create
+    r = Neography::Relationship.create(:friends, node1, node2)
+    key = generate_text(6)
+    value = generate_text
+    r.add_to_index("relationship_test_index", key, value)
+  end
+
+  it "can find a node in an index" do
+    value = generate_text
+    new_node = Neography::Node.create("name" => value)
+    new_node.add_to_index("node_test_index", "name", value)
+    existing_node = Neography::Node.find("node_test_index", "name", value)
+    existing_node.name.should == value
+  end
+
+  it "can find a node in an index with brackets" do
+    value = "Sen. Roy Blunt [R-MO]"
+    new_node = Neography::Node.create("name" => value)
+    new_node.add_to_index("node_test_index", "name", value)
+    existing_node = Neography::Node.find("node_test_index", "name", value)
+    existing_node.name.should == value
+  end
+
+  it "can find a relationship in an index" do
+    value = generate_text
+    node1 = Neography::Node.create
+    node2 = Neography::Node.create
+    r = Neography::Relationship.create(:friends, node1, node2, {"name" => value})
+    r.add_to_index("relationship_test_index", "name", value)
+    existing_r = Neography::Relationship.find("relationship_test_index", "name", value)
+    existing_r.name.should == value
+  end
+
+  it "can find multiple nodes in an index" do
+    value1 = generate_text
+    value2 = generate_text
+    value3 = generate_text
+    node1 = Neography::Node.create("first_name" => value1, "last_name" => value2)
+    node1.add_to_index("node_test_index", "first_name", value1)
+    node2 = Neography::Node.create("first_name" => value1, "last_name" => value3)
+    node2.add_to_index("node_test_index", "first_name", value1)
+
+    existing_nodes = Neography::Node.find("node_test_index", "first_name", value1)
+    existing_nodes.size.should == 2
+    existing_nodes.first.last_name.should == value2
+    existing_nodes.last.last_name.should == value3
+  end
+
+
+end

data/spec/integration/neography_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Neography do
+  describe "ref_node" do
+    it "can get the reference node" do
+      root_node = Neography.ref_node
+      root_node.should have_key("self")
+    end
+  end
+end

data/spec/integration/node_encoding_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Neography::Node do
+
+  describe "create and new" do
+
+    it "can create a node with UTF-8 encoded properties" do
+      new_node = Neography::Node.create("name" => "美都池水")
+      new_node.name.should == "美都池水"
+    end
+
+    it "can create a node with more than one UTF-8 encoded properties" do
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      new_node.first_name.should == "美都"
+      new_node.last_name.should == "池水"
+    end
+
+  end
+
+  describe "load" do
+    it "can get a node with UTF-8 encoded properties that exists" do
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      existing_node = Neography::Node.load(new_node)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+      existing_node.first_name.should == "美都"
+      existing_node.last_name.should == "池水"
+    end
+
+    it "can get a node with UTF-8 encoded properties from an index" do
+      @neo = Neography::Rest.new
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node)
+      node_from_index = @neo.get_node_index("test_node_index", key, value)
+      existing_node = Neography::Node.load(node_from_index)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+      existing_node.first_name.should == "美都"
+      existing_node.last_name.should == "池水"
+    end
+
+    it "can get a node with UTF-8 encoded properties that exists via cypher" do
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      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
+      existing_node.first_name.should == "美都"
+      existing_node.last_name.should == "池水"
+    end
+
+    it "can get columns of data from a node with UTF-8 encoded properties that exists via cypher" do
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      cypher = "START me = node({id})
+                    RETURN me.first_name, me.last_name"
+      @neo = Neography::Rest.new
+      results = @neo.execute_query(cypher, {:id => new_node.neo_id.to_i})
+      results['data'][0].should == ["美都","池水"]
+    end
+
+  end
+
+end

data/spec/integration/node_path_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe Neography::NodePath do
+
+  def create_nodes
+    johnathan = Neography::Node.create("name" =>'Johnathan')
+    mark      = Neography::Node.create("name" =>'Mark')
+    phill     = Neography::Node.create("name" =>'Phill')
+    mary      = Neography::Node.create("name" =>'Mary')
+
+    johnathan.both(:friends) << mark
+    mark.both(:friends) << mary
+    mark.both(:friends) << phill
+    phill.both(:friends) << mary
+
+    [johnathan, mark, phill, mary]
+  end
+
+  describe "all_paths" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_paths_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+
+  describe "all_simple_paths" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+
+  describe "all_shortest_paths_to" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+
+  describe "path_to" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.path_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.path_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+
+  describe "simple_path_to" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.simple_path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.simple_path_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.simple_path_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+
+  describe "shortest_path_to" do
+    it "can return nodes" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.shortest_path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_true}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+      end
+    end
+
+    it "can return relationships" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.shortest_path_to(mary).incoming(:friends).depth(4).rels.each do |path|
+         path.map{|n| n.is_a?(Neography::Node).should be_false}
+         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+      end
+    end
+
+    it "can return both" do
+      johnathan, mark, phill, mary = create_nodes
+
+      johnathan.shortest_path_to(mary).incoming(:friends).depth(4).each do |path|
+        path.each_with_index do  |n,i| 
+          if i.even?
+            n.is_a?(Neography::Node).should be_true
+          else
+            n.is_a?(Neography::Relationship).should be_true 
+          end
+        end
+      end
+    end
+  end
+end