grumlin 0.6.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6633f34f12f74200b56d3447e7b1cd5c2c4185cd4013a27157d809b2f97f01b2
-  data.tar.gz: a5b0c1b0f4a8ef813a48144b79b17a71c6385802ff77b46ef0fa703643790ac1
+  metadata.gz: 360fd18e170020dfe02e879e9e20e29a958de425e20dd3217c70c1317ae87850
+  data.tar.gz: ec7c3b496802689d0bd5cd82b9eba303ec4b5f60deb993f0fe48bf446d69004a
 SHA512:
-  metadata.gz: 6824448759e26af95f8753a1461fac6b0b66677e1cab723b8e79c76333c4e791b5364da81f87844b624796238a3e02b13065a7afb64d7a5ef7ca83a6e9c3e8be
-  data.tar.gz: d7ce1a01b2b50f90a317d270ad005561220fcb0f69da5036b97d20c88b2458e5dd7ea285c384cef5d5e9521ff077f2d43650985c1e928942e463cfc29bbdd247
+  metadata.gz: 79e60622d3c58154b13939880a394062f96fdade9eb5eafbe2ed13b040ad2d4749d134e4cc2ad5ba18c48872ed04d71d3ef833525e16765b774fb489cfb24f95
+  data.tar.gz: 4a00526ab10dd4c90a1c83f5fb94a572152b14bd5884be096605d6a1acf8b80c8143ab24a766b9ad25b5d2b93b78f848bce94784c13bd3b1afbdfa6567a24070

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    grumlin (0.6.2)
+    grumlin (0.10.0)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
+      oj (~> 3.12)
+      zeitwerk (~> 2.4)
 
 GEM
   remote: https://rubygems.org/
@@ -62,6 +64,7 @@ GEM
     nio4r (2.5.8)
     nokogiri (1.11.7-x86_64-linux)
       racc (~> 1.4)
+    oj (3.13.4)
     overcommit (0.57.0)
       childprocess (>= 0.6.3, < 5)
       iniparse (~> 1.4)

data/grumlin.gemspec

@@ -25,4 +25,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "async-pool", "~> 0.3"
   spec.add_dependency "async-websocket", "~> 0.19"
+  spec.add_dependency "oj", "~> 3.12"
+  spec.add_dependency "zeitwerk", "~> 2.4"
 end

data/lib/async/channel.rb

@@ -32,7 +32,7 @@ module Async
     end
 
     def close
-      raise(ChannelClosedError, "Cannot close a closed channel") if closed?
+      return if closed?
 
       @queue << [:close]
       @closed = true

data/lib/grumlin/anonymous_step.rb

@@ -2,43 +2,39 @@
 
 module Grumlin
   class AnonymousStep
-    attr_reader :name, :args
+    attr_reader :name, :args, :previous_step
 
     # TODO: add other steps
     SUPPORTED_STEPS = %w[E V addE addV as by coalesce count dedup drop elementMap emit fold from group groupCount has
                          hasId hasLabel hasNot in inV label limit not order out outE path project property repeat select
-                         to unfold valueMap values where].freeze
+                         to unfold union valueMap values where].freeze
 
-    def initialize(name, *args, previous_steps: [])
+    def initialize(name, *args, previous_step: nil)
       @name = name
-      @previous_steps = previous_steps
+      @previous_step = previous_step
       @args = args
     end
 
     SUPPORTED_STEPS.each do |step|
-      define_method step do |*args|
-        add_step(step, args, previous_steps: steps)
+      define_method(step) do |*args|
+        add_step(step, args)
       end
     end
 
     def inspect
-      @inspect ||= to_bytecode.to_s
+      bytecode.inspect
     end
 
     alias to_s inspect
 
-    def to_bytecode
-      @to_bytecode ||= (@previous_steps.last&.to_bytecode || []) + [Translator.to_bytecode(self)]
-    end
-
-    def steps
-      (@previous_steps + [self])
+    def bytecode(no_return: false)
+      @bytecode ||= Bytecode.new(self, no_return: no_return)
     end
 
     private
 
-    def add_step(step_name, args, previous_steps:)
-      self.class.new(step_name, *args, previous_steps: previous_steps)
+    def add_step(step_name, args)
+      self.class.new(step_name, *args, previous_step: self)
     end
   end
 end

