trailblazer 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 796e342235352bda7ad6efbfbb4917f016846ff5
-  data.tar.gz: b7f53417cf1b74c08f8177a92f536e2990675dca
+  metadata.gz: c73755bd284523c496d97f90e637048d778a4233
+  data.tar.gz: 8c380418456b199836576b6d6cb78611d5e8ca73
 SHA512:
-  metadata.gz: e8a5e6fbdb459b89c6dbf7c97d1771691d4b0ca0e259a27fb6318b977de11ba557b38db00f8816e0d671975ba9a5b58a180771e9d2ecad0d7a6d0d69e0f6bf5a
-  data.tar.gz: f801d455bae0cafa1746c362d435e6ee39b23430836577c908b15904178abc42ba4a3af550ec763ae74328c7042f0bc4ac281bf5d2cf3e16d88ca43978d06bb9
+  metadata.gz: 8aee8a0a4ccfa11d016504d269e7f9248e58696ae508c15031b5f59a0e35f647a68d940f1244b150d5b05a8533e9dab05c47bbe11a1d07ae79a315d949a2ff61
+  data.tar.gz: 7d6086b907f98b3d53bf152d1a72ef47d71bdbb5482ec38f6096cf682bc3e44f1faa83a35b30c7700e79936181ade80838d08190981d6355a9dc62e4a2993a61

data/CHANGES.md

@@ -102,6 +102,13 @@ You can now inject the following objects via `::call`:
 
 * You can't call `Create.().contract` anymore. The contract instance(s) are available through the `Result` object.
 
+# 2.0.0.beta2
+
+* Removed `Operation::Controller`.
+* Renamed `Persist` to `Contract::Persist`.
+* Simplify inheritance by introducing `Operation::override`.
+* `Contract` paths are now consistent.
+
 # 2.0.0.beta1
 
 * Still undefined `self.~`.

data/Gemfile

@@ -20,8 +20,8 @@ gem "dry-matcher"
 gem "dry-validation"
 
 
-# gem "trailblazer-operation", path: "../operation"
-gem "pipetree"#, path: "../pipetree"
+gem "trailblazer-operation"#, path: "../operation"
+# gem "pipetree", path: "../pipetree"
 
 gem "minitest-line"
 

data/README.md

@@ -127,7 +127,7 @@ Again, the controller only dispatchs to the operation and handles successful/inv
 
 Operations encapsulate business logic and are the heart of a Trailblazer architecture.
 
