grumlin 0.23.0 → 1.0.0.rc1

data/lib/grumlin/steps_serializers/string.rb

@@ -1,43 +1,39 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module StepsSerializers
-    class String < Serializer
-      # constructor params: apply_shortcuts: true|false, default: false
-      # constructor params: anonymous: true|false, default: false
-      # TODO: add pretty
+class Grumlin::StepsSerializers::String < Grumlin::StepsSerializers::Serializer
+  # constructor params: apply_shortcuts: true|false, default: false
+  # constructor params: anonymous: true|false, default: false
+  # TODO: add pretty
 
-      def serialize
-        steps = @params[:apply_shortcuts] ? ShortcutsApplyer.call(@steps) : @steps
+  def serialize
+    steps = @params[:apply_shortcuts] ? Grumlin::ShortcutsApplyer.call(@steps) : @steps
 
-        steps = [steps.configuration_steps, steps.steps].map do |stps|
-          stps.map { |step| serialize_step(step) }
-        end
+    steps = [steps.configuration_steps, steps.steps].map do |stps|
+      stps.map { |step| serialize_step(step) }
+    end
 
-        "#{prefix}.#{(steps[0] + steps[1]).join(".")}"
-      end
+    "#{prefix}.#{(steps[0] + steps[1]).join(".")}"
+  end
 
-      private
+  private
 
-      def serialize_step(step)
-        "#{step.name}(#{(step.args + [step.params.any? ? step.params : nil].compact).map do |a|
-          serialize_arg(a)
-        end.join(", ")})"
-      end
+  def serialize_step(step)
+    "#{step.name}(#{(step.args + [step.params.any? ? step.params : nil].compact).map do |a|
+                      serialize_arg(a)
+                    end.join(", ")})"
+  end
 
-      def prefix
-        @prefix ||= @params[:anonymous] ? "__" : "g"
-      end
+  def prefix
+    @prefix ||= @params[:anonymous] ? "__" : "g"
+  end
 
-      def serialize_arg(arg)
-        return "\"#{arg}\"" if arg.is_a?(::String) || arg.is_a?(Symbol)
-        return "#{arg.type}.#{arg.value}" if arg.is_a?(Grumlin::TypedValue)
-        return arg.to_s if arg.is_a?(Grumlin::Expressions::WithOptions)
+  def serialize_arg(arg)
+    return "\"#{arg}\"" if arg.is_a?(::String) || arg.is_a?(Symbol)
+    return "#{arg.type}.#{arg.value}" if arg.is_a?(Grumlin::TypedValue)
+    return arg.to_s if arg.is_a?(Grumlin::Expressions::WithOptions)
 
-        return arg unless arg.is_a?(Steps)
+    return arg unless arg.is_a?(Grumlin::Steps)
 
-        StepsSerializers::String.new(arg, anonymous: true, **@params).serialize
-      end
-    end
+    Grumlin::StepsSerializers::String.new(arg, anonymous: true, **@params).serialize
   end
 end

data/lib/grumlin/test/rspec/db_cleaner_context.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Test
-    module RSpec
-      module DBCleanerContext
-      end
+module Grumlin::Test::RSpec
+  module DBCleanerContext
+  end
 
-      ::RSpec.shared_context DBCleanerContext do
-        include DBCleanerContext
+  ::RSpec.shared_context DBCleanerContext do
+    include DBCleanerContext
 
-        before do
-          g.E.drop.iterate
-          g.V.drop.iterate
-        end
-      end
+    before do
+      g.E.drop.iterate
+      g.V.drop.iterate
     end
   end
 end

data/lib/grumlin/test/rspec/gremlin_context.rb

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Test
-    module RSpec
-      module GremlinContext
-      end
+module Grumlin::Test::RSpec
+  module GremlinContext
+  end
 
-      ::RSpec.shared_context GremlinContext do
-        include GremlinContext
-        include Grumlin::Sugar
+  ::RSpec.shared_context GremlinContext do
+    include GremlinContext
+    include Grumlin::Expressions
 
