trailblazer-operation 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d379cb34eaae932a9888c234de9f852e4793f035
-  data.tar.gz: a3ff9e0af8fe676ea60713c7c6946efdad2c3863
+  metadata.gz: d0302dd8b35ae2d64dd482bbc330604e5c55b65c
+  data.tar.gz: fb8028b158f2be7fff5778ceffe5f2730dbccad5
 SHA512:
-  metadata.gz: e1f26f8663297e30f8bd36893d8d853c15232841eb47f36e265683b787203672f714af0ae84096da7a3ec75f91ed4427fadce578a4ee31333d3377dd631e81c0
-  data.tar.gz: 7be6cb8f3e07df31a64c3f3b9e2f11cfc4be6a020641b0cf0a4bf0ecccb654dbd92845fce8f015cc28575e7fe67056d465fd54fffb56c3dc310497b41217a408
+  metadata.gz: 7f55c1460c22161d1ab7c75461da57476b6aee19abb8041132ac6b33893b9711616852cd553aa606929e732b8584f296b5df92d049905c609d2a2599df991ad9
+  data.tar.gz: 0f7dc9a51dbf361dc519e47c1fdb0fd1161326ace7fd78a253813c751ec007c8c07641967bf497d24e4e0fd535cb23d51a7af62d3abf57bf1704a8a26b75b65d

data/.travis.yml

@@ -5,7 +5,11 @@ matrix:
   include:
     - rvm: 1.9.3
       gemfile: "test/gemfiles/Gemfile.ruby-1.9"
+    # - rvm: 2.0.0
+    #   gemfile: "test/gemfiles/Gemfile.ruby-2.0"
     - rvm: 2.1
       gemfile: Gemfile
+    - rvm: 2.2.3
+      gemfile: Gemfile
     - rvm: 2.3.1
       gemfile: Gemfile

data/CHANGES.md

@@ -1,3 +1,12 @@
+## 0.0.10
+
+* `Flow` is now `Railway`.
+* Any `Right` subclass will now be interpreted as success.
+* Add `fail!`, `fail_fast!`, `pass!`, and `pass_fast!`.
+* The only semi-public method to modify the pipe is `Railway#add`
+* Removed `&`, `>`, `<` and `%` "operators" in favor of `#add`.
+* Extremely simplified the macro API. Macros now return a callable step with the interface `->(input, options)` and their pipe options, e.g. `[ step, name: "my.macro"]`.
+
 ## 0.0.9
 
 Removing `Operation::consider`, which is now `step`.

data/Gemfile

@@ -10,3 +10,4 @@ gem "dry-auto_inject"
 gem "minitest-line"
 gem "benchmark-ips"
 # gem "pipetree", path: "../pipetree"
+# gem "pipetree", github: "apotonick/pipetree"

data/Rakefile

@@ -9,8 +9,10 @@ Rake::TestTask.new(:test) do |test|
 
   test_files = FileList['test/*_test.rb']
 
-  if RUBY_VERSION == "1.9.3"
-    test_files = test_files - %w{test/dry_container_test.rb test/2.0.0-pipetree_test.rb}
+  if    RUBY_VERSION == "1.9.3"
+    test_files = test_files - %w{test/dry_container_test.rb test/2.1.0-pipetree_test.rb  test/2.0.0-pipetree_test.rb}
+  elsif RUBY_VERSION == "2.0.0"
+    test_files = test_files - %w{test/dry_container_test.rb test/2.1.0-pipetree_test.rb}
   end
 
   test.test_files = test_files

data/lib/trailblazer/operation.rb

@@ -10,14 +10,14 @@ module Trailblazer
     extend Declarative::Heritage::Inherited
     extend Declarative::Heritage::DSL
 
-    extend Skill::Accessors # ::[] and ::[]=
+    extend Skill::Accessors        # ::[] and ::[]=
 
-    include Pipetree        # ::call, ::|
+    include Pipetree               # ::call, ::step, ...
     # we want the skill dependency-mechanism.
-    extend Skill::Call      # ::call
+    extend Skill::Call             # ::call(params: {}, current_user: ..)
     extend Skill::Call::Positional # ::call(params, options)
 
     # we want the initializer and the ::call method.
-    include Generic         # #initialize, #call, #process.
+    include Generic                # #initialize, #call, #process.
   end
 end

data/lib/trailblazer/operation/pipetree.rb

@@ -1,5 +1,5 @@
 require "pipetree"
-require "pipetree/flow"
+require "pipetree/railway"
 require "trailblazer/operation/result"
 require "uber/option"
 
