arangorb 1.4.1 → 2.0.0

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