grumlin 0.23.0 → 1.0.0.rc1

data/lib/grumlin/client.rb

@@ -1,125 +1,123 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Client
-    class PoolResource < Async::Pool::Resource
-      attr_reader :client
-
-      def self.call
-        config = Grumlin.config
-        new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
-      end
-
-      def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
-        super(concurrency)
-        @client = client_factory.call(url, parent).tap(&:connect)
-        @parent = parent
-      end
+class Grumlin::Client
+  class PoolResource < Async::Pool::Resource
+    attr_reader :client
 
-      def closed?
-        !@client.connected?
-      end
+    def self.call
+      config = Grumlin.config
+      new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
+    end
 
-      def close
-        @client.close
-      end
+    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 write(query)
-        @client.write(query)
-      ensure
-        @count += 1
-      end
+    def closed?
+      !@client.connected?
+    end
 
-      def viable?
-        !closed?
-      end
+    def close
+      @client.close
+    end
 
-      def reusable?
-        !closed?
-      end
+    def write(query)
+      @client.write(query)
+    ensure
+      @count += 1
     end
 
-    include Console
+    def viable?
+      !closed?
+    end
 
-    # 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
-      @request_dispatcher = nil
-      @transport = nil
+    def reusable?
+      !closed?
     end
+  end
 
-    def connect
-      raise ClientClosedError if @closed
-
-      @transport = build_transport
-      response_channel = @transport.connect
-      @request_dispatcher = RequestDispatcher.new
-      @response_task = @parent.async do
-        response_channel.each do |response|
-          @request_dispatcher.add_response(response)
-        end
-      rescue Async::Stop, Async::TimeoutError, StandardError
-        close(check_requests: false)
+  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
+    @request_dispatcher = nil
+    @transport = nil
+  end
+
+  def connect
+    raise ClientClosedError if @closed
+
+    @transport = build_transport
+    response_channel = @transport.connect
+    @request_dispatcher = Grumlin::RequestDispatcher.new
+    @response_task = @parent.async do
+      response_channel.each do |response|
+        @request_dispatcher.add_response(response)
       end
-      logger.debug(self, "Connected")
+    rescue Async::Stop, Async::TimeoutError, StandardError
+      close(check_requests: false)
     end
+    logger.debug(self, "Connected")
+  end
 
-    # 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
+  # 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
+    @closed = true
 
-      @transport&.close
-      @transport&.wait
+    @transport&.close
+    @transport&.wait
 
-      @response_task&.stop
-      @response_task&.wait
+    @response_task&.stop
+    @response_task&.wait
 
-      return if @request_dispatcher&.requests&.empty?
+    return if @request_dispatcher&.requests&.empty?
 
-      @request_dispatcher.clear unless check_requests
+    @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
+    raise ResourceLeakError, "Request list is not empty: #{@request_dispatcher.requests}" if check_requests
+  ensure
+    logger.debug(self, "Closed")
+  end
 
-    def connected?
-      @transport&.connected? || false
-    end
+  def connected?
+    @transport&.connected? || false
+  end
 
-    # TODO: support yielding
-    def write(query)
-      raise NotConnectedError unless connected?
-
-      channel = @request_dispatcher.add_request(query)
-      begin
-        @transport.write(query)
-        channel.dequeue
-      rescue Async::Stop, Async::TimeoutError
-        close(check_requests: false)
-        raise
-      end
+  # TODO: support yielding
+  def write(query)
+    raise NotConnectedError unless connected?
+
+    channel = @request_dispatcher.add_request(query)
+    begin
+      @transport.write(query)
+      channel.dequeue
+    rescue Async::Stop, Async::TimeoutError
+      close(check_requests: false)
+      raise
     end
+  end
 
-    def inspect
-      "<#{self.class} url=#{@url} connected=#{connected?}>"
-    end
+  def inspect
+    "<#{self.class} url=#{@url} connected=#{connected?}>"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
+  end
 
-    private
+  private
 
-    # This might be overridden in successors
-    def build_transport
-      Transport.new(@url, parent: @parent, **@client_options)
-    end
+  # This might be overridden in successors
+  def build_transport
+    Grumlin::Transport.new(@url, parent: @parent, **@client_options)
   end
 end

data/lib/grumlin/config.rb

