neography-down 1.6.4

data/lib/neography/rest/node_properties.rb

@@ -0,0 +1,52 @@
+module Neography
+  class Rest
+    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
+
+
+    end
+  end
+end

data/lib/neography/rest/node_relationships.rb

@@ -0,0 +1,33 @@
+module Neography
+  class Rest
+    module NodeRelationships
+      include Neography::Rest::Helpers
+    
+      def create_relationship(type, from, to, properties = nil)
+        options = {
+          :body => {
+            :to => @connection.configuration + "/node/#{get_id(to)}",
+            :data => properties,
+            :type => type
+          }.to_json,
+          :headers => json_content_type }
+
+        @connection.post("/node/%{id}/relationships" % {:id => get_id(from)}, options)
+      end
+    
+      def get_node_relationships(id, direction = nil, types = nil)
+        direction = parse_direction(direction)
+
+        if types.nil?
+          node_relationships = @connection.get("/node/%{id}/relationships/%{direction}" % {:id => get_id(id), :direction => direction}) || []
+        else
+          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?
+        node_relationships
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_traversal.rb

@@ -0,0 +1,25 @@
+module Neography
+  class Rest
+    module NodeTraversal
+      include Neography::Rest::Helpers
+    
+      def traverse(id, return_type, description)
+        options = { :body => {
+            "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"       => parse_depth(description["depth"])
+          }.to_json,
+          :headers => json_content_type
+        }
+
+        type = parse_type(return_type)
+
+        @connection.post("/node/%{id}/traverse/%{type}" % {:id => get_id(id), :type => type}, options) || []
+      end
+
+    end
+  end
+end

data/lib/neography/rest/nodes.rb

@@ -0,0 +1,94 @@
+module Neography
+  class Rest
+    module Nodes
+      include Neography::Rest::Helpers
+
+      def get_node(id)
+        @connection.get("/node/%{id}" % {:id => get_id(id)})
+      end
+
+      def get_nodes(*nodes)
+        gotten_nodes = []
+        Array(nodes).flatten.each do |node|
+          gotten_nodes << get_node(node)
+        end
+        gotten_nodes
+      end
+
+      def get_root
+        root_node = @connection.get('/')["reference_node"]
+        @connection.get("/node/%{id}" % {:id => get_id(root_node)})
+      end
+
+      def create_node(*args)
+        if args[0].respond_to?(:each_pair) && args[0]
+          create_node_with_attributes(args[0])
+        else
+          create_empty_node
+        end
+      end
+
+      def create_node_with_attributes(attributes)
+        options = {
+          :body => attributes.delete_if { |k, v| v.nil? }.to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/node", options)
+      end
+
+      def create_empty_node
+        @connection.post("/node")
+      end
+
+      def delete_node(id)
+        @connection.delete("/node/%{id}" % {:id => get_id(id)})
+      end
+
+      def create_nodes(nodes)
+        nodes = Array.new(nodes) if nodes.kind_of? Fixnum
+        created_nodes = []
+        nodes.each do |node|
+          created_nodes << create_node(node)
+        end
+        created_nodes
+      end
+
+      def create_nodes_threaded(nodes)
+        nodes = Array.new(nodes) if nodes.kind_of? Fixnum
+
+        node_queue = Queue.new
+        thread_pool = []
+        responses = Queue.new
+
+        nodes.each do |node|
+          node_queue.push node
+        end
+
+        [nodes.size, @connection.max_threads].min.times do
+          thread_pool << Thread.new do
+            until node_queue.empty? do
+              node = node_queue.pop
+              if node.respond_to?(:each_pair)
+                responses.push( @connection.post("/node", {
+                  :body => node.to_json,
+                  :headers => json_content_type
+                } ) )
+              else
+                responses.push( @connection.post("/node") )
+              end
+            end
+            self.join
+          end
+        end
+
+        created_nodes = []
+
+        while created_nodes.size < nodes.size 
+          created_nodes << responses.pop
+        end
+        created_nodes
+      end
+
+    end
+  end
+end

data/lib/neography/rest/other_node_relationships.rb

@@ -0,0 +1,38 @@
+module Neography
+  class Rest
+    module OtherNodeRelationships
+      include Neography::Rest::Helpers
+    
+      def get_node_relationships_to(id, other_id, direction = "all", types = [nil] )
+        
+        body = case parse_direction(direction)
+                 when "all"
+                   "position.endNode().getId() == " + get_id(other_id)
+                 when "in"
+                   "position.length() > 0 && position.lastRelationship().getStartNode().getId() == " + get_id(other_id)
+                 when "out"
+                   "position.length() > 0 && position.lastRelationship().getEndNode().getId() == " + get_id(other_id) 
+                end
+
+        relationships = {:relationships => Array(types).map{|row| Hash[{:type => row}].merge({:direction => parse_direction(direction)})} }
+
+        if Array(types).first.nil?
+          relationships = {}
+        end
+                
+        options = {
+          :body => {:order      => "breadth_first",
+                    :uniqueness => "relationship_global",
+                    :max_depth  => 1,
+                    :return_filter => {:language => "javascript",
+                                       :body =>  body }
+                    }.merge(relationships).to_json,
+          :headers => json_content_type
+        }
+
+        @connection.post("/node/%{id}/traverse/relationship" % {:id => get_id(id)}, options) || []
+      end
+
+    end
+  end
+end

data/lib/neography/rest/relationship_auto_indexes.rb

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

data/lib/neography/rest/relationship_indexes.rb

@@ -0,0 +1,142 @@
+module Neography
+  class Rest
+    module RelationshipIndexes
+      include Neography::Rest::Helpers
+
+      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 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 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,
+          :type  => type,
+          :start => @connection.configuration + "/node/#{get_id(from)}",
+          :end   => @connection.configuration + "/node/#{get_id(to)}"
+        }
+        
+        body[:properties] = props unless props.nil?
+        
+        options = { :body => body.to_json, :headers => json_content_type }
+
+        @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
+
+      def create_or_fail_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 => 'create_or_fail'}, options)
+
+      end
+
+    end
+  end
+end