grumlin 0.1.1 → 0.4.0

data/lib/grumlin/edge.rb

@@ -15,11 +15,11 @@ module Grumlin
     end
 
     def ==(other)
-      @label == other.label && @id == other.id
+      self.class == other.class && @label == other.label && @id == other.id
     end
 
     def inspect
-      "<E #{@label}(#{@id})>"
+      "e[#{@id}][#{@inV}-#{@label}->#{@outV}]"
     end
     alias to_s inspect
   end

data/lib/grumlin/exceptions.rb

@@ -3,8 +3,14 @@
 module Grumlin
   class Error < StandardError; end
 
+  class UnknownError < Error; end
+
   class ConnectionError < Error; end
 
+  class CannotConnectError < ConnectionError; end
+
+  class DisconnectError < ConnectionError; end
+
   class ConnectionStatusError < Error; end
 
   class NotConnectedError < ConnectionStatusError; end
@@ -24,8 +30,6 @@ module Grumlin
 
   class UnknownTypeError < ProtocolError; end
 
-  class ConnectionClosedError < Error; end
-
   class StatusError < Error
     attr_reader :status
 
@@ -48,4 +52,20 @@ module Grumlin
   class ServerSerializationError < ServerSideError; end
 
   class ServerTimeoutError < ServerSideError; end
+
+  class InternalClientError < Error; end
+
+  class UnknownRequestStoppedError < InternalClientError; end
+
+  class ResourceLeakError < InternalClientError; end
+
+  class UnknownMapKey < InternalClientError
+    attr_reader :key, :map
+
+    def initialize(key, map)
+      @key = key
+      @map = map
+      super("Cannot cast key #{key} in map #{map}")
+    end
+  end
 end

data/lib/grumlin/order.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Order
+    module Order
+      DESC = { "@type": "g:Order", "@value": "desc" }.freeze
+      ASC = { "@type": "g:Order", "@value": "desc" }.freeze
+
+      extend self # rubocop:disable Style/ModuleFunction
+
+      def asc
+        ASC
+      end
+
+      def desc
+        DESC
+      end
+    end
+
+    extend Order
+  end
+end

data/lib/grumlin/p.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module P
+    module P
+      %w[within].each do |step|
+        define_method step do |*args|
+          { # TODO: replace with a class?
+            "@type": "g:P",
+            "@value": { predicate: "within", value: { "@type": "g:List", "@value": args } }
+          }
+        end
+      end
+    end
+
+    extend P
+  end
+end

data/lib/grumlin/path.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Path
+    def initialize(path)
+      @labels = Typing.cast(path[:labels])
+      @objects = Typing.cast(path[:objects])
+    end
+
+    def inspect
+      "p[#{@objects}]"
+    end
+    alias to_s inspect
+  end
+end

data/lib/grumlin/pop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Pop
+    module Pop
+      extend self # rubocop:disable Style/ModuleFunction
+
+      FIRST = { "@type": "g:Pop", "@value": "first" }.freeze
+      LAST = { "@type": "g:Pop", "@value": "last" }.freeze
+      ALL = { "@type": "g:Pop", "@value": "all" }.freeze
+      MIXED = { "@type": "g:Pop", "@value": "mixed" }.freeze
+
+      def first
+        FIRST
+      end
+
+      def last
+        LAST
+      end
+
+      def all
+        ALL
+      end
+
+      def mixed
+        MIXED
+      end
+    end
+
+    extend Pop
+  end
+end

data/lib/grumlin/request_dispatcher.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class RequestDispatcher
+    attr_reader :requests
+
+    SUCCESS = {
+      200 => :success,
+      204 => :no_content,
+      206 => :partial_content
+    }.freeze
+
+    ERRORS = {
+      499 => InvalidRequestArgumentsError,
+      500 => ServerError,
+      597 => ScriptEvaluationError,
+      599 => ServerSerializationError,
+      598 => ServerTimeoutError,
+
+      401 => ClientSideError,
+      407 => ClientSideError,
+      498 => ClientSideError
+    }.freeze
+
+    def initialize
+      @requests = {}
+    end
+
+    def add_request(request)
+      raise "ERROR" if @requests.key?(request[:requestId])
+
+      Async::Channel.new.tap do |channel|
+        @requests[request[:requestId]] = { request: request, result: [], channel: channel }
+      end
+    end
+
+    # builds a response object, when it's ready sends it to the client via a channel
+    # TODO: sometimes response does not include requestID, no idea how to handle it so far.
+    def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      request_id = response[:requestId]
+      raise "ERROR" unless ongoing_request?(request_id)
+
+      request = @requests[request_id]
+
+      check_errors!(response[:status])
+
+      case SUCCESS[response.dig(:status, :code)]
+      when :success
+        request[:channel] << request[:result] + [response.dig(:result, :data)]
+        close_request(request_id)
+      when :partial_content then request[:result] << response.dig(:result, :data)
+      when :no_content
+        request[:channel] << []
+        close_request(request_id)
+      end
+    rescue StandardError => e
+      request[:channel].exception(e)
+      close_request(request_id)
+    end
+
+    def close_request(request_id)
+      raise "ERROR" unless ongoing_request?(request_id)
+
+      request = @requests.delete(request_id)
+      request[:channel].close
+    end
+
+    def ongoing_request?(request_id)
+      @requests.key?(request_id)
+    end
+
+    private
+
+    def check_errors!(status)
+      if (error = ERRORS[status[:code]])
+        raise(error, status)
+      end
+
+      return unless SUCCESS[status[:code]].nil?
+
+      raise(UnknownResponseStatus, status)
+    end
+  end
+end

data/lib/grumlin/step.rb

