arango-driver 3.5.0.alpha0

data/lib/arango/task.rb

@@ -0,0 +1,223 @@
+# === TASK ===
+
+module Arango
+  class Task
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::DatabaseAssignment
+    include Arango::Helper::ServerAssignment
+
+    class << self
+      # Takes a hash and instantiates a Arango::Task object from it.
+      #
+      # @param task_hash [Hash]
+      # @return [Arango::Task]
+      def from_h(task_hash, server: nil)
+        raise Arango::Error.new(err: :no_task_id) unless task_hash.key?(:id)
+        task_hash = task_hash.transform_keys { |k| k.to_s.underscore.to_sym }
+        task_hash.merge!(server: server) if server
+        if task_hash[:database].class == String
+          task_hash[:database] = Arango::Database.new(task_hash[:database], server: server)
+        end
+        created = task_hash.delete(:created)
+        offset = task_hash.delete(:offset)
+        type = task_hash.delete(:type)
+        task = Arango::Task.new(task_hash.delete(:id), **task_hash)
+        task.instance_variable_set(:@created, created)
+        task.instance_variable_set(:@offset, offset)
+        task.instance_variable_set(:@type, type)
+        task
+      end
+
+      # Takes a Arango::Result and instantiates a Arango::Task object from it.
+      #
+      # @param arango_result [Arango::Result]
+      # @return [Arango::Task]
+      def from_result(arango_result, server: nil)
+        from_h(arango_result.to_h, server: server)
+      end
+
+      # Delete a task from the server or from a database.
+      #
+      # @param id [String] The id of the Task
+      # @param database [Arango::Database] A database, optional if server is given.
+      # @param server [Arango::Server] Server, optional if database is given.
+      # @return [Arango::Task]
+      def drop(id, database: nil, server: Arango.current_server)
+        if database
+          database.request(delete: "_api/tasks/#{id}")
+        elsif server
+          server.request(delete: "_api/tasks/#{id}")
+        end
+        nil
+      end
+      alias delete drop
+      alias destroy drop
+
+      # Gets a task from the server or from a database.
+      #
+      # @param id [String] The id of the Task
+      # @param database [Arango::Database] A database, optional if server is given.
+      # @param server [Arango::Server] Server, optional if database is given.
+      # @return [Arango::Task]
+      def get(id, database: nil, server: Arango.current_server)
+        if database
+          result = database.request(get: "_api/tasks/#{id}")
+          server = database.arango_server
+        elsif server
+          result = server.request(get: "_api/tasks/#{id}")
+        end
+        Arango::Task.from_result(result, server: server)
+      end
+      alias fetch get
+      alias retrieve get
+
+      # Get all tasks from a server or from a database
+      #
+      # @param database [Arango::Database] A database, optional if server is given.
+      # @param server [Arango::Server] Server, optional if database is given.
+      # @return [Array<Arango::Task>]
+      def all(database: nil, server: Arango.current_server)
+        if database
+          result = database.request(get: "_api/tasks")
+          server = database.arango_server
+        elsif server
+          result = server.request(get: "_api/tasks")
+        end
+        result.map { |task| Arango::Task.from_h(task, server: server) }
+      end
+
+      # List all tasks ids from a server or from a database
+      #
+      # @param database [Arango::Database] A database, optional if server is given.
+      # @param server [Arango::Server] Server, optional if database is given.
+      # @return [Array<String>]
+      def list(database: nil, server: Arango.current_server)
+        if database
+          result = database.request(get: '_api/tasks')
+        elsif server
+          result = server.request(get: '_api/tasks')
+        end
+        result.map { |task| task[:id] }
+      end
+
+      def exist?(id, database: nil, server: Arango.current_server)
+        result = list(database: database, server: server)
+        result.include?(id)
+      end
+    end
+
+    # Access the javascript code of the task.
+    # @return [String] The javascript code as string.
+    attr_accessor :command
+    alias javascript_command command
+    alias javascript_command= command=
+
+    # The Task id.
+    # @return [String]
+    attr_accessor :id
+
+    # The Task name.
+    # @return [String] or nil
+    attr_accessor :name
+
+    # The number of seconds initial delay.
+    # @return [Integer] or nil
+    attr_accessor :offset
+
+    # Hash of params to pass to the command
+    # # @return [Hash] or nil
+    attr_accessor :params
+
+    # Number of seconds between executions.
+    # @return [Integer] or nil
+    attr_accessor :period
+
+    # Time this task has been created at, timestamp.
+    # return [BigDecimal]
+    attr_reader :created
+
+    # Database the task belongs to
+    # return [Arango::Database] or nil
+    attr_reader :database
+
+    # Server the Task belongs to.
+    # return [Arango::Server]
+    attr_reader :server
+
+    # Task type.
+    # return [Symbol] Either :periodic or :timed.
+    attr_reader :type
+
+    # Instantiate a new task.
+    #
+    # @param command [String] The javascript code to execute, optional.
+    # @param name [String] The task name, optional.
+    # @param offset [Integer] The number of seconds initial delay, optional.
+    # @param params [Hash] Hash of params to pass to the command, optional.
+    # @param period [Integer] Number of seconds between executions, optional.
+    # @return [Arango::Task]
+    def initialize(id = nil, command: nil, name: nil, offset: nil, params: nil, period: nil, database: nil, server: Arango.current_server)
+      if database
+        assign_database(database)
+        @requester = @database
+      elsif server
+        assign_server(server)
+        @requester = @server
+      end
+      @id = id
+      @command = command
+      @name = name
+      @offset = offset
+      @params = params
+      @period = period
+    end
+
+    # Convert the Task to a Hash
+    # @return [Hash]
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        type: @type,
+        period: @period,
+        command: @command,
+        params: @params,
+        created: @created,
+        cache_name: @cache_name,
+        database: @database ? @database.name : nil
+      }.delete_if{|_,v| v.nil?}
+    end
+
+    # Create the task in the database.
+    # return [Arango::Task] Returns the task.
+    def create
+      body = {
+        name: @name,
+        command: @command,
+        period: @period,
+        offset: @offset,
+        params: @params,
+        database: @database ? @database.name : nil
+      }
+      if @id
+        result = @requester.request(put: "_api/tasks/#{@id}", body: body)
+      else
+        result = @requester.request(post: "_api/tasks", body: body)
+        @id = result.id
+      end
+      @type = result.type.to_sym
+      @created = result.created
+      @name = result.name
+      self
+    end
+
+    # Remove the task from the database.
+    # return nil.
+    def drop
+      @requester.request(delete: "_api/tasks/#{@id}")
+      nil
+    end
+    alias delete drop
+    alias destroy drop
+  end
+end

