grumlin 0.23.0 → 1.0.0.rc1

data/lib/grumlin/step.rb

@@ -1,94 +1,92 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Step < Steppable
-    attr_reader :name, :args, :params, :next_step, :configuration_steps, :previous_step, :shortcut
-
-    # TODO: replace pool, session_id and middlewares with a context?
-    def initialize(name, args: [], params: {}, previous_step: nil, pool: nil, session_id: nil, # rubocop:disable Metrics/ParameterLists
-                   middlewares: Grumlin.default_middlewares)
-      super(pool: pool, session_id: session_id, middlewares: middlewares)
-
-      @name = name.to_sym
-      @args = args # TODO: add recursive validation: only json types or Step
-      @params = params # TODO: add recursive validation: only json types
-      @previous_step = previous_step
-      @shortcut = shortcuts[@name]
-    end
-
-    def configuration_step?
-      CONFIGURATION_STEPS.include?(@name) || name.to_sym == :tx
-    end
-
-    def start_step?
-      START_STEPS.include?(@name)
-    end
-
-    def regular_step?
-      REGULAR_STEPS.include?(@name)
-    end
-
-    def supported_step?
-      ALL_STEPS.include?(@name)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @name == other.name &&
-        @args == other.args &&
-        @params == other.params &&
-        @previous_step == other.previous_step &&
-        shortcuts == other.shortcuts
-    end
-
-    def steps
-      @steps ||= Steps.from(self)
-    end
-
-    def to_s(**params)
-      StepsSerializers::String.new(steps, **params).serialize
-    end
-
-    # TODO: add human readable mode
-    def inspect
-      conf_steps, regular_steps = StepsSerializers::HumanReadableBytecode.new(steps).serialize
-      "#{conf_steps.any? ? conf_steps : nil}#{regular_steps}"
-    end
-
-    def bytecode(no_return: false)
-      StepsSerializers::Bytecode.new(steps, no_return: no_return)
-    end
-
-    def 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
-      send_query(need_results: true)
-    end
-
-    def iterate
-      send_query(need_results: false)
-    end
-
-    private
-
-    def send_query(need_results:)
-      @middlewares.call(traversal: self,
-                        need_results: need_results,
-                        session_id: @session_id,
-                        pool: @pool)
-    end
+class Grumlin::Step < Grumlin::Steppable
+  attr_reader :name, :args, :params, :next_step, :configuration_steps, :previous_step, :shortcut
+
+  # TODO: replace pool, session_id and middlewares with a context?
+  def initialize(name, args: [], params: {}, previous_step: nil, pool: nil, session_id: nil, # rubocop:disable Metrics/ParameterLists
+                 middlewares: Grumlin.default_middlewares)
+    super(pool: pool, session_id: session_id, middlewares: middlewares)
+
+    @name = name.to_sym
+    @args = args # TODO: add recursive validation: only json types or Step
+    @params = params # TODO: add recursive validation: only json types
+    @previous_step = previous_step
+    @shortcut = shortcuts[@name]
+  end
+
+  def configuration_step?
+    CONFIGURATION_STEPS.include?(@name) || name.to_sym == :tx
+  end
+
+  def start_step?
+    START_STEPS.include?(@name)
+  end
+
+  def regular_step?
+    REGULAR_STEPS.include?(@name)
+  end
+
+  def supported_step?
+    ALL_STEPS.include?(@name)
+  end
+
+  def ==(other)
+    self.class == other.class &&
+      @name == other.name &&
+      @args == other.args &&
+      @params == other.params &&
+      @previous_step == other.previous_step &&
+      shortcuts == other.shortcuts
+  end
+
+  def steps
+    @steps ||= Grumlin::Steps.from(self)
+  end
+
+  def to_s(**params)
+    Grumlin::StepsSerializers::String.new(steps, **params).serialize
+  end
+
+  # TODO: add human readable mode
+  def inspect
+    conf_steps, regular_steps = Grumlin::StepsSerializers::HumanReadableBytecode.new(steps).serialize
+    "#{conf_steps.any? ? conf_steps : nil}#{regular_steps}"
+  end
+
+  def bytecode(no_return: false)
+    Grumlin::StepsSerializers::Bytecode.new(steps, no_return: no_return)
+  end
+
+  def 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
+    send_query(need_results: true)
+  end
+
+  def iterate
+    send_query(need_results: false)
+  end
+
+  private
+
+  def send_query(need_results:)
+    @middlewares.call(traversal: self,
+                      need_results: need_results,
+                      session_id: @session_id,
+                      pool: @pool)
   end
 end

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,40 +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: nil, session_id: nil, middlewares: Grumlin.default_middlewares)
-      @pool = pool
-      @session_id = session_id
+  def initialize(pool: nil, session_id: nil, middlewares: Grumlin.default_middlewares)
+    @pool = pool
+    @session_id = session_id
 