@@ -14,14 +14,13 @@ class Trailblazer::Operation
 
   # Implements the API to populate the operation's pipetree and
   # `Operation::call` to invoke the latter.
-  # http://trailblazer.to/gems/operation/2.0/pipetree.html
+  # Learn more about the Pipetree gem here: https://github.com/apotonick/pipetree
   module Pipetree
     def self.included(includer)
       includer.extend ClassMethods # ::call, ::inititalize_pipetree!
       includer.extend DSL          # ::|, ::> and friends.
 
       includer.initialize_pipetree!
-      includer._insert(:>>, New, name: "operation.new", wrap: false)
     end
 
     module ClassMethods
@@ -32,104 +31,112 @@ class Trailblazer::Operation
 
         last, operation = pipe.(self, options)
 
-        # The reason the Result wraps the Skill object (`options`), not the operation
-        # itself is because the op should be irrelevant, plus when stopping the pipe
-        # before op instantiation, this would be confusing (and wrong!).
-        Result.new(last == ::Pipetree::Flow::Right, options)
+        # Any subclass of Right will be interpreted as successful.
+        Result.new(!!(last <= Railway::Right), options)
       end
 
       # This method would be redundant if Ruby had a Class::finalize! method the way
       # Dry.RB provides it. It has to be executed with every subclassing.
       def initialize_pipetree!
         heritage.record :initialize_pipetree!
-        self["pipetree"] = ::Pipetree::Flow.new
+
+        self["pipetree"] = Railway.new
+
+        strut = ->(last, input, options) { [last, New.(input, options)] } # first step in pipe.
+        self["pipetree"].add(Railway::Right, strut, name: "operation.new") # DISCUSS: using pipe API directly here. clever?
       end
     end
 
-    module DSL
-      # They all inherit.
-      def >(*args); _insert(:>, *args) end
-      def &(*args); _insert(:&, *args) end
-      def <(*args); _insert(:<, *args) end
-
-      def |(cfg, user_options={})
-        DSL.import(self, self["pipetree"], cfg, user_options) &&
-          heritage.record(:|, cfg, user_options)
-      end
+    class Railway < ::Pipetree::Railway
+      FailFast = Class.new(Left)
+      PassFast = Class.new(Right)
 
-      alias_method :step,     :|
-      alias_method :failure,  :<
-      alias_method :success,  :>
-      alias_method :override, :|
-      alias_method :~, :override
+      def self.fail!     ; Left     end
+      def self.fail_fast!; FailFast end
+      def self.pass!     ; Right    end
+      def self.pass_fast!; PassFast end
+    end
 
-      # :private:
-      # High-level user step API that allows ->(options) procs.
-      def _insert(operator, proc, options={})
-        heritage.record(:_insert, operator, proc, options)
+    # The Strut wrapping each step. Makes sure that Track signals are returned immediately.
+    class Switch < ::Pipetree::Railway::Strut
+      Decider = ->(result, config, *args) do
+        return result if result.is_a?(Class) && result <= Railway::Track # this might be pretty slow?
 
-        DSL.insert(self["pipetree"], operator, proc, options, definer_name: self.name)
+        config[:decider_class].(result, config, *args) # e.g. And::Decider.(result, ..)
       end
+    end
+
+    # Strut that doesn't evaluate the step's result but stays on `last` or configured :signal.
+    class Stay < ::Pipetree::Railway::Strut
+      Decider = ->(result, config, last, *) { config[:signal] || last }
+    end
+
+    module DSL
+      def success(*args); add(Railway::Right, Stay::Decider, *args) end
+      def failure(*args); add(Railway::Left,  Stay::Decider, *args) end
+      def step(*args)   ; add(Railway::Right, Railway::And::Decider, *args) end
 
-      # :public:
-      # Wrap the step into a proc that only passes `options` to the step.
-      # This is pure convenience for the developer and will be the default
-      # API for steps. ATM, we also automatically generate a step `:name`.
-      def self.insert(pipe, operator, proc, options={}, kws={}) # TODO: definer_name is a hack for debugging, only.
-        _proc =
-          if options[:wrap] == false
-            proc
-          else
-            Option::KW.(proc) do |type|
-              options[:name] ||= proc if type == :symbol
-              options[:name] ||= "#{kws[:definer_name]}:#{proc.source_location.last}" if proc.is_a? Proc if type == :proc
-              options[:name] ||= proc.class  if type == :callable
-            end
-          end
-
-        pipe.send(operator, _proc, options) # ex: pipetree.> Validate, after: Model::Build
+    private
+      # Operation-level entry point.
+      def add(track, decider_class, proc, options={})
+        heritage.record(:add, track, decider_class, proc, options)
+
+        DSL.insert(self["pipetree"], track, decider_class, proc, options)
       end
 
