grumlin 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a847514be85565126dc453b6f088ad5c9a388464e74f6744e34427f09a07ec9c
-  data.tar.gz: ea6b1241c611222aa7866b8c3a7b4b798d5a68ba09f79f030196758d4f2dd7f0
+  metadata.gz: 22dad640b5ac86f86381b9bc9fab03989e7b8c42c4b19234efc6b3a223d07055
+  data.tar.gz: c0cea0f26f1e5a5a9ef1c6ab96335bf24e7f642968030b2b1f1c0a74210898d7
 SHA512:
-  metadata.gz: 2aa5546c4b0139b1fd81cf2c2d5b32886a0c54ee958ddf3d9684ff9a38a19c8401fb2ef89a6767840f2dc0a12fbc86ea0b4821477f0721d767fc4c4f3a6cd7c1
-  data.tar.gz: 38da748bde5febd21a8d94a8ae00768fa8b25bb544dd9b9895a9dd544136faa489a8591d01386afcbb8ed103e5f909c7c4dfff2af9a69f2c42a77fa963be7438
+  metadata.gz: 71b7e970733edc7db87736c449008389b47431d41c12382c426b0db348e106047343d279e3d8901d76dd44175478279b4c2e22cd896b690c9d63eedbf605b6ec
+  data.tar.gz: 82f71e74fb61435de9d6a86fa8cceb4cea32cd8a87f91c6a941bbfbd622a21b67b434f3ccbe298f94265edb9999faa33ea4f80148a56a1e39c6491a575df1ae6

data/.overcommit.yml

@@ -3,6 +3,3 @@ PreCommit:
     enabled: true
     on_warn: fail # Treat all warnings as failures
 
-PrePush:
-  RSpec:
-    enabled: true

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    grumlin (0.6.0)
+    grumlin (0.8.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
-                         hasLabel hasNot in inV label limit not order out outE path project property repeat select to
-                         unfold valueMap values where].freeze
+                         hasId hasLabel hasNot in inV label limit not order out outE path project property repeat select
+                         to unfold 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,36 +24,69 @@ module Grumlin
         @client.close
       end
 
-      def write(*args)
-        @client.write(*args)
+      def write(bytecode)
+        @client.write(bytecode)
+      ensure
+        @count += 1
+      end
+
+      def viable?
+        !closed?
+      end
+
+      def reusable?
+        !closed?
       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
-      @transport.close
-      raise ResourceLeakError, "Request list is not empty: #{requests}" if @request_dispatcher.requests.any?
+    # 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
+      @transport&.wait
 
-      reset!
+      @response_task&.stop
+      @response_task&.wait
+
+      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?
@@ -60,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
 
@@ -84,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
@@ -46,7 +48,7 @@ module Grumlin
 
       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,6 +71,10 @@ module Grumlin
       @requests.key?(request_id)
     end
 
+    def clear
+      @requests.clear
+    end
+
     private
 
     def check_errors!(status)

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.6.0"
+  VERSION = "0.8.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,41 +15,92 @@ 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
+
+    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
 
-module Grumlin
   class Config
     attr_accessor :url, :pool_size, :client_concurrency, :client_factory
 
-    # For some reason, client_concurrency must be greater than pool_size
     def initialize
       @pool_size = 10
-      @client_concurrency = 20
+      @client_concurrency = 5
       @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
     end
 
@@ -67,5 +121,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.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-30 00:00:00.000000000 Z
+date: 2021-09-07 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