-      @middlewares = middlewares
+    @middlewares = middlewares
 
-      return if respond_to?(:shortcuts)
+    return if respond_to?(:shortcuts)
 
-      raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
-    end
-
-    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
+    raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
+  end
 
-    def step(name, *args, **params)
-      shortcuts.step_class.new(name, args: args, params: params, previous_step: self,
+  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,78 +1,76 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Steps
-    CONFIGURATION_STEPS = Step::CONFIGURATION_STEPS
-    ALL_STEPS = Step::ALL_STEPS
-
-    def self.from(step)
-      raise ArgumentError, "expected: #{Step}, given: #{step.class}" unless step.is_a?(Step)
-
-      new(step.shortcuts).tap do |chain|
-        until step.nil? || step.is_a?(TraversalStart)
-          chain.add(step.name, args: step.args, params: step.params, to: :begin)
-          step = step.previous_step
-        end
-      end
-    end
+class Grumlin::Steps
+  CONFIGURATION_STEPS = Grumlin::Step::CONFIGURATION_STEPS
+  ALL_STEPS = Grumlin::Step::ALL_STEPS
 
-    attr_reader :configuration_steps, :steps, :shortcuts
+  def self.from(step)
+    raise ArgumentError, "expected: #{Grumlin::Step}, given: #{step.class}" unless step.is_a?(Grumlin::Step)
 
-    def initialize(shortcuts, configuration_steps: [], steps: [])
-      @shortcuts = shortcuts
-      @configuration_steps = configuration_steps
-      @steps = steps
+    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
 
-    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
+  attr_reader :configuration_steps, :steps, :shortcuts
 
-      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
+  def initialize(shortcuts, configuration_steps: [], steps: [])
+    @shortcuts = shortcuts
+    @configuration_steps = configuration_steps
+    @steps = steps
+  end
 
-        raise ArgumentError, "'to:' must be either :begin or :end, given: '#{to}'"
-      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 uses_shortcuts?
-      shortcuts?(@configuration_steps) || shortcuts?(@steps)
-    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
 
-    def ==(other)
-      self.class == other.class &&
-        @shortcuts == other.shortcuts &&
-        @configuration_steps == other.configuration_steps &&
-        @steps == other.steps
+      raise ArgumentError, "'to:' must be either :begin or :end, given: '#{to}'"
     end
+  end
 
-    # TODO: add #bytecode, to_s, inspect
+  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
+
+  # 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: {}, to: :end)
-      raise ArgumentError, "cannot use configuration steps after start step was used" if @steps.any? && to == :end
+  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|
-        next @configuration_steps << step if to == :end
-        next @configuration_steps.unshift(step) if to == :begin
+    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
 
-        raise ArgumentError, "to must be either :begin or :end, given: '#{to}'"
-      end
+      raise ArgumentError, "to must be either :begin or :end, given: '#{to}'"
     end
+  end
 
-    def cast_arguments(arguments)
-      arguments.map { |arg| arg.is_a?(Step) ? Steps.from(arg) : arg }
-    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