guacamole 0.3.0 → 0.4.0

data/lib/guacamole/edge_collection.rb

@@ -0,0 +1,91 @@
+# -*- encoding : utf-8 -*-
+
+require 'guacamole/collection'
+require 'guacamole/graph_query'
+
+require 'ashikawa-core'
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+module Guacamole
+  module EdgeCollection
+    extend ActiveSupport::Concern
+    include Guacamole::Collection
+
+    class << self
+      def for(edge_class)
+        collection_name = [edge_class.name.pluralize, 'Collection'].join
+
+        collection_name.constantize
+      rescue NameError
+        create_edge_collection(collection_name)
+      end
+
+      def create_edge_collection(collection_name)
+        new_collection_class = Class.new
+        Object.const_set(collection_name, new_collection_class)
+        new_collection_class.send(:include, Guacamole::EdgeCollection)
+      end
+    end
+
+    module ClassMethods
+      def connection
+        @connection ||= graph.edge_collection(collection_name)
+      end
+
+      def edge_class
+        @edge_class ||= model_class
+      end
+
+      def add_edge_definition_to_graph
+        graph.add_edge_definition(collection_name,
+                                  from: [edge_class.from],
+                                  to: [edge_class.to])
+      rescue Ashikawa::Core::ResourceNotFound
+        # FIXME: We just assume this 404 is raised because the edge definition is already created.
+        #        But the source of the error could be something else too. Had to be changed as soon
+        #        https://github.com/triAGENS/ashikawa-core/issues/136 is done.
+      end
+
+      def neighbors(model, direction = :inbound)
+        aql_string = <<-AQL
+        FOR n IN GRAPH_NEIGHBORS(@graph,
+                        { _key: @model_key },
+                        { direction: @direction, edgeCollectionRestriction: @edge_collection })
+          RETURN n.vertex
+        AQL
+
+        bind_parameters = {
+          graph: Guacamole.configuration.graph.name,
+          model_key: model.key,
+          edge_collection: collection_name,
+          direction: direction
+        }
+
+        options = { return_as: nil, for_in: nil }
+
+        query                 = AqlQuery.new(self, mapper_for_target(model), options)
+        query.aql_fragment    = aql_string
+        query.bind_parameters = bind_parameters
+        query
+      end
+
+      def mapper_for_target(model)
+        vertex_mapper.find { |mapper| !mapper.responsible_for?(model) }
+      end
+
+      def mapper_for_start(model)
+        vertex_mapper.find { |mapper| mapper.responsible_for?(model) }
+      end
+
+      def vertex_mapper
+        [edge_class.from_collection, edge_class.to_collection].map(&:mapper)
+      end
+    end
+
+    included do
+      add_edge_definition_to_graph
+    end
+  end
+end

data/lib/guacamole/exceptions.rb

@@ -2,9 +2,4 @@
 
 module Guacamole
   class GenericError < StandardError; end
-  class AQLNotSupportedError < GenericError
-    def initialize(msg = 'AQL is an experimental feature. Please activate it in the config: https://github.com/triAGENS/guacamole#experimental-aql-support')
-      super
-    end
-  end
 end

data/lib/guacamole/graph_query.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+
+require 'guacamole/query'
+
+module Guacamole
+  class GraphQuery < Query
+    def neighbors(start, edge_collection)
+      options[:type] = :neighbors
+      options[:start] = start
+      options[:edge_collection] = edge_collection
+      self
+    end
+
+    # @todo implement reasonable comparison
+    def ==(*)
+    end
+
+    private
+
+    def perfom_query(iterator)
+      enumerator = case options[:type]
+                   when :neighbors
+                     connection.neighbors(options[:start], edges: options[:edge_collection])
+                   else
+                     [].to_enum
+                   end
+
+      enumerator.each(&iterator)
+    end
+  end
+end

data/lib/guacamole/model.rb

@@ -218,6 +218,10 @@ module Guacamole
         key
       end
 
+      def _id
+        persisted? ? [self.class.name.underscore.pluralize, key].join('/') : nil
+      end
+
       def valid_with_callbacks?(context = nil)
         callbacks.run_callbacks :validate do
           valid_without_callbacks?(context)

data/lib/guacamole/proxies/proxy.rb

@@ -26,16 +26,20 @@ module Guacamole
       # @param [Object] base The class holding the reference. Currently not used.
       # @param [#call] target The lambda for getting the required objects from the database.
       def init(base, target)
-        @base = base
+        @base   = base
         @target = target
       end
 
       def method_missing(meth, *args, &blk)
