arango-driver 3.5.0.alpha0

data/lib/arango/graph.rb

@@ -0,0 +1,202 @@
+# === GRAPH ===
+
+module Arango
+  class Graph
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::DatabaseAssignment
+
+    def initialize(name:, database:, body: {}, cache_name: nil, edge_definitions: [], is_smart: nil, number_of_shards: nil, orphan_collections: [],
+                   replication_factor: nil, smart_graph_attribute: 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[:edgeDefinitions]     ||= edge_definitions
+      body[:isSmart]             ||= is_smart
+      body[:numberOfShards]      ||= number_of_shards
+      body[:orphanCollections]   ||= orphan_collections
+      body[:replicationFactor]   ||= replication_factor
+      body[:smartGraphAttribute] ||= smart_graph_attribute
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_reader :body, :cache_name, :database, :id, :is_smart, :name, :rev, :server
+    attr_accessor :number_of_shards, :replication_factor, :smart_graph_attribute
+    alias key name
+
+    def body=(result)
+      @body = result
+      assign_edge_definitions(result[:edgeDefinitions] || @edge_definitions)
+      assign_orphan_collections(result[:orphanCollections] || @orphan_collections)
+      @name    = result[:_key]    || @name
+      @id      = result[:_id]     || @id
+      @id      = "_graphs/#{@name}" if @id.nil? && !@name.nil?
+      @rev     = result[:_rev]    || @rev
+      @is_smart = result[:isSmart] || @is_smart
+      @number_of_shards = result[:numberOfShards] || @number_of_shards
+      @replication_factor = result[:replicationFactor] || @replication_factor
+      @smart_graph_attribute = result[:smartGraphAttribute] || @smart_graph_attribute
+      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 edge_definitions_raw
+      @edge_definitions ||= []
+      @edge_definitions.map do |edgedef|
+        {
+          collection: edgedef[:collection].name,
+          from: edgedef[:from].map{|t| t.name},
+          to: edgedef[:to].map{|t| t.name}
+        }
+      end
+    end
+    private :edge_definitions_raw
+
+    def edge_definitions(raw=false)
+      return edge_definitions_raw if raw
+      return @edge_definitions
+    end
+
+    def edge_definitions=(edge_definitions)
+      @edge_definitions = []
+      edge_definitions ||= []
+      edge_definitions = [edge_definitions] unless edge_definitions.is_a?(Array)
+      edge_definitions.each do |edge_definition|
+        hash = {}
+        hash[:collection] = return_collection(edge_definition[:collection], :edge)
+        edge_definition[:from] ||= []
+        edge_definition[:to]   ||= []
+        hash[:from] = edge_definition[:from].map{|t| return_collection(t)}
+        hash[:to]   = edge_definition[:to].map{|t| return_collection(t)}
+        setup_orphan_collection_after_adding_edge_definitions(hash)
+        @edge_definitions << hash
+      end
+    end
+    alias assign_edge_definitions edge_definitions=
+
+    def orphan_collections=(orphan_collections)
+      orphan_collections ||= []
+      orphan_collections = [orphan_collections] unless orphan_collections.is_a?(Array)
+      @orphan_collections = orphan_collections.map{|oc| add_orphan_collection(oc)}
+    end
+    alias assign_orphan_collections orphan_collections=
+
+    def orphan_collections_raw
+      @orphan_collections ||= []
+      @orphan_collections.map{|oc| oc.name}
+    end
+    private :orphan_collections_raw
+
+    def orphan_collections(raw=false)
+      return orphan_collections_raw if raw
+      return @orphan_collections
+    end
+
+# === HANDLE ORPHAN COLLECTION ===
+
+    def add_orphan_collection(orphanCollection)
+      orphanCollection = return_collection(orphanCollection)
+      if @edge_definitions.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_orphan_collection_after_adding_edge_definitions(edge_definition)
+      collection = []
+      collection |= edge_definition[:from]
+      collection |= edge_definition[:to]
+      @orphan_collections.delete_if{|c| collection.include?(c.name)}
+    end
+    private :setup_orphan_collection_after_adding_edge_definitions
+
+    def setup_orphan_collection_after_removing_edge_definitions(edge_definition)
+      edgeCollection = edge_definition[:collection].name
+      collections |= []
+      collections |= edge_definition[:from]
+      collections |= edge_definition[:to]
+      collections.each do |collection|
+        unless @edge_definitions.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 @orphan_collections.map{|oc| oc.name}.include?(collection.name)
+            @orphan_collections << collection
+          end
+        end
+      end
+    end
+    private :setup_orphan_collection_after_removing_edge_definitions
+
+# === REQUEST ===
+
+    def request(action, url, body: {}, headers: {}, query: {}, key: nil, return_direct_result: false)
+      url = "_api/gharial/#{@name}/#{url}"
+      @database.request(action, url, body: body, headers: headers,
+        query: query, key: key, return_direct_result: return_direct_result)
+    end
+
+# === TO HASH ===
+
+    def to_h
+      {
+        name: @name,
+        id: @id,
+        rev: @rev,
+        isSmart: @is_smart,
+        numberOfShards: @number_of_shards,
+        replicationFactor: @replication_factor,
+        smartGraphAttribute: @smart_graph_attribute,
+        edgeDefinitions: edge_definitions_raw,
+        orphanCollections: orphan_collections_raw,
+        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
+
+  end
+end

data/lib/arango/graph/basics.rb

@@ -0,0 +1,39 @@
+module Arango
+  module Graph
+    module Basics
+      def create(is_smart: @is_smart, smart_graph_attribute: @smart_graph_attribute,
+                 number_of_shards: @number_of_shards)
+        body = {
+          name: @name,
+          edgeDefinitions:   edge_definitions_raw,
+          orphanCollections: orphan_collections_raw,
+          isSmart: is_smart,
+          options: {
+            smartGraphAttribute: smart_graph_attribute,
+            numberOfShards: number_of_shards
+          }
+        }
+        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
+
+      def exist?
+
+      end
+      alias exists? exist?
+
+      def info
+
+      end
+
+      def drop(dropCollections: nil)
+        query = { dropCollections: dropCollections }
+        result = @database.request("DELETE", "_api/gharial/#{@name}", query: query,
+                                   key: :removed)
+        return_delete(result)
+      end
+    end
+  end
+end

data/lib/arango/graph/edge_access.rb

@@ -0,0 +1,56 @@
+module Arango
+  module Graph
+    module EdgeAccess
+      def edge_collection
+
+      end
+
+      def edge_collections
+        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 edge_definitions
+
+      end
+
+      def add_edge_definition(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 replace_edge_definition(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 remove_edge_definition(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
+end

data/lib/arango/graph/vertex_access.rb

@@ -0,0 +1,33 @@
+module Arango
+  module Graph
+    module VertexAccess
+      def vertex_collection
+
+      end
+
+      def vertex_collections
+        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
+
+      def add_vertex_collection(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 remove_vertex_collection(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
+    end
+  end
+end

data/lib/arango/helper/collection_assignment.rb

@@ -0,0 +1,13 @@
+module Arango
+  module Helper
+    module CollectionAssignment
+      def assign_collection(collection)
+        satisfy_class?(collection, [Arango::Collection])
+        @collection = collection
+        @graph = @collection.graph
+        @database = @collection.database
+        @arango_server = @database.arango_server
+      end
+    end
+  end
+end

data/lib/arango/helper/database_assignment.rb

@@ -0,0 +1,14 @@
+module Arango
+  module Helper
+    module DatabaseAssignment
+
+      protected
+
+      def assign_database(database)
+        satisfy_class?(database, [Arango::Database])
+        @database = database
+        @server = @database.arango_server
+      end
+    end
+  end
+end

data/lib/arango/helper/request_method.rb

@@ -0,0 +1,45 @@
+module Arango
+  module Helper
+    module RequestMethod
+      def request_method(method_name, &block)
+        promise_method_name = "batch_#{method_name}".to_sym
+        define_method(method_name) do |*args|
+          request_hash = instance_exec(*args, &block)
+          @database.execute_request(request_hash)
+        end
+        define_method(promise_method_name) do |*args|
+          request_hash = instance_exec(*args, &block)
+          @database.batch_request(request_hash)
+        end
+      end
+
+      def multi_request_method(method_name, &block)
+        promise_method_name = "batch_#{method_name}".to_sym
+        define_method(method_name) do |*args|
+          requests = instance_exec(*args, &block)
+          @database.execute_requests(requests)
+        end
+        define_method(promise_method_name) do |*args|
+          requests= instance_exec(*args, &block)
+          promises = []
+          requests.each do |request_hash|
+            promises << @database.batch_request(request_hash)
+          end
+          Promise.when(*promises).then { |values| values.last }
+        end
+      end
+
+      def aql_request_method(method_name, &block)
+        promise_method_name = "batch_#{method_name}".to_sym
+        define_method(method_name) do |*args|
+          request_hash = instance_exec(*args, &block)
+          @database.execute_aql(request_hash)
+        end
+        define_method(promise_method_name) do |*args|
+          request_hash = instance_exec(*args, &block)
+          @database.batch_execute_aql(request_hash)
+        end
+      end
+    end
+  end
+end

data/lib/arango/helper/return.rb

@@ -0,0 +1,21 @@
+module Arango
+  module Helper
+    module Return
+      def return_directly?(result)
+        return result if @server.async || @server.return_output
+        result == true
+      end
+
+      def return_element(result)
+        return result unless @server.async
+        assign_attributes(result)
+        return_directly?(result) ? result : self
+      end
+
+      def return_delete(result)
+        return result unless @server.async
+        return_directly?(result) ? result : true
+      end
+    end
+  end
+end

data/lib/arango/helper/satisfaction.rb

@@ -0,0 +1,28 @@
+module Arango
+  module Helper
+    module Satisfaction
+      def satisfy_class?(object, classes=[String], array=false)
+        if array
+          object = [object] unless object.is_a?(Array)
+          object.each do |obj|
+            satisfy_class?(obj, classes, false)
+          end
+        else
+          return if classes.include?(object.class)
+          name ||= object.object_id.to_s
+          raise Arango::Error.new err: :wrong_class, data: { wrong_value: name, wrong_class: object.class.to_s, expected_class: classes.to_s }
+        end
+      end
+
+      def satisfy_category?(object, list)
+        return if list.include?(object)
+        name = object.object_id.to_s
+        raise Arango::Error.new err: :wrong_element, data: { wrong_attribute: name, wrong_value: object, list: list }
+      end
+
+      def warning_deprecated(warning, name)
+        puts "ARANGORB WARNING: #{name} function is deprecated" if warning
+      end
+    end
+  end
+end