-The bare bones operation without any Trailblazery is implemented in [the `trailblazer-operation` gem[(https://github.com/trailblazer/trailblazer-operation) and can be used without our stack.
+The bare bones operation without any Trailblazery is implemented in [the `trailblazer-operation` gem](https://github.com/trailblazer/trailblazer-operation) and can be used without our stack.
 
 Operations don't know about HTTP or the environment. You could use an operation in Rails, Hanami, or Roda, it wouldn't know.
 

data/lib/trailblazer.rb

@@ -9,7 +9,6 @@ require "trailblazer/operation/model"
 require "trailblazer/operation/contract"
 require "trailblazer/operation/validate"
 require "trailblazer/operation/representer"
-require "trailblazer/operation/present"
 require "trailblazer/operation/policy"
 require "trailblazer/operation/pundit"
 require "trailblazer/operation/guard"

data/lib/trailblazer/operation/builder.rb

@@ -20,7 +20,5 @@ class Trailblazer::Operation
     DSL = Uber::Builder::DSL
   end
 
-  def self.Builder(*args, &block)
-    [ Builder, args, block ]
-  end
+  DSL.macro!(:Builder, Builder) # Operation::Builder()
 end

data/lib/trailblazer/operation/callback.rb

@@ -40,7 +40,5 @@ class Trailblazer::Operation
     end
   end
 
-  def self.Callback(*args, &block)
-    [ Callback, args, block ]
-  end
+  DSL.macro!(:Callback, Callback) # Operation::Callback()
 end

data/lib/trailblazer/operation/contract.rb

@@ -6,41 +6,41 @@
 #
 # Needs Operation#model.
 # Needs #[], #[]= skill dependency.
-module Trailblazer::Operation::Contract
-  module Build
-    # bla build contract at runtime.
-    def self.build_contract!(operation, options, name:"default", constant:nil, builder: nil)
-      # TODO: we could probably clean this up a bit at some point.
-      contract_class = constant || options["contract.#{name}.class"]
-      model          = operation["model"] # FIXME: model.default
+class Trailblazer::Operation
+  module Contract
+    module Build
+      # bla build contract at runtime.
+      def self.build_contract!(operation, options, name:"default", constant:nil, builder: nil)
+        # TODO: we could probably clean this up a bit at some point.
+        contract_class = constant || options["contract.#{name}.class"]
+        model          = operation["model"] # FIXME: model.default
 
-      return operation["contract.#{name}"] = Uber::Option[builder].(operation, constant: contract_class, model: model) if builder
+        return operation["contract.#{name}"] = Uber::Option[builder].(operation, constant: contract_class, model: model) if builder
 
-      operation["contract.#{name}"] = contract_class.new(model)
-    end
+        operation["contract.#{name}"] = contract_class.new(model)
+      end
 
-    def self.import!(operation, import, **args)
-      import.(:>, ->(operation, options) { build_contract!(operation, options, **args) },
-        name: "contract.build")
+      def self.import!(operation, import, **args)
+        import.(:>, ->(operation, options) { build_contract!(operation, options, **args) },
+          name: "contract.build")
+      end
     end
-  end
 
-  def self.Build(*args, &block)
-    [ Build, args, block ]
-  end
+    module DSL
+      # This is the class level DSL method.
+      #   Op.contract #=> returns contract class
+      #   Op.contract do .. end # defines contract
+      #   Op.contract CommentForm # copies (and subclasses) external contract.
+      #   Op.contract CommentForm do .. end # copies and extends contract.
+      def contract(name=:default, constant=nil, base: Reform::Form, &block)
+        heritage.record(:contract, name, constant, &block)
 
-  module DSL
-    # This is the class level DSL method.
-    #   Op.contract #=> returns contract class
-    #   Op.contract do .. end # defines contract
-    #   Op.contract CommentForm # copies (and subclasses) external contract.
-    #   Op.contract CommentForm do .. end # copies and extends contract.
-    def contract(name=:default, constant=nil, base: Reform::Form, &block)
-      heritage.record(:contract, name, constant, &block)
+        path, form_class = Trailblazer::DSL::Build.new.({ prefix: :contract, class: base, container: self }, name, constant, block)
 
-      path, form_class = Trailblazer::DSL::Build.new.({ prefix: :contract, class: base, container: self }, name, constant, block)
+        self[path] = form_class
+      end
+    end # Contract
+  end
 
-      self[path] = form_class
-    end
-  end # Contract
+  DSL.macro!(:Build, Contract::Build, Contract.singleton_class)
 end

data/lib/trailblazer/operation/guard.rb

@@ -4,8 +4,8 @@ require "uber/option"
 class Trailblazer::Operation
   module Policy
     module Guard
-      def self.import!(operation, import, user_proc, options={})
-        Policy.add!(operation, import, options) { Guard.build(user_proc) }
+      def self.import!(operation, import, user_proc, options={}, insert_options={})
+        Policy.add!(operation, import, options, insert_options) { Guard.build(user_proc) }
       end
 
       def self.build(callable)
@@ -17,8 +17,13 @@ class Trailblazer::Operation
       end
     end # Guard
 
-    def self.Guard(*args, &block)
-      [ Guard, args, block ]
+    def self.Guard(proc, name: :default, &block)
+      options = {
+        name:  name,
+        path: "policy.#{name}.eval",
+      }
+
+      [Guard, [proc, options], block]
     end
   end
 end

data/lib/trailblazer/operation/model.rb

@@ -3,16 +3,13 @@ class Trailblazer::Operation
     Step = ->(operation, options) { options["model"] = operation.model!(options["params"]) }
 
     def self.import!(operation, import, model_class, action=nil)
-      if import.inheriting? # not sure how to do overrides!
-        # FIXME: prototyping inheritance. should we handle that here?
-        return operation["model.action"] = model_class
-      end
-
-      import.(:&, Step, name: "model.build")
-
+      # configure
       operation["model.class"] = model_class
       operation["model.action"] = action
 
+      # add
+      import.(:&, Step, name: "model.build")
+
       operation.send :include, BuildMethods
     end
 

data/lib/trailblazer/operation/persist.rb

@@ -1,13 +1,15 @@
 class Trailblazer::Operation
-  module Persist
-    def self.import!(operation, import, options={})
-      save_method   = options[:method] || :save
-      contract_name = options[:name] || "contract.default"
+  module Contract
+    module Persist
+      def self.import!(operation, import, options={})
+        save_method   = options[:method] || :save
+        contract_name = options[:name] || "contract.default"
 
-      import.(:&, ->(input, options) { options[contract_name].send(save_method) }, # TODO: test me.
-        name: "persist.save")
+        import.(:&, ->(input, options) { options[contract_name].send(save_method) }, # TODO: test me.
+          name: "persist.save")
+      end
     end
   end
 
-  DSL.macro!(:Persist, Persist)
+  DSL.macro!(:Persist, Contract::Persist, Contract.singleton_class) # Contract::Persist()
 end

data/lib/trailblazer/operation/policy.rb

@@ -2,7 +2,6 @@ class Trailblazer::Operation
   module Policy
     # Step: This generically `call`s a policy and then pushes its result to `options`.
     # You can use any callable object as a policy with this step.
-    # :private:
     class Eval
       include Uber::Callable
 
@@ -23,17 +22,24 @@ class Trailblazer::Operation
       end
     end
 
-    # Adds the `yield` result to the pipe and treats it like a policy-compatible object at runtime.
-    def self.add!(operation, import, options)
-      name = options[:name] || :default
+    # Adds the `yield` result to the pipe and treats it like a
+    # policy-compatible  object at runtime.
+    def self.add!(operation, import, options, insert_options, &block)
+      name = options[:name]
+      path = options[:path]
 
-      # configure class level.
-      operation[path = "policy.#{name}.eval"] = yield
+      configure!(operation, import, options, &block)
 
       # add step.
       import.(:&, Eval.new( name: name, path: path ),
-        name: path
+        insert_options.merge(name: path)
       )
     end
+
+  private
+    def self.configure!(operation, import, options)
+      # configure class level.
+      operation[ options[:path] ] = yield
+    end
   end
 end

data/lib/trailblazer/operation/pundit.rb

@@ -1,8 +1,8 @@
 class Trailblazer::Operation
   module Policy
     module Pundit
-      def self.import!(operation, import, policy_class, action, options={})
-        Policy.add!(operation, import, options) { Pundit.build(policy_class, action) }
+      def self.import!(operation, import, policy_class, action, options={}, insert_options={})
+        Policy.add!(operation, import, options, insert_options) { Pundit.build(policy_class, action) }
       end
 
       def self.build(*args, &block)
@@ -35,8 +35,13 @@ class Trailblazer::Operation
       end
     end
 
-    def self.Pundit(*args, &block)
-      [ Pundit, args, block ]
+    def self.Pundit(policy, condition, name: :default, &block)
+      options = {
+        name:  name,
+        path: "policy.#{name}.eval",
+      }
+
+      [Pundit, [policy, condition, options], block]
     end
   end
 end

data/lib/trailblazer/operation/resolver.rb

@@ -18,7 +18,5 @@ class Trailblazer::Operation
     # end
   end
 
-  def self.Resolver(*args, &block)
-    [ Resolver, args, block ]
-  end
+  DSL.macro!(:Resolver, Resolver)
 end

data/lib/trailblazer/operation/validate.rb

@@ -1,50 +1,55 @@
-module Trailblazer::Operation::Contract
-  # result.contract = {..}
-  # result.contract.errors = {..}
-  # Deviate to left track if optional key is not found in params.
-  # Deviate to left if validation result falsey.
-  module Validate
-    def self.import!(operation, import, skip_extract:false, name: "default", representer:false, **args) # DISCUSS: should we introduce something like Validate::Deserializer?
-      if representer
-        skip_extract = true
-        operation["representer.#{name}.class"] = representer
-      end
+class Trailblazer::Operation
+  module Contract
+    # result.contract = {..}
+    # result.contract.errors = {..}
+    # Deviate to left track if optional key is not found in params.
+    # Deviate to left if validation result falsey.
+    module Validate
+      def self.import!(operation, import, skip_extract:false, name: "default", representer:false, key: nil) # DISCUSS: should we introduce something like Validate::Deserializer?
+        if representer
+          skip_extract = true
+          operation["representer.#{name}.class"] = representer
+        end
 
-      import.(:&, ->(input, options) { extract_params!(input, options, **args) },
-        name: "validate.params.extract") unless skip_extract
+        params_path = "contract.#{name}.params" # extract_params! save extracted params here.
 
-      # call the actual contract.validate(params)
-      # DISCUSS: should we pass the representer here, or do that in #validate! i'm still mulling over what's the best, most generic approach.
-      import.(:&, ->(operation, options) { validate!(operation, options, name: name, representer: options["representer.#{name}.class"], **args) },
-        name: "contract.validate")
-      end
+        import.(:&, ->(input, options) { extract_params!(input, options, key: key, path: params_path) },
+          name: params_path) unless skip_extract
 
-    def self.extract_params!(operation, options, key:nil, **)
-      # TODO: introduce nested pipes and pass composed input instead.
-      options["params.validate"] = key ? options["params"][key] : options["params"]
-    end
+        # call the actual contract.validate(params)
+        # DISCUSS: should we pass the representer here, or do that in #validate! i'm still mulling over what's the best, most generic approach.
+        import.(:&, ->(operation, options) do
+            validate!(operation, options, name: name, representer: options["representer.#{name}.class"], key: key, params_path: params_path)
+          end,
+          name: "contract.#{name}.validate", # visible name of the pipe step.
+        )
+        end
 
-    def self.validate!(operation, options, name: nil, representer:false, from: "document", **)
-      path     = "contract.#{name}"
-      contract = operation[path]
+      def self.extract_params!(operation, options, key:nil, path:nil)
+        # TODO: introduce nested pipes and pass composed input instead.
+        options[path] = key ? options["params"][key] : options["params"]
+      end
 
-      # this is for 1.1-style compatibility and should be removed once we have Deserializer in place:
-      operation["result.#{path}"] = result =
-        if representer
-          # use "document" as the body and let the representer deserialize to the contract.
-          # this will be simplified once we have Deserializer.
-          # translates to contract.("{document: bla}") { MyRepresenter.new(contract).from_json .. }
-          contract.(options[from]) { |document| representer.new(contract).parse(document) }
-        else
-          # let Reform handle the deserialization.
-          contract.(options["params.validate"])
-        end
+      def self.validate!(operation, options, name: nil, representer:false, from: "document", params_path:nil, **)
+        path     = "contract.#{name}"
+        contract = operation[path]
 
-      result.success?
+        # this is for 1.1-style compatibility and should be removed once we have Deserializer in place:
+        operation["result.#{path}"] = result =
+          if representer
+            # use "document" as the body and let the representer deserialize to the contract.
+            # this will be simplified once we have Deserializer.
+            # translates to contract.("{document: bla}") { MyRepresenter.new(contract).from_json .. }
+            contract.(options[from]) { |document| representer.new(contract).parse(document) }
+          else
+            # let Reform handle the deserialization.
+            contract.(options[params_path])
+          end
+
+        result.success?
+      end
     end
   end
 
-  def self.Validate(*args, &block)
-    [ Validate, args, block ]
-  end
+  DSL.macro!(:Validate, Contract::Validate, Contract.singleton_class)
 end

data/lib/trailblazer/operation/wrap.rb

@@ -1,7 +1,7 @@
 class Trailblazer::Operation
   module Wrap
     def self.import!(operation, import, wrap, _options={}, &block)
-      pipe_api = API.new(operation, pipe = ::Pipetree::Flow[])
+      pipe_api = API.new(operation, pipe = ::Pipetree::Flow.new)
 
       # DISCUSS: don't instance_exec when |pipe| given?
       # yield pipe_api # create the nested pipe.
@@ -32,6 +32,5 @@ class Trailblazer::Operation
   DSL.macro!(:Wrap, Wrap)
 end
 
-
 # (options, *) => (options, operation, bla)
 # (*, params:, **) => (options, operation, bla, options)

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "2.0.0.beta1"
+  VERSION = "2.0.0.beta2"
 end

data/test/docs/contract_test.rb

@@ -24,7 +24,7 @@ class DocsContractOverviewTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
     #~contractonly end
   end
   #:overv-reform end
@@ -121,7 +121,7 @@ class DocsContractExplicitTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:reform-inline-op end
 end
@@ -141,11 +141,11 @@ class DocsContractKeyTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()
     step Contract::Validate( key: "song" )
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:key end
 
-  it { Create.({}).inspect("model").must_equal %{<Result:false [#<struct DocsContractKeyTest::Song id=nil, title=nil>] >} }
+  it { Create.({}).inspect("model", "result.contract.default.extract").must_equal %{<Result:false [#<struct DocsContractKeyTest::Song id=nil, title=nil>, nil] >} }
   it { Create.({"song" => { title: "SVG" }}).inspect("model").must_equal %{<Result:true [#<struct DocsContractKeyTest::Song id=nil, title="SVG">] >} }
 end
 
@@ -168,10 +168,10 @@ class DocsContractSeparateKeyTest < Minitest::Spec
     step Contract::Build()
     consider :extract_params!
     step Contract::Validate( skip_extract: true )
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
 
     def extract_params!(options)
-      options["params.validate"] = options["params"][type]
+      options["contract.default.params"] = options["params"][type]
     end
   end
   #:key-extr end
@@ -196,7 +196,7 @@ class ContractConstantTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract )
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:constant end
 
@@ -217,7 +217,7 @@ class ContractNamedConstantTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract, name: "form" )
     step Contract::Validate( name: "form" )
-    step Persist( method: :sync, name: "contract.form" )
+    step Contract::Persist( method: :sync, name: "contract.form" )
   end
   #:constant-name end
 
@@ -241,7 +241,7 @@ class ContractInjectConstantTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:di-constant end
 
@@ -285,11 +285,13 @@ class DryValidationContractTest < Minitest::Spec
     step Model( Song, :new )                             # create the op's main model.
     step Contract::Build( name: "form" )                 # create the Reform contract.
     step Contract::Validate( name: "form" )              # validate the Reform contract.
-    step Persist( method: :sync, name: "contract.form" ) # persist the contract's data via the model.
+    step Contract::Persist( method: :sync, name: "contract.form" ) # persist the contract's data via the model.
     #~form end
   end
   #:dry-schema end
 
+  puts "@@@@@ #{Create["pipetree"].inspect(style: :rows)}"
+
   it { Create.({}).inspect("model", "result.contract.params").must_equal %{<Result:false [nil, #<Dry::Validation::Result output={} errors={:id=>[\"is missing\"]}>] >} }
   it { Create.({ id: 1 }).inspect("model", "result.contract.params").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>, #<Dry::Validation::Result output={:id=>1} errors={}>] >} }
   # it { Create.({ id: 1, title: "" }).inspect("model", "result.contract.form").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
@@ -349,7 +351,7 @@ class DocContractBuilderTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( builder: :default_contract! )
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
 
     def default_contract!(constant:, model:)
       constant.new(model, current_user: self["current_user"])
@@ -377,7 +379,7 @@ class DocContractBuilderTest < Minitest::Spec
     })
     #:builder-proc end
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
 
   it { Update.({}).inspect("model").must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
@@ -397,7 +399,7 @@ class DocContractTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()            # resolves to "contract.class.default" and is resolved at runtime.
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
 
   it { Block.({}).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title=nil>] >} }

data/test/docs/dry_test.rb

@@ -22,7 +22,7 @@ class DryContainerTest < Minitest::Spec
     self.| Model( Song, :new )
     self.| Contract::Build()
     self.| Contract::Validate()
-    self.| Persist( method: :sync )
+    self.| Contract::Persist( method: :sync )
   end
   #:key end
 

data/test/docs/guard_test.rb

@@ -29,6 +29,7 @@ class DocsGuardProcTest < Minitest::Spec
    #---
   #- Guard inheritance
   class New < Create
+    override Policy::Guard( ->(options) { options["current_user"] } )
   end
 
   it { New["pipetree"].inspect.must_equal %{[>>operation.new,&policy.default.eval,>process]} }

data/test/docs/nested_test.rb

@@ -27,7 +27,7 @@ class DocsNestedOperationTest < Minitest::Spec
   class Update < Trailblazer::Operation
     step Nested( Edit )
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:update end
 

data/test/docs/operation_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class DocsOperationExampleTest < Minitest::Spec
+  Song = Struct.new(:id, :title, :created_by) do
+    def save; true; end
+  end
+  #:op
+
+  class Song::Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+      validates :title, presence: true
+    end
+
+    step     Model( Song, :new )
+    consider :assign_current_user!
+    step     Contract::Build()
+    step     Contract::Validate( )
+    failure  :log_error!
+    step     Contract::Persist(  )
+
+    def log_error!(options)
+      # ..
+    end
+
+    def assign_current_user!(options)
+      options["model"].created_by =
+        options["current_user"]
+    end
+  end
+  #:op end
+
+  it { Song::Create.({ }).inspect("model").must_equal %{<Result:false [#<struct DocsOperationExampleTest::Song id=nil, title=nil, created_by=nil>] >} }
+  it { Song::Create.({ title: "Nothin'" }, "current_user"=>Module).inspect("model").must_equal %{<Result:true [#<struct DocsOperationExampleTest::Song id=nil, title="Nothin'", created_by=Module>] >} }
+end
+
+class DndTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    consider :authorize!
+    failure  :auth_err!
+    consider :save!
+    self.< Wrap
+  end
+end

data/test/docs/pundit_test.rb

@@ -9,6 +9,10 @@ class MyPolicy
   def create?
     @user == Module && @model.id.nil?
   end
+
+  def new?
+    @user == Class
+  end
 end
 #:policy end
 
@@ -38,12 +42,31 @@ class DocsPunditProcTest < Minitest::Spec
     result["result.policy.default"]["policy"].is_a?(MyPolicy).must_equal true
   end
 
-   #---
-  #- Guard inheritance
+  #---
+  #- override
   class New < Create
+    override Policy::Pundit( MyPolicy, :new? )
   end
 
   it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,&policy.default.eval]} }
+  it { New.({}, "current_user" => Class ).inspect("model").must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
+  it { New.({}, "current_user" => nil ).inspect("model").must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
+
+  #---
+  #- override with :name
+  class Edit < Trailblazer::Operation
+    step Policy::Pundit( MyPolicy, :create?, name: "first" )
+    step Policy::Pundit( MyPolicy, :new?,    name: "second" )
+  end
+
+  class Update < Edit
+    override Policy::Pundit( MyPolicy, :new?, name: "first" )
+  end
+
+  it { Edit["pipetree"].inspect.must_equal %{[>>operation.new,&policy.first.eval,&policy.second.eval]} }
+  it { Edit.({}, "current_user" => Class).inspect("model").must_equal %{<Result:false [nil] >} }
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&policy.first.eval,&policy.second.eval]} }
+  it { Update.({}, "current_user" => Class).inspect("model").must_equal %{<Result:true [nil] >} }
 
   #---
   # dependency injection

data/test/docs/representer_test.rb

@@ -15,7 +15,7 @@ class DocsRepresenterInferTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract )
     step Contract::Validate( representer: Representer.infer(MyContract, format: Representable::JSON) )
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:infer end
 
@@ -44,7 +44,7 @@ class DocsRepresenterExplicitTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract )
     step Contract::Validate( representer: MyRepresenter ) # :representer
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:explicit-op end
 
@@ -108,7 +108,7 @@ class DocsRepresenterDITest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract )
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
 
   let (:json) { MultiJson.dump(id: 1) }
@@ -136,7 +136,7 @@ class DocsRepresenterInlineTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build( constant: MyContract )
     step Contract::Validate( representer: self["representer.default.class"] )
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:inline end
 
@@ -231,7 +231,7 @@ class DocsRepresenterFullExampleTest < Minitest::Spec
     step Model( Song, :new )
     step Contract::Build()
     step Contract::Validate( representer: self["representer.parse.class"] )
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:full end
 

data/test/docs/rescue_test.rb

@@ -20,7 +20,7 @@ class NestedRescueTest < Minitest::Spec
       self.< ->(options) { options["inner-err"] = true }
     }
     step ->(options) { options["e"] = true }
-    self.< ->(options) { options["outer-err"] = true }
+    failure ->(options) { options["outer-err"] = true }
   end
 
   it { NestedInsanity["pipetree"].inspect.must_equal %{[>>operation.new,&Rescue:10,>:22,<NestedRescueTest::NestedInsanity:23]} }
@@ -61,7 +61,7 @@ class RescueTest < Minitest::Spec
       step Contract::Build( constant: MyContract )
     }
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
   #:simple end
 
@@ -82,7 +82,7 @@ class RescueTest < Minitest::Spec
       step Contract::Build( constant: MyContract )
     }
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
 
     def rollback!(exception, options)
       options["x"] = exception.class
@@ -122,7 +122,7 @@ class RescueTest < Minitest::Spec
         step ->(options) { options["model"].lock! } # lock the model.
         step Contract::Build( constant: MyContract )
         step Contract::Validate( )
-        step Persist( method: :sync )
+        step Contract::Persist( method: :sync )
       }
     }
     failure :error! # handle all kinds of errors.

data/test/docs/wrap_test.rb

@@ -23,7 +23,7 @@ class WrapTest < Minitest::Spec
       step Contract::Build( constant: MyContract )
     }
     step Contract::Validate()
-    step Persist( method: :sync )
+    step Contract::Persist( method: :sync )
   end
 
   it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct WrapTest::Song id=1, title="Prodigal Son">} }
@@ -100,7 +100,7 @@ class WrapTest < Minitest::Spec
       #~wrap-only
       step Contract::Build( constant: MyContract )
       step Contract::Validate( )
-      step Persist( method: :sync )
+      step Contract::Persist( method: :sync )
       #~wrap-only end
     }
     failure :error! # handle all kinds of errors.
@@ -150,7 +150,7 @@ class WrapTest < Minitest::Spec
       #~wrap-onlyy
       step Contract::Build( constant: MyContract )
       step Contract::Validate( )
-      step Persist( method: :sync )
+      step Contract::Persist( method: :sync )
       #~wrap-onlyy end
     }
     failure :error! # handle all kinds of errors.

data/test/operation/callback_test.rb

@@ -55,7 +55,7 @@ class OperationCallbackTest < MiniTest::Spec
 
   #---
   #- inheritance
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&validate.params.extract,&contract.validate,&callback.default]} }
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&callback.default]} }
 
 
   it "invokes all callbacks" do

