trailblazer-operation 0.4.1 → 0.6.0

data/test/dry_container_test.rb

@@ -9,6 +9,7 @@ class DryContainerTest < Minitest::Spec
   end
 
   class Create < Trailblazer::Operation
+    extend Trailblazer::Operation::Container
   end
 
   it "allows 2.2 call style" do
@@ -18,7 +19,7 @@ class DryContainerTest < Minitest::Spec
   it { Create.({}, {}, my_container)["user_repository"].must_equal Object }
   it { Create.({}, {}, my_container)["contract.create"].must_equal Array }
   # also allows our own options PLUS containers.
-  it { Create.({}, { "model" => String }, my_container)["model"].must_equal String }
-  it { Create.({}, { "model" => String }, my_container)["user_repository"].must_equal Object }
-  it { Create.({}, { "user_repository" => Fixnum }, my_container)["user_repository"].must_equal Fixnum }
+  it { Create.({}, {"model" => String}, my_container)["model"].must_equal String }
+  it { Create.({}, {"model" => String}, my_container)["user_repository"].must_equal Object }
+  it { Create.({}, {"user_repository" => Integer}, my_container)["user_repository"].must_equal Integer }
 end

data/test/fast_track_test.rb

@@ -1,42 +1,25 @@
 require "test_helper"
 
 class FastTrackTest < Minitest::Spec
-  # #failure fails fast.
-  # class Create < Trailblazer::Operation
-  #   step ->(options, *) { options["x"] = options["dont_fail"] }
-  #   failure ->(options, *) { options["a"] = true; options["fail_fast"] }, fail_fast: true
-  #   failure ->(options, *) { options["b"] = true }
-  #   step ->(options, *) { options["y"] = true }
-  # end
-
-  # puts Create["pipetree"].inspect
-
-  # require "trailblazer/diagram/bpmn"
-  # puts Trailblazer::Diagram::BPMN.to_xml(Create["pipetree"])
-
-  # it { Create.("fail_fast" => true, "dont_fail" => true ).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, nil, nil, true] >} }
-  # it { Create.("fail_fast" => true                  ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
-  # it { Create.("fail_fast" => false                 ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
-
   # #success passes fast.
   class Retrieve < Trailblazer::Operation
     pass ->(options, **) { options["x"] = options["dont_fail"] }, pass_fast: true
     fail ->(options, **) { options["b"] = true }
     step ->(options, **) { options["y"] = true }
   end
-  it { Retrieve.("dont_fail" => true  ).inspect("x", "b", "y").must_equal %{<Result:true [true, nil, nil] >} }
-  it { Retrieve.("dont_fail" => false ).inspect("x", "b", "y").must_equal %{<Result:true [false, nil, nil] >} }
+  it { Retrieve.("dont_fail" => true).inspect("x", "b", "y").must_equal %{<Result:true [true, nil, nil] >} }
+  it { Retrieve.("dont_fail" => false).inspect("x", "b", "y").must_equal %{<Result:true [false, nil, nil] >} }
 
   # #step fails fast if option set and returns false.
   class Update < Trailblazer::Operation
     step ->(options, *) { options["x"] = true }
     step ->(options, *) { options["a"] = options["dont_fail"] }, fail_fast: true # only on false.
-    failure ->(options, *) { options["b"] = true }
+    fail ->(options, *) { options["b"] = true }
     step ->(options, *) { options["y"] = true }
   end
 
   it { Update.("dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, true] >} }
-  it { Update.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, nil, nil] >} }
+  it { Update.({}).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, nil, nil] >} }
 
   # #step passes fast if option set and returns true.
   class Delete < Trailblazer::Operation
@@ -47,14 +30,14 @@ class FastTrackTest < Minitest::Spec
   end
 
   it { Delete.("dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, nil] >} }
-  it { Delete.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, true, nil] >} }
+  it { Delete.({}).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, true, nil] >} }
 end
 
 class FailBangTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step ->(options, *) { options["x"] = true; Railway.fail! }
     step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
+    fail ->(options, *) { options["a"] = true }
   end
 
   it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, true] >} }
@@ -64,7 +47,7 @@ class PassBangTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step ->(options, *) { options["x"] = true; Railway.pass! }
     step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
+    fail ->(options, *) { options["a"] = true }
   end
 
   it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, true, nil] >} }
