neography 0.0.31 → 1.0.0

data/lib/neography/node_traverser.rb

@@ -59,16 +59,18 @@ module Neography
     end
 
     def filter(body)
-      @filter = Hash.new
-      @filter["language"] = "javascript"
-      @filter["body"] = body
+      @filter = {
+        "language" => "javascript",
+        "body"     => body
+      }
       self
     end
 
     def prune(body)
-      @prune = Hash.new
-      @prune["language"] = "javascript"
-      @prune["body"] = body
+      @prune = {
+        "language" => "javascript",
+        "body"     => body
+      }
       self
     end
 
@@ -79,9 +81,10 @@ module Neography
     end
 
     def include_start_node
-      @filter = Hash.new
-      @filter["language"] = "builtin"
-      @filter["name"] = "all"
+      @filter = {
+        "language" => "builtin",
+        "name"     => "all"
+      }
       self
     end
 
@@ -108,13 +111,14 @@ module Neography
     end
 
     def iterator
-      options = Hash.new
-      options["order"] = @order
-      options["uniqueness"] = @uniqueness
-      options["relationships"] = @relationships
-      options["prune evaluator"] = @prune unless @prune.nil?
-      options["return filter"] = @filter unless @filter.nil?
-      options["depth"] = @depth unless @depth.nil?
+      options = {
+        "order"         => @order,
+        "uniqueness"    => @uniqueness,
+        "relationships" => @relationships
+      }
+      options["prune evaluator"] = @prune  unless @prune.nil?
+      options["return filter"]   = @filter unless @filter.nil?
+      options["depth"]           = @depth  unless @depth.nil?
 
       if @relationships[0]["type"].empty?
         rels = @from.neo_server.get_node_relationships(@from, @relationships[0]["direction"])
@@ -124,11 +128,11 @@ module Neography
           when "out"
             rels.collect { |r| @from.neo_server.get_node(r["end"]) } #.uniq
           else