data/lib/grumlin/bytecode.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Grumlin
+  # Incapsulates logic of converting step chains and step arguments to queries that can be sent to the server
+  # and to human readable strings.
+  class Bytecode
+    class NoneStep
+      def to_bytecode
+        ["none"]
+      end
+    end
+
+    NONE_STEP = NoneStep.new
+
+    def initialize(step, no_return: false)
+      @step = step
+      @no_return = no_return
+    end
+
+    def inspect
+      to_readable_bytecode.to_s
+    end
+    alias to_s inspect
+
+    def to_query
+      {
+        requestId: SecureRandom.uuid,
+        op: "bytecode",
+        processor: "traversal",
+        args: {
+          gremlin: to_bytecode,
+          aliases: { g: :g }
+        }
+      }
+    end
+
+    def to_readable_bytecode
+      @to_readable_bytecode ||= steps.map { |s| serialize_arg(s, serialization_method: :to_readable_bytecode) }
+    end
+
+    def to_bytecode
+      @to_bytecode ||= {
+        "@type": "g:Bytecode",
+        "@value": { step: (steps + (@no_return ? [NONE_STEP] : [])).map { |s| serialize_arg(s) } }
+      }
+    end
+
+    private
+
+    # Serializes step or a step argument to either an executable query or a human readable string representation
+    # depending on the `serialization_method` parameter. I should be either `:to_readable_bytecode` for human readable
+    # representation or `:to_bytecode` for query.
+    def serialize_arg(arg, serialization_method: :to_bytecode)
+      return arg.send(serialization_method) if arg.respond_to?(:to_bytecode)
+      return arg unless arg.is_a?(AnonymousStep)
+
+      arg.args.flatten.each.with_object([arg.name]) do |a, res|
+        res << if a.instance_of?(AnonymousStep)
+                 a.bytecode.send(serialization_method)
+               else
+                 serialize_arg(a, serialization_method: serialization_method)
+               end
+      end
+    end
+
+    def steps
+      @steps ||= [].tap do |result|
+        step = @step
+        until step.nil?
+          result.unshift(step)
+          step = step.previous_step
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/client.rb

@@ -13,6 +13,7 @@ module Grumlin
       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?
@@ -23,8 +24,10 @@ module Grumlin
         @client.close
       end
 
-      def write(*args)
-        @client.write(*args)
+      def write(bytecode)
+        @client.write(bytecode)
+      ensure
+        @count += 1
       end
 
       def viable?
@@ -36,33 +39,54 @@ module Grumlin
       end
     end
 
+    include Console
+
+    # 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
-      reset!
+      @request_dispatcher = nil
+      @transport = nil
     end
 
     def connect
+      raise "ClientClosed" if @closed
+
       @transport = build_transport
       response_channel = @transport.connect
       @request_dispatcher = RequestDispatcher.new
-      @parent.async do
+      @response_task = @parent.async do
         response_channel.each do |response|
           @request_dispatcher.add_response(response)
         end
-      rescue StandardError
-        close
+      rescue Async::Stop, Async::TimeoutError, StandardError
+        close(check_requests: false)
       end
+      logger.debug(self, "Connected")
     end
 
-    def close
+    # 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
+
+      @closed = true
+
       @transport&.close
-      if @request_dispatcher&.requests&.any?
-        raise ResourceLeakError, "Request list is not empty: #{@request_dispatcher.requests}"
-      end
+      @transport&.wait
+
+      @response_task&.stop
+      @response_task&.wait
 
-      reset!
+      return if @request_dispatcher&.requests&.empty?
+
+      @request_dispatcher.clear unless check_requests
+
+      raise ResourceLeakError, "Request list is not empty: #{@request_dispatcher.requests}" if check_requests
+    ensure
+      logger.debug(self, "Closed")
     end
 
     def connected?
@@ -70,19 +94,18 @@ module Grumlin
     end
 
     # TODO: support yielding
-    def write(*args)
+    def write(bytecode)
       raise NotConnectedError unless connected?
 
-      request_id = SecureRandom.uuid
-      request = to_query(request_id, args)
+      request = bytecode.to_query
       channel = @request_dispatcher.add_request(request)
       @transport.write(request)
 
       begin
         channel.dequeue.flat_map { |item| Typing.cast(item) }
-      rescue Async::Stop
-        retry if @request_dispatcher.ongoing_request?(request_id)
-        raise Grumlin::UnknownRequestStoppedError, "#{request_id} is not in the ongoing requests list"
+      rescue Async::Stop, Async::TimeoutError
+        close(check_requests: false)
+        raise
       end
     end
 
