grumlin 0.7.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4260297c3d75ec7bc1f987d8c7bad4efd75c81627814fdf984a0aaac0045332b
-  data.tar.gz: 1cb521906a08cf5390f058a28f380492a2999e55ef023c473fc6bae64533b53b
+  metadata.gz: 2306eba516eebd5d53ac7e8e77acd5d7b2fcb7ad3579e9abc734210aec20ce29
+  data.tar.gz: ebd72733ea3f6ac4554044a00aac252f6a14997664a7b95ebdba01d082e4c8cd
 SHA512:
-  metadata.gz: 992d2192402f3fe282203a3fd0eff1e6c886470899cb37f00ca2abf1392e4d946c7391be0eb7d6560c9941f7a17a3552682a8a47f56273f4299c06551c1e9ffc
-  data.tar.gz: d8695e2485915cb7b4d37a755e42d20b6d7f575d906ae5a0aca5f508c01a104c08f7bb51a2285c9dac48a0091771882afeb405fd26e7802c4d48513274e2895f
+  metadata.gz: bda5181c00cabc8d69fdaa891a81943527dabfaa69ce70babbba6c1f11efc83b6f942d23d6aaf792d580f842ca7f64971986def6e1cfc1e6d4d3626da05efa1b
+  data.tar.gz: 212fbac76d50dfe281e574604ffbb82e8008937d777c279575a05468ee0f063faa6f0a8fa1417e8ea40e96f72b1b9f1f61c9e881e7c9b800d25964ce3ad7932a

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    grumlin (0.7.0)
+    grumlin (0.10.1)
       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.6)
     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/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

@@ -24,8 +24,8 @@ module Grumlin
         @client.close
       end
 
-      def write(*args)
-        @client.write(*args)
+      def write(bytecode)
+        @client.write(bytecode)
       ensure
         @count += 1
       end
@@ -94,11 +94,10 @@ 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)
 
@@ -118,18 +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 build_transport
       Transport.new(@url, parent: @parent, **@client_options)
     end

data/lib/grumlin/request_dispatcher.rb

@@ -44,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
@@ -77,9 +77,9 @@ module Grumlin
 
     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,32 +4,42 @@ 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
 
     def next
-      @enum ||= toList.to_enum
-      @enum.next
+      to_enum.next
+    end
+
+    def hasNext # rubocop:disable Naming/MethodName
+      to_enum.peek
+      true
+    rescue StopIteration
+      false
+    end
+
+    def to_enum
+      @to_enum ||= toList.to_enum
     end
 
     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/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.7.0"
+  VERSION = "0.10.1"
 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,34 +15,87 @@ 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
 
@@ -48,16 +104,10 @@ module Grumlin
       @client_concurrency = 5
       @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
 
+  @pool_mutex = Mutex.new
+
   class << self
     def configure
       yield config
@@ -66,5 +116,31 @@ module Grumlin
     def config
       @config ||= Config.new
     end
+
+    def default_pool
+      if Thread.current.thread_variable_get(:grumlin_default_pool)
+        return Thread.current.thread_variable_get(:grumlin_default_pool)
+      end
+
+      @pool_mutex.synchronize do
+        Thread.current.thread_variable_set(:grumlin_default_pool,
+                                           Async::Pool::Controller.new(Grumlin::Client::PoolResource,
+                                                                       limit: config.pool_size))
+      end
+    end
+
+    def close
+      return if Thread.current.thread_variable_get(:grumlin_default_pool).nil?
+
+      @pool_mutex.synchronize do
+        pool = Thread.current.thread_variable_get(:grumlin_default_pool)
+        pool.wait while pool.busy?
+        pool.close
+        Thread.current.thread_variable_set(:grumlin_default_pool, nil)
+      end
+    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.7.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-13 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