grumlin 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8db95b253561a642cf2dde6a4ac063e1b45af6c15604c19d5721a71eba882b2
-  data.tar.gz: 035b95544c95e7609ddd2ac5d16b2096a67ea4c4e58b18d508176139efc1d5bf
+  metadata.gz: c0290e4d77bd50f701a803390ff2a0489b039f4beb231e8883ced690180c7abc
+  data.tar.gz: b4948d687c09ffea5bf9da26eda8644fc3fcffa1954e4e61fe2d628192984e7e
 SHA512:
-  metadata.gz: de9132526ee1da7f7319662ebd646a22d72b1a949730380c0449e185a2bfbb8bdc4c7f79fb6d045068c745093a310b8e828922306e2f72c677ed52e3aa07dd07
-  data.tar.gz: edf8f9bd0ed7ba23d7f5acac79ff7f4baa7466e11f4d1f08dde4ec2e0a052e7e08b4bb40e8621d51ce00cc26dda22ca0ed6e082474128d5310aa465c9787d197
+  metadata.gz: 3846fe491a606989f51f0f609e8c7ae2049b8a1005272ea531f085402e7d998a7f8723ccdafae01ce7d913f9ad9272f9da1e86a307cb7aeb5066ef4ad4024e4b
+  data.tar.gz: 1b20d251d16c95cb12657c6becbbb4592b8e206e9e83a7defee42281bbdd7c3f84d04785b2cc89bcc1328d05d11aa14b865b6bc6832899d3a73ce7b86283be5b

data/.overcommit.yml

@@ -0,0 +1,8 @@
+PreCommit:
+  RuboCop:
+    enabled: true
+    on_warn: fail # Treat all warnings as failures
+
+PrePush:
+  RSpec:
+    enabled: true

data/.rubocop.yml

@@ -33,3 +33,6 @@ RSpec/NestedGroups:
 
 RSpec/ExampleLength:
   Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false

data/Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "nokogiri"
 gem "rubocop"
 gem "rubocop-performance"
 gem "rubocop-rspec"
@@ -12,5 +13,6 @@ gem "solargraph"
 
 gem "async-rspec"
 gem "factory_bot"
+gem "overcommit"
 gem "rspec"
 gem "simplecov"

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    grumlin (0.1.3)
-      async-websocket (~> 0.18)
+    grumlin (0.2.0)
+      async-websocket (~> 0.19)
 
 GEM
   remote: https://rubygems.org/
@@ -14,33 +14,34 @@ GEM
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.2)
-    async (1.29.0)
+    async (1.30.0)
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-http (0.56.2)
-      async (~> 1.25)
-      async-io (~> 1.28)
-      async-pool (~> 0.2)
+    async-http (0.56.5)
+      async (>= 1.25)
+      async-io (>= 1.28)
+      async-pool (>= 0.2)
       protocol-http (~> 0.22.0)
       protocol-http1 (~> 0.14.0)
       protocol-http2 (~> 0.14.0)
-    async-io (1.31.0)
-      async (~> 1.14)
-    async-pool (0.3.6)
-      async (~> 1.25)
+    async-io (1.32.2)
+      async
+    async-pool (0.3.8)
+      async (>= 1.25)
     async-rspec (1.16.0)
       rspec (~> 3.0)
       rspec-files (~> 1.0)
       rspec-memory (~> 1.0)
-    async-websocket (0.18.0)
+    async-websocket (0.19.0)
       async-http (~> 0.54)
       async-io (~> 1.23)
       protocol-websocket (~> 0.7.0)
-    backport (1.1.2)
+    backport (1.2.0)
     benchmark (0.1.1)
+    childprocess (4.0.0)
     concurrent-ruby (1.1.8)
-    console (1.12.0)
+    console (1.13.1)
       fiber-local
     diff-lcs (1.4.4)
     docile (1.4.0)
@@ -50,6 +51,7 @@ GEM
     fiber-local (1.0.0)
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
+    iniparse (1.5.0)
     jaro_winkler (1.5.4)
     kramdown (2.3.1)
       rexml
