neography-calamitates 1.2.3.1

data/lib/neography/rest/helpers.rb

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

data/lib/neography/rest/indexes.rb

@@ -0,0 +1,100 @@
+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, unique = false)
+        options = {
+          :body => (
+            { :uri   => @connection.configuration + "/#{@index_type}/#{get_id(id)}",
+              :key   => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        path = unique ? unique_path(:index => index) : base_path(:index => index)
+        @connection.post(path, 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
+
+      def drop(index)
+        @connection.delete(base_path(:index => index))
+      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,50 @@
+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 :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 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
+
+      def get_or_create_unique(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(uniqueness_path(:index => index, :function => 'get_or_create'), options)
+        
+      end
+
+    end
+  end
+end

data/lib/neography/rest/node_labels.rb

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