trailblazer 1.1.2 → 2.0.0.beta1

data/lib/trailblazer/operation/rescue.rb

@@ -0,0 +1,23 @@
+class Trailblazer::Operation
+  module Rescue
+    def self.import!(_operation, import, *exceptions, handler:->(*){}, &block)
+      exceptions = [StandardError] unless exceptions.any?
+      handler    = Pipetree::DSL::Option.(handler)
+
+      rescue_block = ->(options, operation, *, &nested_pipe) {
+        begin
+          res = nested_pipe.call
+          res.first == ::Pipetree::Flow::Right # FIXME.
+        rescue *exceptions => exception
+          handler.call(operation, exception, options)
+          false
+        end
+      }
+
+      Wrap.import! _operation, import, rescue_block, name: "Rescue:#{block.source_location.last}", &block
+    end
+  end
+
+  DSL.macro!(:Rescue, Rescue)
+end
+

data/lib/trailblazer/operation/resolver.rb

@@ -1,30 +1,24 @@
-require "trailblazer/operation/model/external"
-require "trailblazer/operation/policy"
-
 class Trailblazer::Operation
-  # Provides builds-> (model, policy, params).
   module Resolver
-    def self.included(includer)
-      includer.class_eval do
-        include Policy # ::build_policy
-        include Model::External # ::build_operation_class
-
-        extend BuildOperation # ::build_operation
-      end
+    def self.import!(operation, import)
+      operation.extend Model::BuildMethods
+      operation.| operation.Builder(operation.builders)
     end
 
-    module BuildOperation
-      def build_operation(params, options={})
-        model  = model!(params)
-        policy = policy_config.call(params[:current_user], model)
-        build_operation_class(model, policy, params).
-          new(params, options.merge(model: model, policy: policy))
-      end
-    end
+    # def self.included(includer)
+    #   includer.class_eval do
+    #     extend Model::DSL  # ::model
+    #     extend Model::BuildMethods  # ::model!
+    #     extend Policy::DSL # ::policy
+    #     extend Policy::BuildPermission
+    #   end
 
-    def initialize(params, options)
-      @policy = options[:policy]
-      super
-    end
+    #   includer.> Model::Build, prepend: true
+    #   includer.& Policy::Evaluate, after: Model::Build
+    # end
+  end
+
+  def self.Resolver(*args, &block)
+    [ Resolver, args, block ]
   end
-end
+end

data/lib/trailblazer/operation/validate.rb

@@ -0,0 +1,50 @@
+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
+
+      import.(:&, ->(input, options) { extract_params!(input, options, **args) },
+        name: "validate.params.extract") unless skip_extract
+
+      # 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
+
+    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
+
+    def self.validate!(operation, options, name: nil, representer:false, from: "document", **)
+      path     = "contract.#{name}"
+      contract = operation[path]
+
+      # 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
+
+      result.success?
+    end
+  end
+
+  def self.Validate(*args, &block)
+    [ Validate, args, block ]
+  end
+end

data/lib/trailblazer/operation/wrap.rb

@@ -0,0 +1,37 @@
+class Trailblazer::Operation
+  module Wrap
+    def self.import!(operation, import, wrap, _options={}, &block)
+      pipe_api = API.new(operation, pipe = ::Pipetree::Flow[])
+
+      # DISCUSS: don't instance_exec when |pipe| given?
+      # yield pipe_api # create the nested pipe.
+      pipe_api.instance_exec(&block) # evaluate the nested pipe. this gets written onto `pipe`.
+
+      import.(:&, ->(input, options) { wrap.(options, input, pipe, & ->{ pipe.(input, options) }) }, _options)
+    end
+
+    class API
+      include Pipetree::DSL
+      include Pipetree::DSL::Macros
+
+      def initialize(target, pipe)
+        @target, @pipe = target, pipe
+      end
+
+      def _insert(operator, proc, options={}) # TODO: test me.
+        Pipetree::DSL.insert(@pipe, operator, proc, options, definer_name: @target.name)
+      end
+
+      def |(cfg, user_options={})
+        Pipetree::DSL.import(@target, @pipe, cfg, user_options)
+      end
+      alias_method :step, :| # DISCUSS: uhm...
+    end
+  end # Wrap
+
+  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 = "1.1.2"
+  VERSION = "2.0.0.beta1"
 end

data/test/{operation/controller_test.rb → controller_test.rb}