@@ -57,13 +59,16 @@ GEM
       kramdown (~> 2.0)
     minitest (5.14.4)
     nio4r (2.5.7)
-    nokogiri (1.11.5-x86_64-linux)
+    nokogiri (1.11.7-x86_64-linux)
       racc (~> 1.4)
+    overcommit (0.57.0)
+      childprocess (>= 0.6.3, < 5)
+      iniparse (~> 1.4)
     parallel (1.20.1)
     parser (3.0.1.1)
       ast (~> 2.4.1)
     protocol-hpack (1.4.2)
-    protocol-http (0.22.0)
+    protocol-http (0.22.5)
     protocol-http1 (0.14.1)
       protocol-http (~> 0.22)
     protocol-http2 (0.14.2)
@@ -95,16 +100,16 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    rubocop (1.15.0)
+    rubocop (1.16.1)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.5.0, < 2.0)
+      rubocop-ast (>= 1.7.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.5.0)
+    rubocop-ast (1.7.0)
       parser (>= 3.0.1.1)
     rubocop-performance (1.11.3)
       rubocop (>= 1.7.0, < 2.0)
@@ -119,10 +124,11 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    solargraph (0.40.4)
-      backport (~> 1.1)
+    solargraph (0.42.4)
+      backport (~> 1.2)
       benchmark
       bundler (>= 1.17.2)
+      diff-lcs (~> 1.4)
       e2mmap
       jaro_winkler (~> 1.5)
       kramdown (~> 2.3)
@@ -149,6 +155,8 @@ DEPENDENCIES
   async-rspec
   factory_bot
   grumlin!
+  nokogiri
+  overcommit
   rspec
   rubocop
   rubocop-performance

data/bin/console

@@ -5,9 +5,12 @@ require "bundler/setup"
 require "grumlin"
 require "irb"
 
+Grumlin.configure do |config|
+  config.url = ENV["GREMLIN_URL"] || "ws://localhost:8182/gremlin"
+end
+
 Async do
-  client = Grumlin::Client.new("ws://localhost:8182/gremlin", mode: :bytecode)
-  g = Grumlin::Traversal.new(client)
+  g = Grumlin::Traversal.new
 
   IRB.setup(nil)
   workspace = IRB::WorkSpace.new(binding)
@@ -16,5 +19,5 @@ Async do
 rescue StandardError
   raise
 ensure
-  client.disconnect
+  Grumlin.config.default_client&.disconnect
 end

data/bin/setup

@@ -4,5 +4,6 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
+bundle exec overcommit --sign
 
 # Do any other automated setup that you need to do here

data/grumlin.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "async-websocket", "~> 0.18"
+  spec.add_dependency "async-websocket", "~> 0.19"
 end

data/lib/grumlin.rb

@@ -5,20 +5,53 @@ require "json"
 
 require "async"
 require "async/queue"
+require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
 require_relative "grumlin/version"
 require_relative "grumlin/exceptions"
 
+require_relative "grumlin/transport/async"
+
 require_relative "grumlin/vertex"
 require_relative "grumlin/edge"
+require_relative "grumlin/path"
 require_relative "grumlin/typing"
 require_relative "grumlin/client"
 require_relative "grumlin/traversal"
+
+require_relative "grumlin/anonymous_step"
 require_relative "grumlin/step"
+
 require_relative "grumlin/translator"
-require_relative "grumlin/traversing_context"
+require_relative "grumlin/t"
+require_relative "grumlin/order"
+require_relative "grumlin/u"
+require_relative "grumlin/p"
+require_relative "grumlin/pop"
+require_relative "grumlin/sugar"
 
 module Grumlin
+  class Config
+    attr_accessor :url
+
+    def default_client
+      @default_client ||= Grumlin::Client.new(url)
+    end
+
+    def reset!
+      @default_client = nil
+    end
+  end
+
+  class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= Config.new
+    end
+  end
 end

