arangorb3 0.0.10

data/lib/Traversal.rb

@@ -0,0 +1,224 @@
+# === TRAVERSAL ===
+
+module Arango
+  class Traversal
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Database_Return
+
+    def initialize(body: {}, edgeCollection: nil,
+      sort: nil, direction: nil, minDepth: nil,
+      vertex:, visitor: nil, itemOrder: nil, strategy: nil,
+      filter: nil, init: nil, maxIterations: nil, maxDepth: nil,
+      uniqueness: nil, order: nil, expander: nil)
+      satisfy_category?(direction, ["outbound", "inbound", "any", nil])
+      satisfy_category?(itemOrder, ["forward", "backward", nil])
+      satisfy_category?(strategy, ["depthfirst", "breadthfirst", nil])
+      satisfy_category?(order, ["preorder", "postorder", "preorder-expander", nil])
+      body[:sort]           ||= sort
+      body[:direction]      ||= direction
+      body[:maxDepth]       ||= maxDepth
+      body[:minDepth]       ||= minDepth
+      body[:startVertex]    ||= vertex
+      body[:visitor]        ||= visitor
+      body[:itemOrder]      ||= itemOrder
+      body[:strategy]       ||= strategy
+      body[:filter]         ||= filter
+      body[:init]           ||= init
+      body[:maxiterations]  ||= maxIterations
+      body[:uniqueness]     ||= uniqueness
+      body[:order]          ||= order
+      body[:expander]       ||= expander
+      body[:edgeCollection] ||= edgeCollection
+      assign_body(body)
+      @vertices = nil
+      @paths = nil
+    end
+
+# === DEFINE ===
+
+    attr_accessor :sort, :maxDepth, :minDepth, :visitor, :filter, :init, :maxiterations, :uniqueness, :expander
+    attr_reader :vertices, :paths, :direction, :itemOrder,
+      :strategy, :order, :database, :server, :vertex, :edgeCollection, :graph, :body, :collection
+    alias startVertex vertex
+
+    def body=(body)
+      @body = body
+      @sort        = body[:sort] || @sort
+      @direction   = body[:direction] || @direction
+      @maxDepth    = body[:maxDepth] || @maxDepth
+      @minDepth    = body[:minDepth] || @minDepth
+      return_vertex(body[:startVertex] || @vertex)
+      @visitor     = body[:visitor] || @visitor
+      @itemOrder   = body[:itemOrder] || @itemOrder
+      @strategy    = body[:strategy] || @strategy
+      @filter      = body[:filter] || @filter
+      @init        = body[:init] || @init
+      @maxIterations = body[:maxiterations] || @maxIterations
+      @uniqueness  = body[:uniqueness] || @uniqueness
+      @order       = body[:order] || @order
+      @expander    = body[:expander] || @expander
+      return_edgeCollection(body[:edgeCollection] || @edgeCollection)
+    end
+    alias assign_body body=
+
+    def direction=(direction)
+      satisfy_category?(direction, ["outbound", "inbound", "any", nil])
+      @direction = direction
+    end
+
+    def itemOrder=(itemOrder)
+      satisfy_category?(itemOrder, ["forward", "backward", nil])
+      @itemOrder = itemOrder
+    end
+
+    def strategy=(strategy)
+      satisfy_category?(strategy, ["depthfirst", "breadthfirst", nil])
+      @strategy = strategy
+    end
+
+    def order=(order)
+      satisfy_category?(order, ["preorder", "postorder", "preorder-expander", nil])
+      @order = order
+    end
+
+    def startVertex=(vertex)
+      case vertex
+      when Arango::Edge
+      when Arango::Document, Arango::Vertex
+        @vertex = vertex
+        @collection = @vertex.collection
+        @database = @collection.database
+        @graph  = @collection.graph
+        @server = @database.server
+        return
+      when String
+        if @database.nil?
+          raise Arango::Error.new err: :database_undefined_for_traversal
+        elsif vertex.include? "/"
+          val = vertex.split("/")
+          @collection = Arango::Collection.new(database: @database, name: val[0])
+          @vertex = Arango::Document.new(collection: @collection, name: val[1])
+          return
+        end
+      end
+      raise Arango::Error.new err: :wrong_start_vertex_type
+    end
+    alias vertex= startVertex=
+    alias return_vertex startVertex=
+
+    def edgeCollection=(collection)
+      return nil if collection.nil?
+      satisfy_class?(collection, [Arango::Collection, String])
+      case collection
+      when Arango::Collection
+        if collection.type != :edge
+          raise Arango::Error.new err: :edge_collection_should_be_of_type_edge
+        end
+        @edgeCollection = collection
+      when String
+        collection_instance = Arango::Collection.new(name: edgedef[:collection],
+          database: @database, type: :edge, graph: @graph)
+        @edgeCollection = collection_instance
+      end
+    end
+    alias return_edgeCollection edgeCollection=
+
+    alias vertex= startVertex=
+    alias vertex startVertex
+    alias max maxDepth
+    alias max= maxDepth=
+    alias min minDepth
+    alias min= minDepth=
+
+    def in
+      @direction = "inbound"
+    end
+
+    def out
+      @direction = "outbound"
+    end
+
+    def any
+      @direction = "any"
+    end
+
+  # === TO HASH ===
+
+    def to_h
+      {
+        "sort": @sort,
+        "direction": @direction,
+        "maxDepth": @maxDepth,
+        "minDepth": @minDepth,
+        "visitor": @visitor,
+        "itemOrder": @itemOrder,
+        "strategy": @strategy,
+        "filter": @filter,
+        "init": @init,
+        "maxiterations": @maxiterations,
+        "uniqueness": @uniqueness,
+        "order": @order,
+        "expander": @expander,
+        "vertices": @vertices&.map{|x| x.id},
+        "paths": @paths&.map do |x|
+          {
+            "edges": x[:edges]&.map{|e| e.id},
+            "vertices": x[:vertices]&.map{|v| v.id}
+          }
+        end,
+        "idCache": @idCache,
+        "startVertex": @vertex&.id,
+        "graph": @graph&.name,
+        "edgeCollection": @edgeCollection&.name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+  # === EXECUTE ===
+
+    def execute
+      body = {
+        "sort": @sort,
+        "direction": @direction,
+        "maxDepth": @maxDepth,
+        "minDepth": @minDepth,
+        "startVertex": @vertex&.id,
+        "visitor": @visitor,
+        "itemOrder": @itemOrder,
+        "strategy": @strategy,
+        "filter": @filter,
+        "init": @init,
+        "maxiterations": @maxiterations,
+        "uniqueness": @uniqueness,
+        "order": @order,
+        "graphName": @graph&.name,
+        "expander": @expander,
+        "edgeCollection": @edgeCollection&.name
+      }
+      result = @database.request("POST", "_api/traversal", body: body)
+      return result if @server.async != false
+      @vertices = result[:result][:visited][:vertices].map do |x|
+        collection = Arango::Collection.new(name: x[:_id].split("/")[0],
+          database:  @database)
+        Arango::Document.new(name: x[:_key], collection: collection, body: x)
+      end
+      @paths = result[:result][:visited][:paths].map do |x|
+        {
+          "edges": x[:edges].map do |e|
+            collection_edge = Arango::Collection.new(name: e[:_id].split("/")[0],
+              database:  @database, type: :edge)
+            Arango::Document.new(name: e[:_key], collection: collection_edge,
+              body: e, from: e[:_from], to: e[:_to])
+          end,
+          "vertices": x[:vertices].map do |v|
+            collection_vertex = Arango::Collection.new(name: v[:_id].split("/")[0],
+              database:  @database)
+            Arango::Document.new(name: v[:_key], collection: collection_vertex, body: v)
+          end
+        }
+      end
+      return return_directly?(result) ? result : self
+    end
+  end
+end

data/lib/User.rb

@@ -0,0 +1,197 @@
+# === USER ===
+
+module Arango
+  class User
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Server_Return
+
+    def self.new(*args)
+      hash = args[0]
+      super unless hash.is_a?(Hash)
+      database = hash[:database]
+      if database.is_a?(Arango::Database) && database.server.active_cache
+        cache_name = hash[:name]
+        cached = database.server.cache.cache.dig(:user, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = {}
+          [:password, :extra, :active].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(server:, password: "", name:, extra: {}, active: nil, cache_name: nil)
+      assign_server(server)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:user, cache_name, self)
+      end
+      @password = password
+      @name     = name
+      @extra    = extra
+      @active   = active
+    end
+
+# === DEFINE ===
+
+    attr_accessor :name, :extra, :active
+    attr_reader :server, :body, :cache_name
+    attr_writer :password
+    alias user name
+    alias user= name=
+
+    def body=(result)
+      @body   = result
+      @password = result[:password] || @password
+      @name   = result[:user]   || @name
+      @extra  = result[:extra]  || @extra
+      @active = result[:active].nil? ? @active : result[:active]
+      if @server.active_cache && @cache_name.nil?
+        @cache_name = @name
+        @server.cache.save(:user, @cache_name, self)
+      end
+    end
+    alias assign_attributes body=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "user": @name,
+        "extra": @extra,
+        "active": @active,
+        "cache_name": @cache_name,
+        "server": @server.base_uri
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def [](database)
+      if self.databases[database.to_sym] == "rw"
+        Arango::Database.new name: database, server: @server
+      else
+        "This User does not have access to Database #{database}."
+      end
+    end
+    alias database []
+
+  # == USER ACTION ==
+
+    def create(password: @password, active: @active, extra: @extra)
+      body = {
+        "user": @name,
+        "passwd": password,
+        "extra": extra,
+        "active": active
+      }
+      result = @server.request("POST", "_api/user", body: body)
+      return_element(result)
+    end
+
+    def retrieve
+      result = @server.request("GET", "_api/user/#{@name}", body: body)
+      return_element(result)
+    end
+
+    def replace(password: @password, active: @active, extra: @extra)
+      body = {
+        "passwd": password,
+        "active": active,
+        "extra": extra
+      }
+      result = @server.request("PUT", "_api/user/#{@name}", body: body)
+      @password = password
+      return_element(result)
+    end
+
+    def update(password: @password, active: @active, extra: @extra)
+      body = {
+        "passwd": password,
+        "active": active,
+        "extra": extra
+      }
+      result = @server.request("PATCH", "_api/user/#{@name}", body: body)
+      @password = password
+      return_element(result)
+    end
+
+    def destroy
+      result = @server.request("DELETE", "_api/user/#{@name}")
+      return return_directly?(result) ? result : true
+    end
+
+  # == ACCESS ==
+
+    def addDatabaseAccess(grant:, database:)
+      satisfy_category?(grant, ["rw", "ro", "none"])
+      satisfy_class?(database, [Arango::Database, String])
+      database = database.name if database.is_a?(Arango::Database)
+      body = {"grant": grant}
+      result = @server.request("PUT", "_api/user/#{@name}/database/#{database}",
+        body: body)
+      return return_directly?(result) ? result : result[database.to_sym]
+    end
+
+    def grant(database:)
+      addDatabaseAccess(grant: "rw", database: database)
+    end
+
+    def addCollectionAccess(grant:, database:, collection:)
+      satisfy_category?(grant, ["rw", "ro", "none"])
+      satisfy_class?(database, [Arango::Database, String])
+      satisfy_class?(collection, [Arango::Collection, String])
+      database = database.name     if database.is_a?(Arango::Database)
+      collection = collection.name if collection.is_a?(Arango::Collection)
+      body = {"grant": grant}
+      result = @server.request("PUT", "_api/user/#{@name}/database/#{database}/#{collection}",
+        body: body)
+      return return_directly?(result) ? result : result[:"#{database}/#{collection}"]
+    end
+
+    def revokeDatabaseAccess(database:)
+      satisfy_class?(database, [Arango::Database, String])
+      database = database.name if database.is_a?(Arango::Database)
+      result = @server.request("DELETE", "_api/user/#{@name}/database/#{database}")
+      return return_directly?(result) ? result : true
+    end
+    alias revoke revokeDatabaseAccess
+
+    def revokeCollectionAccess(database:, collection:)
+      satisfy_class?(database, [Arango::Database, String])
+      satisfy_class?(collection, [Arango::Collection, String])
+      database = database.name     if database.is_a?(Arango::Database)
+      collection = collection.name if collection.is_a?(Arango::Collection)
+      result = @server.request("DELETE", "_api/user/#{@name}/database/#{database}/#{collection}")
+      return return_directly?(result) ? result : true
+    end
+
+    def listAccess(full: nil)
+      query = {"full": full}
+      result = @server.request("GET", "_api/user/#{@name}/database", query: query)
+      return return_directly?(result) ? result : result[:result]
+    end
+    alias databases listAccess
+
+    def databaseAccess(database:)
+      satisfy_class?(database, [Arango::Database, String])
+      database = database.name if database.is_a?(Arango::Database)
+      result = @server.request("GET", "_api/user/#{@name}/database/#{database}")
+      return return_directly?(result) ? result : result[:result]
+    end
+
+    def collectionAccess(database:, collection:)
+      satisfy_class?(database, [Arango::Database, String])
+      satisfy_class?(collection, [Arango::Collection, String])
+      database = database.name     if database.is_a?(Arango::Database)
+      collection = collection.name if collection.is_a?(Arango::Collection)
+      result = @server.request("GET", "_api/user/#{@name}/database/#{database}/#{collection}",
+        body: body)
+      return return_directly?(result) ? result : result[:result]
+    end
+  end
+end

data/lib/Vertex.rb

@@ -0,0 +1,127 @@
+# === GRAPH VERTEX ===
+
+module Arango
+  class Vertex < Arango::Document
+    def initialize(name: nil, collection:, body: {}, rev: nil, cache_name: nil)
+      assign_collection(collection)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:document, cache_name, self)
+      end
+      body[:_key] ||= name
+      body[:_rev] ||= rev
+      body[:_id]  ||= "#{@collection.name}/#{name}" unless name.nil?
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_reader :collection, :database, :server, :graph
+
+    def collection=(collection)
+      satisfy_class?(collection, [Arango::Collection])
+      if collection.graph.nil?
+        raise Arango::Error.new err: :collection_does_not_have_a_graph, data:
+          {"name_collection": collection.name, "graph": nil}
+      end
+      @collection = collection
+      @graph = @collection.graph
+      @database = @collection.database
+      @server = @database.server
+    end
+    alias assign_collection collection=
+
+# == GET ==
+
+    def retrieve(if_match: false)
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("GET", "vertex/#{@collection.name}/#{@body[:_key]}",
+        headers: headers, key: :vertex)
+      return_element(result)
+    end
+
+# == POST ==
+
+    def create(body: {}, waitForSync: nil)
+      body = @body.merge(body)
+      query = {"waitForSync": waitForSync}
+      result = @graph.request("POST", "vertex/#{@collection.name}", body: body,
+        query: query, key: :vertex)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# == PUT ==
+
+    def replace(body: {}, waitForSync: nil, keepNull: nil, if_match: false)
+      query = {
+        "waitForSync": waitForSync,
+        "keepNull": keepNull
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PUT", "vertex/#{@collection.name}/#{@body[:_key]}",
+        body: body, query: query, headers: headers, key: :vertex)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+    def update(body: {}, waitForSync: nil, if_match: false, keepNull: nil)
+      query = {"waitForSync": waitForSync, "keepNull": keepNull}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PATCH", "vertex/#{@collection.name}/#{@body[:_key]}", body: body,
+        query: query, headers: headers, key: :vertex)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      body = @body.merge(body)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# === DELETE ===
+
+    def destroy(waitForSync: nil, if_match: false)
+      query = {"waitForSync": waitForSync}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("DELETE", "vertex/#{@collection.name}/#{@body[:_key]}",
+        query: query, headers: headers)
+      return_delete(result)
+    end
+
+# === TRAVERSAL ===
+
+    def traversal(body: {}, sort: nil, direction: nil, minDepth: nil,
+      visitor: nil, itemOrder: nil, strategy: nil,
+      filter: nil, init: nil, maxIterations: nil, maxDepth: nil,
+      uniqueness: nil, order: nil, expander: nil,
+      edgeCollection: nil)
+      Arango::Traversal.new(body: body,
+        sort: sort, direction: direction, minDepth: minDepth,
+        vertex: self, visitor: visitor,itemOrder: itemOrder,
+        strategy: strategy, filter: filter, init: init,
+        maxIterations: maxIterations, maxDepth: maxDepth,
+        uniqueness: uniqueness, order: order, 
+        expander: expander, edgeCollection: edgeCollection)
+    end
+
+# === WRONG ===
+
+    def from=(arg)
+      raise Arango::Error.new err: you_cannot_assign_from_or_to_to_a_vertex
+    end
+    alias to= from=
+    alias to from=
+    alias toR from=
+    alias fromR from=
+  end
+end

