neography 1.3.14 → 1.4.0

data/lib/neography/rest/node_relationships.rb

@@ -1,18 +1,9 @@
 module Neography
   class Rest
-    class NodeRelationships
-      extend Neography::Rest::Paths
+    module NodeRelationships
       include Neography::Rest::Helpers
-
-      add_path :base,       "/node/:id/relationships"
-      add_path :direction,  "/node/:id/relationships/:direction"
-      add_path :type,       "/node/:id/relationships/:direction/:types"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def create(type, from, to, properties = nil)
+    
+      def create_relationship(type, from, to, properties = nil)
         options = {
           :body => {
             :to => @connection.configuration + "/node/#{get_id(to)}",
@@ -21,16 +12,16 @@ module Neography
           }.to_json,
           :headers => json_content_type }
 
-        @connection.post(base_path(:id => get_id(from)), options)
+        @connection.post("/node/%{id}/relationships" % {:id => get_id(from)}, options)
       end
-
-      def get(id, direction = nil, types = nil)
+    
+      def get_node_relationships(id, direction = nil, types = nil)
         direction = parse_direction(direction)
 
         if types.nil?
-          node_relationships = @connection.get(direction_path(:id => get_id(id), :direction => direction)) || []
+          node_relationships = @connection.get("/node/%{id}/relationships/%{direction}" % {:id => get_id(id), :direction => direction}) || []
         else
-          node_relationships = @connection.get(type_path(:id => get_id(id), :direction => direction, :types => Array(types).join('&'))) || []
+          node_relationships = @connection.get("/node/%{id}/relationships/%{direction}/%{types}" % {:id => get_id(id), :direction => direction, :types => encode(Array(types).join('&'))}) || []
         end
 
         return [] if node_relationships.empty?

data/lib/neography/rest/node_traversal.rb

@@ -1,79 +1,23 @@
 module Neography
   class Rest
-    class NodeTraversal
-      extend Neography::Rest::Paths
+    module NodeTraversal
       include Neography::Rest::Helpers
-
-      add_path :traversal, "/node/:id/traverse/:type"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
+    
       def traverse(id, return_type, description)
         options = { :body => {
-            "order"           => get_order(description["order"]),
-            "uniqueness"      => get_uniqueness(description["uniqueness"]),
+            "order"           => parse_order(description["order"]),
+            "uniqueness"      => parse_uniqueness(description["uniqueness"]),
             "relationships"   => description["relationships"],
             "prune_evaluator" => description["prune evaluator"],
             "return_filter"   => description["return filter"],
-            "max_depth"       => get_depth(description["depth"])
+            "max_depth"       => parse_depth(description["depth"])
           }.to_json,
           :headers => json_content_type
         }
 
-        type = get_type(return_type)
-
-        @connection.post(traversal_path(:id => get_id(id), :type => type), options) || []
-      end
-
-      private
-
-      def get_order(order)
-        case order
-          when :breadth, "breadth", "breadth first", "breadthFirst", :wide, "wide"
-            "breadth first"
-          else
-            "depth first"
-        end
-      end
-
-      def get_uniqueness(uniqueness)
-        case uniqueness
-          when :nodeglobal, "node global", "nodeglobal", "node_global"
-            "node global"
-          when :nodepath, "node path", "nodepath", "node_path"
-            "node path"
-          when :noderecent, "node recent", "noderecent", "node_recent"
-            "node recent"
-          when :relationshipglobal, "relationship global", "relationshipglobal", "relationship_global"
-            "relationship global"
-          when :relationshippath, "relationship path", "relationshippath", "relationship_path"
-            "relationship path"
-          when :relationshiprecent, "relationship recent", "relationshiprecent", "relationship_recent"
-            "relationship recent"
-          else
-            "none"
-        end
-      end
-
-      def get_depth(depth)
-        return nil if depth.nil?
-        return 1 if depth.to_i == 0
-        depth.to_i
-      end
+        type = parse_type(return_type)
 
-      def get_type(type)
-        case type
-          when :relationship, "relationship", :relationships, "relationships"
-            "relationship"
-          when :path, "path", :paths, "paths"
-            "path"
-          when :fullpath, "fullpath", :fullpaths, "fullpaths"
-            "fullpath"
-          else
-            "node"
-        end
+        @connection.post("/node/%{id}/traverse/%{type}" % {:id => get_id(id), :type => type}, options) || []
       end
 
     end

data/lib/neography/rest/nodes.rb

@@ -1,67 +1,59 @@
 module Neography
   class Rest
-    class Nodes
-      extend Neography::Rest::Paths
+    module Nodes
       include Neography::Rest::Helpers
 
-      add_path :index,  "/node"
-      add_path :base,   "/node/:id"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def get(id)
-        @connection.get(base_path(:id => get_id(id)))
+      def get_node(id)
+        @connection.get("/node/%{id}" % {:id => get_id(id)})
       end
 
-      def get_each(*nodes)
+      def get_nodes(*nodes)
         gotten_nodes = []
         Array(nodes).flatten.each do |node|
