grumlin 0.22.4 → 1.0.0.rc1

data/lib/grumlin/step_data.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class StepData
-    attr_reader :name, :args, :params
+class Grumlin::StepData
+  attr_reader :name, :args, :params
 
-    def initialize(name, args: [], params: {})
-      @name = name
-      @args = args
-      @params = params
-    end
+  def initialize(name, args: [], params: {})
+    @name = name
+    @args = args
+    @params = params
+  end
 
-    def ==(other)
-      self.class == other.class &&
-        @name == other.name &&
-        @args == other.args &&
-        @params == other.params
-    end
+  def ==(other)
+    self.class == other.class &&
+      @name == other.name &&
+      @args == other.args &&
+      @params == other.params
   end
 end

data/lib/grumlin/steppable.rb

@@ -1,36 +1,38 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Steppable
-    extend Forwardable
+class Grumlin::Steppable
+  extend Forwardable
 
-    attr_reader :session_id
+  attr_reader :session_id
 
-    START_STEPS = Grumlin.definitions.dig(:steps, :start).map(&:to_sym).freeze
-    REGULAR_STEPS = Grumlin.definitions.dig(:steps, :regular).map(&:to_sym).freeze
-    CONFIGURATION_STEPS = Grumlin.definitions.dig(:steps, :configuration).map(&:to_sym).freeze
+  START_STEPS = Grumlin.definitions.dig(:steps, :start).map(&:to_sym).freeze
+  REGULAR_STEPS = Grumlin.definitions.dig(:steps, :regular).map(&:to_sym).freeze
+  CONFIGURATION_STEPS = Grumlin.definitions.dig(:steps, :configuration).map(&:to_sym).freeze
 
-    ALL_STEPS = START_STEPS + CONFIGURATION_STEPS + REGULAR_STEPS
+  ALL_STEPS = START_STEPS + CONFIGURATION_STEPS + REGULAR_STEPS
 
-    def initialize(pool: Grumlin.default_pool, session_id: nil)
-      @pool = pool
-      @session_id = session_id
+  def initialize(pool: nil, session_id: nil, middlewares: Grumlin.default_middlewares)
+    @pool = pool
+    @session_id = session_id
 
-      return if respond_to?(:shortcuts)
+    @middlewares = middlewares
 
-      raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
-    end
+    return if respond_to?(:shortcuts)
 
-    ALL_STEPS.each do |step|
-      define_method step do |*args, **params|
-        shortcuts.action_class.new(step, args: args, params: params, previous_step: self, session_id: @session_id)
-      end
-    end
+    raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
+  end
 
-    def step(name, *args, **params)
-      shortcuts.action_class.new(name, args: args, params: params, previous_step: self, session_id: @session_id)
+  ALL_STEPS.each do |step|
+    define_method step do |*args, **params|
+      shortcuts.step_class.new(step, args: args, params: params, previous_step: self,
+                                     session_id: @session_id, pool: @pool, middlewares: @middlewares)
     end
+  end
 
-    def_delegator :shortcuts, :__
+  def step(name, *args, **params)
+    shortcuts.step_class.new(name, args: args, params: params, previous_step: self,
+                                   session_id: @session_id, pool: @pool, middlewares: @middlewares)
   end
+
+  def_delegator :shortcuts, :__
 end

data/lib/grumlin/steps.rb

@@ -1,79 +1,76 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Steps
-    CONFIGURATION_STEPS = Action::CONFIGURATION_STEPS
-    ALL_STEPS = Action::ALL_STEPS
+class Grumlin::Steps
+  CONFIGURATION_STEPS = Grumlin::Step::CONFIGURATION_STEPS
+  ALL_STEPS = Grumlin::Step::ALL_STEPS
 
-    def self.from(action)
-      raise ArgumentError, "expected: #{Action}, given: #{action.class}" unless action.is_a?(Action)
+  def self.from(step)
+    raise ArgumentError, "expected: #{Grumlin::Step}, given: #{step.class}" unless step.is_a?(Grumlin::Step)
 