@@ -1,41 +1,41 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Config
-    attr_accessor :url, :pool_size, :client_concurrency, :client_factory, :provider
-
-    SUPPORTED_PROVIDERS = %i[neptune tinkergraph].freeze
-
-    DEFAULT_MIDDLEWARES = Middleware::Builder.new do |b|
-      b.use Middlewares::SerializeToSteps
-      b.use Middlewares::ApplyShortcuts
-      b.use Middlewares::SerializeToBytecode
-      b.use Middlewares::BuildQuery
-      b.use Middlewares::CastResults
-      b.use Middlewares::RunQuery
-    end.freeze
-
-    class ConfigurationError < Grumlin::Error; end
-
-    class UnknownProviderError < ConfigurationError; end
-
-    def initialize
-      @pool_size = 10
-      @client_concurrency = 5
-      @provider = :tinkergraph
-      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
-    end
+class Grumlin::Config
+  attr_accessor :url, :pool_size, :client_concurrency, :client_factory, :provider
+
+  SUPPORTED_PROVIDERS = [:neptune, :tinkergraph].freeze
+
+  DEFAULT_MIDDLEWARES = Grumlin::Middlewares::Builder.new do |b|
+    b.use Grumlin::Middlewares::SerializeToSteps
+    b.use Grumlin::Middlewares::ApplyShortcuts
+    b.use Grumlin::Middlewares::SerializeToBytecode
+    b.use Grumlin::Middlewares::BuildQuery
+    b.use Grumlin::Middlewares::CastResults
+    b.use Grumlin::Middlewares::RunQuery
+  end
 
-    def middlewares
-      @middlewares ||= Middleware::Builder.new do |b|
-        b.use DEFAULT_MIDDLEWARES
-      end
-    end
+  class ConfigurationError < Grumlin::Error; end
+
+  class UnknownProviderError < ConfigurationError; end
 
-    def validate!
-      return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
+  def initialize
+    @pool_size = 10
+    @client_concurrency = 5
+    @provider = :tinkergraph
+    @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
+  end
 
-      raise UnknownProviderError, "provider '#{provider}' is unknown. Supported providers: #{SUPPORTED_PROVIDERS}"
+  def middlewares
+    @middlewares ||= Grumlin::Middlewares::Builder.new do |b|
+      b.use DEFAULT_MIDDLEWARES
     end
+    yield(@middlewares) if block_given?
+    @middlewares
+  end
+
+  def validate!
+    return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
+
+    raise UnknownProviderError, "provider '#{provider}' is unknown. Supported providers: #{SUPPORTED_PROVIDERS}"
   end
 end

data/lib/grumlin/dummy_transaction.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class DummyTransaction < Transaction
-    attr_reader :uuid
+class Grumlin::DummyTransaction < Grumlin::Transaction
+  attr_reader :uuid
 
-    include Console
+  include Console
 
-    def initialize(traversal_start_class, middlewares:, pool: nil) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
-      @traversal_start_class = traversal_start_class
+  def initialize(traversal_start_class, middlewares:, pool: nil) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
+    @traversal_start_class = traversal_start_class
 
-      logger.info(self) do
-        "#{Grumlin.config.provider} does not support transactions. commit and rollback are ignored, data will be saved"
-      end
+    logger.info(self) do
+      "#{Grumlin.config.provider} does not support transactions. commit and rollback are ignored, data will be saved"
     end
+  end
 
-    def commit
-      nil
-    end
+  def commit
+    nil
+  end
 
-    def rollback
-      nil
-    end
+  def rollback
+    nil
   end
 end

data/lib/grumlin/edge.rb

@@ -1,28 +1,26 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Edge
-    attr_reader :label, :id, :inVLabel, :outVLabel, :inV, :outV
+class Grumlin::Edge
+  attr_reader :label, :id, :inVLabel, :outVLabel, :inV, :outV
 
-    def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:)
-      @label = label
-      @id = Typing.cast(id)
-      @inVLabel = inVLabel
-      @outVLabel = outVLabel
-      @inV = Typing.cast(inV)
-      @outV = Typing.cast(outV)
-    end
+  def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:)
+    @label = label
+    @id = Grumlin::Typing.cast(id)
+    @inVLabel = inVLabel
+    @outVLabel = outVLabel
+    @inV = Grumlin::Typing.cast(inV)
+    @outV = Grumlin::Typing.cast(outV)
+  end
 
-    def ==(other)
-      self.class == other.class && @label == other.label && @id == other.id
-    end
+  def ==(other)
+    self.class == other.class && @label == other.label && @id == other.id
+  end
 
-    def inspect
-      "e[#{@id}][#{@outV}-#{@label}->#{@inV}]"
-    end
+  def inspect
+    "e[#{@id}][#{@outV}-#{@label}->#{@inV}]"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end

