neography 1.3.14 → 1.4.0

data/lib/neography/rest/cypher.rb

@@ -1,13 +1,9 @@
 module Neography
   class Rest
-    class Cypher
+    module Cypher
       include Neography::Rest::Helpers
 
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def query(query, parameters = {}, cypher_options = nil)
+      def execute_query(query, parameters = {}, cypher_options = nil)
         options = {
           :body => {
             :query => query,

data/lib/neography/rest/extensions.rb

@@ -1,17 +1,13 @@
 module Neography
   class Rest
-    class Extensions
+    module Extensions
       include Neography::Rest::Helpers
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def get(path)
+    
+      def get_extension(path)
         @connection.get(path)
       end
 
-      def post(path, body = {}, headers = nil)
+      def post_extension(path, body = {}, headers = nil)
         options = {
           :body => headers.nil? ? body.to_json : body,
           :headers => headers || json_content_type.merge({'Accept' => 'application/json;stream=true'})

data/lib/neography/rest/gremlin.rb

@@ -1,13 +1,9 @@
 module Neography
   class Rest
-    class Gremlin
+    module Gremlin
       include Neography::Rest::Helpers
 
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def execute(script, parameters = {})
+      def execute_script(script, parameters = {})
         options = {
           :body => {
             :script => script,

data/lib/neography/rest/helpers.rb

@@ -32,6 +32,64 @@ module Neography
         end
       end
 
+      def encode(value)
+        CGI.escape(value.to_s).gsub("+", "%20")
+      end
+      
+      def escape(value)
+        if value.class == String
+          "%22"+encode(value.to_s)+"%22";
+        else
+          encode(value.to_s)
+        end
+      end
+      
+      def parse_order(order)
+        case order
+          when :breadth, "breadth", "breadth first", "breadthFirst", :wide, "wide"
+            "breadth first"
+          else
+            "depth first"
+        end
+      end
+
+      def parse_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 parse_depth(depth)
+        return nil if depth.nil?
+        return 1 if depth.to_i == 0
+        depth.to_i
+      end
+
+      def parse_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
+      end      
 
     end
   end

data/lib/neography/rest/node_auto_indexes.rb

@@ -1,13 +1,59 @@
 module Neography
   class Rest
-    class NodeAutoIndexes < AutoIndexes
-      extend Neography::Rest::Paths
-
-      add_path :key_value,        "/index/auto/node/:key/:value"
-      add_path :query_index,      "/index/auto/node/?query=:query"
-      add_path :index_status,     "/index/auto/node/status"
-      add_path :index_properties, "/index/auto/node/properties"
-      add_path :index_property,   "/index/auto/node/properties/:property"
+    module NodeAutoIndexes 
+    
+      def get_node_auto_index(key, value)
+        index = @connection.get("/index/auto/node/%{key}/%{value}" % {:key => key, :value => encode(value)}) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find_node_auto_index(key_or_query, value = nil)
+        if value
+          index = find_node_auto_index_by_value(key_or_query, value)
+        else
+          index = query_node_auto_index(key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find_node_auto_index_by_value(key, value)
+        @connection.get("/index/auto/node/%{key}/%{value}" % {:key => key, :value => encode(value)}) || []
+      end
+
+      def query_node_auto_index(query_expression)
+        @connection.get("/index/auto/node/?query=%{query}" % {:query => query_expression}) || []
+      end
+
+      def get_node_auto_index_status
+        @connection.get("/index/auto/node/status")
+      end
+
+      def set_node_auto_index_status(value = true)
+        options = {
+          :body => value.to_json,
+          :headers => json_content_type
+        }
+        @connection.put("/index/auto/node/status", options)
+      end
+
+      def get_node_auto_index_properties
+        @connection.get("/index/auto/node/properties")
+      end
+
+      def add_node_auto_index_property(property)
+        options = {
+          :body => property,
+          :headers => json_content_type
+        }
+        @connection.post("/index/auto/node/properties", options)
+      end
+
+      def remove_node_auto_index_property(property)
+        @connection.delete("/index/auto/node/properties/%{property}" % {:property => property})
+      end
+
 
     end
   end

data/lib/neography/rest/node_indexes.rb

@@ -1,24 +1,99 @@
 module Neography
   class Rest
-    class NodeIndexes < Indexes
-      extend Neography::Rest::Paths
+    module NodeIndexes 
       include Neography::Rest::Helpers
 
-      add_path :all,       "/index/node"
-      add_path :base,      "/index/node/:index"
-      add_path :unique,    "/index/node/:index?unique"
-      add_path :uniqueness,    "/index/node/:index?uniqueness=:function"
-      add_path :id,        "/index/node/:index/:id"
-      add_path :key,       "/index/node/:index/:key/:id"
-      add_path :value,     "/index/node/:index/:key/:value/:id"
-      add_path :key_value, "/index/node/:index/:key/:value"
-      add_path :query,     "/index/node/:index?query=:query"
+      def list_node_indexes
+        @connection.get("/index/node")
+      end
+
+      def create_node_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/node", options)
+      end
+
+      def create_node_auto_index(type = "exact", provider = "lucene")
+        create_node_index("node_auto_index", type, provider)
+      end
+
+      def add_node_to_index(index, key, value, id, unique = false)
+        options = {
+          :body => (
+            { :uri   => @connection.configuration + "/node/#{get_id(id)}",
+              :key   => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        path = unique ? "/index/node/%{index}?unique" % {:index => index} : "/index/node/%{index}" % {:index => index}
+        @connection.post(path, options)
+      end
+
+      def get_node_index(index, key, value)
+        index = @connection.get("/index/node/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(value)}) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find_node_index(index, key_or_query, value = nil)
+        if value
+          index = find_node_index_by_key_value(index, key_or_query, value)
+        else
+          index = find_node_index_by_query(index, key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find_node_index_by_key_value(index, key, value)
+        @connection.get("/index/node/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(value)}) || []
+      end
+
+      def find_node_index_by_query(index, query)
+        @connection.get("/index/node/%{index}?query=%{query}" % {:index => index, :query => encode(query)}) || []
+      end
+
+      # Mimick original neography API in Rest class.
+      def remove_node_from_index(index, id_or_key, id_or_value = nil, id = nil)
+        if id
+          remove_node_index_by_value(index, id, id_or_key, id_or_value)
+        elsif id_or_value
+          remove_node_index_by_key(index, id_or_value, id_or_key)
+        else
+          remove_node_index_by_id(index, id_or_key)
+        end
+      end
+
+      def remove_node_index_by_id(index, id)
+        @connection.delete("/index/node/%{index}/%{id}" % {:index => index, :id => get_id(id)})
+      end
+
+      def remove_node_index_by_key(index, id, key)
+        @connection.delete("/index/node/%{index}/%{key}/%{id}" % {:index => index, :id => get_id(id), :key => key})
+      end
+
+      def remove_node_index_by_value(index, id, key, value)
+        @connection.delete("/index/node/%{index}/%{key}/%{value}/%{id}" % {:index => index, :id => get_id(id), :key => key, :value => encode(value)})
+      end
 
-      def initialize(connection)
-        super(connection, :node)
+      def drop_node_index(index)
+        @connection.delete("/index/node/%{index}" % {:index => index})
       end
 
-      def create_unique(index, key, value, properties = {})
+      def create_unique_node(index, key, value, properties = {})
         options = {
           :body => (
             { :properties => properties,
@@ -28,10 +103,10 @@ module Neography
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(unique_path(:index => index), options)
+        @connection.post("/index/node/%{index}?unique" % {:index => index}, options)
       end
 
-      def get_or_create_unique(index, key, value, properties = {})
+      def get_or_create_unique_node(index, key, value, properties = {})
         options = {
           :body => (
             { :properties => properties,
@@ -41,7 +116,7 @@ module Neography
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(uniqueness_path(:index => index, :function => 'get_or_create'), options)
+        @connection.post("/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'get_or_create'}, options)
         
       end
 

data/lib/neography/rest/node_labels.rb

@@ -1,57 +1,46 @@
 module Neography
   class Rest
-    class NodeLabels
-      extend Neography::Rest::Paths
+    module NodeLabels
       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=:value"
-      add_path :delete,    "/node/:id/labels/:label"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def list
-        @connection.get(base_path)
+      def list_labels
+        @connection.get("/labels")
       end
 
-      def get(id)
-        @connection.get(node_path(:id => get_id(id)))
+      def get_node_labels(id)
+        @connection.get("/node/%{id}/labels"  % {:id => get_id(id)})
       end
 
-      def get_nodes(label)
-        @connection.get(nodes_path(:label => label))
+      def get_nodes_labeled(label)
+        @connection.get("/label/%{label}/nodes" % {:label => label})
       end
 
-      def find_nodes(label, hash)
-        @connection.get(find_path(:label => label, :property => hash.keys.first, :value => hash.values.first))
+      def find_nodes_labeled(label, hash)
+        @connection.get("/label/%{label}/nodes?%{property}=%{value}"  % {:label => label, :property => hash.keys.first, :value => escape(hash.values.first)})
       end
 
-      def add(id, label)
+      def add_label(id, label)
         options = {
           :body => (
             label
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(node_path(:id => get_id(id)), options)
+        @connection.post("/node/%{id}/labels"  % {:id => get_id(id)}, options)
       end
 
-      def set(id, label)
+      def set_label(id, label)
         options = {
           :body => (
             Array(label)
           ).to_json,
           :headers => json_content_type
         }
-        @connection.put(node_path(:id => get_id(id)), options)
+        @connection.put("/node/%{id}/labels"  % {:id => get_id(id)}, options)
       end
 
-      def delete(id, label)
-        @connection.delete(delete_path(:id => get_id(id), :label => label))
+      def delete_label(id, label)
+        @connection.delete("/node/%{id}/labels/%{label}" % {:id => get_id(id), :label => label})
       end
 
 

data/lib/neography/rest/node_paths.rb

@@ -1,29 +1,21 @@
 module Neography
   class Rest
-    class NodePaths
-      extend Neography::Rest::Paths
+    module NodePaths
       include Neography::Rest::Helpers
-
-      add_path :base, "/node/:id/path"
-      add_path :all,  "/node/:id/paths"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def get(from, to, relationships, depth = 1, algorithm = "shortestPath")
+    
+      def get_path(from, to, relationships, depth = 1, algorithm = "shortestPath")
         options = path_options(to, relationships, depth, algorithm)
-        @connection.post(base_path(:id => get_id(from)), options) || {}
+        @connection.post("/node/%{id}/path" % {:id => get_id(from)}, options) || {}
       end
 
-      def get_all(from, to, relationships, depth = 1, algorithm = "allPaths")
+      def get_paths(from, to, relationships, depth = 1, algorithm = "allPaths")
         options = path_options(to, relationships, depth, algorithm)
-        @connection.post(all_path(:id => get_id(from)), options) || []
+        @connection.post("/node/%{id}/paths" % {:id => get_id(from)}, options) || []
       end
 
-      def shortest_weighted(from, to, relationships, weight_attribute = "weight", depth = 1, algorithm = "dijkstra")
+      def get_shortest_weighted_path(from, to, relationships, weight_attribute = "weight", depth = 1, algorithm = "dijkstra")
         options = path_options(to, relationships, depth, algorithm, { :cost_property => weight_attribute })
-        @connection.post(all_path(:id => get_id(from)), options) || {}
+        @connection.post("/node/%{id}/paths" % {:id => get_id(from)}, options) || {}
       end
 
       private

data/lib/neography/rest/node_properties.rb

@@ -1,10 +1,51 @@
 module Neography
   class Rest
-    class NodeProperties < Properties
-      extend Neography::Rest::Paths
+    module NodeProperties
+    
+      def set_node_properties(id, properties)
+        properties.each do |property, value|
+          options = { :body => value.to_json, :headers => json_content_type }
+          @connection.put("/node/%{id}/properties/%{property}" % {:id => get_id(id), :property => property}, options)
+        end
+      end
+
+      def reset_node_properties(id, properties)
+        options = { :body => properties.to_json, :headers => json_content_type }
+        @connection.put("/node/%{id}/properties" % {:id => get_id(id)}, options)
+      end
+
+      def get_node_properties(id, *properties)
+        if properties.none?
+          @connection.get("/node/%{id}/properties" % {:id => get_id(id)})
+        else
+          get_each_node_properties(id, *properties)
+        end
+      end
+
+      def get_each_node_properties(id, *properties)
+        retrieved_properties = properties.flatten.inject({}) do |memo, property|
+          value = @connection.get("/node/%{id}/properties/%{property}" % {:id => get_id(id), :property => property})
+          memo[property] = value unless value.nil?
+          memo
+        end
+        return nil if retrieved_properties.empty?
+        retrieved_properties
+      end
+
+      def remove_node_properties(id, *properties)
+        if properties.none?
+          @connection.delete("/node/%{id}/properties" % {:id => get_id(id)})
+        else
+          remove_each_node_properties(id, *properties)
+        end
+      end
+
+      def remove_each_node_properties(id, *properties)
+        properties.flatten.each do |property|
+          @connection.delete("/node/%{id}/properties/%{property}" % {:id => get_id(id), :property => property})
+        end
+      end
 
-      add_path :all,    "/node/:id/properties"
-      add_path :single, "/node/:id/properties/:property"
 
     end
   end