trailblazer-operation 0.4.1 → 0.6.0

data/test/step_test.rb

@@ -7,45 +7,46 @@ require "test_helper"
 # ---  step MyMacro
 class StepTest < Minitest::Spec
   class Callable
-    def self.call(options, b:nil, **)
+    def self.call(options, b: nil, **)
       options["b"] = b
     end
   end
 
   module Implementation
     module_function
-    def c(options, c:nil, **)
+
+    def c(options, c: nil, **)
       options["c"] = c
     end
   end
 
-  MyMacro = ->( (options, flow_options), * ) do
+  MyMacro = ->((options, flow_options), *) do
     options["e"] = options[:e]
 
-    [ Trailblazer::Activity::Right, options, flow_options ]
+    [Trailblazer::Activity::Right, options, flow_options]
   end
 
   class Create < Trailblazer::Operation
-    step ->(options, a:nil, **) { options["a"] = a }
+    step ->(options, a: nil, **) { options["a"] = a }
     step Callable
     step Implementation.method(:c)
     step :d
-    step( { task: MyMacro, id: "MyMacro" } ) # doesn't provide `runner_options` and `outputs`.
+    step(task: MyMacro, id: "MyMacro") # doesn't provide `runner_options` and `outputs`.
 
-    def d(options, d:nil, **)
+    def d(options, d: nil, **)
       options["d"] = d
     end
   end
 
   it { Create.(a: 1, b: 2, c: 3, d: 4, e: 5).inspect("a", "b", "c", "d", "e").must_equal "<Result:true [1, 2, 3, 4, 5] >" }
 
-  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
+  it { Trailblazer::Developer.railway(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::30 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
 
   #---
   #- :before, :after, :replace, :delete, :override
   class A < Trailblazer::Operation
     step :a!
-    def a!(options, **); options["order"] << "a" ; end
+    def a!(options, **); options["order"] << "a"; end
   end
 
   class B < A
@@ -53,47 +54,51 @@ class StepTest < Minitest::Spec
     step :c!, before: :a!
     step :d!, after:  :b!
 
-    def b!(options, **); options["order"] << "b" ; end
-    def c!(options, **); options["order"] << "c" ; end
-    def d!(options, **); options["order"] << "d" ; end
+    def b!(options, **); options["order"] << "b"; end
+
+    def c!(options, **); options["order"] << "c"; end
+
+    def d!(options, **); options["order"] << "d"; end
   end
 
-  it { Trailblazer::Operation::Inspect.(B).must_equal %{[>b!,>d!,>c!,>a!]} }
+  it { Trailblazer::Developer.railway(B).must_equal %{[>b!,>d!,>c!,>a!]} }
 
   class C < B
     step :e!, replace: :c!
     step "nil", delete: :d!
-    def e!(options, **); options["order"] << "e" ; end
+    def e!(options, **); options["order"] << "e"; end
   end
 
-  it { Trailblazer::Operation::Inspect.(C).must_equal %{[>b!,>e!,>a!]} }
-  it { C.("order"=>[]).inspect("order").must_equal %{<Result:true [["b", "e", "a"]] >} }
+  it { Trailblazer::Developer.railway(C).must_equal %{[>b!,>e!,>a!]} }
+  it { C.("order" => []).inspect("order").must_equal %{<Result:true [["b", "e", "a"]] >} }
 
   #---
   #- override: true
   class D < Trailblazer::Operation
     step :a!
     step :add!
-    step :add!, id: :another_add!#, override: true
+    step :add!, id: :another_add! # , override: true
 
     def a!(options, **);   options["a"] = []; end
+
     def add!(options, **); options["a"] << :b; end
   end
 
-  it { Trailblazer::Operation::Inspect.(D).must_equal %{[>a!,>add!,>another_add!]} }
+  it { Trailblazer::Developer.railway(D).must_equal %{[>a!,>add!,>another_add!]} }
   it { D.().inspect("a").must_equal %{<Result:true [[:b, :b]] >} }
 
   class E < Trailblazer::Operation
-    step :a!
-    step :add!
-    step :add!, override: true
+    imp = T.def_task(:b)
 
-    def a!(options, **);   options["a"] = []; end
-    def add!(options, **); options["a"] << :b; end
+    step :a
+    step(task: :b, id: :b)
+    step({task: imp, id: :b}, override: true)
+
+    include T.def_steps(:a)
   end
 
-  it { Trailblazer::Operation::Inspect.(E).must_equal %{[>a!,>add!]} }
-  it { E.().inspect("a").must_equal %{<Result:true [[:b]] >} }
+  it { Trailblazer::Developer.railway(E).must_equal %{[>a,>b]} }
+  it { E.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :b]] >} }
 
   #- with proc
   class F < Trailblazer::Operation
