grumlin 0.22.4 → 1.0.0.rc1

data/lib/async/channel.rb

@@ -1,74 +1,72 @@
 # frozen_string_literal: true
 
-module Async
-  # Channel is a wrapper around Async::Queue that provides
-  # a protocol and handy tools for passing data, exceptions and closing.
-  # It is designed to be used only with one publisher and one subscriber
-  class Channel
-    class ChannelError < StandardError; end
-
-    class ChannelClosedError < ChannelError; end
-
-    def initialize
-      @queue = Async::Queue.new
-      @closed = false
-    end
+# Channel is a wrapper around Async::Queue that provides
+# a protocol and handy tools for passing data, exceptions and closing.
+# It is designed to be used only with one publisher and one subscriber
+class Async::Channel
+  class ChannelError < StandardError; end
 
-    def closed?
-      @closed
-    end
+  class ChannelClosedError < ChannelError; end
 
-    def open?
-      !@closed
-    end
+  def initialize
+    @queue = Async::Queue.new
+    @closed = false
+  end
 
-    # Methods for a publisher
-    def <<(payload)
-      raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
+  def closed?
+    @closed
+  end
 
-      @queue << [:payload, payload]
-    end
+  def open?
+    !@closed
+  end
 
-    def exception(exception)
-      raise(ChannelClosedError, "Cannot send to a closed channel") if closed?
+  # Methods for a publisher
+  def <<(payload)
+    raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
 
-      @queue << [:exception, exception]
-    end
+    @queue << [:payload, payload]
+  end
 
-    def close
-      return if closed?
+  def exception(exception)
+    raise(ChannelClosedError, "Cannot send to a closed channel") if closed?
 
-      @queue << [:close]
-      @closed = true
-    end
+    @queue << [:exception, exception]
+  end
 
-    def close!
-      return if closed?
+  def close
+    return if closed?
 
-      exception(ChannelClosedError.new("Channel was forcefully closed"))
-      close
-    end
+    @queue << [:close]
+    @closed = true
+  end
 
-    # Methods for a subscriber
-    def dequeue
-      each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended
-        return payload
-      end
+  def close!
+    return if closed?
+
+    exception(ChannelClosedError.new("Channel was forcefully closed"))
+    close
+  end
+
+  # Methods for a subscriber
+  def dequeue
+    each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended
+      return payload
     end
+  end
 
-    def each
-      raise(ChannelClosedError, "Cannot receive from a closed channel") if closed?
-
-      @queue.each do |type, payload|
-        case type
-        when :exception
-          payload.set_backtrace(caller + (payload.backtrace || [])) # A hack to preserve full backtrace
-          raise payload
-        when :payload
-          yield payload
-        when :close
-          break
-        end
+  def each
+    raise(ChannelClosedError, "Cannot receive from a closed channel") if closed?
+
+    @queue.each do |type, payload|
+      case type
+      when :exception
+        payload.set_backtrace(caller + (payload.backtrace || [])) # A hack to preserve full backtrace
+        raise payload
+      when :payload
+        yield payload
+      when :close
+        break
       end
     end
   end

data/lib/grumlin/benchmark/repository.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Benchmark
-    class Repository
-      extend Grumlin::Repository
+class Grumlin::Benchmark::Repository
+  extend Grumlin::Repository
 
-      shortcut :simple_test do
-        self.V
-      end
+  shortcut :simple_test do
+    self.V
+  end
 
-      def simple_test
-        g.V.bytecode.serialize
-      end
+  def simple_test
+    g.V.bytecode.serialize
+  end
 
-      def simple_test_with_shortcut
-        g.simple_test.bytecode.serialize
-      end
-    end
+  def simple_test_with_shortcut
+    g.simple_test.bytecode.serialize
   end
 end

data/lib/grumlin/client.rb

@@ -1,143 +1,123 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Client
-    class PoolResource < Async::Pool::Resource
-      attr_reader :client
-
-      def self.call
-        config = Grumlin.config
-        new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
-      end
-
-      def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
-        super(concurrency)
-        @client = client_factory.call(url, parent).tap(&:connect)
-        @parent = parent
-      end
-
-      def closed?
-        !@client.connected?
-      end
+class Grumlin::Client
+  class PoolResource < Async::Pool::Resource
+    attr_reader :client
 
-      def close
-        @client.close
-      end
+    def self.call
+      config = Grumlin.config
+      new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
+    end
 
-      def write(bytecode, session_id: nil)
-        @client.write(bytecode, session_id: session_id)
-      ensure
-        @count += 1
-      end
+    def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
+      super(concurrency)
+      @client = client_factory.call(url, parent).tap(&:connect)
+      @parent = parent
+    end
 
-      def viable?
-        !closed?
-      end
+    def closed?
+      !@client.connected?
+    end
 
-      def reusable?
-        !closed?
-      end
+    def close
+      @client.close
     end
 
-    include Console
+    def write(query)
+      @client.write(query)
+    ensure
+      @count += 1
+    end
 