@@ -74,16 +57,16 @@ class FailFastBangTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step ->(options, *) { options["x"] = true; Railway.fail_fast! }
     step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
+    fail ->(options, *) { options["a"] = true }
   end
 
   # without proper configuration, emitting a FastTrack signal is illegal.
-  it { assert_raises(Trailblazer::Circuit::IllegalSignalError) { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} } }
+  it { assert_raises(Trailblazer::Activity::Circuit::IllegalSignalError) { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} } }
 
   class Update < Trailblazer::Operation
     step ->(options, *) { options["x"] = true; Railway.fail_fast! }, fast_track: true
     step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
+    fail ->(options, *) { options["a"] = true }
   end
 
   it { Update.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} }
@@ -93,7 +76,7 @@ class PassFastBangTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step ->(options, *) { options["x"] = true; Railway.pass_fast! }, fast_track: true
     step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
+    fail ->(options, *) { options["a"] = true }
   end
 
   it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, nil, nil] >} }
@@ -103,7 +86,7 @@ end
 class NestedFastTrackTest < Minitest::Spec
   #- The ::step DSL method automatically connects the nested's End.fail_fast/End.pass_fast to Update's End.fail_fast/End.pass_fast.
   #
-  # Edit has fast-tracked steps, so it has outputs :success/:failure/:pass_fast/:fail_fast.
+  # Edit has fast-tracked steps, so it has outputs :success/:fail/:pass_fast/:fail_fast.
   class Edit < Trailblazer::Operation
     step :a, fast_track: true # task is connected to End.pass_fast and End.fail_fast.
 
@@ -115,7 +98,7 @@ class NestedFastTrackTest < Minitest::Spec
 
   module Steps
     def b(options, a:, **)
-      options["b"] = a+1
+      options["b"] = a + 1
     end
 
     def f(options, **)
@@ -126,9 +109,7 @@ class NestedFastTrackTest < Minitest::Spec
   describe "Nested, fast_track: true and all its outputs given" do
     let(:update) do
       Class.new(Trailblazer::Operation) do
-        step task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
-          outputs: Edit.outputs ,
-          fast_track: true
+        step Subprocess(Edit), fast_track: true
         step :b
         fail :f
 
@@ -138,7 +119,7 @@ class NestedFastTrackTest < Minitest::Spec
 
     # Edit returns End.success
     it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
-    # Edit returns End.failure
+    # Edit returns End.fail
     it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
     # Edit returns End.pass_fast
     it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
@@ -151,8 +132,7 @@ class NestedFastTrackTest < Minitest::Spec
       Class.new(Trailblazer::Operation) do
         include Steps
 
-        step task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
-          outputs: Edit.outputs  # all outputs given means it "works"
+        step Subprocess(Edit), Output(:pass_fast) => Track(:pass_fast), Output(:fail_fast) => Track(:fail_fast)
         step :b
         fail :f
       end
@@ -160,7 +140,7 @@ class NestedFastTrackTest < Minitest::Spec
 
     # Edit returns End.success
     it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
-    # Edit returns End.failure
+    # Edit returns End.fail
     it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
     # Edit returns End.pass_fast
     it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
@@ -173,9 +153,10 @@ class NestedFastTrackTest < Minitest::Spec
       Class.new(Trailblazer::Operation) do
         include Steps
 
-        step({task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
-                  outputs: Edit.outputs },
-          {Output(:pass_fast) => Track(:success), Output(:fail_fast) => Track(:failure)} )# manually rewire the fast-track outputs to "conventional" railway ends.
+        step Subprocess(Edit),
+             # manually rewire the fast-track outputs to "conventional" railway ends.
+             Output(:pass_fast) => Track(:success),
+             Output(:fail_fast) => Track(:failure)
 
         step :b
         fail :f
@@ -183,15 +164,14 @@ class NestedFastTrackTest < Minitest::Spec
     end
 
     # it { puts Trailblazer::Activity::Introspect.Cct(update.instance_variable_get(:@process)) }
-    it { update.to_h  }
+    it { update.to_h }
     # Edit returns End.success
     it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
-    # Edit returns End.failure
+    # Edit returns End.fail
     it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
     # Edit returns End.pass_fast, but behaves like :success.
     it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