-      shortcuts = action.shortcuts
-      actions = []
-
-      until action.nil? || action.is_a?(TraversalStart)
-        actions.unshift(action)
-        action = action.previous_step
-      end
-
-      new(shortcuts).tap do |chain|
-        actions.each do |act|
-          chain.add(act.name, args: act.args, params: act.params)
-        end
+    new(step.shortcuts).tap do |chain|
+      until step.nil? || step.is_a?(Grumlin::TraversalStart)
+        chain.add(step.name, args: step.args, params: step.params, to: :begin)
+        step = step.previous_step
       end
     end
+  end
 
-    attr_reader :configuration_steps, :steps, :shortcuts
+  attr_reader :configuration_steps, :steps, :shortcuts
 
-    def initialize(shortcuts, configuration_steps: [], steps: [])
-      @shortcuts = shortcuts
-      @configuration_steps = configuration_steps
-      @steps = steps
+  def initialize(shortcuts, configuration_steps: [], steps: [])
+    @shortcuts = shortcuts
+    @configuration_steps = configuration_steps
+    @steps = steps
+  end
+
+  def add(name, args: [], params: {}, to: :end)
+    if CONFIGURATION_STEPS.include?(name) || name.to_sym == :tx
+      return add_configuration_step(name, args: args, params: params, to: to)
     end
 
-    def add(name, args: [], params: {})
-      if CONFIGURATION_STEPS.include?(name) || name.to_sym == :tx
-        return add_configuration_step(name, args: args, params: params)
-      end
+    Grumlin::StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
+      next @steps << step if to == :end
+      next @steps.unshift(step) if to == :begin
 
-      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
-        @steps << step
-      end
+      raise ArgumentError, "'to:' must be either :begin or :end, given: '#{to}'"
     end
+  end
 
-    def uses_shortcuts?
-      shortcuts?(@configuration_steps) || shortcuts?(@steps)
-    end
+  def uses_shortcuts?
+    shortcuts?(@configuration_steps) || shortcuts?(@steps)
+  end
 
-    def ==(other)
-      self.class == other.class &&
-        @shortcuts == other.shortcuts &&
-        @configuration_steps == other.configuration_steps &&
-        @steps == other.steps
-    end
+  def ==(other)
+    self.class == other.class &&
+      @shortcuts == other.shortcuts &&
+      @configuration_steps == other.configuration_steps &&
+      @steps == other.steps
+  end
 
-    # TODO: add #bytecode, to_s, inspect
+  # TODO: add #bytecode, to_s, inspect
 
-    private
+  private
 
-    def shortcuts?(steps_ary)
-      steps_ary.any? do |step|
-        @shortcuts.known?(step.name) || step.args.any? do |arg|
-          arg.is_a?(Steps) ? arg.uses_shortcuts? : false
-        end
+  def shortcuts?(steps_ary)
+    steps_ary.any? do |step|
+      @shortcuts.known?(step.name) || step.args.any? do |arg|
+        arg.is_a?(Grumlin::Steps) ? arg.uses_shortcuts? : false
       end
     end
+  end
 
-    def add_configuration_step(name, args: [], params: {})
-      raise ArgumentError, "cannot use configuration steps after start step was used" unless @steps.empty?
+  def add_configuration_step(name, args: [], params: {}, to: :end)
+    raise ArgumentError, "cannot use configuration steps after start step was used" if @steps.any? && to == :end
 
-      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
-        @configuration_steps << step
-      end
-    end
+    Grumlin::StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
+      next @configuration_steps << step if to == :end
+      next @configuration_steps.unshift(step) if to == :begin
 
-    def cast_arguments(arguments)
-      arguments.map { |arg| arg.is_a?(Action) ? Steps.from(arg) : arg }
+      raise ArgumentError, "to must be either :begin or :end, given: '#{to}'"
     end
   end
