grumlin 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1696d48d04fdfc23de590598ed655a9d2fc59e66e87eb04c5cd579df3805f972
-  data.tar.gz: cfa3d4f3ce67d35d5d1b0e5af78024ddb3461b9f4272b1a49015a3527fcc85f0
+  metadata.gz: 11e434ab0f5cd463d357e69dd3cbf5083f85a1bdd32e4d2c96023ce262704020
+  data.tar.gz: f24dd70f8b0abe9b370f77587d590802b32aa3e7b8a20380b9518004868cc6c7
 SHA512:
-  metadata.gz: 97b8df1e4b6c02d874c9659d7c506704d21f9cfaf419c427c3e00378e3b8a3f3ca30ad53e04b0e6b18dc9161302ed63ddcfcd4df6948edd777beba435424fcf5
-  data.tar.gz: c6b0ad7814fdefa25909c4c008ead2a130e807760eed5528d728e854ea88e2c08dbcd9dd5c30caec2c737178285e6c929c0348cf24ce01e4468c09ce72a3723d
+  metadata.gz: 5bfbd0d4db9ef46d35839b8ca5654cdc1f5038ee2c4ca004b678471380095d1fb587fa89a8df0c5a4769e3943ceb4e0b88734b701593ccf1047a05ab85baaaf5
+  data.tar.gz: a7d87e630e6b2076bedd079365e709018b3fc61f1577564c504593ffdeb4deab88f56d8785c30877489171b6c9d7fd245982475a75f4c639647c923e2ca296ef

data/.github/workflows/main.yml

@@ -48,7 +48,7 @@ jobs:
     needs:
       - lint
       - test
-    # if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
     steps:
       - uses: actions/checkout@v2
 

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,9 @@
 PATH
   remote: .
   specs:
-    grumlin (0.1.1)
-      async-websocket (~> 0.18)
+    grumlin (0.4.0)
+      async-pool (~> 0.3)
+      async-websocket (~> 0.19)
 
 GEM
   remote: https://rubygems.org/
@@ -14,33 +15,34 @@ GEM
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.2)
-    async (1.29.0)
+    async (1.30.1)
       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,20 +52,24 @@ 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
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     minitest (5.14.4)
-    nio4r (2.5.7)
-    nokogiri (1.11.5-x86_64-linux)
+    nio4r (2.5.8)
+    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 +101,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 +125,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.43.0)
+      backport (~> 1.2)
       benchmark
       bundler (>= 1.17.2)
+      diff-lcs (~> 1.4)
       e2mmap
       jaro_winkler (~> 1.5)
       kramdown (~> 2.3)
@@ -149,6 +156,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_pool.close
 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

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Gleb Sinyavskiy"]
   spec.email         = ["zhulik.gleb@gmail.com"]
 
-  spec.summary       = "A ruby client for Gremlin query language."
-  spec.description   = "A ruby client for Gremlin query language."
+  spec.summary       = "Gremlin query language DSL for Ruby."
+  spec.description   = "Gremlin query language DSL for Ruby."
   spec.homepage      = "https://github.com/zhulik/grumlin"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "async-websocket", "~> 0.18"
+  spec.add_dependency "async-pool", "~> 0.3"
+  spec.add_dependency "async-websocket", "~> 0.19"
 end

data/lib/async/channel.rb

@@ -0,0 +1,64 @@
+# 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 with only one publisher and one subscriber
+  class Channel
+    class ChannelError < StandardError; end
+
+    class ChannelClosedError < ChannelError; end
+
+    def initialize
+      @queue = Async::Queue.new
+      @closed = false
+    end
+
+    def closed?
+      @closed
+    end
+
+    # Methods for a publisher
+    def <<(payload)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
+
+      @queue << [:payload, payload]
+    end
+
+    def exception(exception)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if closed?
+
+      @queue << [:exception, exception]
+    end
+
+    def close
+      raise(ChannelClosedError, "Cannot close a closed channel") if closed?
+
+      @queue << [:close]
+      @closed = true
+    end
+
+    # Methods for a subscriber
+    def dequeue
+      each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended
+        return payload
+      end
+    end
+
+    def each # rubocop:disable Metrics/MethodLength
+      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
+  end
+end

data/lib/grumlin.rb

@@ -4,21 +4,67 @@ require "securerandom"
 require "json"
 
 require "async"
+require "async/pool"
+require "async/pool/resource"
+require "async/pool/controller"
 require "async/queue"
+require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
+require_relative "async/channel"
+
 require_relative "grumlin/version"
 require_relative "grumlin/exceptions"
 
+require_relative "grumlin/transport"
+require_relative "grumlin/client"
+
 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/step"
+require_relative "grumlin/request_dispatcher"
 require_relative "grumlin/translator"