@@ -94,23 +117,6 @@ module Grumlin
 
     private
 
-    def to_query(request_id, message)
-      {
-        requestId: request_id,
-        op: "bytecode",
-        processor: "traversal",
-        args: {
-          gremlin: Typing.to_bytecode(Translator.to_bytecode_query(message)),
-          aliases: { g: :g }
-        }
-      }
-    end
-
-    def reset!
-      @request_dispatcher = nil
-      @transport = nil
-    end
-
     def build_transport
       Transport.new(@url, parent: @parent, **@client_options)
     end

data/lib/grumlin/request_dispatcher.rb

@@ -22,6 +22,8 @@ module Grumlin
       498 => ClientSideError
     }.freeze
 
+    include Console
+
     def initialize
       @requests = {}
     end
@@ -42,11 +44,11 @@ module Grumlin
 
       request = @requests[request_id]
 
-      check_errors!(response[:status])
+      check_errors!(response[:status], request[:request])
 
       case SUCCESS[response.dig(:status, :code)]
       when :success
-        request[:channel] << request[:result] + [response.dig(:result, :data)]
+        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
@@ -69,11 +71,15 @@ module Grumlin
       @requests.key?(request_id)
     end
 
+    def clear
+      @requests.clear
+    end
+
     private
 
-    def check_errors!(status)
+    def check_errors!(status, query)
       if (error = ERRORS[status[:code]])
-        raise(error, status)
+        raise error.new(status, query)
       end
 
       return unless SUCCESS[status[:code]].nil?

data/lib/grumlin/step.rb

@@ -4,8 +4,8 @@ module Grumlin
   class Step < AnonymousStep
     attr_reader :client
 
-    def initialize(pool, name, *args, previous_steps: [])
-      super(name, *args, previous_steps: previous_steps)
+    def initialize(pool, name, *args, previous_step: nil)
+      super(name, *args, previous_step: previous_step)
       @pool = pool
     end
 
@@ -16,20 +16,20 @@ module Grumlin
 
     def toList
       @pool.acquire do |client|
-        client.write(*steps)
+        client.write(bytecode)
       end
     end
 
     def iterate
       @pool.acquire do |client|
-        client.write(*(steps + [nil]))
+        client.write(bytecode(no_return: true))
       end
     end
 
     private
 
-    def add_step(step_name, args, previous_steps:)
-      self.class.new(@pool, step_name, *args, previous_steps: previous_steps)
+    def add_step(step_name, args)
+      self.class.new(@pool, step_name, *args, previous_step: self)
     end
   end
 end

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

@@ -18,8 +18,7 @@ module Grumlin
         end
 
         after do
-          Grumlin.config.default_pool.close
-          Grumlin.config.reset!
+          Grumlin.close
         end
       end
     end

data/lib/grumlin/transport.rb

@@ -5,47 +5,33 @@ module Grumlin
     # A transport based on https://github.com/socketry/async
     # and https://github.com/socketry/async-websocket
 
+    include Console
+
     attr_reader :url
 
+    # Transport is not reusable. Once closed should be recreated.
     def initialize(url, parent: Async::Task.current, **client_options)
       @url = url
       @parent = parent
       @client_options = client_options
       @request_channel = Async::Channel.new
       @response_channel = Async::Channel.new
-      reset!
     end
 
     def connected?
-      @connected
+      !@connection.nil?
     end
 
-    def connect # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def connect
+      raise "ClientClosed" if @closed
       raise AlreadyConnectedError if connected?
 
       @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
+      logger.debug(self) { "Connected to #{@url}." }
 
-      @response_task = @parent.async do
-        loop do
-          data = @connection.read
-          @response_channel << data
-        end
-      rescue Async::Stop
-        @response_channel.close
-      rescue StandardError => e
-        @response_channel.exception(e)
-      end
+      @response_task = @parent.async { run_response_task }
 
-      @request_task = @parent.async do
-        @request_channel.each do |message|
-          @connection.write(message)
-          @connection.flush
-        end
-      rescue StandardError => e
-        @response_channel.exception(e)
-      end
-
-      @connected = true
+      @request_task = @parent.async { run_request_task }
 
       @response_channel
     end
@@ -57,30 +43,59 @@ module Grumlin
     end
 
     def close
-      return unless connected?
+      return if @closed
 
-      @request_channel.close
-      @request_task.wait
+      @closed = true
 