-      # note: does not calls heritage.record
-      def self.import(operation, pipe, cfg, user_options={})
-        # a normal step is added as "consider"/"may deviate", so its result matters.
-        return insert(pipe, :&, cfg, user_options, {}) unless cfg.is_a?(Array)
+      def self.insert(pipe, track, decider_class, proc, options={}) # TODO: make :name required arg.
+        _proc, options = proc.is_a?(Array) ? macro!(proc, options) : step!(proc, options)
+
+        options = options.merge(replace: options[:name]) if options[:override] # :override
+        strut_class, strut_options = AddOptions.(decider_class, options)       # :fail_fast and friends.
 
-        # e.g. from Contract::Validate
-        mod, args, block = cfg
+        pipe.add(track, strut_class.new(_proc, strut_options), options)
+      end
 
-        import = Import.new(pipe, user_options) # API object.
+      def self.macro!(proc, options)
+        _proc, macro_options = proc
 
-        mod.import!(operation, import, *args, &block)
+        [ _proc, macro_options.merge(options) ]
       end
 
-      # Try to abstract as much as possible from the imported module. This is for
-      # forward-compatibility.
-      # Note that Import#call will push the step directly on the pipetree which gives it the
-      # low-level (input, options) interface.
-      Import = Struct.new(:pipetree, :user_options) do
-        def call(operator, step, options)
-          insert_options = options.merge(user_options)
-
-          # Inheritance: when the step is already defined in the pipe,
-          # simply replace it with the new.
-          if name = insert_options[:name]
-            insert_options[:replace] = name if pipetree.index(name)
-          end
-
-          pipetree.send operator, step, insert_options
+      def self.step!(proc, options)
+        name  = ""
+        _proc = Option::KW.(proc) do |type|
+          name = proc if type == :symbol
+          name = "#{proc.source_location[0].split("/").last}:#{proc.source_location.last}" if proc.is_a? Proc if type == :proc
+          name = proc.class  if type == :callable
         end
+
+        [ _proc, { name: name }.merge(options) ]
       end
 
-      Macros = Module.new
-      # create a class method on `target`, e.g. Contract::Validate() for step macros.
-      def self.macro!(name, constant, target=Macros)
-        target.send :define_method, name do |*args, &block|
-          [constant, args, block]
+      AddOptions = ->(decider_class, options) do
+        # for #failure and #success:
+        if decider_class == Stay::Decider
+          return [Stay, signal: Railway::FailFast] if options[:fail_fast]
+          return [Stay, signal: Railway::PassFast] if options[:pass_fast]
+          return [Stay, {}]
+        else # for #step:
+          return [Switch, decider_class: decider_class, on_false: Railway::FailFast] if options[:fail_fast]
+          return [Switch, decider_class: decider_class, on_true:  Railway::PassFast] if options[:pass_fast]
+          return [Switch, decider_class: decider_class]
         end
       end
     end # DSL
   end
 
-  extend Pipetree::DSL::Macros
+  # Allows defining dependencies and inject/override them via runtime options, if desired.
+  class Pipetree::Step
+    include Uber::Callable
+
+    def initialize(step, dependencies={})
+      @step, @dependencies = step, dependencies
+    end
+
+    def call(input, options)
+      @dependencies.each { |k, v| options[k] ||= v } # not sure i like this, but the step's API is cool.
+
+      @step.(input, options)
+    end
+  end
 end

data/lib/trailblazer/operation/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Operation
-    VERSION = "0.0.9"
+    VERSION = "0.0.10"
   end
 end

data/test/2.0.0-pipetree_test.rb

@@ -1,8 +1,27 @@
 require "test_helper"
 
+class KWBugsTest < Minitest::Spec
+  Merchant = Struct.new(:id)
+
+  class Merchant::New < Trailblazer::Operation
+    step ->(options) {
+      options["model"] = 1
+       options["bla"] = true # this breaks Ruby 2.2.2.
+     }
+
+    step :add!
+    def add!(yo:nil, model:nil, **)
+      raise if model.nil?
+    end
+  end
+
+  it { Merchant::New.( {}, { "yo"=> nil   } ) }
+end
+
+
 class Ruby200PipetreeTest < Minitest::Spec
   class Create < Trailblazer::Operation