data/lib/arango/transaction.rb

@@ -0,0 +1,113 @@
+# === TRANSACTION ===
+
+module Arango
+  class Transaction
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::DatabaseAssignment
+
+    def initialize(action:, database:, intermediate_commit_size: nil, intermediate_commit_count: nil, lock_timeout: nil, max_transaction_size: nil,
+                   params: nil, read: [], wait_for_sync: nil, write: [])
+      assign_database(database)
+      @action = action
+      @intermediate_commit_count = intermediate_commit_count
+      @intermediate_commit_size   = intermediate_commit_size
+      @lock_timeout             = lock_timeout
+      @max_transaction_size      = max_transaction_size
+      @params = params
+      @read   = return_write_or_read(read)
+      @result = nil
+      @wait_for_sync             = wait_for_sync
+      @write  = return_write_or_read(write)
+    end
+
+# === DEFINE ===
+
+    attr_reader :database, :read, :result, :server, :write
+    attr_accessor :action, :intermediate_commit_count, :intermediate_commit_size, :lock_timeout, :max_transaction_size, :params, :wait_for_sync
+
+    def write=(write)
+      @write = return_write_or_read(write)
+    end
+
+    def add_write(write)
+      write = return_write_or_read(write)
+      @write ||= []
+      @write << write
+    end
+
+    def read=(read)
+      @read = return_write_or_read(read)
+    end
+
+    def add_read(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,
+        database: @database.name,
+        params: @params,
+        read: @read.map{|x| x.name},
+        result: @result,
+        write: @write.map{|x| x.name}
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === EXECUTE ===
+
+    def execute(action: @action, params: @params,
+      max_transaction_size: @max_transaction_size,
+      lock_timeout: @lock_timeout, wait_for_sync: @wait_for_sync,
+      intermediate_commit_count: @intermediate_commit_count,
+      intermediate_commit_size: @intermediate_commit_size)
+      body = {
+        collections: {
+          read: @read.map{|x| x.name},
+          write: @write.map{|x| x.name}
+        },
+        action: action,
+        intermediate_commit_size: intermediate_commit_size,
+        intermediateCommitCount: intermediate_commit_count,
+        lockTimeout: lock_timeout,
+        maxTransactionSize: max_transaction_size,
+        params: params,
+        waitForSync: wait_for_sync
+      }
+      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/arango/traversal.rb

@@ -0,0 +1,212 @@
+# === TRAVERSAL ===
+
+module Arango
+  class Traversal
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::DatabaseAssignment
+
+    def initialize(body: {}, direction: nil, edge_collection: nil, expander: nil, filter: nil, init: nil, item_order: nil, max_depth: nil,
+                   max_iterations: nil, min_depth: nil, order: nil, sort: nil, strategy: nil, uniqueness: nil, vertex:, visitor: nil)
+      satisfy_category?(direction, ["outbound", "inbound", "any", nil])
+      satisfy_category?(item_order, ["forward", "backward", nil])
+      satisfy_category?(order, ["preorder", "postorder", "preorder-expander", nil])
+      satisfy_category?(strategy, ["depthfirst", "breadthfirst", nil])
+      body[:direction]       ||= direction
+      body[:edge_collection] ||= edge_collection
+      body[:expander]        ||= expander
+      body[:filter]          ||= filter
+      body[:init]            ||= init
+      body[:item_order]      ||= item_order
+      body[:max_depth]       ||= max_depth
+      body[:max_iterations]  ||= max_iterations
+      body[:min_depth]       ||= min_depth
+      body[:order]           ||= order
+      body[:sort]            ||= sort
+      body[:startVertex]     ||= vertex
+      body[:strategy]        ||= strategy
+      body[:uniqueness]      ||= uniqueness
+      body[:visitor]         ||= visitor
+      assign_body(body)
+      @vertices = nil
+      @paths = nil
+    end
+
+# === DEFINE ===
+
+    attr_accessor :expander, :filter, :init, :max_depth, :max_iterations, :min_depth, :sort, :uniqueness, :visitor
+    attr_reader :body, :collection, :database, :direction, :edge_collection, :graph, :item_order, :order, :paths, :server, :strategy,
+                :vertex, :vertices
+    alias start_vertex vertex
+
+    def body=(body)
+      @body = body
+      @direction      = body[:direction] || @direction
+      @expander       = body[:expander] || @expander
+      @filter         = body[:filter] || @filter
+      @init           = body[:init] || @init
+      @item_order     = body[:item_order] || @item_order
+      @max_depth      = body[:maxDepth] || @max_depth
+      @max_iterations = body[:max_iterations] || @max_iterations
+      @min_depth      = body[:min_depth] || @min_depth
+      @order          = body[:order] || @order
+      @sort           = body[:sort] || @sort
+      @strategy       = body[:strategy] || @strategy
+      @uniqueness     = body[:uniqueness] || @uniqueness
+      @visitor       = body[:visitor] || @visitor
+      send(:edge_collection=, body[:edge_collection] || @edge_collection)
+      send(:start_vertex=, body[:startVertex] || @vertex)
+    end
+    alias assign_body body=
+
+    def direction=(direction)
+      satisfy_category?(direction, ["outbound", "inbound", "any", nil])
+      @direction = direction
+    end
+
+    def item_order=(itemOrder)
+      satisfy_category?(itemOrder, ["forward", "backward", nil])
+      @item_order = 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 start_vertex=(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= start_vertex=
+
+    def edge_collection=(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
+        @edge_collection = collection
+      when String
+        collection_instance = Arango::Collection.new(name:     collection,
+                                                     database: @database, type: :edge, graph: @graph)
+        @edge_collection = collection_instance
+      end
+    end
+
+    def in
+      @direction = "inbound"
+    end
+
+    def out
+      @direction = "outbound"
+    end
+
+    def any
+      @direction = "any"
+    end
+
+  # === TO HASH ===
+
+    def to_h
+      {
+        database: @database.name,
+        direction: @direction,
+        edgeCollection: @edge_collection&.name,
+        expander: @expander,
+        filter: @filter,
+        graph: @graph&.name,
+        idCache: @id_cache,
+        init: @init,
+        itemOrder: @item_order,
+        maxDepth: @max_depth,
+        maxiterations: @max_iterations,
+        minDepth: @min_depth,
+        order: @order,
+        paths: @paths&.map do |x|
+          {
+            edges: x[:edges]&.map{|e| e.id},
+            vertices: x[:vertices]&.map{|v| v.id}
+          }
+        end,
+        sort: @sort,
+        startVertex: @vertex&.id,
+        strategy: @strategy,
+        uniqueness: @uniqueness,
+        vertices: @vertices&.map{|x| x.id},
+        visitor: @visitor
+      }.delete_if{|k,v| v.nil?}
+    end
+
+  # === EXECUTE ===
+
+    def execute
+      body = {
+        direction: @direction,
+        edgeCollection: @edge_collection&.name,
+        expander: @expander,
+        filter: @filter,
+        graphName: @graph&.name,
+        init: @init,
+        itemOrder: @item_order,
+        maxDepth: @max_depth,
+        maxiterations: @max_iterations,
+        minDepth: @min_depth,
+        order: @order,
+        sort: @sort,
+        startVertex: @vertex&.id,
+        strategy: @strategy,
+        uniqueness: @uniqueness,
+        visitor: @visitor
+      }
+      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