-        @target.call.send meth, *args, &blk
+        target.call.send meth, *args, &blk
       end
 
       def respond_to_missing?(name, include_private = false)
-        @target.respond_to?(name, include_private)
+        target.respond_to?(name, include_private)
+      end
+
+      def target
+        @target || ->() { nil }
       end
     end
   end

data/lib/guacamole/proxies/relation.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'guacamole/proxies/proxy'
+require 'guacamole/edge_collection'
+
+module Guacamole
+  module Proxies
+    class Relation < Proxy
+      def initialize(model, edge_class, options = {})
+        responsible_edge_collection = EdgeCollection.for(edge_class)
+
+        direction = options[:inverse] ? :inbound : :outbound
+
+        if options[:just_one]
+          init model, -> () { responsible_edge_collection.neighbors(model, direction).to_a.first }
+        else
+          init model, -> () { responsible_edge_collection.neighbors(model, direction) }
+        end
+      end
+    end
+  end
+end

data/lib/guacamole/railtie.rb

@@ -30,7 +30,7 @@ module Guacamole
       elsif (config_file = Rails.root.join('config', 'guacamole.yml')).file?
         Guacamole::Configuration.load config_file
       else
-        warn_msg = '[WARNING] No configuration could be found. Either provide a `guacamole.yml` or a connection URI with `ENV["DATABASE_URL"]`'
+        warn_msg = '[WARNING] No configuration could be found. Either set a connection URI with `ENV["DATABASE_URL"]` or provide a `guacamole.yml`.'
         warn warn_msg
         Guacamole.logger.warn warn_msg
       end

data/lib/guacamole/transaction.rb

@@ -0,0 +1,177 @@
+# -*- encoding : utf-8 -*-
+
+require 'ashikawa-core'
+
+module Guacamole
+  class Transaction
+    extend Forwardable
+    def_delegators :collection, :mapper, :database
+
+    attr_reader :collection, :model
+
+    class TxEdgeCollection
+      attr_reader :edge_collection, :model, :ea, :to_models, :from_models, :old_edges
+
+      def initialize(ea, model)
+        @ea              = ea
+        @model           = model
+        @edge_collection = EdgeCollection.for(ea.edge_class)
+
+        init
+      end
+
+      def init
+        case model
+        when ea.edge_class.from_collection.model_class
+          @from_models = [model]
+          @to_models   = [ea.get_value(model)].compact.flatten
+          @old_edges   = edge_collection.by_example(_from: model._id).map(&:key)
+        when ea.edge_class.to_collection.model_class
+          @to_models   = [model]
+          @from_models = [ea.get_value(model)].compact.flatten
+          @old_edges   = edge_collection.by_example(_to: model._id).map(&:key)
+        else
+          raise RuntimeError
+        end
+      end
+
+      def select_mapper
+        ->(m) { edge_collection.mapper_for_start(m) }
+      end
+
+      def from_vertices
+        from_models.map do |m|
+          {
+            object_id: m.object_id,
+            collection: edge_collection.edge_class.from_collection.collection_name,
+            document: select_mapper.call(m).model_to_document(m),
+            _key: m.key,
+            _id: m._id
+          }
+        end
+      end
+
+      def to_vertices
+        to_models.map do |m|
+          {
+            object_id: m.object_id,
+            collection: edge_collection.edge_class.to_collection.collection_name,
+            document: select_mapper.call(m).model_to_document(m),
+            _key: m.key,
+            _id: m._id
+          }
+        end
+      end
+
+      def to_vertices_with_only_existing_documents
+        to_vertices.select { |v| v[:_key].nil?  }
+      end
+
+      def edges
+        from_vertices.each_with_object([]) do |from_vertex, edges|
+          to_vertices.each do |to_vertex|
+            edges << {
+              _from: from_vertex[:_id] || from_vertex[:object_id],
+              _to: to_vertex[:_id] || to_vertex[:object_id],
+              attributes: {}
+            }
+          end
+        end
+      end
+
+      def edge_collection_for_transaction
+        {
+          name: edge_collection.collection_name,
+          fromVertices: from_vertices,
+          toVertices: to_vertices_with_only_existing_documents,
+          edges: edges,
+          oldEdges: old_edges
+        }
+      end
+    end
+
+    class << self
+      def run(options)
+        new(options).execute_transaction
+      end
+    end
+
+    def initialize(options)
+      @collection = options[:collection]
+      @model      = options[:model]
+    end
+
+    def real_edge_collections
+      @real_edge_collections ||= mapper.edge_attributes.each_with_object([]) do |ea, edge_collections|
+        edge_collections << prepare_edge_collection_for_transaction(ea)
+      end
+    end
+
+    def fake_edge_collections
+      fake_vertex = {
+        object_id: model.object_id,
+        collection: collection.collection_name,
+        document: mapper.model_to_document(model),
+        _key: model.key,
+        _id: model._id
+      }
+
+      [
+        {
+          name: nil,
+          fromVertices: [fake_vertex],
+          toVertices: [],
+          edges: [],
+          oldEdges: []
+        }
+      ]
+    end
+
+    def edge_collections
+      real_edge_collections.present? ? real_edge_collections : fake_edge_collections
+    end
+
+    def prepare_edge_collection_for_transaction(ea)
+      TxEdgeCollection.new(ea, model).edge_collection_for_transaction
+    end
+
+    def write_collections
+      edge_collections.map do |ec|
+        [ec[:name]] +
+          ec[:fromVertices].map { |fv| fv[:collection] } +
+          ec[:toVertices].map { |tv| tv[:collection] }
+      end.flatten.uniq.compact
+    end
+
+    def read_collections
+      write_collections
+    end
+
+    def transaction_params
+      {
+        edgeCollections: edge_collections,
+        graph: Guacamole.configuration.graph.name,
+        log_level: 'debug'
+      }
+    end
+
+    def execute_transaction
+      transaction.execute(transaction_params)
+    end
+
+    def transaction_code
+      File.read(Guacamole.configuration.shared_path.join('transaction.js'))
+    end
+
+    private
+
+    def transaction
+      transaction = database.create_transaction(transaction_code,
+                                                write: write_collections,
+                                                read:  read_collections)
+      transaction.wait_for_sync = true
+
+      transaction
+    end
+  end
+end