-    # Client is not reusable. Once closed should be recreated.
-    def initialize(url, parent: Async::Task.current, **client_options)
-      @url = url
-      @client_options = client_options
-      @parent = parent
-      @request_dispatcher = nil
-      @transport = nil
+    def viable?
+      !closed?
     end
 
-    def connect
-      raise ClientClosedError if @closed
-
-      @transport = build_transport
-      response_channel = @transport.connect
-      @request_dispatcher = RequestDispatcher.new
-      @response_task = @parent.async do
-        response_channel.each do |response|
-          @request_dispatcher.add_response(response)
-        end
-      rescue Async::Stop, Async::TimeoutError, StandardError
-        close(check_requests: false)
-      end
-      logger.debug(self, "Connected")
+    def reusable?
+      !closed?
     end
+  end
 
-    # Before calling close the user must ensure that:
-    # 1) There are no ongoing requests
-    # 2) There will be no new writes after
-    def close(check_requests: true) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      return if @closed
+  include Console
 
-      @closed = true
+  # Client is not reusable. Once closed should be recreated.
+  def initialize(url, parent: Async::Task.current, **client_options)
+    @url = url
+    @client_options = client_options
+    @parent = parent
+    @request_dispatcher = nil
+    @transport = nil
+  end
 
-      @transport&.close
-      @transport&.wait
+  def connect
+    raise ClientClosedError if @closed
 
-      @response_task&.stop
-      @response_task&.wait
+    @transport = build_transport
+    response_channel = @transport.connect
+    @request_dispatcher = Grumlin::RequestDispatcher.new
+    @response_task = @parent.async do
+      response_channel.each do |response|
+        @request_dispatcher.add_response(response)
+      end
+    rescue Async::Stop, Async::TimeoutError, StandardError
+      close(check_requests: false)
+    end
+    logger.debug(self, "Connected")
+  end
 
-      return if @request_dispatcher&.requests&.empty?
+  # Before calling close the user must ensure that:
+  # 1) There are no ongoing requests
+  # 2) There will be no new writes after
+  def close(check_requests: true) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    return if @closed
 
-      @request_dispatcher.clear unless check_requests
+    @closed = true
 
-      raise ResourceLeakError, "Request list is not empty: #{@request_dispatcher.requests}" if check_requests
-    ensure
-      logger.debug(self, "Closed")
-    end
+    @transport&.close
+    @transport&.wait
 
-    def connected?
-      @transport&.connected? || false
-    end
+    @response_task&.stop
+    @response_task&.wait
 
-    # TODO: support yielding
-    def write(bytecode, session_id: nil)
-      raise NotConnectedError unless connected?
+    return if @request_dispatcher&.requests&.empty?
 
-      request = to_query(bytecode, session_id: session_id)
+    @request_dispatcher.clear unless check_requests
 
-      channel = @request_dispatcher.add_request(request)
-      begin
-        @transport.write(request)
-        channel.dequeue.flat_map { |item| Typing.cast(item) }
-      rescue Async::Stop, Async::TimeoutError
-        close(check_requests: false)
-        raise
-      end
-    end
+    raise ResourceLeakError, "Request list is not empty: #{@request_dispatcher.requests}" if check_requests
+  ensure
+    logger.debug(self, "Closed")
+  end
 
-    def inspect
-      "<#{self.class} url=#{@url} connected=#{connected?}>"
-    end
+  def connected?
+    @transport&.connected? || false
+  end
 
-    def to_s
-      inspect
+  # TODO: support yielding
+  def write(query)
+    raise NotConnectedError unless connected?
+
+    channel = @request_dispatcher.add_request(query)
+    begin
+      @transport.write(query)
+      channel.dequeue
+    rescue Async::Stop, Async::TimeoutError
+      close(check_requests: false)
+      raise
     end
+  end
 
-    private
+  def inspect
+    "<#{self.class} url=#{@url} connected=#{connected?}>"
+  end
 
-    # This might be overridden in successors
-    def build_transport
-      Transport.new(@url, parent: @parent, **@client_options)
-    end
+  def to_s
+    inspect
+  end
 
-    def to_query(bytecode, session_id:)
-      {
-        requestId: SecureRandom.uuid,
-        op: :bytecode,
-        processor: session_id ? :session : :traversal,
-        args: {
-          gremlin: {
-            :@type => "g:Bytecode",
-            :@value => bytecode.serialize
-          },
-          aliases: { g: :g },
-          session: session_id
-        }.compact
-      }
-    end
+  private
+
+  # This might be overridden in successors
+  def build_transport
+    Grumlin::Transport.new(@url, parent: @parent, **@client_options)
   end
 end

data/lib/grumlin/config.rb

@@ -1,26 +1,41 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Config
-    attr_accessor :url, :pool_size, :client_concurrency, :client_factory, :provider
+class Grumlin::Config
+  attr_accessor :url, :pool_size, :client_concurrency, :client_factory, :provider
 
-    SUPPORTED_PROVIDERS = %i[neptune tinkergraph].freeze
+  SUPPORTED_PROVIDERS = [:neptune, :tinkergraph].freeze
 