@@ -104,33 +109,33 @@ class StepTest < Minitest::Spec
     def a!(options, **);   options["a"] = []; end
   end
 
-  it { Trailblazer::Operation::Inspect.(F).must_equal %{[>a!,>add!!!]} }
+  it { Trailblazer::Developer.railway(F).must_equal %{[>a!,>add!!!]} }
   it { F.().inspect("a").must_equal %{<Result:true [[:b]] >} }
 
   #- with macro
   class G < Trailblazer::Operation
-    MyMacro1 = ->((options, flow_options), *) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
-    MyMacro2 = ->((options, flow_options), *) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
+    MyMacro1 = ->((options, flow_options), *) { options["a"] << :b; [Trailblazer::Activity::Right, options, flow_options] }
+    MyMacro2 = ->((options, flow_options), *) { options["a"] << :b; [Trailblazer::Activity::Right, options, flow_options] }
     # MyMacro3 = ->(options, flow_options) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
 
     step :a!
-    step( { task: MyMacro1, id: "add" })
-    step( { task: MyMacro2, id: "add" }, replace: "add")
+    step(task: MyMacro1, id: "add")
+    step({task: MyMacro2, id: "add"}, replace: "add")
     # step [ MyMacro3, {id: "add"}, {} ], override: true
 
     def a!(options, **);   options["a"] = []; end
   end
 
-  it { Trailblazer::Operation::Inspect.(G).must_equal %{[>a!,>add]} }
+  it { Trailblazer::Developer.railway(G).must_equal %{[>a!,>add]} }
   it { G.().inspect("a").must_equal %{<Result:true [[:b]] >} }
 
   # override: true in inherited class with macro
   class Go < G
-    MyMacro = ->((options, flow_options), *) { options["a"] << :m; [ Trailblazer::Activity::Right, options, flow_options ] }
+    MyMacro = ->((options, flow_options), *) { options["a"] << :m; [Trailblazer::Activity::Right, options, flow_options] }
     step task: MyMacro, override: true, id: "add"
   end
 
-  it { Trailblazer::Operation::Inspect.(Go).must_equal %{[>a!,>add]} }
+  it { Trailblazer::Developer.railway(Go).must_equal %{[>a!,>add]} }
   it { Go.().inspect("a").must_equal %{<Result:true [[:m]] >} }
 
   #- with inheritance
@@ -139,6 +144,7 @@ class StepTest < Minitest::Spec
     step :add!
 
     def a!(options, **);   options["a"] = []; end
+
     def add!(options, **); options["a"] << :b; end
   end
 
@@ -148,7 +154,7 @@ class StepTest < Minitest::Spec
     def _add!(options, **); options["a"] << :hh; end
   end
 
-  it { Trailblazer::Operation::Inspect.(Hh).must_equal %{[>a!,>_add!]} }
+  it { Trailblazer::Developer.railway(Hh).must_equal %{[>a!,>_add!]} }
   it { Hh.().inspect("a").must_equal %{<Result:true [[:hh]] >} }
 
   #- inheritance unit test
@@ -157,23 +163,21 @@ class StepTest < Minitest::Spec
   end
 
   class Ii < I
-    step :a, override: true
+    step({task: T.def_task(:b), id: :a}, override: true)
   end
 
   # FIXME: we have all fast track ends here.
-  it { skip;Ii["__activity__"].circuit.instance_variable_get(:@map).size.must_equal 6 }
+  it { skip; Ii["__activity__"].circuit.instance_variable_get(:@map).size.must_equal 6 }
 
   #---
   #-
   # not existent :name
   it do