-          gotten_nodes << get(node)
+          gotten_nodes << get_node(node)
         end
         gotten_nodes
       end
 
-      def root
+      def get_root
         root_node = @connection.get('/')["reference_node"]
-        @connection.get(base_path(:id => get_id(root_node)))
+        @connection.get("/node/%{id}" % {:id => get_id(root_node)})
       end
 
-      def create(*args)
+      def create_node(*args)
         if args[0].respond_to?(:each_pair) && args[0]
-          create_with_attributes(args[0])
+          create_node_with_attributes(args[0])
         else
-          create_empty
+          create_empty_node
         end
       end
 
-      def create_with_attributes(attributes)
+      def create_node_with_attributes(attributes)
         options = {
           :body => attributes.delete_if { |k, v| v.nil? }.to_json,
           :headers => json_content_type
         }
-        @connection.post(index_path, options)
+        @connection.post("/node", options)
       end
 
-      def create_empty
-        @connection.post(index_path)
+      def create_empty_node
+        @connection.post("/node")
       end
 
-      def delete(id)
-        @connection.delete(base_path(:id => get_id(id)))
+      def delete_node(id)
+        @connection.delete("/node/%{id}" % {:id => get_id(id)})
       end
 
-      def create_multiple(nodes)
+      def create_nodes(nodes)
         nodes = Array.new(nodes) if nodes.kind_of? Fixnum
         created_nodes = []
         nodes.each do |node|
-          created_nodes << create(node)
+          created_nodes << create_node(node)
         end
         created_nodes
       end
 
-      def create_multiple_threaded(nodes)
+      def create_nodes_threaded(nodes)
         nodes = Array.new(nodes) if nodes.kind_of? Fixnum
 
         node_queue = Queue.new
@@ -77,12 +69,12 @@ module Neography
             until node_queue.empty? do
               node = node_queue.pop
               if node.respond_to?(:each_pair)