-        before do
-          Grumlin::Expressions.constants.each do |tool|
-            stub_const(tool.to_s, Grumlin::Expressions.const_get(tool))
-          end
-        end
+    [:__, :g].each do |name|
+      define_method(name) do |cuts = Grumlin::Shortcuts::Storage.empty|
+        cuts.send(name)
+      end
+    end
 
-        after do
-          Grumlin.close
-        end
+    before do
+      Grumlin::Expressions.constants.each do |tool|
+        stub_const(tool.to_s, Grumlin::Expressions.const_get(tool))
       end
     end
+
+    after do
+      Grumlin.close
+    end
   end
 end

data/lib/grumlin/test/rspec.rb

@@ -3,9 +3,5 @@
 require "grumlin/test/rspec/db_cleaner_context"
 require "grumlin/test/rspec/gremlin_context"
 
-module Grumlin
-  module Test
-    module RSpec
-    end
-  end
+module Grumlin::Test::RSpec
 end

data/lib/grumlin/transaction.rb

@@ -1,40 +1,38 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Transaction
-    attr_reader :session_id
-
-    include Console
-
-    COMMIT = Grumlin::Repository.new.g.step(:tx, :commit)
-    ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback)
-
-    def initialize(traversal_start_class, pool:, middlewares:)
-      @traversal_start_class = traversal_start_class
-      @pool = pool
-      @session_id = SecureRandom.uuid
-      @middlewares = middlewares
-    end
-
-    def begin
-      @traversal_start_class.new(session_id: @session_id)
-    end
-
-    def commit
-      finalize(COMMIT)
-    end
-
-    def rollback
-      finalize(ROLLBACK)
-    end
-
-    private
-
-    def finalize(step)
-      @middlewares.call(traversal: step,
-                        need_results: false,
-                        session_id: @session_id,
-                        pool: @pool)
-    end
+class Grumlin::Transaction
+  attr_reader :session_id
+
+  include Console
+
+  COMMIT = Grumlin::Repository.new.g.step(:tx, :commit)
+  ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback)
+
+  def initialize(traversal_start_class, pool:, middlewares:)
+    @traversal_start_class = traversal_start_class
+    @pool = pool
+    @session_id = SecureRandom.uuid
+    @middlewares = middlewares
+  end
+
+  def begin
+    @traversal_start_class.new(session_id: @session_id)
+  end
+
+  def commit
+    finalize(COMMIT)
+  end
+
+  def rollback
+    finalize(ROLLBACK)
+  end
+
+  private
+
+  def finalize(step)
+    @middlewares.call(traversal: step,
+                      need_results: false,
+                      session_id: @session_id,
+                      pool: @pool)
   end
 end

data/lib/grumlin/transport.rb

@@ -1,101 +1,99 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Transport
-    # 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
-    end
+class Grumlin::Transport
+  # A transport based on https://github.com/socketry/async
+  # and https://github.com/socketry/async-websocket
 
-    def connected?
-      !@connection.nil?
-    end
+  include Console
 
-    def connect
-      raise ClientClosedError if @closed
-      raise AlreadyConnectedError if connected?
+  attr_reader :url
 
