neography-calamitates 1.2.3.1

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/other_node_relationships.rb

@@ -0,0 +1,48 @@
+module Neography
+  class Rest
+    class OtherNodeRelationships
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,       "/node/:id/traverse/relationship"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def get(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 => types.map{|row| Hash[{:type => row}].merge({:direction => parse_direction(direction)})} }
+
+        if 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
+        }
+
+        node_relationships = @connection.post(base_path(:id => get_id(id)), options) || []
+
+        return nil if node_relationships.empty?
+        node_relationships
+      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)
+        CGI.escape(value).gsub("+", "%20")
+      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/relationship_types.rb

@@ -0,0 +1,18 @@
+module Neography
+  class Rest
+    class RelationshipTypes
+      extend Neography::Rest::Paths
+
+      add_path :all,    "/relationship/types"
+      
+      def initialize(connection)
+        @connection = connection
+      end
+            
+      def list
+        @connection.get(all_path)
+      end
+
+    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

data/lib/neography/rest/schema_indexes.rb

@@ -0,0 +1,34 @@
+module Neography
+  class Rest
+    class SchemaIndexes
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,      "/schema/index/:label"
+      add_path :drop,      "/schema/index/:label/:index"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def list(label)
+        @connection.get(base_path(:label => label))
+      end
+
+      def drop(label, index)
+        @connection.delete(drop_path(:label => label, :index => index))
+      end
+
+      def create(label, keys = [])
+        options = {
+          :body => (
+            { :property_keys => keys
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(base_path(:label => label), options)
+      end
+    end
+  end
+end

data/lib/neography/rest/transactions.rb

@@ -0,0 +1,102 @@
+module Neography
+  class Rest
+    class Transactions
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :base,   "/transaction"
+      add_path :tx,    "/transaction/:id"
+      add_path :commit, "/transaction/:id/commit"
+      
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def begin(statements = [], commit = "")
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(base_path + commit, options)
+      end
+
+      def add(tx, statements = [])
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(tx_path(:id => get_id(tx)), options)
+      end
+
+      def commit(tx, statements = [])
+        options = {
+          :body => (
+            convert_cypher(statements)
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post(commit_path(:id => get_id(tx)), options)
+      end
+      
+      def rollback(tx)
+        @connection.delete(tx_path(:id => get_id(tx)))
+      end
+
+      private
+      
+      def get_id(tx)
+        return tx if tx.is_a?(Integer)
+        return tx.split("/")[-2] if tx.is_a?(String)
+        return tx["commit"].split("/")[-2] if tx["commit"]
+        raise NeographyError.new("Could not determine transaction id", nil, tx)
+      end
+      
+      def convert_cypher(statements)
+        array = []
+        query = nil
+        parameters = nil
+        Array(statements).each do |statement|
+          case 
+            when query && parameters && statement.is_a?(Array)
+              then
+                array << {:statement => query, :parameters => parameters, :resultDataContents => statement }
+                query = nil
+                parameters = nil        
+            when query && parameters && statement.is_a?(String)
+              then
+                array << {:statement => query, :parameters => parameters}
+                query = statement
+                parameters = nil                 
+            when query && statement.is_a?(Hash)
+              then
+                parameters = statement            
+            when query && statement.is_a?(Array)
+              then
+                array << {:statement => query, :resultDataContents => statement }
+                query = nil
+                parameters = nil                       
+            else
+              query = statement
+          end
+
+        end
+        
+        if query && parameters
+          array << {:statement => query, :parameters => parameters}
+          query = nil
+        end
+        
+        if query
+          array << {:statement => query}
+        end
+        
+        { :statements => array }
+      end
+
+    end
+  end
+end