-require_relative "grumlin/traversing_context"
+
+require_relative "grumlin/anonymous_step"
+require_relative "grumlin/step"
+
+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, :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_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
+    end
+
+    def default_pool
+      @default_pool ||= Async::Pool::Controller.new(Grumlin::Client::PoolResource, limit: pool_size)
+    end
+
+    def reset!
+      @default_pool = 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,172 +1,108 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Client # rubocop:disable Metrics/ClassLength
-    SUCCESS_STATUS = 200
-    NO_CONTENT_STATUS = 204
-    PARTIAL_CONTENT_STATUS = 206
-
-    ERRORS = {
-      499 => InvalidRequestArgumentsError,
-      500 => ServerError,
-      597 => ScriptEvaluationError,
-      599 => ServerSerializationError,
-      598 => ServerTimeoutError,
-
-      401 => ClientSideError,
-      407 => ClientSideError,
-      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
-
-      connect if autoconnect
-    end
-
-    def connect # rubocop:disable Metrics/MethodLength
-      raise AlreadyConnectedError unless @connection_task.nil?
+  class Client
+    class PoolResource < Async::Pool::Resource
+      attr_reader :client
 
-      @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
+      def self.call
+        config = Grumlin.config
+        new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
       end
-    end
-
-    def disconnect
-      raise NotConnectedError if @connection_task.nil?
-
-      @connection_task&.stop
-      @connection_task&.wait
-      @connection_task = nil
-      @requests = {}
-    end
-
-    def query(*args) # rubocop:disable Metrics/MethodLength
-      response_queue, request_id = schedule_query(args)
-      result = []
 
-      response_queue.each do |status, response|
-        reraise_error!(response) if status == :error
-
-        status = response[:status]
-
-        if status[:code] == NO_CONTENT_STATUS
-          close_request(request_id)
-          return []
-        end
+      def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
+        super(concurrency)
+        @client = client_factory.call(url, parent).tap(&:connect)
+      end
 
-        check_errors!(status, request_id)
+      def closed?
+        !@client.connected?
+      end
 
-        page = Typing.cast(response.dig(:result, :data))
+      def close
+        @client.close
+      end
 
-        case status[:code]
-        when SUCCESS_STATUS
-          close_request(request_id)
-          return result + page
-        when PARTIAL_CONTENT_STATUS
-          result += page
-        else
-          raise UnknownResponseStatus, status
-        end
+      def write(*args)
+        @client.write(*args)
       end
     end
 
-    private
-
-    def schedule_query(args)
-      uuid = SecureRandom.uuid
-      queue = Async::Queue.new
-      @requests[uuid] = queue
-      @query_queue << to_query(uuid, args)
-
-      [queue, uuid]
+    def initialize(url, parent: Async::Task.current, **client_options)
+      @url = url
+      @client_options = client_options
+      @parent = parent
+      reset!
     end
 
-    def to_query(uuid, message)
-      case message.first
-      when String
-        string_query_message(uuid, *message)
-      when Grumlin::Step
-        build_query(uuid, message)
+    def connect
+      @transport = build_transport
+      response_channel = @transport.connect
+      @request_dispatcher = RequestDispatcher.new
+      @parent.async do
+        response_channel.each do |response|
+          @request_dispatcher.add_response(response)
+        end
+      rescue StandardError
+        close
       end
     end
 
-    def check_errors!(status, request_id)
-      error = ERRORS[status[:code]]
-      close_request(request_id)
-      raise(error, status) if error
-    end
+    def close
+      @transport.close
+      raise ResourceLeakError, "Request list is not empty: #{requests}" if @request_dispatcher.requests.any?
 
-    def close_request(request_id)
-      @requests.delete(request_id)
+      reset!
     end
 
-    def reraise_error!(error)
-      raise error
-    rescue StandardError
-      raise ConnectionError
+    def connected?
+      @transport&.connected? || false
     end
 
-    def query_task(connection)
-      loop do
-        connection.write @query_queue.dequeue
-        connection.flush
-      end
-    end
+    # TODO: support yielding
+    def write(*args) # rubocop:disable Metrics/MethodLength
+      raise NotConnectedError unless connected?
+
+      request_id = SecureRandom.uuid
+      request = to_query(request_id, args)
+      channel = @request_dispatcher.add_request(request)
+      @transport.write(request)
 
-    def response_task(connection)
-      loop do
-        response = connection.read
-        response_queue = @requests[response[:requestId]]
-        response_queue << [:response, response]
+      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"
       end
     end
 
-    def string_query_message(uuid, query, bindings)
-      {
-        requestId: uuid,
-        op: "eval",
-        processor: "",
-        args: {
-          gremlin: query,
-          bindings: bindings,
-          language: "gremlin-groovy"
-        }
-      }
+    def inspect
+      "<#{self.class} url=#{@url} connected=#{connected?}>"
     end
 
-    def bytecode_query_message(uuid, bytecode)
+    alias to_s inspect
+
+    private
+
+    def to_query(request_id, message)
       {
-        requestId: uuid,
+        requestId: request_id,
         op: "bytecode",
         processor: "traversal",
         args: {
-          gremlin: { "@type": "g:Bytecode", "@value": { step: bytecode } },
+          gremlin: Typing.to_bytecode(Translator.to_bytecode_query(message)),
           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
+    def reset!
+      @request_dispatcher = nil
+      @transport = nil
+    end
+
+    def build_transport
+      Transport.new(@url, parent: @parent, **@client_options)
     end
   end
 end