+
+  def cast_arguments(arguments)
+    arguments.map { |arg| arg.is_a?(Grumlin::Step) ? Grumlin::Steps.from(arg) : arg }
+  end
 end

data/lib/grumlin/steps_serializers/bytecode.rb

@@ -1,72 +1,69 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module StepsSerializers
-    class Bytecode < Serializer
-      # constructor params: no_return: true|false, default false
-      # TODO: add pretty
+class Grumlin::StepsSerializers::Bytecode < Grumlin::StepsSerializers::Serializer
+  # constructor params: no_return: true|false, default false
+  # TODO: add pretty
 
-      NONE_STEP = StepData.new("none")
+  NONE_STEP = Grumlin::StepData.new("none")
 
-      def serialize
-        steps = ShortcutsApplyer.call(@steps)
-        no_return = @params.fetch(:no_return, false)
-        {}.tap do |result|
-          result[:step] = serialize_steps(steps.steps + (no_return ? [NONE_STEP] : [])) if steps.steps.any?
-          result[:source] = serialize_steps(steps.configuration_steps) if steps.configuration_steps.any?
-        end
-      end
+  def serialize
+    steps = Grumlin::ShortcutsApplyer.call(@steps)
+    no_return = @params.fetch(:no_return, false)
+    {}.tap do |result|
+      result[:step] = serialize_steps(steps.steps + (no_return ? [NONE_STEP] : [])) if steps.steps.any?
+      result[:source] = serialize_steps(steps.configuration_steps) if steps.configuration_steps.any?
+    end
+  end
 
-      private
+  private
 
-      def serialize_steps(steps)
-        steps.map { |s| serialize_step(s) }
-      end
+  def serialize_steps(steps)
+    steps.map { |s| serialize_step(s) }
+  end
 
-      def serialize_step(step)
-        [step.name].tap do |result|
-          step.args.each do |arg|
-            result << serialize_arg(arg)
-          end
-          result << step.params if step.params.any?
-        end
+  def serialize_step(step)
+    [step.name].tap do |result|
+      step.args.each do |arg|
+        result << serialize_arg(arg)
       end
+      result << step.params if step.params.any?
+    end
+  end
 
-      def serialize_arg(arg)
-        return serialize_typed_value(arg) if arg.is_a?(TypedValue)
-        return serialize_predicate(arg) if arg.is_a?(Expressions::P::Predicate)
-        return arg.value if arg.is_a?(Expressions::WithOptions)
+  def serialize_arg(arg)
+    return serialize_typed_value(arg) if arg.is_a?(Grumlin::TypedValue)
+    return serialize_predicate(arg) if arg.is_a?(Grumlin::Expressions::P::Predicate)
+    return arg.value if arg.is_a?(Grumlin::Expressions::WithOptions)
 
-        return arg unless arg.is_a?(Steps)
+    return arg unless arg.is_a?(Grumlin::Steps)
 
-        { :@type => "g:Bytecode", :@value => Bytecode.new(arg, **@params.merge(no_return: false)).serialize }
-      end
+    { :@type => "g:Bytecode",
+      :@value => Grumlin::StepsSerializers::Bytecode.new(arg, **@params.merge(no_return: false)).serialize }
+  end
 
-      def serialize_typed_value(value)
-        return value.value if value.type.nil?
+  def serialize_typed_value(value)
+    return value.value if value.type.nil?
 
-        {
-          "@type": "g:#{value.type}",
-          "@value": value.value
-        }
-      end
+    {
+      "@type": "g:#{value.type}",
+      "@value": value.value
+    }
+  end
 
-      def serialize_predicate(value)
-        {
-          "@type": "g:#{value.namespace}",
-          "@value": {
-            predicate: value.name,
-            value: if value.type.nil?
-                     value.value
-                   else
-                     {
-                       "@type": "g:#{value.type}",
-                       "@value": value.value
-                     }
-                   end
-          }
-        }
-      end
-    end
+  def serialize_predicate(value)
+    {
+      "@type": "g:#{value.namespace}",
+      "@value": {
+        predicate: value.name,
+        value: if value.type.nil?
+                 value.value
+               else
+                 {
+                   "@type": "g:#{value.type}",
+                   "@value": value.value
+                 }
+               end
+      }
+    }
   end
 end