-    step ->(*, params:, **) { params["run"] }    # only test kws.
+    step ->(*, params:nil, **) { params["run"] }    # only test kws.
     step ->(options, params:nil, **) { options["x"] = params["run"] } # read and write.
     step ->(options) { options["y"] = options["params"]["run"] } # old API.
   end
@@ -16,7 +35,7 @@ class Ruby200PipetreeTest < Minitest::Spec
     step :x! # read and write.
     step :y! # old API.
 
-    def params!(*, params:, **)
+    def params!(*, params:nil, **)
       params["run"]
     end
 
@@ -36,7 +55,7 @@ class Ruby200PipetreeTest < Minitest::Spec
   class Delete < Trailblazer::Operation
     class Params
       extend Uber::Callable
-      def self.call(*, params:, **)
+      def self.call(*, params:nil, **)
         params["run"]
       end
     end

data/test/2.1.0-pipetree_test.rb

@@ -0,0 +1,84 @@
+require "test_helper"
+
+class KWBugsTest < Minitest::Spec
+  Merchant = Struct.new(:id)
+
+  class Merchant::New < Trailblazer::Operation
+    step ->(options) {
+      options["model"] = 1
+       options["bla"] = true # this breaks Ruby 2.2.2.
+     }
+
+    step :add!
+    def add!(yo:, model:, **)
+      raise if model.nil?
+    end
+  end
+
+  it { Merchant::New.( {}, { "yo"=> nil   } ) }
+end
+
+
+class Ruby200PipetreeTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(*, params:, **) { params["run"] }    # only test kws.
+    step ->(options, params:nil, **) { options["x"] = params["run"] } # read and write.
+    step ->(options) { options["y"] = options["params"]["run"] } # old API.
+  end
+
+  it { Create.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
+  it { Create.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
+
+  #- instance methods
+  class Update < Trailblazer::Operation
+    step :params!    # only test kws.
+    step :x! # read and write.
+    step :y! # old API.
+
+    def params!(*, params:, **)
+      params["run"]
+    end
+
+    def x!(options, params:nil, **)
+      options["x"] = params["run"]
+    end
+
+    def y!(options)
+      options["y"] = options["params"]["run"]
+    end
+  end
+
+  it { Update.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
+  it { Update.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
+
+
+  class Delete < Trailblazer::Operation
+    class Params
+      extend Uber::Callable
+      def self.call(*, params:, **)
+        params["run"]
+      end
+    end
+
+    class X
+      extend Uber::Callable
+      def self.call(options, params:nil, **)
+        options["x"] = params["run"]
+      end
+    end
+
+    class Y
+      extend Uber::Callable
+      def self.call(options)
+        options["y"] = options["params"]["run"]
+      end
+    end
+
+    step Params
+    step X
+    step Y
+  end
+
+  it { Delete.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
+  it { Delete.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
+end

data/test/call_test.rb

@@ -11,14 +11,14 @@ class CallTest < Minitest::Spec
 
     it { Create.().must_be_instance_of Trailblazer::Operation::Result }
 
-    it { Create.({}).inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{}} {\"pipetree\"=>[>>operation.new]}> >} }
-    it { Create.(name: "Jacob").inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>>operation.new]}> >} }
-    it { Create.({ name: "Jacob" }, { policy: Object }).inspect.must_equal %{<Result:true <Skill {} {:policy=>Object, \"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>>operation.new]}> >} }
+    it { Create.({}).inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{}} {\"pipetree\"=>[>operation.new]}> >} }
+    it { Create.(name: "Jacob").inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
+    it { Create.({ name: "Jacob" }, { policy: Object }).inspect.must_equal %{<Result:true <Skill {} {:policy=>Object, \"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
 
     #---
     # success?
     class Update < Trailblazer::Operation
-      self.& ->(options) { options["params"] }, after: "operation.new"
+      step ->(options) { options["params"] }, after: "operation.new"
     end
 
     it { Update.(true).success?.must_equal true }

data/test/gemfiles/Gemfile.ruby-1.9

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 gemspec path: "../../"
 
 gem "declarative"
-gem "pipetree"
+# gem "pipetree", github: "apotonick/pipetree"

data/test/gemfiles/Gemfile.ruby-1.9.lock

@@ -1,9 +1,9 @@
 PATH
   remote: ../../
   specs:
-    trailblazer-operation (0.0.8)
+    trailblazer-operation (0.0.10)
       declarative
-      pipetree (>= 0.0.5, < 0.1.0)
+      pipetree (>= 0.1.0, < 0.2.0)
       uber (>= 0.1.0, < 0.2.0)
 
 GEM
@@ -12,7 +12,7 @@ GEM
     declarative (0.0.8)
       uber (>= 0.0.15)
     minitest (5.10.1)
-    pipetree (0.0.5)
+    pipetree (0.1.0)
       uber
     rake (12.0.0)
     uber (0.1.0)
@@ -24,7 +24,6 @@ DEPENDENCIES
   bundler
   declarative
   minitest
-  pipetree
   rake
   trailblazer-operation!
 

data/test/gemfiles/Gemfile.ruby-2.0

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec path: "../../"
+
+gem "declarative"
+gem "pipetree"
+gem "dry-container"

data/test/gemfiles/Gemfile.ruby-2.0.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: ../../
+  specs:
+    trailblazer-operation (0.0.9)
+      declarative
+      pipetree (>= 0.0.5, < 0.1.0)
+      uber (>= 0.1.0, < 0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.2)
+    declarative (0.0.8)
+      uber (>= 0.0.15)
+    dry-configurable (0.4.0)
+      concurrent-ruby (~> 1.0)
+    dry-container (0.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    minitest (5.10.1)
+    pipetree (0.0.5)
+      uber
+    rake (12.0.0)
+    uber (0.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  declarative
+  dry-container
+  minitest
+  pipetree
+  rake
+  trailblazer-operation!
+
+BUNDLED WITH
+   1.12.5

data/test/operation_skill_test.rb

@@ -16,7 +16,7 @@ class OperationCompetenceTest < Minitest::Spec
   # Operation#[]=
   # arbitrary options can be saved via Op#[].
   class Create < Trailblazer::Operation
-    self.> :call
+    success :call
 
     def call(*)
       self["drink"] = "Little Creatures"
@@ -37,7 +37,7 @@ class OperationCompetenceTest < Minitest::Spec
   # Operation::[]
   # Operation::[]=
   class Update < Trailblazer::Operation
-    self.> :call
+    success :call
 
     self["drink"] = "Beer"
 
@@ -56,7 +56,7 @@ class OperationCompetenceTest < Minitest::Spec
 
   # instance can override class-level
   class Delete < Trailblazer::Operation
-    self.> :call
+    success :call
 
     self["drink"] = "Beer"
 

data/test/pipetree_test.rb

@@ -1,34 +1,28 @@
 require "test_helper"
 
 class PipetreeTest < Minitest::Spec
-  module Validate
-    def self.import!(operation, pipe)
-      pipe.(:>, ->{ snippet }, name: "validate", before: "operation.new")
-    end
+  def self.Validate
+    step = ->{ snippet }
+
+    [ step, name: "validate", before: "operation.new" ]
   end
 
-  #---
-  # ::|
   # without options
   class Create < Trailblazer::Operation
-    step [Validate]
+    step PipetreeTest::Validate()
+    step PipetreeTest::Validate(), name: "VALIDATE!"
   end
 
-  it { Create["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
+  it { Create["pipetree"].inspect.must_equal %{[>validate,>VALIDATE!,>operation.new]} }
 
-  # without any options or []
-  # class New < Trailblazer::Operation
-  #   step Validate
-  # end
 
-  # it { New["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
 
   # with options
   class Update < Trailblazer::Operation
-    step [Validate], after: "operation.new"
+    step PipetreeTest::Validate(), after: "operation.new"
   end
 
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,>validate]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>validate]} }
 
   #---
   # ::step
@@ -63,41 +57,129 @@ class PipetreeTest < Minitest::Spec
   # with proc, method, callable.
   class Right < Trailblazer::Operation
     MyProc = ->(*) { }
-    self.> ->(options) { options[">"] = options["params"][:id] }, better_api: true
+    success ->(options) { options[">"] = options["params"][:id] }, better_api: true
 
-    self.> :method_name!
+    success :method_name!
     def method_name!(options); self["method_name!"] = options["params"][:id] end
 
     class MyCallable
       include Uber::Callable
       def call(options); options["callable"] = options["params"][:id] end
     end
-    self.> MyCallable.new
+    success MyCallable.new
   end
 
   it { Right.( id: 1 ).slice(">", "method_name!", "callable").must_equal [1, 1, 1] }
-  it { Right["pipetree"].inspect.must_equal %{[>>operation.new,>PipetreeTest::Right:66,>method_name!,>PipetreeTest::Right::MyCallable]} }
+  it { Right["pipetree"].inspect.must_equal %{[>operation.new,>pipetree_test.rb:60,>method_name!,>PipetreeTest::Right::MyCallable]} }
 
   #---
   # inheritance
   class Righter < Right
-    self.> ->(options) { options["righter"] = true }
+    success ->(options) { options["righter"] = true }
   end
 
   it { Righter.( id: 1 ).slice(">", "method_name!", "callable", "righter").must_equal [1, 1, 1, true] }
 end
 
-#---
-#- kw args
-class OperationKwArgsTest < Minitest::Spec
-  Song = Struct.new(:id)
 
+class FailPassFastOptionTest < 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
+
+  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
+    success ->(options, *) { options["x"] = options["dont_fail"] }, pass_fast: true
+    failure ->(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] >} }
+
+  # #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 }
+    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] >} }
+
+  # #step passes fast if option set and returns true.
+  class Delete < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true }
+    step ->(options, *) { options["a"] = options["dont_fail"] }, pass_fast: true # only on true.
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  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] >} }
+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 }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, true] >} }
+end
+
+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 }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, true, nil] >} }
+end
+
+class FailFastBangTest < Minitest::Spec
   class Create < Trailblazer::Operation
