arangorb 1.4.1 → 2.0.0

data/lib/Task.rb

@@ -0,0 +1,120 @@
+# === TASK ===
+
+module Arango
+  class Task
+    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(:task, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:name, :type, :period, :command, :params, :created].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+        end
+      end
+      super
+    end
+
+    def initialize(id: nil, name: nil, type: nil, period: nil, command: nil,
+      params: nil, created: nil, body: {}, database:, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:task, cache_name, self)
+      end
+      [:id, :name, :type, :period, :command, :params, :created].each do |k|
+        body[k] ||= binding.local_variable_get(k)
+      end
+      assign_attributes(body)
+    end
+
+ # === DEFINE ===
+
+    attr_reader :server, :body, :database, :cache_name
+    attr_accessor :id, :name, :type, :period, :created,
+      :command, :params, :offset
+
+    def body=(result)
+      @body    = result
+      @id      = result[:id]      || @id
+      @name    = result[:name]    || @name
+      @type    = result[:type]    || @type
+      @period  = result[:period]  || @period
+      @command = result[:command] || @command
+      @params  = result[:params]  || @params
+      @offset  = result[:offset]  || @offset
+      @created = result[:created] || @created
+      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=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "id": @id,
+        "name": @name,
+        "type": @type,
+        "period": @period,
+        "command": @command,
+        "params": @params,
+        "created": @created,
+        "cache_name": @cache_name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# == RETRIEVE
+
+    def retrieve
+      result = @database.request("GET", "_api/tasks/#{@id}")
+      return return_element(result)
+    end
+
+    def create(command: @command, period: @period, offset: @offset, params: @params)
+      body = {
+        "id": @id,
+        "name": @name,
+        "command": command,
+        "period": period,
+        "offset": offset,
+        "params": params,
+        "database": @database.name
+      }
+      result = @database.request("POST", "_api/tasks", body: body)
+      return return_element(result)
+    end
+
+    def update(command: @command, period: @period, offset: @offset,
+      params: @params)
+      body = {
+        "id": @id,
+        "name": @name,
+        "command": command,
+        "period": period,
+        "offset": offset,
+        "params": params
+      }
+      result = @database.request("PUT", "_api/tasks/#{@id}", body: body)
+      return return_element(result)
+    end
+
+    def destroy
+      result = @server.request("DELETE", "_api/tasks/#{@id}")
+      return return_directly?(result) ? result : true
+    end
+  end
+end

data/lib/Transaction.rb

@@ -0,0 +1,115 @@
+  # === TRANSACTION ===
+
+module Arango
+  class Transaction
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Database_Return
+
+    def initialize(database:, action:, write: [], read: [], params: nil,
+      maxTransactionSize: nil, lockTimeout: nil, waitForSync: nil, intermediateCommitCount: nil, intermedateCommitSize: nil)
+      assign_database(database)
+      @action = action
+      @write  = return_write_or_read(write)
+      @read   = return_write_or_read(read)
+      @params = params
+      @maxTransactionSize      = maxTransactionSize
+      @lockTimeout             = lockTimeout
+      @waitForSync             = waitForSync
+      @intermediateCommitCount = intermediateCommitCount
+      @intermedateCommitSize   = intermedateCommitSize
+      @result = nil
+    end
+
+# === DEFINE ===
+
+    attr_reader :read, :write, :result, :server, :database
+    attr_accessor :action, :params, :maxTransactionSize,
+      :lockTimeout, :waitForSync, :intermediateCommitCount,
+      :intermedateCommitSize
+
+    def write=(write)
+      @write = return_write_or_read(write)
+    end
+
+    def addWrite(write)
+      write = return_write_or_read(write)
+      @write ||= []
+      @write << write
+    end
+
+    def read=(read)
+      @read = return_write_or_read(read)
+    end
+
+    def addRead(read)
+      read = return_write_or_read(read)
+      @read ||= []
+      @read << read
+    end
+
+    def return_write_or_read(value)
+      case value
+      when Array
+        return value.map{|x| return_collection(x)}
+      when String, Arango::Collection
+        return [return_collection(value)]
+      when NilClass
+        return []
+      else
+        raise Arango::Error.new err: :read_or_write_should_be_string_or_collections, data: {"wrong_value": value, "wrong_class": value.class}
+      end
+    end
+    private :return_write_or_read
+
+    def return_collection(collection, type=nil)
+      satisfy_class?(collection, [Arango::Collection, String])
+      case collection
+      when Arango::Collection
+        return collection
+      when String
+        return Arango::Collection.new(name: collection, database: @database)
+      end
+    end
+    private :return_collection
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "action": @action,
+        "result": @result,
+        "params": @params,
+        "read": @read.map{|x| x.name},
+        "write": @write.map{|x| x.name},
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === EXECUTE ===
+
+    def execute(action: @action, params: @params,
+      maxTransactionSize: @maxTransactionSize,
+      lockTimeout: @lockTimeout, waitForSync: @waitForSync,
+      intermediateCommitCount: @intermediateCommitCount,
+      intermedateCommitSize: @intermedateCommitSize)
+      body = {
+        "collections": {
+          "read": @read.map{|x| x.name},
+          "write": @write.map{|x| x.name}
+        },
+        "action": action,
+        "params": params,
+        "lockTimeout": lockTimeout,
+        "waitForSync": waitForSync,
+        "maxTransactionSize": maxTransactionSize,
+        "intermediateCommitCount": intermediateCommitCount,
+        "intermedateCommitSize": intermedateCommitSize
+      }
+      result = @database.request("POST", "_api/transaction", body: body)
+      return result if @server.async != false
+      @result = result[:result]
+      return return_directly?(result) ? result : result[:result]
+    end
+  end
+end

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