data/lib/grumlin/anonymous_step.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class AnonymousStep
+    attr_reader :name, :args
+
+    def initialize(name, *args, previous_steps: [])
+      @name = name
+      @previous_steps = previous_steps
+      @args = args
+    end
+
+    %w[addV addE V E limit count drop property valueMap select from to as order by has hasLabel values hasNot
+       not outE groupCount label group in out fold unfold inV path dedup project coalesce repeat emit
+       elementMap where].each do |step|
+      define_method step do |*args|
+        add_step(step, args, previous_steps: steps)
+      end
+    end
+
+    alias addVertex addV
+    alias addEdge addE
+
+    def inspect
+      @inspect ||= to_bytecode.to_s
+    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])
+    end
+
+    private
+
+    def add_step(step_name, args, previous_steps:)
+      self.class.new(step_name, *args, previous_steps: previous_steps)
+    end
+  end
+end

data/lib/grumlin/client.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Client # rubocop:disable Metrics/ClassLength
-    SUCCESS_STATUS = 200
-    NO_CONTENT_STATUS = 204
-    PARTIAL_CONTENT_STATUS = 206
+  class Client
+    extend Forwardable
+
+    SUCCESS = {
+      200 => :success,
+      204 => :no_content,
+      206 => :partial_content
+    }.freeze
 
     ERRORS = {
       499 => InvalidRequestArgumentsError,
@@ -18,126 +22,80 @@ module Grumlin
       498 => ClientSideError
     }.freeze
 
-    def initialize(url, task: Async::Task.current, autoconnect: true, mode: :bytecode)
-      @task = task
-      @endpoint = Async::HTTP::Endpoint.parse(url)
-      @mode = mode
-
-      @requests = {}
-      @query_queue = Async::Queue.new
-
+    def initialize(url, autoconnect: true)
+      @url = url
+      @transport = Transport::Async.new(url)
       connect if autoconnect
     end
 
-    def connect # rubocop:disable Metrics/MethodLength
-      raise AlreadyConnectedError unless @connection_task.nil?
+    def_delegators :@transport, :connect, :disconnect, :requests
 
-      @connection_task = @task.async do |subtask|
-        Async::WebSocket::Client.connect(@endpoint) do |connection|
-          subtask.async { query_task(connection) }
-          response_task(connection)
-        end
-      rescue StandardError => e
-        @requests.each_value do |queue|
-          queue << [:error, e]
-        end
-        disconnect
-      end
+    # TODO: support yielding
+    def submit(*args)
+      request_id = SecureRandom.uuid
+      queue = @transport.submit(to_query(request_id, args))
+      wait_for_response(request_id, queue)
+    ensure
+      @transport.close_request(request_id)
     end
 
-    def disconnect
-      raise NotConnectedError if @connection_task.nil?
-
-      @connection_task&.stop
-      @connection_task&.wait
-      @connection_task = nil
-      @requests = {}
+    def inspect
+      "<#{self.class} @url=#{@url}>"
     end
 
-    def query(*args) # rubocop:disable Metrics/MethodLength
-      response_queue, request_id = schedule_query(args)
-      result = []
+    alias to_s inspect
 
-      response_queue.each do |status, response|
-        reraise_error!(response) if status == :error
+    private
 
-        status = response[:status]
+    def wait_for_response(request_id, queue, result: []) # rubocop:disable Metrics/MethodLength
+      queue.each do |status, response|
+        check_errors!(request_id, status, response)
 
-        if status[:code] == NO_CONTENT_STATUS
-          close_request(request_id)
+        case SUCCESS[response.dig(:status, :code)]
+        when :success
+          return result + Typing.cast(response.dig(:result, :data))
+        when :partial_content then result += Typing.cast(response.dig(:result, :data))
+        when :no_content
           return []
         end
-
-        check_errors!(status, request_id)
-
-        page = Typing.cast(response.dig(:result, :data))
-
-        case status[:code]
-        when SUCCESS_STATUS
-          close_request(request_id)
-          return result + page
-        when PARTIAL_CONTENT_STATUS
-          result += page
-        else
-          raise UnknownResponseStatus, status
-        end
       end
+    rescue ::Async::Stop
+      retry if @transport.ongoing_request?(request_id)
+      raise UnknownRequestStopped, "#{request_id} is not in the ongoing requests list"
     end
 