data/test/operation/contract_test.rb

@@ -295,6 +295,7 @@ class ValidateTest < Minitest::Spec
     self.| Contract::Build()
     self.| Contract::Validate( key: :song) # generic validate call for you.
     # ->(*) { validate(options["params"][:song]) } # <-- TODO
+    step Contract::Persist( method: :sync )
   end
 
   # success
@@ -305,16 +306,24 @@ class ValidateTest < Minitest::Spec
   it { Upsert.().success?.must_equal false }
 
   #---
-  # params.validate gets set (TODO: change in 2.1)
+  # contract.default.params gets set (TODO: change in 2.1)
   it { Upsert.(song: { title: "SVG" })["params"].must_equal({:song=>{:title=>"SVG"}}) }
-  it { Upsert.(song: { title: "SVG" })["params.validate"].must_equal({:title=>"SVG"}) }
+  it { Upsert.(song: { title: "SVG" })["contract.default.params"].must_equal({:title=>"SVG"}) }
 
   #---
   #- inheritance
   class New < Upsert
   end
 
-  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&validate.params.extract,&contract.validate]} }
+  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&persist.save]} }
+
+  #- overwriting Validate
+  class NewHit < Upsert
+    override Contract::Validate( key: :hit )
+  end
+
+  it { NewHit["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&persist.save]} }
+  it { NewHit.(:hit => { title: "Hooray For Me" }).inspect("model").must_equal %{<Result:true [#<struct ContractTest::Song title=\"Hooray For Me\">] >} }
 end
 
 # #---

data/test/operation/dsl/contract_test.rb

@@ -17,7 +17,7 @@ class DslContractTest < MiniTest::Spec
       includer.| Trailblazer::Operation::Model( OpenStruct, :new )
       includer.| Trailblazer::Operation::Contract::Build()
       includer.| Trailblazer::Operation::Contract::Validate()
-      includer.| Trailblazer::Operation::Persist( save_method: :sync )
+      includer.| Trailblazer::Operation::Contract::Persist( save_method: :sync )
       # includer.> ->(op, *) { op["x"] = [] }
     end
   end

data/test/operation/model_test.rb

@@ -16,7 +16,7 @@ class ModelTest < Minitest::Spec
   it { Create.({})["model"].inspect.must_equal %{#<struct ModelTest::Song id=nil>} }
 
   class Update < Create
-    self.~ Model :update # DISCUSS: do we need the ~ operator?
+    override Model(Song, :update)
   end
 
   # :find it

data/test/operation/persist_test.rb

@@ -15,7 +15,7 @@ class PersistTest < Minitest::Spec
     self.| Contract::Build()
     self.| Contract::Validate()
     self.< ->(options) { options["1. fail"] = "Validate" }
-    self.| Persist()
+    self.| Contract::Persist()
     self.< ->(options) { options["2. fail"] = "Persist" }
   end
 
@@ -35,7 +35,7 @@ class PersistTest < Minitest::Spec
   class Update < Create
   end
 
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&validate.params.extract,&contract.validate,<PersistTest::Update:17,&persist.save,<PersistTest::Update:19]} }
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,<PersistTest::Update:17,&persist.save,<PersistTest::Update:19]} }
 
   #---
   it do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-07 00:00:00.000000000 Z
+date: 2016-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
@@ -189,7 +189,6 @@ files:
 - lib/trailblazer/operation/builder.rb
 - lib/trailblazer/operation/callback.rb
 - lib/trailblazer/operation/contract.rb
-- lib/trailblazer/operation/controller.rb
 - lib/trailblazer/operation/guard.rb
 - lib/trailblazer/operation/model.rb
 - lib/trailblazer/operation/module.rb
@@ -197,7 +196,6 @@ files:
 - lib/trailblazer/operation/params.rb
 - lib/trailblazer/operation/persist.rb
 - lib/trailblazer/operation/policy.rb
-- lib/trailblazer/operation/present.rb
 - lib/trailblazer/operation/procedural/contract.rb
 - lib/trailblazer/operation/procedural/validate.rb
 - lib/trailblazer/operation/pundit.rb
@@ -213,6 +211,7 @@ files:
 - test/docs/dry_test.rb
 - test/docs/guard_test.rb
 - test/docs/nested_test.rb
+- test/docs/operation_test.rb
 - test/docs/policy_test.rb
 - test/docs/pundit_test.rb
 - test/docs/representer_test.rb
@@ -272,6 +271,7 @@ test_files:
 - test/docs/dry_test.rb
 - test/docs/guard_test.rb
 - test/docs/nested_test.rb
+- test/docs/operation_test.rb
 - test/docs/policy_test.rb
 - test/docs/pundit_test.rb
 - test/docs/representer_test.rb

data/lib/trailblazer/operation/controller.rb

@@ -1,90 +0,0 @@
-module Trailblazer::Operation::Controller
-private
-  def form(operation_class, options={})
-    res, options = operation_for!(operation_class, options) { |params| { operation: operation_class.present(params) } }
-    res.contract.prepopulate!(options) # equals to @form.prepopulate!
-
-    res.contract
-  end
-
-  # Provides the operation instance, model and contract without running #process.
-  # Returns the operation.
-  def present(operation_class, options={})
-    res, options = operation_for!(operation_class, options.merge(skip_form: true)) { |params| { operation: operation_class.present(params) } }
-    res # FIXME.
-  end
-
-  def collection(*args)
-    res, op = operation!(*args)
-    @collection = op.model
-    op
-  end
-
-  def run(operation_class, options={}, &block)
-    res = operation_for!(operation_class, options) { |params| operation_class.(params) }
-
-    yield res if res[:valid] and block_given?
-
-    res # FIXME.
-  end
-
-  # The block passed to #respond is always run, regardless of the validity result.
-  def respond(operation_class, options={}, &block)
-    res, op = operation_for!(operation_class, options) { |params| operation_class.run(params) }
-    namespace = options.delete(:namespace) || []
-
-    return respond_with *namespace, op, options if not block_given?
-    respond_with *namespace, op, options, &Proc.new { |formats| block.call(op, formats) } if block_given?
-  end
-
-private
-  def process_params!(params)
-  end
-
-  # Normalizes parameters and invokes the operation (including its builders).
-  def operation_for!(operation_class, options, &block)
-    params = options[:params] || self.params # TODO: test params: parameter properly in all 4 methods.
-    process_params!(params) # deprecate or rename to #setup_params!
-
-    res = Endpoint.new(operation_class, params, request, options).(&block)
-    setup_operation_instance_variables!(res, options)
-
-    [res, options.merge(params: params)]
-  end
-
-  def setup_operation_instance_variables!(result, options)
-    @operation = result # FIXME: remove!
-    @model     = result["model"]
-    @form      = result["contract"] unless options[:skip_form]
-  end
-
-  # Encapsulates HTTP-specific logic needed before running an operation.
-  # Right now, all this does is #document_body! which figures out whether or not to pass the request body
-  # into params, so the operation can use a representer to deserialize the original document.
-  # To be used in Hanami, Roda, Rails, etc.
-  class Endpoint
-    def initialize(operation_class, params, request, options)
-      @operation_class = operation_class
-      @params          = params
-      @request         = request
-      @is_document     = options[:is_document]
-    end
-
-    def call
-      document_body! if @is_document
-      yield @params# Create.run(params)
-    end
-
-  private
-    attr_reader :params, :operation_class, :request
-
-    def document_body!
-      # this is what happens:
-      # respond_with Comment::Update::JSON.run(params.merge(comment: request.body.string))
-      concept_name = operation_class.model_class.to_s.underscore # this could be renamed to ::concept_class soon.
-      request_body = request.body.respond_to?(:string) ? request.body.string : request.body.read
-
-      params.merge!(concept_name => request_body)
-    end
-  end
-end

data/lib/trailblazer/operation/present.rb

@@ -1,19 +0,0 @@
-class Trailblazer::Operation
-  module Present
-    def self.included(includer)
-      includer.extend PresentMethod
-      includer.& Stop, before: Call
-    end
-
-    module PresentMethod
-      def present(params={}, options={}, *args)
-        call(params, options.merge("present.stop?" => true), *args)
-      end
-    end
-  end
-
-  # Stops the pipeline if "present.stop?" is set, which usually happens in Operation::present.
-  Present::Stop = ->(input, options) { ! options["present.stop?"] } # false returns Left.
-end
-
-# TODO: another stop for present without the contract!