@@ -28,12 +28,15 @@ class ControllerTest < Minitest::Spec
   Comment = Struct.new(:body)
 
   class Comment::Update < Trailblazer::Operation
+    include Contract
+    include Present
+
     def model!(params)
       Comment.new(params[:body])
     end
 
     def inspect
-      super.sub(/:0x\w+/, "")
+      "<Update: #{@params.inspect} #{self["model"].inspect}>"
     end
   end
 
@@ -46,7 +49,7 @@ class ControllerTest < Minitest::Spec
     end
 
     it do
-      controller.show.inspect.must_equal "#<ControllerTest::Comment::Update @options={}, @valid=true, @params={:current_user=>#<struct ControllerTest::User role=:admin>}, @model=#<struct ControllerTest::Comment body=nil>>"
+      controller.show.inspect.must_equal "<Update: {:current_user=>#<struct ControllerTest::User role=:admin>} #<struct ControllerTest::Comment body=nil>>"
     end
   end
 
@@ -61,7 +64,7 @@ class ControllerTest < Minitest::Spec
       end
     end
 
-    it { controller.show.inspect.must_equal "#<ControllerTest::Comment::Update @options={}, @valid=true, @params={:body=>\"Cool!\"}, @model=#<struct ControllerTest::Comment body=\"Cool!\">>" }
+    it { controller.show.inspect.must_equal "<Update: {:body=>\"Cool!\"} #<struct ControllerTest::Comment body=\"Cool!\">>" }
   end
 
   describe "#form" do
@@ -70,6 +73,7 @@ class ControllerTest < Minitest::Spec
         Comment.new
       end
 
+      include Contract
       contract do
         def prepopulate!(options)
           @options = options
@@ -108,4 +112,4 @@ class ControllerTest < Minitest::Spec
       it { controller(__body: "Great!").show.options.inspect.must_equal "{:admin=>true, :params=>{:__body=>\"Great!\", :user=>#<struct ControllerTest::User role=nil>}}" }
     end
   end
-end
+end

data/test/docs/auto_inject_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+require "dry/container"
+require "trailblazer/operation/auto_inject"
+
+class DryAutoInjectTest < Minitest::Spec
+  my_container = Dry::Container.new
+  my_container.register(:user_repository, -> { Object })
+
+  AutoInject = Trailblazer::Operation::AutoInject(my_container)
+
+  class Create < Trailblazer::Operation
+    include AutoInject[:user_repository]
+  end
+
+  it "auto-injects user_repository" do
+    res = Create.({})
+    res[:user_repository].must_equal Object
+  end
+
+  it "allows dependency injection via ::call" do
+    Create.({}, user_repository: String)[:user_repository].must_equal String
+  end
+
+  describe "inheritance" do
+    class Update < Create
+    end
+
+    it { Update.()[:user_repository].must_equal Object }
+  end
+end

data/test/docs/contract_test.rb