-    private
-
-    def schedule_query(args)
-      uuid = SecureRandom.uuid
-      queue = Async::Queue.new
-      @requests[uuid] = queue
-      @query_queue << to_query(uuid, args)
-
-      [queue, uuid]
-    end
-
-    def to_query(uuid, message)
-      case message.first
+    def to_query(request_id, message)
+      case message.first # TODO: properly handle unknown type of message
       when String
-        string_query_message(uuid, *message)
+        string_query_message(request_id, *message)
       when Grumlin::Step
-        build_query(uuid, message)
+        bytecode_query_message(request_id, Translator.to_bytecode_query(message))
       end
     end
 
-    def check_errors!(status, request_id)
-      error = ERRORS[status[:code]]
-      close_request(request_id)
-      raise(error, status) if error
-    end
+    def check_errors!(_request_id, status, response)
+      reraise_error!(response) if status == :error
+
+      status = response[:status]
 
-    def close_request(request_id)
-      @requests.delete(request_id)
+      if (error = ERRORS[status[:code]])
+        raise(error, status)
+      end
+
+      return unless SUCCESS[status[:code]].nil?
+
+      raise(UnknownResponseStatus, status)
     end
 
     def reraise_error!(error)
       raise error
     rescue StandardError
-      raise ConnectionError
-    end
-
-    def query_task(connection)
-      loop do
-        connection.write @query_queue.dequeue
-        connection.flush
-      end
-    end
-
-    def response_task(connection)
-      loop do
-        response = connection.read
-        response_queue = @requests[response[:requestId]]
-        response_queue << [:response, response]
-      end
+      raise UnknownError
     end
 