data/lib/grumlin/steps_serializers/human_readable_bytecode.rb

@@ -1,30 +1,26 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module StepsSerializers
-    class HumanReadableBytecode < Bytecode
-      def serialize
-        steps = ShortcutsApplyer.call(@steps)
-        [steps.configuration_steps, steps.steps].map do |stps|
-          stps.map { |s| serialize_step(s) }
-        end
-      end
+class Grumlin::StepsSerializers::HumanReadableBytecode < Grumlin::StepsSerializers::Bytecode
+  def serialize
+    steps = Grumlin::ShortcutsApplyer.call(@steps)
+    [steps.configuration_steps, steps.steps].map do |stps|
+      stps.map { |s| serialize_step(s) }
+    end
+  end
 
-      private
+  private
 
-      def serialize_arg(arg)
-        return arg.to_s if arg.is_a?(TypedValue)
-        return serialize_predicate(arg) if arg.is_a?(Expressions::P::Predicate)
-        return arg.value if arg.is_a?(Expressions::WithOptions)
+  def serialize_arg(arg)
+    return arg.to_s if arg.is_a?(Grumlin::TypedValue)
+    return serialize_predicate(arg) if arg.is_a?(Grumlin::Expressions::P::Predicate)
+    return arg.value if arg.is_a?(Grumlin::Expressions::WithOptions)
 
-        return arg unless arg.is_a?(Steps)
+    return arg unless arg.is_a?(Grumlin::Steps)
 
-        HumanReadableBytecode.new(arg, **@params.merge(no_return: false)).serialize[1]
-      end
+    Grumlin::StepsSerializers::HumanReadableBytecode.new(arg, **@params.merge(no_return: false)).serialize[1]
+  end
 
-      def serialize_predicate(arg)
-        "#{arg.name}(#{arg.value})"
-      end
-    end
+  def serialize_predicate(arg)
+    "#{arg.name}(#{arg.value})"
   end
 end

data/lib/grumlin/steps_serializers/serializer.rb

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module StepsSerializers
-    class Serializer
-      def initialize(steps, **params)
-        @steps = steps
-        @params = params
-      end
+class Grumlin::StepsSerializers::Serializer
+  def initialize(steps, **params)
+    @steps = steps
+    @params = params
+  end
 
-      def serialize
-        raise NotImplementedError
-      end
-    end
+  def serialize
+    raise NotImplementedError
   end
 end

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,39 +1,38 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Transaction
-    attr_reader :session_id
+class Grumlin::Transaction
+  attr_reader :session_id
 
-    include Console
+  include Console
 
-    COMMIT = Grumlin::Repository.new.g.step(:tx, :commit).bytecode
-    ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback).bytecode
+  COMMIT = Grumlin::Repository.new.g.step(:tx, :commit)
+  ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback)
 
-    def initialize(traversal_start_class, pool: Grumlin.default_pool)
-      @traversal_start_class = traversal_start_class
-      @pool = pool
-
-      @session_id = SecureRandom.uuid
-    end
+  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 begin
+    @traversal_start_class.new(session_id: @session_id)
+  end
 
-    def commit
-      finalize(COMMIT)
-    end
+  def commit
+    finalize(COMMIT)
+  end
 
-    def rollback
-      finalize(ROLLBACK)
-    end
+  def rollback
+    finalize(ROLLBACK)
+  end
 
-    private
+  private
 
-    def finalize(action)
-      @pool.acquire do |client|
-        client.write(action, session_id: @session_id)
-      end
-    end
+  def finalize(step)
+    @middlewares.call(traversal: step,
+                      need_results: false,
+                      session_id: @session_id,
+                      pool: @pool)
   end
 end