-    # Edit returns End.fail_fast, but behaves like :failure.
+    # Edit returns End.fail_fast, but behaves like :fail.
     it { update.(edit_return: Trailblazer::Operation::Railway.fail_fast!).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
   end
 end
-

data/test/inheritance_test.rb

@@ -5,22 +5,23 @@ class InheritanceTest < Minitest::Spec
     def self.find_by(options); options[:id].nil? ? nil : new(options[:id]) end
   end
 
-  class Create < Trailblazer::Operation
-    self["a"] = "A"
-    self["b"] = "B"
-    self["c"] = "D"
+  # class Create < Trailblazer::Operation
+  #   self["a"] = "A"
+  #   self["b"] = "B"
+  #   self["c"] = "D"
 
-    def self.class(*skills)
-      Class.new(Trailblazer::Operation). tap do |klass|
-        skills.each { |skill| klass.heritage.record(:[]=, skill, self[skill]) }
-      end
-    end
-  end
+  #   def self.class(*skills)
+  #     Class.new(Trailblazer::Operation). tap do |klass|
+  #       skills.each { |skill| klass.heritage.record(:[]=, skill, self[skill]) }
+  #     end
+  #   end
+  # end
 
-  class Update < Create.class("a", "b")
-  end
+  # class Update < Create.class("a", "b")
+  # end
 
   it do
+    skip "https://trello.com/c/t8bUJlqb/25-op-class-dependencies"
     Update["a"].must_equal "A"
     Update["b"].must_equal "B"
     Update["c"].must_be_nil

data/test/introspect_test.rb

@@ -1,10 +1,10 @@
 require "test_helper"
 
 class IntrospectTest < Minitest::Spec
-  A = ->(*args) { [ Activity::Right, *args ] }
-  B = ->(*args) { [ Activity::Right, *args ] }
-  C = ->(*args) { [ Activity::Right, *args ] }
-  D = ->(*args) { [ Activity::Right, *args ] }
+  A = ->(*args) { [Activity::Right, *args] }
+  B = ->(*args) { [Activity::Right, *args] }
+  C = ->(*args) { [Activity::Right, *args] }
+  D = ->(*args) { [Activity::Right, *args] }
 
   let(:activity) do
     nested = bc
@@ -26,7 +26,7 @@ class IntrospectTest < Minitest::Spec
   describe "#collect" do
     it "iterates over each task element in the top activity" do
       skip
-      all_tasks = Activity::Introspect.collect(activity) do |task, connections|
+      all_tasks = Activity::Introspect.collect(activity) do |task, _connections|
         task
       end
 
@@ -39,7 +39,7 @@ class IntrospectTest < Minitest::Spec
 
     it "iterates over all task elements recursively" do
       skip
-      all_tasks = Activity::Introspect.collect(activity, recursive: true) do |task, connections|
+      all_tasks = Activity::Introspect.collect(activity, recursive: true) do |task, _connections|
         task
       end
 

data/test/operation_test.rb

@@ -13,7 +13,14 @@ class DeclarativeApiTest < Minitest::Spec
     fail :return_true!
     fail :return_false!
 
-    def decide!(options, decide:raise, **)
+    step :bla, input: ->(ctx, *) { {id: ctx.inspect} }, output: ->(scope, ctx) { ctx["hello"] = scope["1"]; ctx }
+
+    def bla(ctx, id:1, **)
+      puts id
+      true
+    end
+
+    def decide!(options, decide: raise, **)
       options["a"] = true
       decide
     end
@@ -26,18 +33,19 @@ class DeclarativeApiTest < Minitest::Spec
       options["x"] = true
     end
 
-    def return_true! (options, **); options["b"] = true end
+    def return_true!(options, **); options["b"] = true end
+
     def return_false!(options, **); options["c"] = false end
   end
 
   it { Create.(decide: true).inspect("a", "x", "y", "b", "c").must_equal %{<Result:true [true, true, false, nil, nil] >} }
   it { Create.(decide: false).inspect("a", "x", "y", "b", "c").must_equal %{<Result:false [true, nil, nil, true, false] >} }
-
+  it { Create.(decide: nil).keys.must_equal(%i(decide a b c)) }
+  it { Create.(decide: nil).to_hash.must_equal(decide: nil, a: true, b: true, c: false) }
   #---
   #- trace
 
   it do
-
   end
 
   #---
@@ -46,14 +54,16 @@ class DeclarativeApiTest < Minitest::Spec
   end
 
   it { Noop.().inspect("params").must_equal %{<Result:true [nil] >} }
+  it { Noop.().keys.must_equal([]) }
+  it { Noop.().to_hash.must_equal({}) }
 
   #---
   #- pass
   #- fail
   class Update < Trailblazer::Operation
-    pass ->(options, **)         { options["a"] = false }
-    step ->(options, params:raise, **) { options["b"] = params[:decide] }
-    fail ->(options, **)         { options["c"] = true }
+    pass ->(options, **) { options["a"] = false }
+    step ->(options, params: raise, **) { options["b"] = params[:decide] }
+    fail ->(options, **) { options["c"] = true }
   end
 
   it { Update.("params" => {decide: true}).inspect("a", "b", "c").must_equal %{<Result:true [false, true, nil] >} }
@@ -73,22 +83,4 @@ class DeclarativeApiTest < Minitest::Spec
     Upsert.("params" => {decide: true}).inspect("a", "b", "c", "d", "e").must_equal %{<Result:true [false, true, nil, 1, nil] >}
     Unset. ("params" => {decide: true}).inspect("a", "b", "c", "d", "e").must_equal %{<Result:true [false, true, nil, 1, 2] >}
   end
-
-  describe "Activity::Interface" do
-    class Edit < Trailblazer::Operation
-      step :a
-      step :b, fast_track: true
-    end
-
-    it "provides #outputs" do
-      Activity::Introspect.Outputs(Edit.outputs).must_equal %{success=> (#<Trailblazer::Operation::Railway::End::Success semantic=:success>, success)
-failure=> (#<Trailblazer::Operation::Railway::End::Failure semantic=:failure>, failure)
-pass_fast=> (#<Trailblazer::Operation::Railway::End::PassFast semantic=:pass_fast>, pass_fast)
-fail_fast=> (#<Trailblazer::Operation::Railway::End::FailFast semantic=:fail_fast>, fail_fast)}
-    end
-
-    it "is an Interface" do
-      Edit.is_a?( Activity::Interface ).must_equal true
-    end
-  end
 end

data/test/result_test.rb

@@ -1,11 +1,11 @@
-  require "test_helper"
+require "test_helper"
 
 class RailwayResultTest < Minitest::Spec
   Result  = Trailblazer::Operation::Railway::Result
   Success = Trailblazer::Operation::Railway::End::Success
 
   let(:event)    { Success.new(semantic: nil) }
-  let (:success) { Result.new(true, { "x"=> String }, event) }
+  let(:success)  { Result.new(true, {"x" => String}, event) }
 
   it { success.success?.must_equal true }
   it { success.failure?.must_equal false }
@@ -20,10 +20,10 @@ class RailwayResultTest < Minitest::Spec
   #---
   # inspect
   it { success.inspect.must_equal %{<Result:true {\"x\"=>String} >} }
-  it { Result.new(true, { "x"=> true, "y"=>1, "z"=>2 }, event).inspect("z", "y").must_equal %{<Result:true [2, 1] >} }
+  it { Result.new(true, {"x" => true, "y" => 1, "z" => 2}, event).inspect("z", "y").must_equal %{<Result:true [2, 1] >} }
 
   class Create < Trailblazer::Operation
-    success :call
+    pass :call
 
     def call(options, **)
       options[:message] = "Result objects are actually quite handy!"

data/test/ruby-2.0.0/operation_test.rb

@@ -13,21 +13,22 @@ class DeclarativeApiTest < Minitest::Spec
     failure :return_true!
     failure :return_false!
 
-    def decide!(options, decide:raise, **o)
+    def decide!(options, decide: raise, **_o)
       options["a"] = true
       decide
     end
 
-    def wasnt_ok!(options, **o)
+    def wasnt_ok!(options, **_o)
       options["y"] = false
     end
 
-    def was_ok!(options, **o)
+    def was_ok!(options, **_o)
       options["x"] = true
     end
 
-    def return_true! (options, **o); options["b"] = true end
-    def return_false!(options, **o); options["c"] = false end
+    def return_true!(options, **_o); options["b"] = true end
+
+    def return_false!(options, **_o); options["c"] = false end
   end
 
   it { Create.({}, decide: true).inspect("a", "x", "y", "b", "c").must_equal %{<Result:true [true, true, false, nil, nil] >} }
@@ -37,7 +38,6 @@ class DeclarativeApiTest < Minitest::Spec
   #- trace
 
   it do
-
   end
 
   #---
@@ -51,9 +51,9 @@ class DeclarativeApiTest < Minitest::Spec
   #- pass
   #- fail
   class Update < Trailblazer::Operation
-    pass ->(options, **o)         { options["a"] = false }
-    step ->(options, params:raise, **o) { options["b"] = params[:decide] }
-    fail ->(options, **o)         { options["c"] = true }
+    pass ->(options, **_o) { options["a"] = false }
+    step ->(options, params: raise, **_o) { options["b"] = params[:decide] }
+    fail ->(options, **_o) { options["c"] = true }
   end
 
   it { Update.(decide: true).inspect("a", "b", "c").must_equal %{<Result:true [false, true, nil] >} }

data/test/ruby-2.0.0/step_test.rb

@@ -7,32 +7,33 @@ require "test_helper"
 # ---  step MyMacro
 class StepTest < Minitest::Spec
   class Callable
-    def self.call(options, b:nil, **o)
+    def self.call(options, b: nil, **_o)
       options["b"] = b
     end
   end
 
   module Implementation
     module_function
-    def c(options, c:nil, **o)
+
+    def c(options, c: nil, **_o)
       options["c"] = c
     end
   end
 
-  MyMacro = ->( direction, options, flow_options ) do
+  MyMacro = ->(direction, options, flow_options) do
     options["e"] = options[:e]
 
-    [ direction, options, flow_options ]
+    [direction, options, flow_options]
   end
 
   class Create < Trailblazer::Operation
-    step ->(options, a:nil, **o) { options["a"] = a }
+    step ->(options, a: nil, **_o) { options["a"] = a }
     step Callable
     step Implementation.method(:c)
     step :d
-    step [ MyMacro, {} ] # doesn't provide runner_options.
+    step [MyMacro, {}] # doesn't provide runner_options.
 
-    def d(options, d:nil, **o)
+    def d(options, d: nil, **_o)
       options["d"] = d
     end
   end
@@ -47,8 +48,8 @@ class StepTest < Minitest::Spec
   #- :before, :after, :replace, :delete, :override
   class A < Trailblazer::Operation
     step :a!
-    def a!(options, **o); options["a"] = 1; end
-    def a!(options, **o); options["a"] = 1; end if RUBY_VERSION == "2.0.0"
+    def a!(options, **_o); options["a"] = 1; end
+    def a!(options, **_o); options["a"] = 1; end if RUBY_VERSION == "2.0.0"
   end
 
   class B < A
@@ -76,7 +77,7 @@ class StepTest < Minitest::Spec
 
   # not existent :name
   it do
-    err = assert_raises Trailblazer::Operation::Railway::Sequence::IndexError  do
+    err = assert_raises Trailblazer::Operation::Railway::Sequence::IndexError do
       class E < Trailblazer::Operation
         step :a, before: "I don't exist!"
       end
@@ -91,8 +92,8 @@ class StepTest < Minitest::Spec
   class Index < Trailblazer::Operation
     step :validate!, name: "my validate"
     step :persist!
-    step [ MyMacro, name: "I win!" ]
-    step [ MyMacro, name: "I win!" ], name: "No, I do!"
+    step [MyMacro, name: "I win!"]
+    step [MyMacro, name: "I win!"], name: "No, I do!"
   end
 
   it { Trailblazer::Operation::Inspect.(Index).must_equal %{[>my validate,>persist!,>I win!,>No, I do!]} }
@@ -114,7 +115,8 @@ 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
@@ -126,11 +128,10 @@ class StepWithDeprecatedMacroTest < Minitest::Spec # TODO: remove me in 2.2.
       end
     end
 
-    step [ MyOutdatedMacro, name: :outdated ]
-    step [ AnotherOldMacro, name: :oldie ]
+    step [MyOutdatedMacro, name: :outdated]
+    step [AnotherOldMacro, name: :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] >} }
 end
-