-    assert_raises Trailblazer::Activity::Schema::Sequence::IndexError  do
-
+    assert_raises Trailblazer::Activity::DSL::Linear::Sequence::IndexError do
       Class.new(Trailblazer::Operation) do
         step :a, before: "I don't exist!"
       end
-
-    end.inspect.must_equal "#<Trailblazer::Activity::Schema::Sequence::IndexError: I don't exist!>"
+    end.inspect.must_equal %{#<Trailblazer::Activity::DSL::Linear::Sequence::IndexError: "I don't exist!">}
   end
 
   #---
@@ -182,30 +186,31 @@ class StepTest < Minitest::Spec
   class Index < Trailblazer::Operation
     step :validate!, id: "my validate"
     step :persist!
-    step( { task: MyMacro, id: "I win!" })
-    step( { task: MyMacro, id: "I win!" }, id: "No, I do!")
+    step(task: MyMacro, id: "I win!")
+    step({task: "MyMacro", id: "I win!"}, id: "No, I do!")
   end
 
-  it { Trailblazer::Operation::Inspect.(Index).must_equal %{[>my validate,>persist!,>I win!,>No, I do!]} }
+  it { Trailblazer::Developer.railway(Index).must_equal %{[>my validate,>persist!,>I win!,>No, I do!]} }
 
   #---
   #- inheritance
   class New < Create
   end
 
-  it { Trailblazer::Operation::Inspect.(New).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
+  it { Trailblazer::Developer.railway(New).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::30 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
 
   class Update < Create
     step :after_save!
   end
 
-  it { Trailblazer::Operation::Inspect.(Update).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro,>after_save!]} }
+  it { Trailblazer::Developer.railway(Update).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::30 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro,>after_save!]} }
 end
 
 #---
 #- Macros with the old `input` arg.
 #  step [ ->(input, options) { } ]
-class StepWithDeprecatedMacroTest < Minitest::Spec # TODO: remove me in 2.2.
+# TODO: remove me in 2.2.
+class StepWithDeprecatedMacroTest < Minitest::Spec
   class Create < Trailblazer::Operation
     MyOutdatedMacro = ->(input, options) {
       options["x"] = input.class
@@ -217,12 +222,12 @@ class StepWithDeprecatedMacroTest < Minitest::Spec # TODO: remove me in 2.2.
       end
     end
 
-    step [ MyOutdatedMacro, id: :outdated ]
-    step [ AnotherOldMacro, id: :oldie ]
+    step [MyOutdatedMacro, id: :outdated]
+    step [AnotherOldMacro, id: :oldie]
   end
 
-  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>outdated,>oldie]} }
-  it { Create.().inspect("x", "y").must_equal %{<Result:true [StepWithDeprecatedMacroTest::Create, StepWithDeprecatedMacroTest::Create] >} }
+  it { skip; Trailblazer::Developer.railway(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>outdated,>oldie]} }
+  it { skip; Create.().inspect("x", "y").must_equal %{<Result:true [StepWithDeprecatedMacroTest::Create, StepWithDeprecatedMacroTest::Create] >} }
 end
 
 # TODO: test failure and success aliases properly.

data/test/test_helper.rb

@@ -2,9 +2,15 @@ require "pp"
 
 require "minitest/autorun"
 require "trailblazer/operation"
+require "trailblazer/activity/testing"
+require "trailblazer/developer/render/linear"
 
-Minitest::Spec::Activity = Trailblazer::Activity
+Minitest::Spec.class_eval do
+  Activity = Trailblazer::Activity
+  T = Activity::Testing
+end
 
+# TODO: replace all this with {Activity::Testing.def_steps}
 module Test
   # Create a step method in `klass` with the following body.
   #
@@ -18,22 +24,10 @@ module Test
       method_def =
         %{def #{name}(options, #{name}_return:, data:, **)
           data << :#{name}
-
           #{name}_return
         end}
 
       klass.class_eval(method_def)
     end
   end