-      @response_task.stop
-      @response_task.wait
+      @request_channel.close
+      @response_channel.close
 
       begin
         @connection.close
-      rescue Errno::EPIPE
+      rescue StandardError
         nil
       end
+      @connection = nil
+
+      @request_task&.stop(true)
+      @response_task&.stop(true)
+    end
 
-      reset!
+    def wait
+      @request_task.wait
+      @response_task.wait
     end
 
     private
 
-    def reset!
-      @connected = false
-      @connection = nil
-      @response_task = nil
-      @request_task = nil
+    def run_response_task
+      with_guard do
+        loop do
+          data = @connection.read
+          @response_channel << data
+        end
+      end
+    end
+
+    def run_request_task
+      with_guard do
+        @request_channel.each do |message|
+          @connection.write(message)
+          @connection.flush
+        end
+      end
+    end
+
+    def with_guard
+      yield
+    rescue Async::Stop, Async::TimeoutError, StandardError => e
+      logger.debug(self) { "Guard error, closing." }
+      begin
+        @response_channel.exception(e)
+      rescue Async::Channel::ChannelClosedError
+        nil
+      end
+      close
     end
   end
 end

data/lib/grumlin/traversal.rb

@@ -7,7 +7,7 @@ module Grumlin
     # TODO: add other start steps
     SUPPORTED_START_STEPS = %w[E V addE addV].freeze
 
-    def initialize(pool = Grumlin.config.default_pool)
+    def initialize(pool = Grumlin.default_pool)
       @pool = pool
     end
 

data/lib/grumlin/typed_value.rb

@@ -8,12 +8,14 @@ module Grumlin
       @value = value
     end
 
-    def inspect(*)
-      "#{@type}.#{@value}"
-    end
-
     def to_bytecode
       @to_bytecode ||= { "@type": "g:#{@type}", "@value": @value }
     end
+
+    def inspect
+      "<#{@type}.#{@value}>"
+    end
+    alias to_s inspect
+    alias to_readable_bytecode inspect
   end
 end

data/lib/grumlin/typing.rb

@@ -31,19 +31,10 @@ module Grumlin
         type.call(value[:@value])
       end
 
-      def to_bytecode(step)
-        {
-          "@type": "g:Bytecode",
-          "@value": { step: step }
-        }
-      end
-
       private
 
-      def castable_type?(value); end
-
       def verify_type!(value)
-        raise TypeError, "#{value.inspect} cannot be casted" unless CASTABLE_TYPES.any? { |t| value.is_a?(t) }
+        raise TypeError, "#{value.inspect} cannot be casted" unless CASTABLE_TYPES.include?(value.class)
       end
 
       def verify_castable_hash!(value, type)

data/lib/grumlin/u.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module U
     # TODO: add other start steps
-    SUPPORTED_START_STEPS = %w[V addV count has out unfold values].freeze
+    SUPPORTED_START_STEPS = %w[V addV count fold has out repeat unfold values].freeze
 
     class << self
       SUPPORTED_START_STEPS.each do |step|

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.6.2"
+  VERSION = "0.10.0"
 end

data/lib/grumlin.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "json"
+require "oj"
+
+Oj.mimic_JSON
+Oj.add_to_json
 
 require "async"
 require "async/pool"
@@ -12,40 +15,93 @@ require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
-require_relative "async/channel"
+require "zeitwerk"
 
-require_relative "grumlin/version"
-require_relative "grumlin/exceptions"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "rspec" => "RSpec",
+  "db_cleaner_context" => "DBCleanerContext"
+)
 
-require_relative "grumlin/transport"
-require_relative "grumlin/client"
-require_relative "grumlin/typed_value"
+db_adapters = "#{__dir__}/grumlin/test"
+loader.do_not_eager_load(db_adapters)
 
-require_relative "grumlin/vertex"
-require_relative "grumlin/edge"
-require_relative "grumlin/path"
-require_relative "grumlin/typing"
-require_relative "grumlin/traversal"
-require_relative "grumlin/request_dispatcher"
-require_relative "grumlin/translator"
+module Grumlin
+  class Error < StandardError; end
 
-require_relative "grumlin/anonymous_step"
-require_relative "grumlin/step"
+  class UnknownError < Error; end
 
