neography 1.3.14 → 1.4.0

data/lib/neography/rest/batch.rb

@@ -1,22 +1,15 @@
 module Neography
   class Rest
-    class Batch
-      extend Neography::Rest::Paths
+    module Batch
       include Neography::Rest::Helpers
-
-      add_path :batch, "/batch"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def execute(*args)
-        batch(*args)
+    
+      def batch(*args)
+        do_batch(*args)
       end
 
       private
 
-      def batch(*args)
+      def do_batch(*args)
         batch = []
         Array(args).each_with_index do |c, i|
           batch << {:id => i }.merge(get_batch(c))
@@ -25,54 +18,54 @@ module Neography
           :body => batch.to_json,
           :headers => json_content_type
         }
-        @connection.post(batch_path, options)
+        @connection.post("/batch", options)
       end
 
       def get_batch(args)
-        if respond_to?(args[0].to_sym, true)
-          send(args[0].to_sym, *args[1..-1])
+        if args[0].class == Symbol
+          send(("batch_" + args[0].to_s).to_sym, *args[1..-1])
         else
-          raise "Unknown option #{args[0]}"
+          raise "Unknown option #{args[0]} - #{args}"
         end
       end
 
       # Nodes
 
-      def get_node(id)
-        get Nodes.base_path(:id => get_id(id))
+      def batch_get_node(id)
+        get "/node/%{id}" % {:id => get_id(id)}
       end
 
-      def delete_node(id)
-        delete Nodes.base_path(:id => get_id(id))
+      def batch_delete_node(id)
+        delete "/node/%{id}" % {:id => get_id(id)}
       end
 
-      def create_node(body)
-        post Nodes.index_path do
+      def batch_create_node(body)
+        post "/node" do
           body
         end
       end
 
       # NodeIndexes
 
-      def create_node_index(name, type = "exact", provider = "lucene", extra_config = nil)
+      def batch_create_node_index(name, type = "exact", provider = "lucene", extra_config = nil)
         config = {
           :type => type,
           :provider => provider
         }
         config.merge!(extra_config) unless extra_config.nil?
-        post NodeIndexes.all_path do
+        post "/index/node" do
           { :name => name,
             :config => config
           }
         end
       end
 
-      def drop_node_index(index)
-        delete NodeIndexes.unique_path(:index => index)
+      def batch_drop_node_index(index)
+        delete "/index/node/%{index}?unique" % {:index => index}
       end
 