-            rels.collect { |r| 
+            rels.collect { |r|
             if @from.neo_id == r["start"].split('/').last
-              @from.neo_server.get_node(r["end"]) 
+              @from.neo_server.get_node(r["end"])
             else
-              @from.neo_server.get_node(r["start"]) 
+              @from.neo_server.get_node(r["start"])
             end
             } #.uniq
         end
@@ -139,4 +143,4 @@ module Neography
 
   end
 
-end
+end

data/lib/neography/property.rb

@@ -1,57 +1,60 @@
 module Neography
   module Property
 
-
     def [](key)
+      key = key.to_sym
       return unless respond_to?(key)
       @table[key]
     end
 
     def []=(key, value)
-      k = key.to_s
+      key = key.to_sym
+      k_str = key.to_s
       if value.nil?
         if self.is_a? Neography::Node
-          neo_server.remove_node_properties(self.neo_id, [key])
+          neo_server.remove_node_properties(self.neo_id, [k_str])
         else
-          neo_server.remove_relationship_properties(self.neo_id, [key])
+          neo_server.remove_relationship_properties(self.neo_id, [k_str])
         end
       else
         if self.is_a? Neography::Node
-          neo_server.set_node_properties(self.neo_id, {k => value})
+          neo_server.set_node_properties(self.neo_id, {k_str => value})
         else
-          neo_server.set_relationship_properties(self.neo_id, {k => value})
+          neo_server.set_relationship_properties(self.neo_id, {k_str => value})
         end
-        new_ostruct_member(k) unless self.respond_to?(key)
+        new_ostruct_member(key) unless self.respond_to?(key)
       end
       @table[key] = value
     end
 
-
-  def new_ostruct_member(name)
-    name = name.to_sym
-    unless self.respond_to?(name)
-      meta = class << self; self; end
-      meta.send(:define_method, name) { @table[name] }
-      meta.send(:define_method, "#{name}=") do |x| 
-        @table[name] = x 
-        self[name.to_sym] = x        
+    def new_ostruct_member(name)
+      name = name.to_sym
+      unless self.respond_to?(name)
+        meta = class << self; self; end
+        meta.send(:define_method, name) { @table[name] }
+        meta.send(:define_method, "#{name}=") do |value|
+          @table[name] = value
+          self[name.to_sym] = value
+        end
       end
+      name
     end
-   name
-  end
 
+    def method_missing(method_sym, *arguments, &block)
+      if (method_sym.to_s =~ /=$/) != nil
+        new_ostruct_member(method_sym.to_s.chomp("="))
 
-  def method_missing(method_sym, *arguments, &block)
-    if (method_sym.to_s =~ /=$/) != nil
-      new_ostruct_member(method_sym.to_s.chomp("="))
+        # We just defined the getter/setter above, but we haven't actually
+        # applied them yet.
+        self.send(method_sym, *arguments)
+      else
+        super
+      end
+    end
 
-      # We just defined the getter/setter above, but we haven't actually
-      # applied them yet.
-      self.send(method_sym, *arguments)
-    else
-      super
+    def attributes
+      @table.keys
     end
-  end
 
   end
-end
+end

data/lib/neography/property_container.rb

@@ -14,4 +14,4 @@ module Neography
     end
 
   end
-end
+end

data/lib/neography/relationship.rb

@@ -8,7 +8,7 @@ module Neography
 
     class << self
 
-      def create(type, from_node, to_node, props=nil)
+      def create(type, from_node, to_node, props = nil)
         rel = Neography::Relationship.new(from_node.neo_server.create_relationship(type, from_node, to_node, props))
         rel.start_node = from_node
         rel.end_node = to_node
@@ -16,17 +16,14 @@ module Neography
         rel
       end
 
-      def load(*args)
-        # the first argument can be an hash of properties to set
-        rel = !args[0].is_a?(Neography::Rest) && args[0] || args[1]
+      def load(rel, db = Neography::Rest.new)
+        raise ArgumentError.new("syntax deprecated") if rel.is_a?(Neography::Rest)
 
-        # a db instance can be given, it is the first argument or the second
-        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
         rel = db.get_relationship(rel)
-        unless rel.nil?
-          rel = Neography::Relationship.new(rel) 
-          rel.start_node = Neography::Node.load(rel.start_node, db) 
-          rel.end_node = Neography::Node.load(rel.end_node, db) 
+        if rel
+          rel = Neography::Relationship.new(rel)
+          rel.start_node = Neography::Node.load(rel.start_node, db)
+          rel.end_node = Neography::Node.load(rel.end_node, db)
         end
         rel
       end
@@ -39,26 +36,26 @@ module Neography
       @rel_type = hash["type"]
       neo_server = server
     end
-    
+
     def neo_server
       @neo_server ||= self.start_node.neo_server
     end
-    
+
     def neo_server=(server)
       @neo_server = server
     end
 
     def del
-      self.start_node.neo_server.delete_relationship(self.neo_id)
+      start_node.neo_server.delete_relationship(neo_id)
     end
 
     def exist?
-      !self.start_node.neo_server.get_relationship(self.neo_id).nil?
-    end
-    
-    def attributes
-      attrs = self.methods - OpenStruct.instance_methods - Neography::Relationship.instance_methods
-      attrs.values_at(*attrs.each_index.select {|i| i.even?})
+      begin
+        start_node.neo_server.get_relationship(neo_id)
+        true
+      rescue Neography::RelationshipNotFoundException
+        false
+      end
     end
 
     def other_node(node)

data/lib/neography/rest/auto_indexes.rb

@@ -0,0 +1,64 @@
+module Neography
+  class Rest
+    class AutoIndexes
+      include Neography::Rest::Helpers
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def get(key, value)
+        index = @connection.get(key_value_path(:key => key, :value => value)) || []
+        return nil if index.empty?
+        index
+      end
+
+      def find_or_query(key_or_query, value = nil)
+        if value
+          index = find(key_or_query, value)
+        else
+          index = query(key_or_query)
+        end
+        return nil if index.empty?
+        index
+      end
+
+      def find(key, value)
+        @connection.get(key_value_path(:key => key, :value => value)) || []
+      end
+
+      def query(query_expression)
+        @connection.get(query_index_path(:query => query_expression)) || []
+      end
+
+      def status
+        @connection.get(index_status_path)
+      end
+
+      def status=(value)
+        options = {
+          :body => value.to_json,
+          :headers => json_content_type
+        }
+        @connection.put(index_status_path, options)
+      end
+
+      def properties
+        @connection.get(index_properties_path)
+      end
+
+      def add_property(property)
+        options = {
+          :body => property,
+          :headers => json_content_type
+        }
+        @connection.post(index_properties_path, options)
+      end
+
+      def remove_property(property)
+        @connection.delete(index_property_path(:property => property))
+      end
+
+    end
+  end
+end

data/lib/neography/rest/batch.rb

@@ -0,0 +1,262 @@
+module Neography
+  class Rest
+    class Batch
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :batch, "/batch"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def execute(*args)
+        batch({'Accept' => 'application/json;stream=true'}, *args)
+      end
+
+      def not_streaming(*args)
+        batch({}, *args)
+      end
+
+      private
+
+      def batch(accept_header, *args)
+        batch = []
+        Array(args).each_with_index do |c, i|
+          batch << {:id => i }.merge(get_batch(c))
+        end
+        options = {
+          :body => batch.to_json,
+          :headers => json_content_type.merge(accept_header)
+        }
+
+        @connection.post(batch_path, options)
+      end
+
+      def get_batch(args)
+        if respond_to?(args[0].to_sym, true)
+          send(args[0].to_sym, *args[1..-1])
+        else
+          raise "Unknown option #{args[0]}"
+        end
+      end
+
+      # Nodes
+
+      def get_node(id)
+        get Nodes.base_path(:id => get_id(id))
+      end
+
+      def delete_node(id)
+        delete Nodes.base_path(:id => get_id(id))
+      end
+
+      def create_node(body)
+        post Nodes.index_path do
+          body
+        end
+      end
+
+      # NodeIndexes
+
+      def create_unique_node(index, key, value, properties)
+        post NodeIndexes.unique_path(:index => index) do
+          {
+            :key        => key,
+            :value      => value,
+            :properties => properties
+          }
+        end
+      end
+
+      def add_node_to_index(index, key, value, id)
+        post NodeIndexes.base_path(:index => index) do
+          {
+            :uri   => build_node_uri(id),
+            :key   => key,
+            :value => value
+          }
+        end
+      end
+
+      def get_node_index(index, key, value)
+        get NodeIndexes.key_value_path(:index => index, :key => key, :value => value)
+      end
+
+      def remove_node_from_index(index, key_or_id, value_or_id = nil, id = nil)
+        delete remove_from_index_path(NodeIndexes, index, key_or_id, value_or_id, id)
+      end
+
+      # NodeProperties
+
+      def set_node_property(id, property)
+        put NodeProperties.single_path(:id => get_id(id), :property => property.keys.first) do
+          property.values.first
+        end
+      end
+
+      def reset_node_properties(id, body)
+        put NodeProperties.all_path(:id => get_id(id)) do
+          body
+        end
+      end
+
+      # NodeRelationships
+
+      def get_node_relationships(id, direction = nil)
+        get NodeRelationships.direction_path(:id => get_id(id), :direction => direction || 'all')
+      end
+
+      # Relationships
+
+      def get_relationship(id)
+        get Relationships.base_path(:id => get_id(id))
+      end
+
+      def delete_relationship(id)
+        delete Relationships.base_path(:id => get_id(id))
+      end
+
+      def create_relationship(type, from, to, data)
+        post build_node_uri(from) + "/relationships" do
+          {
+            :to   => build_node_uri(to),
+            :type => type,
+            :data => data
+          }
+        end
+      end
+
+      # RelationshipIndexes
+
+      def create_unique_relationship(index, key, value, type, from, to)
+        post RelationshipIndexes.unique_path(:index => index) do
+          {
+            :key   => key,
+            :value => value,
+            :type  => type,
+            :start => build_node_uri(from),
+            :end   => build_node_uri(to)
+          }
+        end
+      end
+
+      def add_relationship_to_index(index, key, value, id)
+        post RelationshipIndexes.base_path(:index => index) do
+          {
+            :uri   => build_relationship_uri(id),
+            :key   => key,
+            :value => value
+          }
+        end
+      end
+
+      def get_relationship_index(index, key, value)
+        get RelationshipIndexes.key_value_path(:index => index, :key => key, :value => value)
+      end
+
+      def remove_relationship_from_index(index, key_or_id, value_or_id = nil, id = nil)
+        delete remove_from_index_path(RelationshipIndexes, index, key_or_id, value_or_id, id)
+      end
+
+      # RelationshipProperties
+
+      def set_relationship_property(id, property)
+        put RelationshipProperties.single_path(:id => get_id(id), :property => property.keys.first) do
+          property.values.first
+        end
+      end
+
+      def reset_relationship_properties(id, body)
+        put build_relationship_uri(id) + "/properties" do
+          body
+        end
+      end
+
+      # Cypher
+
+      def execute_query(query, params = nil)
+        request = post @connection.cypher_path do
+          {
+            :query => query
+          }
+        end
+
+        request[:body].merge!({ :params => params }) if params
+
+        request
+      end
+
+      # Gremlin
+
+      def execute_script(script, params = nil)
+        post @connection.gremlin_path do
+          {
+            :script => script,
+            :params => params
+          }
+        end
+      end
+
+      # Similar between nodes and relationships
+
+      def remove_from_index_path(klass, index, key_or_id, value_or_id = nil, id = nil)
+        if id
+          klass.value_path(:index => index, :key => key_or_id, :value => value_or_id, :id => get_id(id))
+        elsif value_or_id
+          klass.key_path(:index => index, :key => key_or_id, :id => get_id(value_or_id))
+        else
+          klass.id_path(:index => index, :id => get_id(key_or_id))
+        end
+      end
+
+      def get(to, &block)
+        request "GET", to, &block
+      end
+
+      def delete(to, &block)
+        request "DELETE", to, &block
+      end
+
+      def post(to, &block)
+        request "POST", to, &block
+      end
+
+      def put(to, &block)
+        request "PUT", to, &block
+      end
+
+      def request(method, to, &block)
+        request = {
+          :method => method,
+          :to     => to
+        }
+        request.merge!({ :body => yield }) if block_given?
+        request
+      end
+
+      # Helper methods
+
+      def build_node_uri(value)
+        build_uri(value, "node")
+      end
+
+      def build_relationship_uri(value)
+        build_uri(value, "relationship")
+      end
+
+      def build_uri(value, type)
+        path_or_variable(value, type) + "#{get_id(value)}"
+      end
+
+      def path_or_variable(value, type)
+        if value.is_a?(String) && value.start_with?("{")
+          ""
+        else
+          "/#{type}/"
+        end
+      end
+
+    end
+  end
+end

data/lib/neography/rest/clean.rb

@@ -0,0 +1,19 @@
+module Neography
+  class Rest
+    class Clean
+      extend Neography::Rest::Paths
+      include Neography::Rest::Helpers
+
+      add_path :clean, "/cleandb/secret-key"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def execute
+        @connection.delete(clean_path)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/cypher.rb

@@ -0,0 +1,24 @@
+module Neography
+  class Rest
+    class Cypher
+      include Neography::Rest::Helpers
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def query(query, parameters = {})
+        options = {
+          :body => {
+            :query => query,
+            :params => parameters
+          }.to_json,
+          :headers => json_content_type.merge({'Accept' => 'application/json;stream=true'})
+        }
+
+        @connection.post(@connection.cypher_path, options)
+      end
+
+    end
+  end
+end

data/lib/neography/rest/gremlin.rb

@@ -0,0 +1,24 @@
+module Neography
+  class Rest
+    class Gremlin
+      include Neography::Rest::Helpers
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def execute(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,26 @@
+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
+
+    end
+  end
+end