bytecode.rb in grumlin-1.0.0.rc1

- old
+ new
@@ -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