-                responses.push( @connection.post(index_path, {
+                responses.push( @connection.post("/node", {
                   :body => node.to_json,
                   :headers => json_content_type
                 } ) )
               else
-                responses.push( @connection.post(index_path) )
+                responses.push( @connection.post("/node") )
               end
             end
             self.join

data/lib/neography/rest/other_node_relationships.rb

@@ -1,16 +1,9 @@
 module Neography
   class Rest
-    class OtherNodeRelationships
-      extend Neography::Rest::Paths
+    module OtherNodeRelationships
       include Neography::Rest::Helpers
-
-      add_path :base,       "/node/:id/traverse/relationship"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def get(id, other_id, direction = "all", types = [nil])
+    
+      def get_node_relationships_to(id, other_id, direction = "all", types = [nil] )
         
         body = case parse_direction(direction)
                  when "all"
@@ -21,9 +14,9 @@ module Neography
                    "position.length() > 0 && position.lastRelationship().getEndNode().getId() == " + get_id(other_id) 
                 end
 
-        relationships = {:relationships => types.map{|row| Hash[{:type => row}].merge({:direction => parse_direction(direction)})} }
+        relationships = {:relationships => Array(types).map{|row| Hash[{:type => row}].merge({:direction => parse_direction(direction)})} }
 
-        if types.first.nil?
+        if Array(types).first.nil?
           relationships = {}
         end
                 
@@ -37,7 +30,7 @@ module Neography
           :headers => json_content_type
         }
 
-        @connection.post(base_path(:id => get_id(id)), options) || []
+        @connection.post("/node/%{id}/traverse/relationship" % {:id => get_id(id)}, options) || []
       end
 
     end

data/lib/neography/rest/relationship_auto_indexes.rb

@@ -1,13 +1,59 @@
 module Neography
   class Rest
-    class RelationshipAutoIndexes < AutoIndexes
-      extend Neography::Rest::Paths
-
-      add_path :key_value,        "/index/auto/relationship/:key/:value"
-      add_path :query_index,      "/index/auto/relationship/?query=:query"
-      add_path :index_status,     "/index/auto/relationship/status"
-      add_path :index_properties, "/index/auto/relationship/properties"
-      add_path :index_property,   "/index/auto/relationship/properties/:property"
+    module RelationshipAutoIndexes 
+    
+      def get_relationship_auto_index(key, value)
+        index = @connection.get("/index/auto/relationship/%{key}/%{value}" % {:key => key, :value => encode(value)}) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find_relationship_auto_index(key_or_query, value = nil)
+        if value
+          index = find_relationship_auto_index_by_value(key_or_query, value)
+        else
+          index = query_relationship_auto_index(key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find_relationship_auto_index_by_value(key, value)
+        @connection.get("/index/auto/relationship/%{key}/%{value}" % {:key => key, :value => encode(value)}) || []
+      end
+
+      def query_relationship_auto_index(query_expression)
+        @connection.get("/index/auto/relationship/?query=%{query}" % {:query => query_expression}) || []
+      end
+
+      def get_relationship_auto_index_status
+        @connection.get("/index/auto/relationship/status")
+      end
+
+      def set_relationship_auto_index_status(value = true)
+        options = {
+          :body => value.to_json,
+          :headers => json_content_type
+        }
+        @connection.put("/index/auto/relationship/status", options)
+      end
+
+      def get_relationship_auto_index_properties
+        @connection.get("/index/auto/relationship/properties")
+      end
+
+      def add_relationship_auto_index_property(property)
+        options = {
+          :body => property,
+          :headers => json_content_type
+        }
+        @connection.post("/index/auto/relationship/properties", options)
+      end
+
+      def remove_relationship_auto_index_property(property)
+        @connection.delete("/index/auto/relationship/properties/%{property}" % {:property => property})
+      end
+
 
     end
   end

data/lib/neography/rest/relationship_indexes.rb

@@ -1,23 +1,99 @@
 module Neography
   class Rest
-    class RelationshipIndexes < Indexes
-      extend Neography::Rest::Paths
+    module RelationshipIndexes 
       include Neography::Rest::Helpers
 
-      add_path :all,       "/index/relationship"
-      add_path :base,      "/index/relationship/:index"
-      add_path :unique,    "/index/relationship/:index?unique"
-      add_path :id,        "/index/relationship/:index/:id"
-      add_path :key,       "/index/relationship/:index/:key/:id"
-      add_path :value,     "/index/relationship/:index/:key/:value/:id"
-      add_path :key_value, "/index/relationship/:index/:key/:value"
-      add_path :query,     "/index/relationship/:index?query=:query"
+      def list_relationship_indexes
+        @connection.get("/index/relationship")
+      end
+
+      def create_relationship_index(name, type = "exact", provider = "lucene", extra_config = nil)
+        config = {
+          :type => type,
+          :provider => provider
+        }
+        config.merge!(extra_config) unless extra_config.nil?
+        options = {
+          :body => (
+            { :name => name,
+              :config => config
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/relationship", options)
+      end
+
+      def create_relationship_auto_index(type = "exact", provider = "lucene")
+        create_relationship_index("relationship_auto_index", type, provider)
+      end
 
-      def initialize(connection)
-        super(connection, :relationship)
+      def add_relationship_to_index(index, key, value, id, unique = false)
+        options = {
+          :body => (
+            { :uri   => @connection.configuration + "/relationship/#{get_id(id)}",
+              :key   => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        path = unique ? "/index/relationship/%{index}?unique" % {:index => index} : "/index/relationship/%{index}" % {:index => index}
+        @connection.post(path, options)
       end
 
-      def create_unique(index, key, value, type, from, to, props = nil)
+      def get_relationship_index(index, key, value)
+        index = @connection.get("/index/relationship/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(value)}) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find_relationship_index(index, key_or_query, value = nil)
+        if value
+          index = find_relationship_index_by_key_value(index, key_or_query, value)
+        else
+          index = find_relationship_index_by_query(index, key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find_relationship_index_by_key_value(index, key, value)
+        @connection.get("/index/relationship/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(value)}) || []
+      end
+
+      def find_relationship_index_by_query(index, query)
+        @connection.get("/index/relationship/%{index}?query=%{query}" % {:index => index, :query => encode(query)}) || []
+      end
+
+      # Mimick original neography API in Rest class.
+      def remove_relationship_from_index(index, id_or_key, id_or_value = nil, id = nil)
+        if id
+          remove_relationship_index_by_value(index, id, id_or_key, id_or_value)
+        elsif id_or_value
+          remove_relationship_index_by_key(index, id_or_value, id_or_key)
+        else
+          remove_relationship_index_by_id(index, id_or_key)
+        end
+      end
+
+      def remove_relationship_index_by_id(index, id)
+        @connection.delete("/index/relationship/%{index}/%{id}" % {:index => index, :id => get_id(id)})
+      end
+
+      def remove_relationship_index_by_key(index, id, key)
+        @connection.delete("/index/relationship/%{index}/%{key}/%{id}" % {:index => index, :id => get_id(id), :key => key})
+      end
+
+      def remove_relationship_index_by_value(index, id, key, value)
+        @connection.delete("/index/relationship/%{index}/%{key}/%{value}/%{id}" % {:index => index, :id => get_id(id), :key => key, :value => encode(value)})
+      end
+
+      def drop_relationship_index(index)
+        @connection.delete("/index/relationship/%{index}" % {:index => index})
+      end
+
+      def create_unique_relationship(index, key, value, type, from, to, props = nil)
         body = {
           :key   => key,
           :value => value,
@@ -28,7 +104,21 @@ module Neography
         }
         options = { :body => body.to_json, :headers => json_content_type }
 
-        @connection.post(unique_path(:index => index), options)
+        @connection.post("/index/relationship/%{index}?unique" % {:index => index}, options)
+      end
+
+      def get_or_create_unique_relationship(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/relationship/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'get_or_create'}, options)
+        
       end
 
     end