-
-  # builder for PlusPoles
-  def self.plus_poles_for(mapping)
-    ary = mapping.collect { |evt, semantic| [Trailblazer:: Activity::Output(evt, semantic), semantic ] }
-
-    Trailblazer::Activity::Magnetic::DSL::PlusPoles.new.merge(::Hash[ary])
-  end
-end
-
-Minitest::Spec.class_eval do
-  Activity = Trailblazer::Activity
 end

data/test/trace_test.rb

@@ -8,50 +8,50 @@ class TraceTest < Minitest::Spec
 
   class Create < Trailblazer::Operation
     step ->(options, a_return:, **) { options[:a] = a_return }, id: "Create.task.a"
-    step( {task: B, id: "MyNested"}, B.outputs[:success] => Track(:success) )
+    step({task: B, id: "MyNested"}, B.to_h[:outputs][0] => Track(:success))
     step ->(options, **) { options[:c] = true }, id: "Create.task.c"
-    step ->(options, params:, **) { params.any? }, id: "Create.task.params"
+    step ->(_options, params:, **) { params.any? }, id: "Create.task.params"
   end
   # raise Create["__task_wraps__"].inspect
 
   it "allows using low-level Activity::Trace" do
-    operation = ->(*args) { puts "@@@@@ #{args.last.inspect}"; Create.__call__(*args) }
+    ->(*args) { puts "@@@@@ #{args.last.inspect}"; Create.__call__(*args) }
 
-    stack, _ = Trailblazer::Activity::Trace.(
+    stack, = Trailblazer::Developer::Trace.(
       Create,
       [
-        { a_return: true, params: {} },
+        {a_return: true, params: {}},
         {}
       ]
     )
 
-    puts output = Trailblazer::Activity::Trace::Present.(stack)
+    puts output = Trailblazer::Developer::Trace::Present.(stack)
 
     output.gsub(/0x\w+/, "").gsub(/@.+_test/, "").must_equal %{`-- TraceTest::Create
-    |-- Start.default
-    |-- Create.task.a
-    |-- MyNested
-    |   |-- Start.default
-    |   |-- B.task.b
-    |   |-- B.task.e
-    |   `-- End.success
-    |-- Create.task.c
-    |-- Create.task.params
-    `-- End.failure}
+   |-- Start.default
+   |-- Create.task.a
+   |-- MyNested
+   |   |-- Start.default
+   |   |-- B.task.b
+   |   |-- B.task.e
+   |   `-- End.success
+   |-- Create.task.c
+   |-- Create.task.params
+   `-- End.failure}
   end
 
   it "Operation::trace" do
-    result = Create.trace({ params: { x: 1 }, a_return: true })
+    result = Create.trace(params: {x: 1}, a_return: true)
     result.wtf.gsub(/0x\w+/, "").gsub(/@.+_test/, "").must_equal %{`-- TraceTest::Create
-    |-- Start.default
-    |-- Create.task.a
-    |-- MyNested
-    |   |-- Start.default
-    |   |-- B.task.b
-    |   |-- B.task.e
-    |   `-- End.success
-    |-- Create.task.c
-    |-- Create.task.params
-    `-- End.success}
+   |-- Start.default
+   |-- Create.task.a
+   |-- MyNested
+   |   |-- Start.default
+   |   |-- B.task.b
+   |   |-- B.task.e
+   |   `-- End.success
+   |-- Create.task.c
+   |-- Create.task.params
+   `-- End.success}
   end
 end

data/test/wiring/defaults_test.rb

@@ -59,7 +59,6 @@ require "test_helper"
 #         [ [:failure], Trailblazer::Operation::Railway::End::Failure.new(:failure), [] ],
 #       ]
 
-
 #       graph = Trailblazer::Activity::Schema.bla(steps + ends)
 #       circuit = Trailblazer::Activity.new(graph)
 #       # pp schema
@@ -79,67 +78,66 @@ require "test_helper"
 class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step :a
-    fail :b, Output(:success) => Track(:success) #{}"End.success"
+    fail :b, Output(:success) => Track(:success) # {}"End.success"
     fail :c, Output(:success) => Track(:success)
 
     Test.step(self, :a, :b, :c)
   end
 
   # a => true
-  it { Create.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a]] >} }
+  it { Create.(a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a]] >} }
   # b => true