-    class ConfigurationError < Grumlin::Error; end
+  DEFAULT_MIDDLEWARES = Grumlin::Middlewares::Builder.new do |b|
+    b.use Grumlin::Middlewares::SerializeToSteps
+    b.use Grumlin::Middlewares::ApplyShortcuts
+    b.use Grumlin::Middlewares::SerializeToBytecode
+    b.use Grumlin::Middlewares::BuildQuery
+    b.use Grumlin::Middlewares::CastResults
+    b.use Grumlin::Middlewares::RunQuery
+  end
 
-    class UnknownProviderError < ConfigurationError; end
+  class ConfigurationError < Grumlin::Error; end
 
-    def initialize
-      @pool_size = 10
-      @client_concurrency = 5
-      @provider = :tinkergraph
-      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
-    end
+  class UnknownProviderError < ConfigurationError; end
 
-    def validate!
-      return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
+  def initialize
+    @pool_size = 10
+    @client_concurrency = 5
+    @provider = :tinkergraph
+    @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
+  end
 
-      raise UnknownProviderError, "provider '#{provider}' is unknown. Supported providers: #{SUPPORTED_PROVIDERS}"
+  def middlewares
+    @middlewares ||= Grumlin::Middlewares::Builder.new do |b|
+      b.use DEFAULT_MIDDLEWARES
     end
+    yield(@middlewares) if block_given?
+    @middlewares
+  end
+
+  def validate!
+    return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
+
+    raise UnknownProviderError, "provider '#{provider}' is unknown. Supported providers: #{SUPPORTED_PROVIDERS}"
   end
 end

data/lib/grumlin/dummy_transaction.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class DummyTransaction < Transaction
-    attr_reader :uuid
+class Grumlin::DummyTransaction < Grumlin::Transaction
+  attr_reader :uuid
 
-    include Console
+  include Console
 
-    def initialize(traversal_start_class, pool: Grumlin.default_pool) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
-      @traversal_start_class = traversal_start_class
+  def initialize(traversal_start_class, middlewares:, pool: nil) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
+    @traversal_start_class = traversal_start_class
 
-      logger.info(self) do
-        "#{Grumlin.config.provider} does not support transactions. commit and rollback are ignored, data will be saved"
-      end
+    logger.info(self) do
+      "#{Grumlin.config.provider} does not support transactions. commit and rollback are ignored, data will be saved"
     end
+  end
 
-    def commit
-      nil
-    end
+  def commit
+    nil
+  end
 
-    def rollback
-      nil
-    end
+  def rollback
+    nil
   end
 end

data/lib/grumlin/edge.rb

@@ -1,28 +1,26 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Edge
-    attr_reader :label, :id, :inVLabel, :outVLabel, :inV, :outV
+class Grumlin::Edge
+  attr_reader :label, :id, :inVLabel, :outVLabel, :inV, :outV
 
-    def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:)
-      @label = label
-      @id = Typing.cast(id)
-      @inVLabel = inVLabel
-      @outVLabel = outVLabel
-      @inV = Typing.cast(inV)
-      @outV = Typing.cast(outV)
-    end
+  def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:)
+    @label = label
+    @id = Grumlin::Typing.cast(id)
+    @inVLabel = inVLabel
+    @outVLabel = outVLabel
+    @inV = Grumlin::Typing.cast(inV)
+    @outV = Grumlin::Typing.cast(outV)
+  end
 
-    def ==(other)
-      self.class == other.class && @label == other.label && @id == other.id
-    end
+  def ==(other)
+    self.class == other.class && @label == other.label && @id == other.id
+  end
 
-    def inspect
-      "e[#{@id}][#{@outV}-#{@label}->#{@inV}]"
-    end
+  def inspect
+    "e[#{@id}][#{@outV}-#{@label}->#{@inV}]"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end

data/lib/grumlin/expressions/cardinality.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Cardinality
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :cardinality).map(&:to_sym).freeze
+module Grumlin::Expressions::Cardinality
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :cardinality).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Cardinality")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Cardinality")
   end
 end

data/lib/grumlin/expressions/column.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Column
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :column).map(&:to_sym).freeze
+module Grumlin::Expressions::Column
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :column).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Column")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Column")
   end
 end

data/lib/grumlin/expressions/expression.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Expression
-      def define_steps(steps, tool_name)
-        steps.each do |step|
-          define_method step do
-            name = "@#{step}"
-            return instance_variable_get(name) if instance_variable_defined?(name)
+module Grumlin::Expressions::Expression
+  def define_steps(steps, tool_name)
+    steps.each do |step|
+      define_method step do
+        name = "@#{step}"
+        return instance_variable_get(name) if instance_variable_defined?(name)
 
-            instance_variable_set(name, TypedValue.new(type: tool_name, value: step))
-          end
-        end
+        instance_variable_set(name, Grumlin::TypedValue.new(type: tool_name, value: step))
       end
     end
   end

data/lib/grumlin/expressions/operator.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Operator
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :operator).map(&:to_sym).freeze
+module Grumlin::Expressions::Operator
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :operator).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Operator")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Operator")
   end
 end

data/lib/grumlin/expressions/order.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Order
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :order).map(&:to_sym).freeze
+module Grumlin::Expressions::Order
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :order).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Order")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Order")
   end
 end