@@ -0,0 +1,429 @@
+require "test_helper"
+
+class DocsContractOverviewTest < Minitest::Spec
+  Song = Struct.new(:length, :title)
+
+  #:overv-reform
+  # app/concepts/comment/create.rb
+  class Create < Trailblazer::Operation
+    #~bla
+    extend Contract::DSL
+
+    contract do
+      property :title
+      #~contractonly
+      property :length
+
+      validates :title,  presence: true
+      validates :length, numericality: true
+      #~contractonly end
+    end
+    #~contractonly
+
+    #~bla end
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    step Persist( method: :sync )
+    #~contractonly end
+  end
+  #:overv-reform end
+
+  puts Create["pipetree"].inspect(style: :rows)
+
+=begin
+  #:overv-reform-pipe
+   0 =======================>>operation.new
+   1 ==========================&model.build
+   2 =======================>contract.build
+   3 ==============&validate.params.extract
+   4 ====================&contract.validate
+   5 =========================&persist.save
+  #:overv-reform-pipe end
+=end
+
+  it do
+    assert Create["contract.default.class"] < Reform::Form
+  end
+
+  #- result
+  it do
+    #:result
+    result = Create.({ length: "A" })
+
+    result["result.contract.default"].success?        #=> false
+    result["result.contract.default"].errors          #=> Errors object
+    result["result.contract.default"].errors.messages #=> {:length=>["is not a number"]}
+
+    #:result end
+    result["result.contract.default"].success?.must_equal false
+    result["result.contract.default"].errors.messages.must_equal ({:title=>["can't be blank"], :length=>["is not a number"]})
+  end
+end
+
+class DocsContractNameTest < Minitest::Spec
+  Song = Struct.new(:length, :title)
+
+  #:contract-name
+  # app/concepts/comment/update.rb
+  class Update < Trailblazer::Operation
+    #~contract
+    extend Contract::DSL
+
+    contract :params do
+      property :id
+      validates :id,  presence: true
+    end
+    #~contract end
+    #~pipe
+    step Model( Song, :new )
+    step Contract::Build( name: "params" )
+    step Contract::Validate( name: "params" )
+    #~pipe end
+  end
+  #:contract-name end
+end
+
+class DocsContractReferenceTest < Minitest::Spec
+  MyContract = Class.new
+  #:contract-ref
+  # app/concepts/comment/update.rb
+  class Update < Trailblazer::Operation
+    #~contract
+    extend Contract::DSL
+    contract :user, MyContract
+  end
+  #:contract-ref end
+end
+
+#---
+# contract MyContract
+class DocsContractExplicitTest < Minitest::Spec
+  Song = Struct.new(:length, :title)
+
+  #:reform-inline
+  class MyContract < Reform::Form
+    property :title
+    property :length
+
+    validates :title,  presence: true
+    validates :length, numericality: true
+  end
+  #:reform-inline end
+
+  #:reform-inline-op
+  # app/concepts/comment/create.rb
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract MyContract
+
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+  #:reform-inline-op end
+end
+
+#---
+#- Validate[key: :song]
+class DocsContractKeyTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #:key
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+    end
+
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate( key: "song" )
+    step Persist( method: :sync )
+  end
+  #:key end
+
+  it { Create.({}).inspect("model").must_equal %{<Result:false [#<struct DocsContractKeyTest::Song id=nil, title=nil>] >} }
+  it { Create.({"song" => { title: "SVG" }}).inspect("model").must_equal %{<Result:true [#<struct DocsContractKeyTest::Song id=nil, title="SVG">] >} }
+end
+
+#- Validate with manual key extraction
+class DocsContractSeparateKeyTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #:key-extr
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+    end
+
+    def type
+      "evergreen" # this is how you could do polymorphic lookups.
+    end
+
+    step Model( Song, :new )
+    step Contract::Build()
+    consider :extract_params!
+    step Contract::Validate( skip_extract: true )
+    step Persist( method: :sync )
+
+    def extract_params!(options)
+      options["params.validate"] = options["params"][type]
+    end
+  end
+  #:key-extr end
+
+  it { Create.({ }).inspect("model").must_equal %{<Result:false [#<struct DocsContractSeparateKeyTest::Song id=nil, title=nil>] >} }
+  it { Create.({"evergreen" => { title: "SVG" }}).inspect("model").must_equal %{<Result:true [#<struct DocsContractSeparateKeyTest::Song id=nil, title="SVG">] >} }
+end
+
+#---
+#- Contract::Build[ constant: XXX ]
+class ContractConstantTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #:constant
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :title
+      validates :title, length: 2..33
+    end
+
+
+
+    step Model( Song, :new )
+    step Contract::Build( constant: MyContract )
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+  #:constant end
+
+  it { Create.({ title: "A" }).inspect("model").must_equal %{<Result:false [#<struct ContractConstantTest::Song id=nil, title=nil>] >} }
+  it { Create.({ title: "Anthony's Song" }).inspect("model").must_equal %{<Result:true [#<struct ContractConstantTest::Song id=nil, title="Anthony's Song">] >} }
+end
+
+#- Contract::Build[ constant: XXX, name: AAA ]
+class ContractNamedConstantTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #:constant-name
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :title
+      validates :title, length: 2..33
+    end
+
+    step Model( Song, :new )
+    step Contract::Build( constant: MyContract, name: "form" )
+    step Contract::Validate( name: "form" )
+    step Persist( method: :sync, name: "contract.form" )
+  end
+  #:constant-name end
+
+  it { Create.({ title: "A" }).inspect("model").must_equal %{<Result:false [#<struct ContractNamedConstantTest::Song id=nil, title=nil>] >} }
+  it { Create.({ title: "Anthony's Song" }).inspect("model").must_equal %{<Result:true [#<struct ContractNamedConstantTest::Song id=nil, title="Anthony's Song">] >} }
+end
+
+#---
+#- dependency injection
+#- contract class
+class ContractInjectConstantTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #:di-constant-contract
+  class MyContract < Reform::Form
+    property :title
+    validates :title, length: 2..33
+  end
+  #:di-constant-contract end
+  #:di-constant
+  class Create < Trailblazer::Operation
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+  #:di-constant end
+
+  it do
+  #:di-contract-call
+  Create.(
+    { title: "Anthony's Song" },
+    "contract.default.class" => MyContract
+  )
+  #:di-contract-call end
+  end
+  it { Create.({ title: "A" }, "contract.default.class" => MyContract).inspect("model").must_equal %{<Result:false [#<struct ContractInjectConstantTest::Song id=nil, title=nil>] >} }
+  it { Create.({ title: "Anthony's Song" }, "contract.default.class" => MyContract).inspect("model").must_equal %{<Result:true [#<struct ContractInjectConstantTest::Song id=nil, title="Anthony's Song">] >} }
+end
+
+class DryValidationContractTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #---
+  # DRY-validation params validation before op,
+  # plus main contract.
+  #- result.path
+  #:dry-schema
+  require "dry/validation"
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    # contract to verify params formally.
+    contract "params", (Dry::Validation.Schema do
+      required(:id).filled
+    end)
+    #~form
+    # domain validations.
+    contract "form" do
+      property :title
+      validates :title, length: 1..3
+    end
+    #~form end
+
+    step Contract::Validate( name: "params" )
+    #~form
+    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.
+    #~form end
+  end
+  #:dry-schema end
+
+  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>] >} }
+  it { Create.({ id: 1, title: "" }).inspect("model").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
+  it { Create.({ id: 1, title: "Yo" }).inspect("model").must_equal %{<Result:true [#<struct DryValidationContractTest::Song id=nil, title="Yo">] >} }
+
+  #:dry-schema-first
+  require "dry/validation"
+  class Delete < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract "params", (Dry::Validation.Schema do
+      required(:id).filled
+    end)
+
+    step Contract::Validate( name: "params" ), before: "operation.new"
+    #~more
+    #~more end
+  end
+  #:dry-schema-first end
+end
+
+class DryExplicitSchemaTest < Minitest::Spec
+  #:dry-schema-explsch
+  # app/concepts/comment/contract/params.rb
+  require "dry/validation"
+  MySchema = Dry::Validation.Schema do
+    required(:id).filled
+  end
+  #:dry-schema-explsch end
+
+  #:dry-schema-expl
+  # app/concepts/comment/delete.rb
+  class Delete < Trailblazer::Operation
+    extend Contract::DSL
+    contract "params", MySchema
+
+    step Contract::Validate( name: "params" ), before: "operation.new"
+  end
+  #:dry-schema-expl end
+end
+
+class DocContractBuilderTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #---
+  #- builder:
+  #:builder-option
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+      property :current_user, virtual: true
+      validates :current_user, presence: true
+    end
+
+    step Model( Song, :new )
+    step Contract::Build( builder: :default_contract! )
+    step Contract::Validate()
+    step Persist( method: :sync )
+
+    def default_contract!(constant:, model:)
+      constant.new(model, current_user: self["current_user"])
+    end
+  end
+  #:builder-option end
+
+  it { Create.({}).inspect("model").must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
+  it { Create.({ title: 1}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
+
+  #- proc
+  class Update < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+      property :current_user, virtual: true
+      validates :current_user, presence: true
+    end
+
+    step Model( Song, :new )
+    #:builder-proc
+    step Contract::Build( builder: ->(operation, constant:, model:) {
+      constant.new(model, current_user: operation["current_user"])
+    })
+    #:builder-proc end
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+
+  it { Update.({}).inspect("model").must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
+  it { Update.({ title: 1}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
+end
+
+class DocContractTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+  #---
+  # with contract block, and inheritance, the old way.
+  class Block < Trailblazer::Operation
+    extend Contract::DSL
+    contract do
+      property :title
+    end
+
+    step Model( Song, :new )
+    step Contract::Build()            # resolves to "contract.class.default" and is resolved at runtime.
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+
+  it { Block.({}).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title=nil>] >} }
+  it { Block.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title="Fame">] >} }
+
+  class Breach < Block
+    contract do
+      property :id
+    end
+  end
+
+  it { Breach.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title="Fame">] >} }
+
+  #-
+  # with constant.
+  class Break < Block
+    class MyContract < Reform::Form
+      property :id
+    end
+    # override the original block as if it's never been there.
+    contract MyContract
+  end
+
+  it { Break.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title=nil>] >} }
+end
+
+
+
+