-  it { Create.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
+  it { Create.(a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
   # c => true
-  it { Create.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
+  it { Create.(a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
   # a => b => c => false
-  it { Create.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+  it { Create.(a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
 
 #   # require "trailblazer/developer"
 #   # it { Trailblazer::Developer::Client.push( operation: Create, name: "ushi" ) }
 
-
 #   #---
 #   # with => Track(:success), steps can still be added before End.success and they will be executed.
   class Update < Create
     pass :d
 
-    def d(options, data:, **)
+    def d(_options, data:, **)
       data << :d
     end
   end
 
   # a => true
-  it { Update.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  it { Update.(a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
   # b => true
-  it { Update.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
+  it { Update.(a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
   # c => true
-  it { Update.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c, :d]] >} }
+  it { Update.(a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c, :d]] >} }
   # a => b => c => false
-  it { Update.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+  it { Update.(a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
 
   #---
   # failure steps reference End.success and not just the polarization. This won't call #d in failure=>success case.
   class Delete < Trailblazer::Operation
     step :a
-    fail :b, Output(:success) => "End.success"
-    fail :c, Output(:success) => "End.success"
+    fail :b, Output(:success) => Id("End.success")
+    fail :c, Output(:success) => Id("End.success")
     pass :d
 
-    Test.step(self, :a, :b, :c)
+    Test.step(self, :a, :b, :c, :d)
 
-    def d(options, data:, **)
+    def d(_options, data:, **)
       data << :d
     end
   end
 
   # a => true
-  it { Delete.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  it { Delete.(a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
   # b => true
-  it { Delete.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
+  it { Delete.(a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
   # c => true
-  it { Delete.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
+  it { Delete.(a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
   # a => b => c => false
-  it { Delete.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+  it { Delete.(a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
 
   #---
   #       |----|
@@ -147,13 +145,13 @@ class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
   # |_____|_|_______ E.f
   class Connect < Trailblazer::Operation
     step :a
-    step :b, Output(:success) => "d"
+    step :b, Output(:success) => Id("d")
     step :c, magnetic_to: [] # otherwise :success will be an open input!
     pass :d, id: "d"
 
     Test.step(self, :a, :b, :c)
 
-    def d(options, data:, **)
+    def d(_options, data:, **)
       data << :d
     end
   end
@@ -161,11 +159,11 @@ class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
   # it { puts Trailblazer::Activity::Magnetic::Introspect.seq( Connect.decompose.first ) }
 
   # a => true
-  it { Connect.( a_return: true, b_return: true,data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
+  it { Connect.(a_return: true, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
   # a => false
-  it { Connect.( a_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a]] >} }
+  it { Connect.(a_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a]] >} }
   # b => false
-  it { Connect.( a_return: true, b_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b]] >} }
+  it { Connect.(a_return: true, b_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b]] >} }
 
   #---
   # |---------|
@@ -175,8 +173,8 @@ class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
   # | \ /  V
   # |__f____g----E.f
   class Post < Trailblazer::Operation
-    step :a, Output(:success) => "d", id: "a"
-    fail :f, Output(:success) => "c"
+    step :a, Output(:success) => Id("d"), id: "a"
+    fail :f, Output(:success) => Id("c")
     step :c, magnetic_to: [], id: "c" # otherwise :success will be an open input!
     fail :g
     step :d, id: "d"
@@ -184,14 +182,12 @@ class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
     Test.step(self, :a, :f, :c, :g, :d)
   end
 
-  pp Post["__sequence__"]
-
   # a => true
-  it { Post.( a_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  it { Post.(a_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
   # a => false
-  it { Post.( a_return: false, f_return: false, g_return: nil, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :g]] >} }
+  it { Post.(a_return: false, f_return: false, g_return: nil, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :g]] >} }
   # a => false, f => true
-  it { Post.( a_return: false, f_return: true, c_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :f, :c, :d]] >} }
+  it { Post.(a_return: false, f_return: true, c_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :f, :c, :d]] >} }
   # a => false, f => true, c => false
-  it { Post.( a_return: false, f_return: true, c_return: false, g_return: true, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :c, :g]] >} }
+  it { Post.(a_return: false, f_return: true, c_return: false, g_return: true, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :c, :g]] >} }
 end