neography-down 1.6.4

data/lib/neography/rest/cypher.rb

@@ -0,0 +1,29 @@
+module Neography
+  class Rest
+    module Cypher
+      include Neography::Rest::Helpers
+
+      def execute_query(query, parameters = {}, cypher_options = nil)
+        options = {
+          :body => {
+            :query => query,
+            :params => parameters
+          }.to_json,
+          :headers => json_content_type.merge({'Accept' => 'application/json;stream=true;charset=UTF-8'})
+        }
+        
+        @connection.post(optioned_path(cypher_options), options)
+      end
+      
+      private
+      def optioned_path(cypher_options = nil)
+        return @connection.cypher_path unless cypher_options
+        options = []
+        options << "includeStats=true" if cypher_options[:stats]
+        options << "profile=true" if cypher_options[:profile]
+        @connection.cypher_path + "?" + options.join("&")
+      end
+
+    end
+  end
+end

data/lib/neography/rest/extensions.rb

@@ -0,0 +1,21 @@
+module Neography
+  class Rest
+    module Extensions
+      include Neography::Rest::Helpers
+    
+      def get_extension(path)
+        @connection.get(path)
+      end
+
+      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'})
+        }
+
+        @connection.post(path, options)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/gremlin.rb

@@ -0,0 +1,20 @@
+module Neography
+  class Rest
+    module Gremlin
+      include Neography::Rest::Helpers
+
+      def execute_script(script, parameters = {})
+        options = {
+          :body => {
+            :script => script,
+            :params => parameters,
+          }.to_json,
+          :headers => json_content_type
+        }
+        result = @connection.post(@connection.gremlin_path, options)
+        result == "null" ? nil : result
+      end
+
+    end
+  end
+end

data/lib/neography/rest/helpers.rb

@@ -0,0 +1,96 @@
+module Neography
+  class Rest
+    module Helpers
+
+      def get_id(id)
+        case id
+        when Array
+          get_id(id.first)
+        when Hash
+          id["self"].split('/').last
+        when String
+          id.split('/').last
+        when Neography::Node, Neography::Relationship
+          id.neo_id
+        else
+          id
+        end
+      end
+
+      def json_content_type
+        {'Content-Type' => 'application/json'}
+      end
+
+      def parse_direction(direction)
+        case direction
+          when :incoming, "incoming", :in, "in"
+            "in"
+          when :outgoing, "outgoing", :out, "out"
+            "out"
+          else
+            "all"
+        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
+end

data/lib/neography/rest/node_auto_indexes.rb

@@ -0,0 +1,60 @@
+module Neography
+  class Rest
+    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 => encode(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
+end

data/lib/neography/rest/node_indexes.rb

@@ -0,0 +1,139 @@
+module Neography
+  class Rest
+    module NodeIndexes
+      include Neography::Rest::Helpers
+
+      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 drop_node_index(index)
+        @connection.delete("/index/node/%{index}" % {:index => index})
+      end
+
+      def create_unique_node(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/node/%{index}?unique" % {:index => index}, options)
+      end
+
+      def get_or_create_unique_node(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'get_or_create'}, options)
+
+      end
+
+      def create_or_fail_unique_node(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'create_or_fail'}, options)
+
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_labels.rb

@@ -0,0 +1,49 @@
+module Neography
+  class Rest
+    module NodeLabels
+      include Neography::Rest::Helpers
+
+      def list_labels
+        @connection.get("/labels")
+      end
+
+      def get_node_labels(id)
+        @connection.get("/node/%{id}/labels"  % {:id => get_id(id)})
+      end
+
+      def get_nodes_labeled(label)
+        @connection.get("/label/%{label}/nodes" % {:label => label})
+      end
+
+      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_label(id, label)
+        options = {
+          :body => (
+            label
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/node/%{id}/labels"  % {:id => get_id(id)}, options)
+      end
+
+      def set_label(id, label)
+        options = {
+          :body => (
+            Array(label)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.put("/node/%{id}/labels"  % {:id => get_id(id)}, options)
+      end
+
+      def delete_label(id, label)
+        @connection.delete("/node/%{id}/labels/%{label}" % {:id => get_id(id), :label => label})
+      end
+
+
+    end
+  end
+end

data/lib/neography/rest/node_paths.rb

@@ -0,0 +1,49 @@
+module Neography
+  class Rest
+    module NodePaths
+      include Neography::Rest::Helpers
+    
+      def get_path(from, to, relationships, depth = 1, algorithm = "shortestPath")
+        options = path_options(to, relationships, depth, algorithm)
+        @connection.post("/node/%{id}/path" % {:id => get_id(from)}, options) || {}
+      end
+
+      def get_paths(from, to, relationships, depth = 1, algorithm = "allPaths")
+        options = path_options(to, relationships, depth, algorithm)
+        @connection.post("/node/%{id}/paths" % {:id => get_id(from)}, options) || []
+      end
+
+      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("/node/%{id}/paths" % {:id => get_id(from)}, options) || {}
+      end
+
+      private
+
+      def get_algorithm(algorithm)
+        case algorithm
+          when :shortest, "shortest", :shortestPath, "shortestPath", :short, "short"
+            "shortestPath"
+          when :allSimplePaths, "allSimplePaths", :simple, "simple"
+            "allSimplePaths"
+          when :dijkstra, "dijkstra"
+            "dijkstra"
+          else
+            "allPaths"
+        end
+      end
+
+      def path_options(to, relationships, depth, algorithm, extra_body = {})
+        options = { :body => {
+            "to"            => @connection.configuration + "/node/#{get_id(to)}",
+            "relationships" => relationships,
+            "max_depth"     => depth,
+            "algorithm"     => get_algorithm(algorithm)
+          }.merge(extra_body).to_json,
+          :headers => json_content_type
+        }
+      end
+
+    end
+  end
+end