data/lib/View.rb

@@ -0,0 +1,151 @@
+# ==== DOCUMENT ====
+
+module Arango
+  class View
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Database_Return
+
+    def self.new(*args)
+      hash = args[0]
+      super unless hash.is_a?(Hash)
+      database = hash[:database]
+      if database.is_a?(Arango::Database) && database.server.active_cache && !hash[:id].nil?
+        cache_name = "#{database.name}/#{hash[:id]}"
+        cached = database.server.cache.cache.dig(:view, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = {}
+          [:type, :name].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(database:, type: "arangosearch", name:, id: nil, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:view, cache_name, self)
+      end
+      satisfy_category?(type, ["arangosearch"])
+      @type = type
+      @name = name
+      @links = {}
+      @id = id
+    end
+
+# === DEFINE ===
+
+    attr_reader :type, :links, :database, :cache_name
+    attr_accessor :id, :name
+
+    def type=(type)
+      satisfy_category?(type, ["arangosearch"])
+      @type = type
+    end
+    alias assign_type type=
+
+    def addLink(collection:, analyzers: nil, fields: {}, includeAllFields: nil, trackListPositions: nil, storeValues: nil)
+      satisfy_class?(collection, [Arango::Collection, String])
+      collection_name = collection.is_a?(String) ? collection : collection.name
+      satisfy_category?(storeValues, ["none", "id", nil])
+      @links[collection_name] = {
+        analyzers: analyzers,
+        fields: fields,
+        includeAllFields: includeAllFields,
+        trackListPositions: trackListPositions,
+        storeValues: storeValues
+      }
+      @links[collection_name].delete_if{|k,v| v.nil?}
+    end
+
+    def to_h
+      {
+        "name": @name,
+        "id": @id,
+        "type": @type,
+        "links": @links,
+        "cache_name": @cache_name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def body=(result)
+      @body  = result
+      @id    = result[:id] || @id
+      @type  = assign_type(result[:type] || @type)
+      @links = result[:links] || @links
+      @name  = result[:name] || name
+      if @server.active_cache && @cache_name.nil?
+        @cache_name = "#{@database.name}/#{@id}"
+        @server.cache.save(:task, @cache_name, self)
+      end
+    end
+    alias assign_attributes body=
+
+    # === COMMANDS ===
+
+    def retrieve
+      result = @database.request("GET", "_api/view/#{@name}")
+      return result.headers[:"x-arango-async-id"] if @server.async == :store
+      return_element(result)
+    end
+
+    def manage_properties(method, url, consolidationIntervalMsec: nil, threshold: nil, segmentThreshold: nil, cleanupIntervalStep: nil)
+      body = {
+        properties: {
+          links: @links.empty? ? nil : @links,
+          consolidationIntervalMsec: consolidationIntervalMsec,
+          consolidationPolicy: {
+            threshold: threshold,
+            segmentThreshold: segmentThreshold
+          },
+          cleanupIntervalStep: cleanupIntervalStep
+        }
+      }
+      if method == "POST"
+        body[:type] = @type
+        body[:name] = @name
+      end
+      body[:properties][:consolidationPolicy].delete_if{|k,v| v.nil?}
+      body[:properties].delete(:consolidationPolicy) if body[:properties][:consolidationPolicy].empty?
+      body[:properties].delete_if{|k,v| v.nil?}
+      body.delete(:properties) if body[:properties].empty?
+      body.delete_if{|k,v| v.nil?}
+      result = @database.request(method, url, body: body)
+      return_element(result)
+    end
+    private :manage_properties
+
+    def create(consolidationIntervalMsec: nil, threshold: nil, segmentThreshold: nil, cleanupIntervalStep: nil)
+      manage_properties("POST", "_api/view", consolidationIntervalMsec: consolidationIntervalMsec, threshold: threshold, segmentThreshold: segmentThreshold, cleanupIntervalStep: cleanupIntervalStep)
+    end
+
+    def replaceProperties(consolidationIntervalMsec: nil, threshold: nil, segmentThreshold: nil, cleanupIntervalStep: nil)
+      manage_properties("PUT", "_api/view/#{@name}/properties", consolidationIntervalMsec: consolidationIntervalMsec, threshold: threshold, segmentThreshold: segmentThreshold, cleanupIntervalStep: cleanupIntervalStep)
+    end
+
+    def updateProperties(consolidationIntervalMsec: nil, threshold: nil, segmentThreshold: nil, cleanupIntervalStep: nil)
+      manage_properties("PATCH", "_api/view/#{@name}/properties", consolidationIntervalMsec: consolidationIntervalMsec, threshold: threshold, segmentThreshold: segmentThreshold, cleanupIntervalStep: cleanupIntervalStep)
+    end
+
+    def rename name:
+      body = {name: name}
+      result = @database.request("PUT", "_api/view/#{@name}/rename", body: body)
+      return_element(result)
+    end
+
+    def properties
+      @database.request("GET", "_api/view/#{@name}/properties")
+    end
+
+    def destroy
+      @database.request("DELETE", "_api/view/#{@name}", key: :result)
+    end
+  end
+end