@@ -1,46 +1,35 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Step
-    attr_reader :client, :name, :args
+  class Step < AnonymousStep
+    attr_reader :client
 
-    # TODO: add support for bytecode
-    def initialize(client, name, *args, previous_steps: [])
-      @client = client
-      @name = name
-      @previous_steps = previous_steps
-      @args = args
+    def initialize(pool, name, *args, previous_steps: [])
+      super(name, *args, previous_steps: previous_steps)
+      @pool = pool
     end
 
-    %w[addV addE V E limit count drop property valueMap select from to as].each do |step|
-      define_method step do |*args|
-        Step.new(@client, step, *args, previous_steps: steps)
-      end
+    def next
+      @enum ||= toList.to_enum
+      @enum.next
     end
 
-    alias addVertex addV
-    alias addEdge addE
-
-    # TODO: add support for next
-    # TODO: add support for iterate
-    # TODO: memoization
     def toList # rubocop:disable Naming/MethodName
-      @client.query(*steps)
-    end
-
-    def inspect
-      "<Step #{self}>" # TODO: substitute bindings
+      @pool.acquire do |client|
+        client.write(*steps)
+      end
     end
 
-    # TODO: memoization
-    def to_s(*)
-      Translator.to_string(steps)
+    def iterate
+      @pool.acquire do |client|
+        client.write(*(steps + [nil]))
+      end
     end
 
-    alias to_gremlin to_s
+    private
 
-    def steps
-      (@previous_steps + [self])
+    def add_step(step_name, args, previous_steps:)
+      self.class.new(@pool, step_name, *args, previous_steps: previous_steps)
     end
   end
 end

data/lib/grumlin/sugar.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Sugar
+    # TODO: how to use it in specs?
+    HELPERS = [
+      Grumlin::U,
+      Grumlin::T,
+      Grumlin::P,
+      Grumlin::Pop,
+      Grumlin::Order
+    ].freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def const_missing(name)
+        helper = HELPERS.find { |h| h.const_defined?(name) }
+        super if helper.nil?
+
+        const_set(name, helper)
+      end
+    end
+
+    def const_missing(name)
+      helper = HELPERS.find { |h| h.const_defined?(name) }
+      super if helper.nil?
+
+      const_set(name, helper)
+    end
+
+    def __
+      Grumlin::U
+    end
+
+    def g
+      Grumlin::Traversal.new
+    end
+  end
+end

data/lib/grumlin/t.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module T
+    module T
+      T_ID = { :@type => "g:T", :@value => "id" }.freeze # TODO: replace with a class?
+      T_LABEL = { :@type => "g:T", :@value => "label" }.freeze # TODO: replace with a class?
+
+      extend self # rubocop:disable Style/ModuleFunction
+
+      def id
+        T_ID
+      end
+
+      def label
+        T_LABEL
+      end
+    end
+
+    extend T
+  end
+end

data/lib/grumlin/test/rspec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "grumlin/test/rspec/db_cleaner_context"
+require "grumlin/test/rspec/gremlin_context"
+
+module Grumlin
+  module Test
+    module RSpec
+    end
+  end
+end

data/lib/grumlin/test/rspec/db_cleaner_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Test
+    module RSpec
+      module DBCleanerContext
+      end
+
+      ::RSpec.shared_context DBCleanerContext do
+        include DBCleanerContext
+
+        before do
+          g.V().drop.iterate
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/test/rspec/gremlin_context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Test
+    module RSpec
+      module GremlinContext
+      end
+
+      ::RSpec.shared_context GremlinContext do
+        include GremlinContext
+
+        let(:g) { Grumlin::Traversal.new }
+
+        after do
+          Grumlin.config.default_pool.close
+          Grumlin.config.reset!
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/translator.rb

@@ -3,38 +3,39 @@
 module Grumlin
   module Translator
     class << self
-      def to_string_query(steps) # rubocop:disable Metrics/MethodLength
-        counter = 0
-        string_steps, bindings = steps.each_with_object([[], {}]) do |step, (acc_g, acc_b)|
-          args = step.args.map do |arg|
-            binding_name(counter).tap do |b|
-              acc_b[b] = arg
-              counter += 1
-            end
-          end.join(", ")
-
-          acc_g << "#{step.name}(#{args})"
-        end
+      def to_bytecode(steps)
+        return arg_to_bytecode(steps) if steps.is_a?(AnonymousStep)
 
-        ["g.#{string_steps.join(".")}", bindings]
+        steps.map do |step|
+          arg_to_bytecode(step)
+        end
       end
 
       def to_bytecode_query(steps)
         steps.map do |step|
-          [step.name, *step.args.flatten]
+          arg_to_query_bytecode(step)
         end
       end
 
-      def to_string(steps)
-        "g." + steps.map do |step| # rubocop:disable Style/StringConcatenation
-          "#{step.name}(#{step.args.map(&:inspect).join(", ")})"
-        end.join(".")
+      private
+
+      def arg_to_bytecode(arg)
+        return arg unless arg.is_a?(AnonymousStep)
+
+        args = arg.args.flatten.map do |a|
+          a.instance_of?(AnonymousStep) ? to_bytecode(a.steps) : arg_to_bytecode(a)
+        end
+        [arg.name, *args]
       end
 
-      private
+      def arg_to_query_bytecode(arg)
+        return ["none"] if arg.nil?
+        return arg unless arg.is_a?(AnonymousStep)
 
-      def binding_name(num)
-        "b_#{num.to_s(16)}"
+        args = arg.args.flatten.map do |a|
+          a.instance_of?(AnonymousStep) ? Typing.to_bytecode(to_bytecode(a.steps)) : arg_to_query_bytecode(a)
+        end
+        [arg.name, *args]
       end
     end
   end