neography 0.0.31 → 1.0.0

data/lib/neography/rest/indexes.rb

@@ -0,0 +1,97 @@
+module Neography
+  class Rest
+    class Indexes
+      include Neography::Rest::Helpers
+
+      def initialize(connection, index_type)
+        @connection = connection
+        @index_type = index_type
+      end
+
+      def list
+        @connection.get(all_path)
+      end
+
+      def create(name, type = "exact", provider = "lucene")
+        options = {
+          :body => (
+            { :name => name,
+              :config => {
+                :type => type,
+                :provider => provider
+              }
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(all_path, options)
+      end
+
+      def create_auto(type = "exact", provider = "lucene")
+        create("#{@index_type}_auto_index", type, provider)
+      end
+
+      def add(index, key, value, id)
+        options = {
+          :body => (
+            { :uri   => @connection.configuration + "/#{@index_type}/#{get_id(id)}",
+              :key   => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+
+        @connection.post(base_path(:index => index), options)
+      end
+
+      def get(index, key, value)
+        index = @connection.get(key_value_path(:index => index, :key => key, :value => value)) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find(index, key_or_query, value = nil)
+        if value
+          index = find_by_key_value(index, key_or_query, value)
+        else
+          index = find_by_query(index, key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find_by_key_value(index, key, value)
+        @connection.get(key_value_path(:index => index, :key => key, :value => value)) || []
+      end
+
+      def find_by_query(index, query)
+        @connection.get(query_path(:index => index, :query => query)) || []
+      end
+
+      # Mimick original neography API in Rest class.
+      def remove(index, id_or_key, id_or_value = nil, id = nil)
+        if id
+          remove_by_value(index, id, id_or_key, id_or_value)
+        elsif id_or_value
+          remove_by_key(index, id_or_value, id_or_key)
+        else
+          remove_by_id(index, id_or_key)
+        end
+      end
+
+      def remove_by_id(index, id)
+        @connection.delete(id_path(:index => index, :id => get_id(id)))
+      end
+
+      def remove_by_key(index, id, key)
+        @connection.delete(key_path(:index => index, :id => get_id(id), :key => key))
+      end
+
+      def remove_by_value(index, id, key, value)
+        @connection.delete(value_path(:index => index, :id => get_id(id), :key => key, :value => value))
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_auto_indexes.rb

@@ -0,0 +1,14 @@
+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"
+
+    end
+  end
+end

data/lib/neography/rest/node_indexes.rb

@@ -0,0 +1,35 @@
+module Neography
+  class Rest
+    class NodeIndexes < Indexes
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :all,       "/index/node"
+      add_path :base,      "/index/node/:index"
+      add_path :unique,    "/index/node/:index?unique"
+      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 initialize(connection)
+        super(connection, :node)
+      end
+
+      def create_unique(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(unique_path(:index => index), options)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_paths.rb

@@ -0,0 +1,57 @@
+module Neography
+  class Rest
+    class NodePaths
+      extend Neography::Rest::Paths
+      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")
+        options = path_options(to, relationships, depth, algorithm)
+        @connection.post(base_path(:id => get_id(from)), options) || {}
+      end
+
+      def get_all(from, to, relationships, depth = 1, algorithm = "allPaths")
+        options = path_options(to, relationships, depth, algorithm)
+        @connection.post(all_path(:id => get_id(from)), options) || []
+      end
+
+      def shortest_weighted(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) || {}
+      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

data/lib/neography/rest/node_properties.rb

@@ -0,0 +1,11 @@
+module Neography
+  class Rest
+    class NodeProperties < Properties
+      extend Neography::Rest::Paths
+
+      add_path :all,    "/node/:id/properties"
+      add_path :single, "/node/:id/properties/:property"
+
+    end
+  end
+end

data/lib/neography/rest/node_relationships.rb

@@ -0,0 +1,53 @@
+module Neography
+  class Rest
+    class NodeRelationships
+      extend Neography::Rest::Paths
+      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)
+        options = {
+          :body => {
+            :to => @connection.configuration + "/node/#{get_id(to)}",
+            :data => properties,
+            :type => type
+          }.to_json,
+          :headers => json_content_type }
+
+        @connection.post(base_path(:id => get_id(from)), options)
+      end
+
+      def get(id, direction = nil, types = nil)
+        direction = parse_direction(direction)
+
+        if types.nil?
+          node_relationships = @connection.get(direction_path(:id => get_id(id), :direction => direction)) || []
+        else
+          node_relationships = @connection.get(type_path(:id => get_id(id), :direction => direction, :types => Array(types).join('&'))) || []
+        end
+
+        return nil if node_relationships.empty?
+        node_relationships
+      end
+
+      def parse_direction(direction)
+        case direction
+          when :incoming, "incoming", :in, "in"
+            "in"
+          when :outgoing, "outgoing", :out, "out"
+            "out"
+          else
+            "all"
+        end
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_traversal.rb

@@ -0,0 +1,81 @@
+module Neography
+  class Rest
+    class NodeTraversal
+      extend Neography::Rest::Paths
+      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"]),
+            "relationships"   => description["relationships"],
+            "prune_evaluator" => description["prune evaluator"],
+            "return_filter"   => description["return filter"],
+            "max_depth"       => get_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
+
+      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
+      end
+
+    end
+  end
+end

data/lib/neography/rest/nodes.rb

@@ -0,0 +1,102 @@
+module Neography
+  class Rest
+    class Nodes
+      extend Neography::Rest::Paths
+      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)))
+      end
+
+      def get_each(*nodes)
+        gotten_nodes = []
+        Array(nodes).flatten.each do |node|
+          gotten_nodes << get(node)
+        end
+        gotten_nodes
+      end
+
+      def root
+        root_node = @connection.get('/')["reference_node"]
+        @connection.get(base_path(:id => get_id(root_node)))
+      end
+
+      def create(*args)
+        if args[0].respond_to?(:each_pair) && args[0]
+          create_with_attributes(args[0])
+        else
+          create_empty
+        end
+      end
+
+      def create_with_attributes(attributes)
+        options = {
+          :body => attributes.delete_if { |k, v| v.nil? }.to_json,
+          :headers => json_content_type
+        }
+        @connection.post(index_path, options)
+      end
+
+      def create_empty
+        @connection.post(index_path)
+      end
+
+      def delete(id)
+        @connection.delete(base_path(:id => get_id(id)))
+      end
+
+      def create_multiple(nodes)
+        nodes = Array.new(nodes) if nodes.kind_of? Fixnum
+        created_nodes = []
+        nodes.each do |node|
+          created_nodes << create(node)
+        end
+        created_nodes
+      end
+
+      def create_multiple_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(index_path, {
+                  :body => node.to_json,
+                  :headers => json_content_type
+                } ) )
+              else
+                responses.push( @connection.post(index_path) )
+              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/paths.rb

@@ -0,0 +1,36 @@
+module Neography
+  class Rest
+    module Paths
+
+      def add_path(key, path)
+        method_name = :"#{key}_path"
+
+        metaclass = (class << self; self; end)
+        metaclass.instance_eval do
+          define_method method_name do |*attributes|
+            if attributes.any?
+              build_path(path, *attributes)
+            else
+              path
+            end
+          end
+        end
+
+        define_method method_name do |*attributes|
+          self.class.send(method_name, *attributes)
+        end
+      end
+
+      def build_path(path, attributes)
+        path.gsub(/:([\w_]*)/) do
+          encode(attributes[$1.to_sym].to_s)
+        end
+      end
+
+      def encode(value)
+        URI.encode(value).gsub("/","%2F")
+      end
+
+    end
+  end
+end

data/lib/neography/rest/properties.rb

@@ -0,0 +1,56 @@
+module Neography
+  class Rest
+    class Properties
+      include Neography::Rest::Helpers
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def set(id, properties)
+        properties.each do |property, value|
+          options = { :body => value.to_json, :headers => json_content_type }
+          @connection.put(single_path(:id => get_id(id), :property => property), options)
+        end
+      end
+
+      def reset(id, properties)
+        options = { :body => properties.to_json, :headers => json_content_type }
+        @connection.put(all_path(:id => get_id(id)), options)
+      end
+
+      def get(id, *properties)
+        if properties.none?
+          @connection.get(all_path(:id => get_id(id)))
+        else
+          get_each(id, *properties)
+        end
+      end
+
+      def get_each(id, *properties)
+        retrieved_properties = properties.flatten.inject({}) do |memo, property|
+          value = @connection.get(single_path(: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(id, *properties)
+        if properties.none?
+          @connection.delete(all_path(:id => get_id(id)))
+        else
+          remove_each(id, *properties)
+        end
+      end
+
+      def remove_each(id, *properties)
+        properties.flatten.each do |property|
+          @connection.delete(single_path(:id => get_id(id), :property => property))
+        end
+      end
+
+    end
+  end
+end

data/lib/neography/rest/relationship_auto_indexes.rb

@@ -0,0 +1,14 @@
+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"
+
+    end
+  end
+end

data/lib/neography/rest/relationship_indexes.rb

@@ -0,0 +1,35 @@
+module Neography
+  class Rest
+    class RelationshipIndexes < Indexes
+      extend Neography::Rest::Paths
+      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 initialize(connection)
+        super(connection, :relationship)
+      end
+
+      def create_unique(index, key, value, type, from, to)
+        body = {
+          :key   => key,
+          :value => value,
+          :type  => type,
+          :start => @connection.configuration + "/node/#{get_id(from)}",
+          :end   => @connection.configuration + "/node/#{get_id(to)}"
+        }
+        options = { :body => body.to_json, :headers => json_content_type }
+
+        @connection.post(unique_path(:index => index), options)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/relationship_properties.rb

@@ -0,0 +1,11 @@
+module Neography
+  class Rest
+    class RelationshipProperties < Properties
+      extend Neography::Rest::Paths
+
+      add_path :all,    "/relationship/:id/properties"
+      add_path :single, "/relationship/:id/properties/:property"
+
+    end
+  end
+end

data/lib/neography/rest/relationships.rb

@@ -0,0 +1,23 @@
+module Neography
+  class Rest
+    class Relationships
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,   "/relationship/:id"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def get(id)
+        @connection.get(base_path(:id => get_id(id)))
+      end
+
+      def delete(id)
+        @connection.delete(base_path(:id => get_id(id)))
+      end
+
+    end
+  end
+end