-require_relative "grumlin/t"
-require_relative "grumlin/order"
-require_relative "grumlin/u"
-require_relative "grumlin/p"
-require_relative "grumlin/pop"
-require_relative "grumlin/sugar"
+  class ConnectionError < Error; end
+
+  class CannotConnectError < ConnectionError; end
+
+  class DisconnectError < ConnectionError; end
+
+  class ConnectionStatusError < Error; end
+
+  class NotConnectedError < ConnectionStatusError; end
+
+  class AlreadyConnectedError < ConnectionStatusError; end
+
+  class ProtocolError < Error; end
+
+  class UnknownResponseStatus < ProtocolError
+    attr_reader :status
+
+    def initialize(status)
+      super("unknown response status code #{status[:code]}")
+      @status = status
+    end
+  end
+
+  class UnknownTypeError < ProtocolError; end
+
+  class StatusError < Error
+    attr_reader :status, :query
+
+    def initialize(status, query)
+      super(status[:message])
+      @status = status
+      @query = query
+    end
+  end
+
+  class ClientSideError < StatusError; end
+
+  class ServerSideError < StatusError; end
+
+  class ScriptEvaluationError < ServerSideError; end
+
+  class InvalidRequestArgumentsError < ServerSideError; end
+
+  class ServerError < ServerSideError; end
+
+  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
 
-module Grumlin
   class Config
     attr_accessor :url, :pool_size, :client_concurrency, :client_factory
 
     def initialize
       @pool_size = 10
-      @client_concurrency = 2
+      @client_concurrency = 5
       @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
     end
 
@@ -66,5 +122,19 @@ module Grumlin
     def config
       @config ||= Config.new
     end
+
+    def default_pool
+      config.default_pool
+    end
+
+    def close
+      default_pool.wait while default_pool.busy?
+
+      default_pool.close
+      config.reset!
+    end
   end
 end
+
+loader.setup
+loader.eager_load

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-03 00:00:00.000000000 Z
+date: 2021-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: Gremlin query language DSL for Ruby.
 email:
 - zhulik.gleb@gmail.com
@@ -66,9 +94,9 @@ files:
 - lib/async/channel.rb
 - lib/grumlin.rb
 - lib/grumlin/anonymous_step.rb
+- lib/grumlin/bytecode.rb
 - lib/grumlin/client.rb
 - lib/grumlin/edge.rb
-- lib/grumlin/exceptions.rb
 - lib/grumlin/order.rb
 - lib/grumlin/p.rb
 - lib/grumlin/path.rb
@@ -80,7 +108,6 @@ files:
 - lib/grumlin/test/rspec.rb
 - lib/grumlin/test/rspec/db_cleaner_context.rb
 - lib/grumlin/test/rspec/gremlin_context.rb
-- lib/grumlin/translator.rb
 - lib/grumlin/transport.rb
 - lib/grumlin/traversal.rb
 - lib/grumlin/typed_value.rb

data/lib/grumlin/exceptions.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-  class AlreadyConnectedError < ConnectionStatusError; end
-
-  class ProtocolError < Error; end
-
-  class UnknownResponseStatus < ProtocolError
-    attr_reader :status
-
-    def initialize(status)
-      super("unknown response status code #{status[:code]}")
-      @status = status
-    end
-  end
-
-  class UnknownTypeError < ProtocolError; end
-
-  class StatusError < Error
-    attr_reader :status
-
-    def initialize(status)
-      super(status[:message])
-      @status = status
-    end
-  end
-
-  class ClientSideError < StatusError; end
-
-  class ServerSideError < StatusError; end
-
-  class ScriptEvaluationError < ServerSideError; end
-
-  class InvalidRequestArgumentsError < ServerSideError; end
-
-  class ServerError < ServerSideError; end
-
-  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/translator.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Grumlin
-  module Translator
-    class << self
-      def to_bytecode(steps)
-        return arg_to_bytecode(steps) if steps.is_a?(AnonymousStep)
-
-        steps.map do |step|
-          arg_to_bytecode(step)
-        end
-      end
-
-      def to_bytecode_query(steps)
-        steps.map do |step|
-          arg_to_query_bytecode(step)
-        end
-      end
-
-      private
-
-      def arg_to_bytecode(arg)
-        return arg.to_bytecode if arg.is_a?(TypedValue)
-        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
-
-      def arg_to_query_bytecode(arg)
-        return ["none"] if arg.nil?
-        return arg.to_bytecode if arg.is_a?(TypedValue)
-        return arg unless arg.is_a?(AnonymousStep)
-
-        # return arg.to_bytecode if arg.is_a?(TypedValue)
-
-        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
-end