data/lib/grumlin/expressions/cardinality.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Cardinality
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :cardinality).map(&:to_sym).freeze
+module Grumlin::Expressions::Cardinality
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :cardinality).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Cardinality")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Cardinality")
   end
 end

data/lib/grumlin/expressions/column.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Column
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :column).map(&:to_sym).freeze
+module Grumlin::Expressions::Column
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :column).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Column")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Column")
   end
 end

data/lib/grumlin/expressions/expression.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Expression
-      def define_steps(steps, tool_name)
-        steps.each do |step|
-          define_method step do
-            name = "@#{step}"
-            return instance_variable_get(name) if instance_variable_defined?(name)
+module Grumlin::Expressions::Expression
+  def define_steps(steps, tool_name)
+    steps.each do |step|
+      define_method step do
+        name = "@#{step}"
+        return instance_variable_get(name) if instance_variable_defined?(name)
 
-            instance_variable_set(name, TypedValue.new(type: tool_name, value: step))
-          end
-        end
+        instance_variable_set(name, Grumlin::TypedValue.new(type: tool_name, value: step))
       end
     end
   end

data/lib/grumlin/expressions/operator.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Operator
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :operator).map(&:to_sym).freeze
+module Grumlin::Expressions::Operator
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :operator).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Operator")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Operator")
   end
 end

data/lib/grumlin/expressions/order.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Order
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :order).map(&:to_sym).freeze
+module Grumlin::Expressions::Order
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :order).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Order")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Order")
   end
 end

data/lib/grumlin/expressions/p.rb

@@ -1,39 +1,35 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    class P
-      class Predicate
-        attr_reader :namespace, :name, :value, :type
+class Grumlin::Expressions::P
+  class Predicate
+    attr_reader :namespace, :name, :value, :type
 
-        def initialize(namespace, name, value:, type: nil)
-          @namespace = namespace
-          @name = name
-          @value = value
-          @type = type
-        end
-      end
+    def initialize(namespace, name, value:, type: nil)
+      @namespace = namespace
+      @name = name
+      @value = value
+      @type = type
+    end
+  end
 
-      class << self
-        # TODO: support more predicates
-        %i[eq gt lt neq].each do |predicate|
-          define_method predicate do |*args|
-            Predicate.new("P", predicate, value: args[0])
-          end
-        end
+  class << self
+    # TODO: support more predicates
+    [:eq, :gt, :lt, :neq].each do |predicate|
+      define_method predicate do |*args|
+        Predicate.new("P", predicate, value: args[0])
+      end
+    end
 
-        %i[within without].each do |predicate|
-          define_method predicate do |*args|
-            args = if args.count == 1 && args[0].is_a?(Array)
-                     args[0]
-                   elsif args.count == 1 && args[0].is_a?(Set)
-                     args[0].to_a
-                   else
-                     args.to_a
-                   end
-            Predicate.new("P", predicate, value: args, type: "List")
-          end
-        end
+    [:within, :without].each do |predicate|
+      define_method predicate do |*args|
+        args = if args.count == 1 && args[0].is_a?(Array)
+                 args[0]
+               elsif args.count == 1 && args[0].is_a?(Set)
+                 args[0].to_a
+               else
+                 args.to_a
+               end
+        Predicate.new("P", predicate, value: args, type: "List")
       end
     end
   end

data/lib/grumlin/expressions/pop.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Pop
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :pop).map(&:to_sym).freeze
+module Grumlin::Expressions::Pop
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :pop).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Pop")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Pop")
   end
 end

data/lib/grumlin/expressions/scope.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Scope
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :scope).map(&:to_sym).freeze
+module Grumlin::Expressions::Scope
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :scope).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Scope")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Scope")
   end
 end

data/lib/grumlin/expressions/t.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module T
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :t).map(&:to_sym).freeze
+module Grumlin::Expressions::T
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :t).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "T")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "T")
   end
 end

data/lib/grumlin/expressions/text_p.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    class TextP < P
-      class << self
-        %i[containing endingWith notContaining notEndingWith notStartingWith startingWith].each do |predicate|
-          define_method predicate do |*args|
-            P::Predicate.new("TextP", predicate, value: args[0])
-          end
-        end
+class Grumlin::Expressions::TextP < Grumlin::Expressions::P
+  class << self
+    [:containing, :endingWith, :notContaining, :notEndingWith, :notStartingWith, :startingWith].each do |predicate|
+      define_method predicate do |*args|
+        P::Predicate.new("TextP", predicate, value: args[0])
       end
     end
   end