-      @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
-      logger.debug(self) { "Connected to #{@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
+  end
 
-      @response_task = @parent.async { run_response_task }
+  def connected?
+    !@connection.nil?
+  end
 
-      @request_task = @parent.async { run_request_task }
+  def connect
+    raise ClientClosedError if @closed
+    raise AlreadyConnectedError if connected?
 
-      @response_channel
-    end
+    @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
+    logger.debug(self) { "Connected to #{@url}." }
 
-    def write(message)
-      raise NotConnectedError unless connected?
+    @response_task = @parent.async { run_response_task }
 
-      @request_channel << message
-    end
+    @request_task = @parent.async { run_request_task }
 
-    def close
-      return if @closed
+    @response_channel
+  end
 
-      @closed = true
+  def write(message)
+    raise NotConnectedError unless connected?
 
-      @request_channel.close
-      @response_channel.close
+    @request_channel << message
+  end
 
-      begin
-        @connection.close
-      rescue StandardError
-        nil
-      end
-      @connection = nil
+  def close
+    return if @closed
 
-      @request_task&.stop(true)
-      @response_task&.stop(true)
-    end
+    @closed = true
+
+    @request_channel.close
+    @response_channel.close
 
-    def wait
-      @request_task.wait
-      @response_task.wait
+    begin
+      @connection.close
+    rescue StandardError
+      nil
     end
+    @connection = nil
 
-    private
+    @request_task&.stop(true)
+    @response_task&.stop(true)
+  end
+
+  def wait
+    @request_task.wait
+    @response_task.wait
+  end
 
-    def run_response_task
-      with_guard do
-        loop do
-          data = @connection.read
-          @response_channel << data
-        end
+  private
+
+  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
+  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
+  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

data/lib/grumlin/traversal_start.rb

@@ -1,42 +1,40 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class TraversalStart < Steppable
-    include WithExtension
-
-    class TraversalError < Grumlin::Error; end
-    class AlreadyBoundToTransactionError < TraversalError; end
-
-    def tx
-      raise AlreadyBoundToTransactionError if @session_id
-
-      transaction = tx_class.new(self.class, pool: @pool, middlewares: @middlewares)
-      return transaction unless block_given?
-
-      begin
-        yield transaction.begin
-      rescue Grumlin::Rollback
-        transaction.rollback
-      rescue StandardError
-        transaction.rollback
-        raise
-      else
-        transaction.commit
-      end
+class Grumlin::TraversalStart < Grumlin::Steppable
+  include Grumlin::WithExtension
+
+  class TraversalError < Grumlin::Error; end
+  class AlreadyBoundToTransactionError < TraversalError; end
+
+  def tx
+    raise AlreadyBoundToTransactionError if @session_id
+
+    transaction = tx_class.new(self.class, pool: @pool, middlewares: @middlewares)
+    return transaction unless block_given?
+
+    begin
+      yield transaction.begin
+    rescue Grumlin::Rollback
+      transaction.rollback
+    rescue StandardError
+      transaction.rollback
+      raise
+    else
+      transaction.commit
     end
+  end
 
-    def to_s(*)
-      self.class.to_s
-    end
+  def to_s(*)
+    self.class.to_s
+  end
 
-    def inspect
-      self.class.inspect
-    end
+  def inspect
+    self.class.inspect
+  end
 
-    private
+  private
 
-    def tx_class
-      Grumlin.features.supports_transactions? ? Transaction : DummyTransaction
-    end
+  def tx_class
+    Grumlin.features.supports_transactions? ? Grumlin::Transaction : Grumlin::DummyTransaction
   end
 end

data/lib/grumlin/traversal_strategies/options_strategy.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module TraversalStrategies
-    class OptionsStrategy < TypedValue
-      def initialize(value)
-        super(type: "OptionsStrategy", value: value)
-      end
-    end
+class Grumlin::TraversalStrategies::OptionsStrategy < Grumlin::TypedValue
+  def initialize(value)
+    super(type: "OptionsStrategy", value: value)
   end
 end

data/lib/grumlin/traverser.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Traverser
-    attr_reader :bulk, :value
+class Grumlin::Traverser
+  attr_reader :bulk, :value
 
-    def initialize(value)
-      @bulk = value.dig(:bulk, :@value) || 1
-      @value = Typing.cast(value[:value])
-    end
+  def initialize(value)
+    @bulk = value.dig(:bulk, :@value) || 1
+    @value = Grumlin::Typing.cast(value[:value])
   end
 end

data/lib/grumlin/typed_value.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class TypedValue
-    attr_reader :type, :value
+class Grumlin::TypedValue
+  attr_reader :type, :value
 
-    def initialize(type: nil, value: nil)
-      @type = type
-      @value = value
-    end
+  def initialize(type: nil, value: nil)
+    @type = type
+    @value = value
+  end
 
-    def inspect
-      "<#{type}.#{value}>"
-    end
+  def inspect
+    "<#{type}.#{value}>"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end