data/lib/guacamole/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Guacamole
   # Current version of the gem
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/shared/transaction.js

@@ -0,0 +1,66 @@
+function(params) {
+    var db        = require("internal").db;
+    var graph     = require("org/arangodb/general-graph")._graph(params.graph);
+    var console   = require("console");
+    var log_level = params['log_level'];
+
+    var rubyObjectMap = {};
+
+    console[log_level]("Input params for transaction: %o", params);
+
+    var insertOrReplaceVertex = function(vertex) {
+        var result;
+        var _key = vertex._key;
+
+        if (rubyObjectMap[vertex.object_id.toString()] !== undefined && (_key === undefined || _key == null)) {
+          return true;
+        }
+
+        console[log_level]("The key for %o is: %s", vertex.document, _key);
+        if (_key === undefined || _key == null) {
+            result = graph[vertex.collection].save(vertex.document);
+        } else {
+            result = graph[vertex.collection].replace(_key, vertex.document);
+        }
+        vertex.document._key = result._key;
+        vertex.document._rev = result._rev;
+        vertex.document._id  = result._id;
+
+        rubyObjectMap[vertex.object_id.toString()] = vertex.document;
+        console[log_level]("Vertex: %o", vertex);
+    }
+
+    var insertOrReplaceConnection = function(edgeCollection) {
+        edgeCollection.fromVertices.forEach(insertOrReplaceVertex);
+        edgeCollection.toVertices.forEach(insertOrReplaceVertex);
+
+        console[log_level]("Current map: %o", rubyObjectMap);
+        console[log_level]("All the edges: %o", edgeCollection.edges);
+
+        if (edgeCollection.oldEdges.length > 0) {
+            var query          = "FOR e IN @@edge_collection FILTER POSITION(@keys, e._key, false) == true REMOVE e IN @@edge_collection";
+            var bindParameters = { "@edge_collection": edgeCollection.name, "keys": edgeCollection.oldEdges }
+
+            console[log_level](query);
+            console[log_level](bindParameters);
+
+            db._query(query, bindParameters);
+        }
+
+        edgeCollection.edges.forEach(function(edge) {
+            console[log_level]("Current Edge: %o", edge);
+            if (edge._from.toString().indexOf('/') == -1) {
+                edge._from = rubyObjectMap[edge._from.toString()]._id;
+            }
+            if (edge._to.toString().indexOf('/') == -1) {
+                edge._to = rubyObjectMap[edge._to.toString()]._id;
+            }
+
+            graph[edgeCollection.name].save(edge._from, edge._to, edge.attributes);
+        });
+    }
+
+    params.edgeCollections.forEach(insertOrReplaceConnection);
+
+    return rubyObjectMap;
+}