-    def string_query_message(uuid, query, bindings)
+    def string_query_message(request_id, query, bindings)
       {
-        requestId: uuid,
+        requestId: request_id,
         op: "eval",
         processor: "",
         args: {
@@ -148,25 +106,16 @@ module Grumlin
       }
     end
 
-    def bytecode_query_message(uuid, bytecode)
+    def bytecode_query_message(request_id, bytecode)
       {
-        requestId: uuid,
+        requestId: request_id,
         op: "bytecode",
         processor: "traversal",
         args: {
-          gremlin: { "@type": "g:Bytecode", "@value": { step: bytecode } },
+          gremlin: Typing.to_bytecode(bytecode),
           aliases: { g: :g }
         }
       }
     end
-
-    def build_query(uuid, steps)
-      case @mode
-      when :string
-        string_query_message(uuid, *Translator.to_string_query(steps))
-      else
-        bytecode_query_message(uuid, Translator.to_bytecode_query(steps))
-      end
-    end
   end
 end

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

@@ -1,46 +1,31 @@
 # 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: [])
+      super(name, *args, previous_steps: previous_steps)
       @client = client
-      @name = name
-      @previous_steps = previous_steps
-      @args = args
     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
+      @toList ||= @client.submit(*steps) # rubocop:disable Naming/VariableName
     end
 
-    # TODO: memoization
-    def to_s(*)
-      Translator.to_string(steps)
+    def iterate
+      @client.submit(*(steps + [nil]))
     end
 
-    alias to_gremlin to_s
+    private
 
-    def steps
-      (@previous_steps + [self])
+    def add_step(step_name, args, previous_steps:)
+      self.class.new(@client, 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,22 @@
+# 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
+          expect(Grumlin.config.default_client.requests).to be_empty
+          Grumlin.config.default_client.disconnect
+          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

data/lib/grumlin/transport/async.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Transport
+    # A transport based on https://github.com/socketry/async
+    # and https://github.com/socketry/async-websocket
+    class Async
+      attr_reader :requests
+
+      def initialize(url, task: ::Async::Task.current)
+        @task = task
+        @endpoint = ::Async::HTTP::Endpoint.parse(url)
+
+        @requests = {}
+        @query_queue = ::Async::Queue.new
+      end
+
+      def connect
+        raise AlreadyConnectedError if connected?
+
+        @client = ::Async::WebSocket::Client.open(@endpoint)
+        @connection = @client.connect(@endpoint.authority, @endpoint.path)
+
+        @tasks_barrier = ::Async::Barrier.new(parent: @task)
+
+        @tasks_barrier.async { query_task }
+        @tasks_barrier.async { response_task }
+      rescue StandardError
+        raise ConnectionError
+      end
+
+      def disconnect
+        raise NotConnectedError unless connected?
+
+        @tasks_barrier.tasks.each(&:stop)
+        @tasks_barrier.wait
+
+        @connection.close
+        @client.close
+
+        @client = nil
+        @connection = nil
+        @tasks_barrier = nil
+
+        raise ResourceLeakError, "ongoing requests list is not empty: #{@requests.count} items" unless @requests.empty?
+        raise ResourceLeakError, "query queue empty: #{@query.count} items" unless @query_queue.empty?
+      end
+
+      # Raw message
+      def submit(message)
+        raise NotConnectedError unless connected?
+
+        uuid = message[:requestId]
+        ::Async::Queue.new.tap do |queue|
+          @requests[uuid] = queue
+          @query_queue << message
+        end
+      end
+
+      def close_request(request_id)
+        @requests.delete(request_id)
+      end
+
+      def ongoing_request?(request_id)
+        @requests.key?(request_id)
+      end
+
+      def connected?
+        !@connection.nil?
+      end
+
+      private
+
+      def query_task
+        @query_queue.each do |query|
+          @connection.write(query)
+          @connection.flush
+        end
+      rescue StandardError
+        raise DisconnectError
+      end
+
+      def response_task
+        loop do
+          response = @connection.read
+          # TODO: sometimes response does not include requestID, no idea how to handle it so far.
+          response_queue = @requests[response[:requestId]]
+          response_queue << [:response, response]
+        end
+      rescue StandardError
+        raise DisconnectError
+      end
+    end
+  end
+end

data/lib/grumlin/traversal.rb

@@ -4,18 +4,15 @@ module Grumlin
   class Traversal
     attr_reader :connection
 
-    def initialize(client_or_url, &block)
+    def initialize(client_or_url = Grumlin.config.default_client)
       @client = if client_or_url.is_a?(String)
                   Grumlin::Client.new(client_or_url)
                 else
                   client_or_url
                 end
-
-      return if block.nil?
-
-      TraversingContext.new(self).instance_exec(&block)
     end
 
+    # TODO: add other start steps
     %w[addV addE V E].each do |step|
       define_method step do |*args|
         Step.new(@client, step, *args)

data/lib/grumlin/typing.rb

@@ -4,15 +4,19 @@ module Grumlin
   module Typing
     TYPES = {
       "g:List" => ->(value) { value.map { |item| cast(item) } },
+      "g:Set" => ->(value) { Set.new(value.map { |item| cast(item) }) },
       "g:Map" => ->(value) { cast_map(value) },
       "g:Vertex" => ->(value) { cast_entity(Grumlin::Vertex, value) },
       "g:Edge" => ->(value) { cast_entity(Grumlin::Edge, value) },
+      "g:Path" => ->(value) { cast_entity(Grumlin::Path, value) },
       "g:Int64" => ->(value) { cast_int(value) },
       "g:Int32" => ->(value) { cast_int(value) },
-      "g:Traverser" => ->(value) { cast(value[:value]) } # TODO: wtf is bulk?
+      "g:Double" => ->(value) { cast_double(value) },
+      "g:Traverser" => ->(value) { cast(value[:value]) }, # TODO: wtf is bulk?
+      "g:T" => ->(value) { value.to_sym }
     }.freeze
 
-    CASTABLE_TYPES = [Hash, String, Integer].freeze
+    CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass].freeze
 
     class << self
       def cast(value)
@@ -27,6 +31,13 @@ module Grumlin
         type.call(value[:@value])
       end
 
+      def to_bytecode(step)
+        {
+          "@type": "g:Bytecode",
+          "@value": { step: step }
+        }
+      end
+
       private
 
       def castable_type?(value); end
@@ -47,6 +58,12 @@ module Grumlin
         value
       end
 
+      def cast_double(value)
+        raise TypeError, "#{value} is not a Double" unless value.is_a?(Float)
+
+        value
+      end
+
       def cast_entity(entity, value)
         entity.new(**value)
       rescue ArgumentError, TypeError
@@ -54,12 +71,15 @@ module Grumlin
       end
 
       def cast_map(value)
-        Hash[*value].transform_keys(&:to_sym).transform_values { |v| cast(v) }
+        Hash[*value].transform_keys do |key|
+          next key.to_sym if key.respond_to?(:to_sym)
+          next cast(key) if key[:@type]
+
+          raise UnknownMapKey, key, value
+        end.transform_values { |v| cast(v) }
       rescue ArgumentError
         raise TypeError, "#{value} cannot be casted to Hash"
       end
-
-      def cast_traverser(value); end
     end
   end
 end

data/lib/grumlin/u.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module U
+    module U
+      extend self # rubocop:disable Style/ModuleFunction
+
+      %w[addV V has count out values unfold].each do |step|
+        define_method step do |*args|
+          AnonymousStep.new(step, *args)
+        end
+      end
+    end
+
+    # TODO: add alias __
+    extend U
+  end
+end

data/lib/grumlin/version.rb

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

data/lib/grumlin/vertex.rb

@@ -10,11 +10,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
-      "<V #{@label}(#{@id})>"
+      "v[#{@id}]"
     end
     alias to_s inspect
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-websocket
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 description: Gremlin query language DSL for Ruby.
 email:
 - zhulik.gleb@gmail.com
@@ -33,6 +33,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/main.yml"
 - ".gitignore"
+- ".overcommit.yml"
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -43,20 +44,30 @@ files:
 - README.md
 - bin/console
 - bin/setup
-- bin/stress
 - docker-compose.yml
 - gremlin_server/Dockerfile
 - gremlin_server/tinkergraph-empty.properties
 - grumlin.gemspec
 - lib/grumlin.rb
+- lib/grumlin/anonymous_step.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
+- lib/grumlin/pop.rb
 - lib/grumlin/step.rb
+- lib/grumlin/sugar.rb
+- lib/grumlin/t.rb
+- 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/async.rb
 - lib/grumlin/traversal.rb
-- lib/grumlin/traversing_context.rb
 - lib/grumlin/typing.rb
+- lib/grumlin/u.rb
 - lib/grumlin/version.rb
 - lib/grumlin/vertex.rb
 homepage: https://github.com/zhulik/grumlin
@@ -81,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Gremlin query language DSL for Ruby.

data/bin/stress

@@ -1,51 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "grumlin"
-require "irb"
-
-def queries(client, uuids)
-  total = 0
-  g = Grumlin::Traversal.new(client)
-
-  loop do
-    uuid = uuids.sample
-    result = g.V(uuid).toList[0]
-    raise "!!!" if result.id != uuid
-
-    total += 1
-  end
-rescue Async::Stop
-  total
-end
-
-def prepare_dataset(client)
-  uuids = Array.new(1000) { SecureRandom.uuid }
-
-  Grumlin::Traversal.new(client) do
-    g.V().drop
-
-    uuids.each do |uuid|
-      g.addV("test_vertex").property(id, uuid).toList
-    end
-  end
-
-  uuids
-end
-
-Async do |task|
-  client = Grumlin::Client.new("ws://localhost:8182/gremlin", mode: :bytecode)
-
-  uuids = prepare_dataset(client)
-  tasks = Array.new(20) { task.async { queries(client, uuids) } }
-
-  task.sleep(60)
-
-  tasks.each(&:stop)
-  total = tasks.sum(&:wait)
-
-  p("#{total} requests performed")
-ensure
-  client.disconnect
-end

data/lib/grumlin/traversing_context.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Grumlin
-  class TraversingContext
-    ID = { :@type => "g:T", :@value => "id" }.freeze
-
-    attr_reader :g
-
-    def initialize(traversal)
-      @g = traversal
-    end
-
-    def id
-      ID
-    end
-  end
-end