-      def create_unique_node(index, key, value, properties)
-        post NodeIndexes.unique_path(:index => index) do
+      def batch_create_unique_node(index, key, value, properties)
+        post "/index/node/%{index}?unique" % {:index => index} do
           {
             :key        => key,
             :value      => value,
@@ -81,8 +74,8 @@ module Neography
         end
       end
 
-      def add_node_to_index(index, key, value, id, unique = false)
-        path = unique ? NodeIndexes.unique_path(:index => index) : NodeIndexes.base_path(:index => index)
+      def batch_add_node_to_index(index, key, value, id, unique = false)
+        path = unique ? "/index/node/%{index}?unique" % {:index => index} : "/index/node/%{index}" % {:index => index}
         post path do
           {
             :uri   => build_node_uri(id),
@@ -92,35 +85,35 @@ module Neography
         end
       end
 
-      def get_node_index(index, key, value)
-        get NodeIndexes.key_value_path(:index => index, :key => key, :value => value)
+      def batch_get_node_index(index, key, value)
+        get "/index/node/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(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)
+      def batch_remove_node_from_index(index, key_or_id, value_or_id = nil, id = nil)
+        delete remove_from_index_path("node", 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
+      def batch_set_node_property(id, property)
+        put "/node/%{id}/properties/%{property}" % {: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
+      def batch_reset_node_properties(id, body)
+        put "/node/%{id}/properties" % {:id => get_id(id)} do
           body
         end
       end
 
-      def remove_node_property(id, property)
-        delete NodeProperties.single_path(:id => get_id(id), :property => property)
+      def batch_remove_node_property(id, property)
+        delete "/node/%{id}/properties/%{property}" % {:id => get_id(id), :property => property}
       end
 
       # NodeLabel
 
-      def add_label(id, body)
+      def batch_add_label(id, body)
         post build_node_uri(id) + "/labels" do
           body
         end
@@ -128,25 +121,25 @@ module Neography
 
       # NodeRelationships
 
-      def get_node_relationships(id, direction = nil, types = nil)
+      def batch_get_node_relationships(id, direction = nil, types = nil)
         if types.nil?
-          get NodeRelationships.direction_path(:id => get_id(id), :direction => direction || 'all')
+          get "/node/%{id}/relationships/%{direction}" % {:id => get_id(id), :direction => direction || 'all'}
         else
-          get NodeRelationships.type_path(:id => get_id(id), :direction => direction, :types => Array(types).join('&'))
+          get "/node/%{id}/relationships/%{direction}/%{types}" % {:id => get_id(id), :direction => direction, :types => Array(types).join('&')}
         end
       end
 
       # Relationships
 
-      def get_relationship(id)
-        get Relationships.base_path(:id => get_id(id))
+      def batch_get_relationship(id)
+        get "/relationship/%{id}" % {:id => get_id(id)}
       end
 
-      def delete_relationship(id)
-        delete Relationships.base_path(:id => get_id(id))
+      def batch_delete_relationship(id)
+        delete "/relationship/%{id}" % {:id => get_id(id)}
       end
 
-      def create_relationship(type, from, to, data = nil)
+      def batch_create_relationship(type, from, to, data = nil)
         post build_node_uri(from) + "/relationships" do
           {
             :to   => build_node_uri(to),
@@ -158,8 +151,8 @@ module Neography
 
       # RelationshipIndexes
 
-      def create_unique_relationship(index, key, value, type, from, to, props = nil)
-        post RelationshipIndexes.unique_path(:index => index) do
+      def batch_create_unique_relationship(index, key, value, type, from, to, props = nil)
+        post "/index/relationship/%{index}?unique" % {:index => index} do
           {
             :key   => key,
             :value => value,
@@ -171,8 +164,8 @@ module Neography
         end
       end
 
-      def add_relationship_to_index(index, key, value, id)
-        post RelationshipIndexes.base_path(:index => index) do
+      def batch_add_relationship_to_index(index, key, value, id)
+        post "/index/relationship/%{index}" % {:index => index} do
           {
             :uri   => build_relationship_uri(id),
             :key   => key,
@@ -181,23 +174,23 @@ module Neography
         end
       end
 
-      def get_relationship_index(index, key, value)
-        get RelationshipIndexes.key_value_path(:index => index, :key => key, :value => value)
+      def batch_get_relationship_index(index, key, value)
+        get "/index/relationship/%{index}/%{key}/%{value}" % {:index => index, :key => key, :value => encode(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)
+      def batch_remove_relationship_from_index(index, key_or_id, value_or_id = nil, id = nil)
+        delete remove_from_index_path("relationship", 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
+      def batch_set_relationship_property(id, property)
+        put "/relationship/%{id}/properties/%{property}" % {:id => get_id(id), :property => property.keys.first} do
           property.values.first
         end
       end
 
-      def reset_relationship_properties(id, body)
+      def batch_reset_relationship_properties(id, body)
         put build_relationship_uri(id) + "/properties" do
           body
         end
@@ -205,7 +198,7 @@ module Neography
 
       # Cypher
 
-      def execute_query(query, params = nil)
+      def batch_execute_query(query, params = nil)
         request = post @connection.cypher_path do
           {
             :query => query
@@ -219,7 +212,7 @@ module Neography
 
       # Gremlin
 
-      def execute_script(script, params = nil)
+      def batch_execute_script(script, params = nil)
         post @connection.gremlin_path do
           {
             :script => script,
@@ -232,22 +225,22 @@ module Neography
 
       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))
+          "/index/#{klass}/%{index}/%{key}/%{value}/%{id}" % {: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))
+          "/index/#{klass}/%{index}/%{key}/%{id}" % {:index => index, :key => key_or_id, :id => get_id(value_or_id)}
         else
-          klass.id_path(:index => index, :id => get_id(key_or_id))
+          "/index/#{klass}/%{index}/%{id}" % {:index => index, :id => get_id(key_or_id)}
         end
       end
 
       # Spatial
       
-      def get_spatial
-        get Spatial.index_path
+      def batch_get_spatial
+        get "/ext/SpatialPlugin"
       end
     
-      def add_point_layer(layer, lat = nil, lon = nil)
-         post Spatial.add_simple_point_layer_path do
+      def batch_add_point_layer(layer, lat = nil, lon = nil)
+         post "/ext/SpatialPlugin/graphdb/addSimplePointLayer" do
           {
               :layer => layer,
               :lat => lat || "lat",
@@ -256,8 +249,8 @@ module Neography
           end
       end
 
-      def add_editable_layer(layer, format = "WKT", node_property_name = "wkt")
-        post Spatial.add_editable_layer_path do 
+      def batch_add_editable_layer(layer, format = "WKT", node_property_name = "wkt")
+        post "/ext/SpatialPlugin/graphdb/addEditableLayer" do 
           {
               :layer => layer,
               :format => format,
@@ -266,16 +259,16 @@ module Neography
         end
       end
 
-      def get_layer(layer)
-        post Spatial.get_layer_path do
+      def batch_get_layer(layer)
+        post "/ext/SpatialPlugin/graphdb/getLayer" do
           {
               :layer => layer
             }
         end
       end
 
-      def add_geometry_to_layer(layer, geometry)
-        post Spatial.add_geometry_to_layer_path do 
+      def batch_add_geometry_to_layer(layer, geometry)
+        post "/ext/SpatialPlugin/graphdb/addGeometryWKTToLayer" do 
           {
               :layer => layer,
               :geometry => geometry
@@ -283,8 +276,8 @@ module Neography
         end
       end
     
-      def edit_geometry_from_layer(layer, geometry, node)
-        post Spatial.edit_geometry_from_layer_path do 
+      def batch_edit_geometry_from_layer(layer, geometry, node)
+        post "/ext/SpatialPlugin/graphdb/updateGeometryFromWKT" do 
           {
               :layer => layer,
               :geometry => geometry,
@@ -293,8 +286,8 @@ module Neography
         end
       end
     
-      def add_node_to_layer(layer, node)
-        post Spatial.add_node_to_layer_path do 
+      def batch_add_node_to_layer(layer, node)
+        post "/ext/SpatialPlugin/graphdb/addNodeToLayer" do 
           {
               :layer => layer,
               :node => get_id(node)
@@ -302,8 +295,8 @@ module Neography
         end
       end
     
-      def find_geometries_in_bbox(layer, minx, maxx, miny, maxy)
-        post Spatial.find_geometries_in_bbox_path do 
+      def batch_find_geometries_in_bbox(layer, minx, maxx, miny, maxy)
+        post "/ext/SpatialPlugin/graphdb/findGeometriesInBBox" do 
           {
               :layer => layer,
               :minx => minx,
@@ -314,8 +307,8 @@ module Neography
         end
       end
     
-      def find_geometries_within_distance(layer, pointx, pointy, distance)
-        post Spatial.find_geometries_within_distance_path do 
+      def batch_find_geometries_within_distance(layer, pointx, pointy, distance)
+        post "/ext/SpatialPlugin/graphdb/findGeometriesWithinDistance" do 
           {
               :layer => layer,
               :pointX => pointx,
@@ -325,8 +318,8 @@ module Neography
         end
       end
       
-      def create_spatial_index(name, type, lat, lon)
-        post NodeIndexes.all_path do
+      def batch_create_spatial_index(name, type, lat, lon)
+        post "/index/node" do
           {
             :name => name,
             :config => {
@@ -339,8 +332,8 @@ module Neography
         end
       end
 
-      def add_node_to_spatial_index(index, id)
-        post NodeIndexes.base_path(:index => index) do
+      def batch_add_node_to_spatial_index(index, id)
+        post "/index/node/%{index}" % {:index => index} do
           {
             :uri   => build_node_uri(id),
             :key   => "k",

data/lib/neography/rest/clean.rb

@@ -1,17 +1,15 @@
 module Neography
   class Rest
-    class Clean
-      extend Neography::Rest::Paths
+    module Clean
       include Neography::Rest::Helpers
 
-      add_path :clean, "/cleandb/secret-key"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def execute
-        @connection.delete(clean_path)
+      def clean_database(sanity_check = "not_really")
+        if sanity_check == "yes_i_really_want_to_clean_the_database"
+          @connection.delete("/cleandb/secret-key")
+          true
+        else
+          false
+        end          
       end
 
     end

data/lib/neography/rest/constraints.rb

@@ -1,46 +1,36 @@
 module Neography
   class Rest
-    class Constraints
-      extend Neography::Rest::Paths
+    module Constraints
       include Neography::Rest::Helpers
-
-      add_path :base,       "/schema/constraint/"
-      add_path :label,      "/schema/constraint/:label"            
-      add_path :uniqueness, "/schema/constraint/:label/uniqueness/"
-      add_path :unique,     "/schema/constraint/:label/uniqueness/:property"
-      
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def drop(label, property)
-        @connection.delete(unique_path(:label => label, :property => property))
-      end
-
-      def list
-        @connection.get(base_path)
+    
+      def drop_constraint(label, property)
+        @connection.delete("/schema/constraint/%{label}/uniqueness/%{property}" % {:label => label, :property => property})
       end
 
-      def get(label)
-        @connection.get(label_path(:label => label))
+      def get_constraints(label=nil)
+        #if label.nil?
+        #  @connection.get(base_path)          
+        #else
+          @connection.get("/schema/constraint/%{label}" % {:label => label})
+        #end
       end
 
       def get_uniqueness(label)
-        @connection.get(uniqueness_path(:label => label))
+        @connection.get("/schema/constraint/%{label}/uniqueness/" % {:label => label})
       end
 
-      def get_unique(label, property)
-        @connection.get(unique_path(:label => label, :property => property))
+      def get_unique_constraint(label, property)
+        @connection.get("/schema/constraint/%{label}/uniqueness/%{property}" % {:label => label, :property => property})
       end
 
-      def create_unique(label, property)
+      def create_unique_constraint(label, property)
         options = {
           :body => {
             :property_keys => [property]
           }.to_json,
           :headers => json_content_type
         }
-        @connection.post(uniqueness_path(:label => label), options)
+        @connection.post("/schema/constraint/%{label}/uniqueness/" % {:label => label}, options)
       end
 
     end