-    self.> ->(options) { options["model"] = "Object" }
-    # self.> ->(model:) { snippet }
+    step ->(options, *) { options["x"] = true; Railway.fail_fast! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} }
+end
+
+class PassFastBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.pass_fast! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, nil, nil] >} }
+end
+
+
+class OverrideTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step :a
+    step :b
+  end
+
+  class Update < Create
+    step :a, override: true
   end
 
-  it {
-    skip
-    Create.() }
+# FIXME: also test Macro
+  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
 end

data/test/result_test.rb

@@ -17,7 +17,7 @@ class ResultTest < Minitest::Spec
   it { Result.new(true, "x"=> true, "y"=>1, "z"=>2).inspect("z", "y").must_equal %{<Result:true [2, 1] >} }
 
   class Create < Trailblazer::Operation
-    self.> :call
+    success :call
 
     def call(*)
       self[:message] = "Result objects are actually quite handy!"

data/trailblazer-operation.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
   spec.description   = %q{Trailblazer's operation object.}
-  spec.summary       = %q{Trailblazer's operation object with dependency management and pipetree flow.}
+  spec.summary       = %q{Trailblazer's operation object with railway flow and integrated error handling.}
   spec.homepage      = "http://trailblazer.to"
   spec.license       = "MIT"
 
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "uber", ">= 0.1.0", "< 0.2.0"
   spec.add_dependency "declarative"
-  spec.add_dependency "pipetree", ">= 0.0.5", "< 0.1.0"
+  spec.add_dependency "pipetree", ">= 0.1.0", "< 0.2.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-operation
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-13 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -50,20 +50,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,11 +129,14 @@ files:
 - lib/trailblazer/operation/version.rb
 - lib/trailblazer/skill.rb
 - test/2.0.0-pipetree_test.rb
+- test/2.1.0-pipetree_test.rb
 - test/benchmark/skill_resolver_benchmark.rb
 - test/call_test.rb
 - test/dry_container_test.rb
 - test/gemfiles/Gemfile.ruby-1.9
 - test/gemfiles/Gemfile.ruby-1.9.lock
+- test/gemfiles/Gemfile.ruby-2.0
+- test/gemfiles/Gemfile.ruby-2.0.lock
 - test/gemfiles/Gemfile.ruby-2.3
 - test/gemfiles/Gemfile.ruby-2.3.lock
 - test/inheritance_test.rb
@@ -166,14 +169,17 @@ rubyforge_project:
 rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
-summary: Trailblazer's operation object with dependency management and pipetree flow.
+summary: Trailblazer's operation object with railway flow and integrated error handling.
 test_files:
 - test/2.0.0-pipetree_test.rb
+- test/2.1.0-pipetree_test.rb
 - test/benchmark/skill_resolver_benchmark.rb
 - test/call_test.rb
 - test/dry_container_test.rb
 - test/gemfiles/Gemfile.ruby-1.9
 - test/gemfiles/Gemfile.ruby-1.9.lock
+- test/gemfiles/Gemfile.ruby-2.0
+- test/gemfiles/Gemfile.ruby-2.0.lock
 - test/gemfiles/Gemfile.ruby-2.3
 - test/gemfiles/Gemfile.ruby-2.3.lock
 - test/inheritance_test.rb