arangorb3 0.0.10

data/lib/Foxx.rb

@@ -0,0 +1,277 @@
+# === FOXX ===
+
+module Arango
+  class Foxx
+    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[:mount].nil?
+        cache_name = "#{database.name}/#{hash[:mount]}"
+        cached = database.server.cache.cache.dig(:foxx, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:mount, :development, :legacy, :provides, :name, :version,
+            :type, :setup, :teardown].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(database:, body: {}, mount:, development: nil, legacy: nil,
+      provides: nil, name: nil, version: nil, type: "application/json",
+      setup: nil, teardown: nil, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:foxx, cache_name, self)
+      end
+      assign_attributes(body)
+      assign_type(type)
+      @mount       ||= mount
+      @development ||= development
+      @setup       ||= setup
+      @legacy      ||= legacy
+      @provides    ||= provides
+      @name        ||= name
+      @version     ||= version
+      @teardown    ||= teardown
+    end
+
+# === DEFINE ===
+
+    attr_reader :database, :server, :type, :body, :cache_name
+    attr_accessor :name, :development, :legacy, :provides,
+      :version, :mount, :setup, :teardown
+
+    def body=(result)
+      if result.is_a?(Hash)
+        @body        = result
+        @name        = result[:name]        || @name
+        @version     = result[:version]     || @version
+        @mount       = result[:mount]       || @mount
+        @development = result[:development] || @development
+        @legacy      = result[:legacy]      || @legacy
+        @provides    = result[:provides]    || @provides
+        if @server.active_cache && @cache_name.nil?
+          @cache_name = "#{@database.name}/#{@mount}"
+          @server.cache.save(:task, @cache_name, self)
+        end
+      end
+    end
+    alias assign_attributes body=
+
+    def type=(type)
+      satisfy_category?(type, ["application/zip", "zip", "application/javascript", "javascript", "application/json", "json", "multipart/form-data", "data"], "type")
+      type = "application/#{type}" if ["zip", "javascript", "json"].include?(type)
+      type = "multipart/form-data" if type == "data"
+      @type = type
+    end
+    alias assign_type type=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "name": @name,
+        "version": @version,
+        "mount": @mount,
+        "development": @development,
+        "legacy": @legacy,
+        "provides": @provides,
+        "type": @type,
+        "teardown": @teardown,
+        "cache_name": @cache_name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def return_foxx(result, val=nil)
+      return result if @server.async != false
+      case val
+      when :configuration
+        @configuration = result
+      when :dependencies
+        @dependencies = result
+      else
+        assign_attributes(result)
+      end
+      return return_directly?(result) ? result : self
+    end
+    private :return_foxx
+
+  # === ACTIONS ===
+
+    def retrieve
+      query = {"mount": @mount}
+      result = @database.request("GET", url: "_api/foxx/service")
+      return_foxx(result)
+    end
+
+    def create(body: @body, type: @type, development: @development,
+      setup: @setup, legacy: @legacy)
+      headers = {"Accept": type}
+      skip_to_json = type != "application/json"
+      query = {
+        "mount":        @mount,
+        "setup":        setup,
+        "development ": development ,
+        "legacy":       legacy
+      }
+      result = @database.request("POST",
+        url: "_api/foxx", body: body, headers: headers,
+        skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def destroy(teardown: @teardown)
+      query = {
+        "mount":    @mount,
+        "teardown": teardown
+      }
+      result = @database.request("DELETE", "_api/foxx/service", query: query)
+      return_foxx(result)
+    end
+
+    def replace(body: @body, type: @type, teardown: @teardown, setup: @setup,
+      legacy: @legacy)
+      headers = {"Accept": type}
+      skip_to_json = type != "application/json"
+      query = {
+        "mount": @mount,
+        "setup": setup,
+        "development ": development,
+        "legacy": legacy
+      }
+      result = @database.request("PUT", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def update(body: @body, type: @type, teardown: @teardown,
+      setup: @setup, legacy: @legacy)
+      assign_type(type)
+      headers = {"Accept": type}
+      skip_to_json = @type != "application/json"
+      query = {
+        "mount":        @mount,
+        "setup":        setup,
+        "development ": development,
+        "legacy":       legacy
+      }
+      result = @database.request("PATCH", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+  # === CONFIGURATION ===
+
+    def retrieveConfiguration
+      query = {"mount": @mount}
+      result = @database.request("GET", "_api/foxx/configuration", query: query)
+      return_foxx(result, :configuration)
+    end
+
+    def updateConfiguration(body:)
+      query = {"mount": @mount}
+      result = @database.request("PATCH", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    def replaceConfiguration(body:)
+      query = {"mount": @mount}
+      result = @database.request("PUT", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    # === DEPENDENCY ===
+
+    def retrieveDependencies
+      query = {"mount": @mount}
+      result = @database.request("GET", "_api/foxx/dependencies", query: query)
+      return_foxx(result, :dependencies)
+    end
+
+    def updateDependencies(body:)
+      query = {"mount": @mount}
+      result = @database.request("PATCH", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    def replaceDependencies(body:)
+      query = {"mount": @mount}
+      result = @database.request("PUT", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    # === MISCELLANEOUS
+
+    def scripts
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/scripts", query: query)
+    end
+
+    def run_script(name:, body: {})
+      query = {"mount": @mount}
+      @database.request("POST", "_api/foxx/scripts/#{name}", query: query, body: body)
+    end
+
+    def tests(reporter: nil, idiomatic: nil)
+      satisfy_category?(reporter, [nil, "default", "suite", "stream", "xunit", "tap"])
+      headers = {}
+      headers[:"Content-Type"] = case reporter
+      when "stream"
+        "application/x-ldjson"
+      when "tap"
+        "text/plain, text/*"
+      when "xunit"
+        "application/xml, text/xml"
+      else
+        nil
+      end
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/scripts", query: query, headers: headers)
+    end
+
+    def enableDevelopment
+      query = {"mount": @mount}
+      @database.request("POST", "_api/foxx/development", query: query)
+    end
+
+    def disableDevelopment
+      query = {"mount": @mount}
+      @database.request("DELETE", "_api/foxx/development", query: query)
+    end
+
+    def readme
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/readme", query: query)
+    end
+
+    def swagger
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/swagger", query: query)
+    end
+
+    def download(path:, warning: @server.warning)
+      query = {"mount": @mount}
+      @server.download("POST", "_db/#{@database.name}/_api/foxx/download",
+        path: path, query: query)
+      puts "File saved in #{path}" if warning
+    end
+
+    def commit(body:, replace: nil)
+      query = {"replace": replace}
+      @database.request("POST", "_api/foxx/commit", body: body, query: query)
+    end
+  end
+end

data/lib/Graph.rb

@@ -0,0 +1,325 @@
+# === GRAPH ===
+
+module Arango
+  class Graph
+    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
+        cache_name = "#{database.name}/#{hash[:name]}"
+        cached = database.server.cache.cache.dig(:graph, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:isSmart, :edgeDefinitions, :orphanCollections, :numberOfShards,
+            :replicationFactor, :smartGraphAttribute].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(name:, database:, edgeDefinitions: [],
+      orphanCollections: [], body: {}, numberOfShards: nil, isSmart: nil,
+      smartGraphAtttribute: nil, replicationFactor: nil, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:graph, cache_name, self)
+      end
+      body[:_key]    ||= name
+      body[:_id]     ||= "_graphs/#{name}"
+      body[:isSmart] ||= isSmart
+      body[:edgeDefinitions]     ||= edgeDefinitions
+      body[:orphanCollections]   ||= orphanCollections
+      body[:numberOfShards]      ||= numberOfShards
+      body[:replicationFactor]   ||= replicationFactor
+      body[:smartGraphAttribute] ||= smartGraphAttribute
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_reader :name, :database, :server, :id, :body, :rev, :isSmart, :cache_name
+    attr_accessor :numberOfShards, :replicationFactor, :smartGraphAttribute
+    alias key name
+
+    def body=(result)
+      @body = result
+      assign_edgeDefinitions(result[:edgeDefinitions] || @edgeDefinitions)
+      assign_orphanCollections(result[:orphanCollections] || @orphanCollections)
+      @name    = result[:_key]    || @name
+      @id      = result[:_id]     || @id
+      @id      = "_graphs/#{@name}" if @id.nil? && !@name.nil?
+      @rev     = result[:_rev]    || @rev
+      @isSmart = result[:isSmart] || @isSmart
+      @numberOfShards = result[:numberOfShards] || @numberOfShards
+      @replicationFactor = result[:replicationFactor] || @replicationFactor
+      @smartGraphAttribute = result[:smartGraphAttribute] || @smartGraphAttribute
+      if @server.active_cache && @cache_name.nil?
+        @cache_name = "#{@database.name}/#{@name}"
+        @server.cache.save(:graph, @cache_name, self)
+      end
+    end
+    alias assign_attributes body=
+
+    def name=(name)
+      @name = name
+      @id = "_graphs/#{@name}"
+    end
+
+    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, type: type, graph: self)
+      end
+    end
+
+    def edgeDefinitionsRaw
+      @edgeDefinitions ||= []
+      @edgeDefinitions.map do |edgedef|
+        {
+          "collection": edgedef[:collection].name,
+          "from": edgedef[:from].map{|t| t.name},
+          "to": edgedef[:to].map{|t| t.name}
+        }
+      end
+    end
+    private :edgeDefinitionsRaw
+
+    def edgeDefinitions(raw=false)
+      return edgeDefinitionsRaw if raw
+      return @edgeDefinitions
+    end
+
+    def edgeDefinitions=(edgeDefinitions)
+      @edgeDefinitions = []
+      edgeDefinitions ||= []
+      edgeDefinitions = [edgeDefinitions] unless edgeDefinitions.is_a?(Array)
+      edgeDefinitions.each do |edgeDefinition|
+        hash = {}
+        hash[:collection] = return_collection(edgeDefinition[:collection], :edge)
+        edgeDefinition[:from] ||= []
+        edgeDefinition[:to]   ||= []
+        hash[:from] = edgeDefinition[:from].map{|t| return_collection(t)}
+        hash[:to]   = edgeDefinition[:to].map{|t| return_collection(t)}
+        setup_orphaCollection_after_adding_edge_definitions(hash)
+        @edgeDefinitions << hash
+      end
+    end
+    alias assign_edgeDefinitions edgeDefinitions=
+
+    def orphanCollections=(orphanCollections)
+      orphanCollections ||= []
+      orphanCollections = [orphanCollections] unless orphanCollections.is_a?(Array)
+      @orphanCollections = orphanCollections.map{|oc| add_orphan_collection(oc)}
+    end
+    alias assign_orphanCollections orphanCollections=
+
+    def orphanCollectionsRaw
+      @orphanCollections ||= []
+      @orphanCollections.map{|oc| oc.name}
+    end
+    private :orphanCollectionsRaw
+
+    def orphanCollections(raw=false)
+      return orphanCollectionsRaw if raw
+      return @orphanCollections
+    end
+
+# === HANDLE ORPHAN COLLECTION ===
+
+    def add_orphan_collection(orphanCollection)
+      orphanCollection = return_collection(orphanCollection)
+      if @edgeDefinitions.any? do |ed|
+          names = []
+          names |= ed[:from].map{|f| f&.name}
+          names |= ed[:to].map{|t| t&.name}
+          names.include?(orphanCollection.name)
+        end
+        raise Arango::Error.new err: :orphan_collection_used_by_edge_definition, data: {"collection": orphanCollection.name}
+      end
+      return orphanCollection
+    end
+    private :add_orphan_collection
+
+    def setup_orphaCollection_after_adding_edge_definitions(edgeDefinition)
+      collection = []
+      collection |= edgeDefinition[:from]
+      collection |= edgeDefinition[:to]
+      @orphanCollections.delete_if{|c| collection.include?(c.name)}
+    end
+    private :setup_orphaCollection_after_adding_edge_definitions
+
+    def setup_orphaCollection_after_removing_edge_definitions(edgeDefinition)
+      edgeCollection = edgeDefinition[:collection].name
+      collections |= []
+      collections |= edgeDefinition[:from]
+      collections |= edgeDefinition[:to]
+      collections.each do |collection|
+        unless @edgeDefinitions.any? do |ed|
+            if ed[:collection].name != edgeCollection
+              names = []
+              names |= ed[:from].map{|f| f&.name}
+              names |= ed[:to].map{|t| t&.name}
+              names.include?(collection.name)
+            else
+              false
+            end
+          end
+          unless @orphanCollections.map{|oc| oc.name}.include?(collection.name)
+            @orphanCollections << collection
+          end
+        end
+      end
+    end
+    private :setup_orphaCollection_after_removing_edge_definitions
+
+# === REQUEST ===
+
+    def request(action, url, body: {}, headers: {}, query: {}, key: nil, return_direct_result: false, skip_to_json: false)
+      url = "_api/gharial/#{@name}/#{url}"
+      @database.request(action, url, body: body, headers: headers,
+        query: query, key: key, return_direct_result: return_direct_result,
+        skip_to_json: skip_to_json)
+    end
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "name": @name,
+        "id": @id,
+        "rev": @rev,
+        "isSmart": @isSmart,
+        "numberOfShards": @numberOfShards,
+        "replicationFactor": @replicationFactor,
+        "smartGraphAttribute": @smartGraphAttribute,
+        "edgeDefinitions": edgeDefinitionsRaw,
+        "orphanCollections": orphanCollectionsRaw,
+        "cache_name": @cache_name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === GET ===
+
+    def retrieve
+      result = @database.request("GET", "_api/gharial/#{@name}", key: :graph)
+      return_element(result)
+    end
+
+# === POST ===
+
+    def create(isSmart: @isSmart, smartGraphAttribute: @smartGraphAttribute,
+      numberOfShards: @numberOfShards)
+      body = {
+        "name": @name,
+        "edgeDefinitions":   edgeDefinitionsRaw,
+        "orphanCollections": orphanCollectionsRaw,
+        "isSmart": isSmart,
+        "options": {
+          "smartGraphAttribute": smartGraphAttribute,
+          "numberOfShards": numberOfShards
+        }
+      }
+      body[:options].delete_if{|k,v| v.nil?}
+      body.delete(:options) if body[:options].empty?
+      result = @database.request("POST", "_api/gharial", body: body, key: :graph)
+      return_element(result)
+    end
+
+# === DELETE ===
+
+    def destroy(dropCollections: nil)
+      query = { "dropCollections": dropCollections }
+      result = @database.request("DELETE", "_api/gharial/#{@name}", query: query,
+        key: :removed)
+      return_delete(result)
+    end
+
+# === VERTEX COLLECTION  ===
+
+    def getVertexCollections
+      result = request("GET", "vertex", key: :collections)
+      return result if return_directly?(result)
+      result.map do |x|
+        Arango::Collection.new(name: x, database: @database, graph: self)
+      end
+    end
+    alias vertexCollections getVertexCollections
+
+    def addVertexCollection(collection:)
+      satisfy_class?(collection, [String, Arango::Collection])
+      collection = collection.is_a?(String) ? collection : collection.name
+      body = { "collection": collection }
+      result = request("POST", "vertex", body: body, key: :graph)
+      return_element(result)
+    end
+
+    def removeVertexCollection(collection:, dropCollection: nil)
+      query = {"dropCollection": dropCollection}
+      satisfy_class?(collection, [String, Arango::Collection])
+      collection = collection.is_a?(String) ? collection : collection.name
+      result = request("DELETE", "vertex/#{collection}", query: query, key: :graph)
+      return_element(result)
+    end
+
+  # === EDGE COLLECTION ===
+
+    def getEdgeCollections
+      result = request("GET", "edge", key: :collections)
+      return result if @database.server.async != false
+      return result if return_directly?(result)
+      result.map{|r| Arango::Collection.new(database: @database, name: r, type: :edge)}
+    end
+
+    def addEdgeDefinition(collection:, from:, to:)
+      satisfy_class?(collection, [String, Arango::Collection])
+      satisfy_class?(from, [String, Arango::Collection], true)
+      satisfy_class?(to, [String, Arango::Collection], true)
+      from = [from] unless from.is_a?(Array)
+      to = [to] unless to.is_a?(Array)
+      body = {}
+      body[:collection] = collection.is_a?(String) ? collection : collection.name
+      body[:from] = from.map{|f| f.is_a?(String) ? f : f.name }
+      body[:to] = to.map{|t| t.is_a?(String) ? t : t.name }
+      result = request("POST", "edge", body: body, key: :graph)
+      return_element(result)
+    end
+
+    def replaceEdgeDefinition(collection:, from:, to:)
+      satisfy_class?(collection, [String, Arango::Collection])
+      satisfy_class?(from, [String, Arango::Collection], true)
+      satisfy_class?(to, [String, Arango::Collection], true)
+      from = [from] unless from.is_a?(Array)
+      to = [to] unless to.is_a?(Array)
+      body = {}
+      body[:collection] = collection.is_a?(String) ? collection : collection.name
+      body[:from] = from.map{|f| f.is_a?(String) ? f : f.name }
+      body[:to] = to.map{|t| t.is_a?(String) ? t : t.name }
+      result = request("PUT", "edge/#{body[:collection]}", body: body, key: :graph)
+      return_element(result)
+    end
+
+    def removeEdgeDefinition(collection:, dropCollection: nil)
+      satisfy_class?(collection, [String, Arango::Collection])
+      query = {"dropCollection": dropCollection}
+      collection = collection.is_a?(String) ? collection : collection.name
+      result = request("DELETE", "edge/#{collection}", query: query, key: :graph)
+      return_element(result)
+    end
+  end
+end