neography-down 1.6.4

data/lib/neography/version.rb

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

data/neography.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "neography/version"
+
+Gem::Specification.new do |s|
+  s.name        = "neography-down"
+  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.license     = 'MIT'
+  
+  s.rubyforge_project = "neography-down"
+
+  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 "coveralls"
+  s.add_development_dependency "debugger"
+  s.add_development_dependency "guard-rspec"
+  s.add_dependency "excon", ">= 0.33.0"
+  s.add_dependency "json", ">= 1.7.7"
+  s.add_dependency "os", ">= 0.9.6"
+  s.add_dependency "multi_json", ">= 1.3.2"
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    s.add_runtime_dependency 'rake', '>= 0.8.7'
+  else
+    s.add_development_dependency "rake", ">= 0.8.7"
+    s.add_dependency "rake", ">= 0.8.7"
+  end
+end

data/spec/integration/authorization_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Neography::Rest, :slow => true do
+  describe "basic authentication"  do
+    describe "get_root", :reference => true do
+      it "can get the root node"do
+        @neo = Neography::Rest.new({:authentication => 'digest', :username => "username", :password => "password"})
+        root_node = @neo.get_root
+        expect(root_node).to have_key("reference_node")
+      end
+    end    
+    
+    describe "create_node" do
+      it "can create an empty node" do
+        @neo = Neography::Rest.new({:authentication => 'basic', :username => "username", :password => "password"})
+        new_node = @neo.create_node
+        expect(new_node).not_to be_nil
+      end
+    end
+
+    describe "quick initializer" do
+      it "can create an empty node" do
+        @neo = Neography::Rest.new("http://username:password@localhost:7474")
+        new_node = @neo.create_node
+        expect(new_node).not_to be_nil
+      end
+    end
+  end
+
+  describe "digest authentication"  do
+    describe "create_node" do
+      it "can create an empty node" do
+        @neo = Neography::Rest.new({:authentication => 'digest', :username => "username", :password => "password"})
+        new_node = @neo.create_node
+        expect(new_node).not_to be_nil
+      end
+    end
+  end
+
+end

data/spec/integration/broken_spatial_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new(:log_enabled => true)
+  end
+  
+  describe "can spatial plugin" do    
+    it "can do spatial in batch", :neo_is_broken => true  do
+      properties = {:lat => 60.1, :lon => 15.2}
+      node = @neo.create_node(properties)
+      batch_result = @neo.batch [:add_point_layer, "restaurantsbatch"],
+                                [:add_node_to_layer, "restaurantsbatch", node],
+                                [:get_layer, "restaurantsbatch"],
+                                [:find_geometries_within_distance, "restaurantsbatch", 60.0,15.0, 100.0],
+                                [:find_geometries_in_bbox, "restaurantsbatch", 60.0, 60.2, 15.0, 15.3]
+      # getting "The transaction is marked for rollback only." errors
+      # possibly related to a Cypher Transaction Bug.
+      puts batch_result.inspect
+      expect(batch_result[0].first["data"]["layer"]).to eq("restaurantsbatch")
+      expect(batch_result[1].first["data"]["lat"]).to eq(properties[:lat])
+      expect(batch_result[1].first["data"]["lon"]).to eq(properties[:lon])
+      expect(batch_result[2].first["data"]["layer"]).to eq("restaurantsbatch")
+      expect(batch_result[3].first["data"]).not_to be_empty
+      expect(batch_result[4].first["data"]).not_to be_empty
+    end
+  end
+end

data/spec/integration/index_spec.rb

@@ -0,0 +1,71 @@
+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)
+    expect(existing_node.name).to eq(value)
+  end
+
+  it "can find a node in an index with brackets" do
+    key = generate_text(6)
+    value = "Sen. Roy Blunt [R-MO]"
+    new_node = Neography::Node.create("name" => value)
+    new_node.add_to_index(key, "name", value)
+    existing_node = Neography::Node.find(key, "name", value)
+    expect(existing_node.name).to eq(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)
+    expect(existing_r.name).to eq(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)
+    expect(existing_nodes.size).to eq(2)
+    expect(existing_nodes.first.last_name).to eq(value2)
+    expect(existing_nodes.last.last_name).to eq(value3)
+  end
+
+
+end

data/spec/integration/neography_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Neography do
+  describe "ref_node", :reference => true do
+    it "can get the reference node" do
+      root_node = Neography.ref_node
+      expect(root_node).to 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" => "美都池水")
+      expect(new_node.name).to eq("美都池水")
+    end
+
+    it "can create a node with more than one UTF-8 encoded properties" do
+      new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
+      expect(new_node.first_name).to eq("美都")
+      expect(new_node.last_name).to eq("池水")
+    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)
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
+    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)
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
+    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)
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
+    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})
+      expect(results['data'][0]).to eq(["美都","池水"])
+    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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to 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?
+            expect(n.is_a?(Neography::Node)).to be true
+          else
+            expect(n.is_a?(Neography::Relationship)).to be true 
+          end
+        end
+      end
+    end
+  end
+end