trailblazer 2.0.7 → 2.1.0

data/test/docs/wrap_test.rb

@@ -1,183 +0,0 @@
-require "test_helper"
-
-class WrapTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      id.nil? ? raise : new(id)
-    end
-  end
-
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    step Wrap ->(options, *, &block) {
-      begin
-        block.call
-      rescue => exception
-        options["result.model.find"] = "argh! because #{exception.class}"
-        false
-      end } {
-      step Model( Song, :find )
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    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">} }
-  it { Create.( id: nil ).inspect("result.model.find").must_equal %{<Result:false [\"argh! because RuntimeError\"] >} }
-
-  #-
-  # Wrap return
-  class WrapReturnTest < Minitest::Spec
-    class Create < Trailblazer::Operation
-      step Wrap ->(options, *, &block) { options["yield?"] ? block.call : false } {
-        step ->(options) { options["x"] = true }
-        success :noop!
-        # ...
-      }
-
-      def noop!(options)
-      end
-    end
-
-    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
-    # returns falsey means deviate to left.
-    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
-  end
-
-  class WrapWithCallableTest < Minitest::Spec
-    class MyWrapper
-      extend Uber::Callable
-
-      def self.call(options, *, &block)
-        options["yield?"] ? yield : false
-      end
-    end
-
-    class Create < Trailblazer::Operation
-      step Wrap( MyWrapper ) {
-        step ->(options) { options["x"] = true }
-        # ...
-      }
-    end
-
-    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
-    # returns falsey means deviate to left.
-    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
-  end
-
-  #-
-  # arguments for Wrap
-  class Update < Trailblazer::Operation
-    step Wrap ->(options, operation, pipe, &block) { operation["yield?"] ? block.call : false } {
-      step ->(options) { options["x"] = true }
-    }
-  end
-
-  it { Update.().inspect("x").must_equal %{<Result:false [nil] >} }
-  it { Update.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
-
-  class WrapExampleProcTest < Minitest::Spec
-    module Sequel
-      def self.transaction
-        yield
-      end
-    end
-
-    module MyNotifier
-      def self.mail; true; end
-    end
-
-  #:sequel-transaction
-  class Create < Trailblazer::Operation
-    #~wrap-only
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    #~wrap-only end
-    step Wrap ->(*, &block) { Sequel.transaction do block.call end } {
-      step Model( Song, :new )
-      #~wrap-only
-      step Contract::Build( constant: MyContract )
-      step Contract::Validate( )
-      step Contract::Persist( method: :sync )
-      #~wrap-only end
-    }
-    failure :error! # handle all kinds of errors.
-    #~wrap-only
-    step :notify!
-
-    def error!(options)
-      # handle errors after the wrap
-    end
-
-    def notify!(options)
-      MyNotifier.mail
-    end
-    #~wrap-only end
-  end
-  #:sequel-transaction end
-
-    it { Create.( title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
-  end
-
-  class WrapExampleCallableTest < Minitest::Spec
-    module Sequel
-      def self.transaction
-        yield
-      end
-    end
-
-    module MyNotifier
-      def self.mail; true; end
-    end
-
-  #:callable-t
-  class MyTransaction
-    extend Uber::Callable
-
-    def self.call(options, *)
-      Sequel.transaction { yield } # yield runs the nested pipe.
-      # return value decides about left or right track!
-    end
-  end
-  #:callable-t end
-  #:sequel-transaction-callable
-  class Create < Trailblazer::Operation
-    #~wrap-onlyy
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    #~wrap-onlyy end
-    step Wrap( MyTransaction ) {
-      step Model( Song, :new )
-      #~wrap-onlyy
-      step Contract::Build( constant: MyContract )
-      step Contract::Validate( )
-      step Contract::Persist( method: :sync )
-      #~wrap-onlyy end
-    }
-    failure :error! # handle all kinds of errors.
-    #~wrap-onlyy
-    step :notify!
-
-    def error!(options)
-      # handle errors after the wrap
-    end
-
-    def notify!(options)
-      MyNotifier.mail # send emails, because success...
-    end
-    #~wrap-onlyy end
-  end
-  #:sequel-transaction-callable end
-
-    it { Create.( title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
-  end
-end
-

data/test/gemfiles/Gemfile.ruby-1.9

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-gemspec path: "../../"
-

data/test/gemfiles/Gemfile.ruby-2.0

@@ -1,12 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in trailblazer.gemspec
-gemspec path: "../../"
-
-gem "multi_json"
-gem "trailblazer-operation"
-gem "minitest-line"
-gem "benchmark-ips"
-gem "activesupport", "~> 4.2.0"
-gem "reform-rails"
-gem "dry-validation"

data/test/gemfiles/Gemfile.ruby-2.3

@@ -1,12 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in trailblazer.gemspec
-gemspec
-
-gem "multi_json"
-
-gem "dry-auto_inject"
-gem "dry-matcher"
-
-gem "minitest-line"
-gem "benchmark-ips"

data/test/module_test.rb

@@ -1,100 +0,0 @@
-require 'test_helper'
-require "trailblazer/operation/module"
-require "trailblazer/operation/callback"
-require "trailblazer/operation/contract"
-
-class OperationModuleTest < MiniTest::Spec
-  Song = Struct.new(:name, :artist)
-  Artist = Struct.new(:id, :full_name)
-
-  class Create < Trailblazer::Operation
-    include Trailblazer::Operation::Callback
-    include Contract::Explicit
-
-    contract do
-      property :name
-      property :artist, populate_if_empty: Artist do
-        property :id
-      end
-    end
-
-    callback do
-      on_change :notify_me!
-    end
-
-    attr_reader :model
-    def call(params)
-      self["model"] = Song.new
-
-      validate(params, model: self["model"]) do
-        contract.sync
-
-        dispatch!
-      end
-
-      self
-    end
-
-    def dispatched
-      self["dispatched"] ||= []
-    end
-
-  private
-    def notify_me!(*)
-      dispatched << :notify_me!
-    end
-  end
-
-
-  module SignedIn
-    include Trailblazer::Operation::Module
-
-    contract do
-      property :artist, inherit: true do
-        property :full_name
-
-        puts definitions.inspect
-      end
-    end
-
-    callback do
-      on_change :notify_you!
-    end
-
-    def notify_you!(*)
-      dispatched << :notify_you!
-    end
-  end
-
-
-  class Update < Create
-    callback do
-      on_change :notify_them!
-    end
-
-    include SignedIn
-
-    def notify_them!(*)
-      dispatched << :notify_them!
-    end
-  end
-
-
-  it do
-    op = Create.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
-
-    op["dispatched"].must_equal [:notify_me!]
-    op["model"].name.must_equal "Feelings"
-    op["model"].artist.id.must_equal 1
-    op["model"].artist.full_name.must_equal nil # property not declared.
-  end
-
-  it do
-    op = Update.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
-
-    op["dispatched"].must_equal [:notify_me!, :notify_them!, :notify_you!]
-    op["model"].name.must_equal "Feelings"
-    op["model"].artist.id.must_equal 1
-    op["model"].artist.full_name.must_equal "The Offspring" # property declared via Module.
-  end
-end

data/test/operation/callback_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-# callbacks are tested in Disposable::Callback::Group.
-class OperationCallbackTest < MiniTest::Spec
-  Song = Struct.new(:name)
-
-  #---
-  # with contract and disposable semantics
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-
-    contract do
-      property :name
-    end
-
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate()
-    step Callback( :default )
-
-
-    extend Callback::DSL
-
-    callback do
-      on_change :notify_me!
-      on_change :notify_you!
-    end
-
-
-    # TODO: always dispatch, pass params.
-
-    def dispatched
-      self["dispatched"] ||= []
-    end
-
-  private
-    def notify_me!(*)
-      dispatched << :notify_me!
-    end
-
-    def notify_you!(*)
-      dispatched << :notify_you!
-    end
-  end
-
-
-  class Update < Create
-    # TODO: allow skipping groups.
-    # skip_dispatch :notify_me!
-
-    callback do
-      remove! :on_change, :notify_me!
-    end
-  end
-
-  #---
-  #- inheritance
-  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>callback.default]} }
-
-
-  it "invokes all callbacks" do
-    res = Create.({"name"=>"Keep On Running"})
-    res["dispatched"].must_equal [:notify_me!, :notify_you!]
-  end
-
-  it "does not invoke removed callbacks" do
-    res = Update.({"name"=>"Keep On Running"})
-    res["dispatched"].must_equal [:notify_you!]
-  end
-end

data/test/operation/contract_test.rb

@@ -1,420 +0,0 @@
-require "test_helper"
-
-class ContractExtractMacroTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step Contract::Validate::Extract( key: "song", params_path: "x" )
-  end
-
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>x]} }
-  it { Create.({}).inspect("x").must_equal %{<Result:false [nil] >} }
-  it { Create.({ "song" => Object }).inspect("x").must_equal %{<Result:true [Object] >} }
-end
-
-
-
-      require "dry/validation"
-
-class DryValidationTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-
-    contract "params", (Dry::Validation.Schema do
-      required(:id).filled
-    end)
-    # self["contract.params"] = Dry::Validation.Schema do
-    #   required(:id).filled
-    # end
-
-    step :process
-
-    include Procedural::Validate
-
-    def process(options)
-      validate(options["params"], contract: self["contract.params"], path: "contract.params") { |f| puts f.inspect }
-    end
-  end
-
-  #- result object, contract
-  # success
-  it { Create.(id: 1)["result.contract.params"].success?.must_equal true }
-  it { Create.(id: 1)["result.contract.params"].errors.must_equal({}) }
-  # failure
-  it { Create.(id: nil)["result.contract.params"].success?.must_equal false }
-  it { Create.(id: nil)["result.contract.params"].errors.must_equal({:id=>["must be filled"]}) }
-
-  #---
-  # with Contract::Validate, but before op even gets instantiated.
-  class Update < Trailblazer::Operation #["contract"]
-    extend Contract::DSL
-
-    contract "params", (Dry::Validation.Schema do
-      required(:id).filled
-    end)
-
-    step ->(options) { options["contract.params"].(options["params"]).success? }, before: "operation.new"
-  end
-
-  it { Update.( id: 1 ).success?.must_equal true }
-  it { Update.( ).success?.must_equal false }
-end
-
-class ContractTest < Minitest::Spec
-  Song = Struct.new(:title)
-#   # generic form for testing.
-#   class Form
-#     def initialize(model, options={})
-#       @inspect = "#{self.class}: #{model} #{options.inspect}"
-#     end
-
-#     def validate
-#       @inspect
-#     end
-#   end
-
-  #---
-  # contract do..end (without constant)
-  #- explicit validate call
-  describe "contract do .. end" do
-    class Index < Trailblazer::Operation
-      extend Contract::DSL
-
-      contract do
-        property :title
-      end
-
-      success ->(options) { options["model"] = Song.new }
-      # step Model( Song, :new )
-      step Contract::Build()
-      step :process
-
-      include Procedural::Validate
-      # TODO: get model automatically in validate!
-
-      def process(options)
-        # validate(params, model: Song.new) { |f| self["x"] = f.to_nested_hash }
-        validate(options["params"]) { |f| self["x"] = f.to_nested_hash }
-      end
-    end
-
-    # will create a Reform::Form for us.
-    it { Index.(title: "Falling Down")["x"].must_equal({"title"=>"Falling Down"}) }
-  end
-
-#   # TODO: in all step tests.
-#   describe "dependency injection" do
-#     class Delete < Trailblazer::Operation
-#       include Contract::Step
-#     end
-
-#     class Follow < Trailblazer::Operation
-#       include Contract::Step
-#     end
-
-#     # inject contract instance via constructor.
-#     it { Delete.({}, "contract" => "contract/instance")["contract"].must_equal "contract/instance" }
-#     # inject contract class.
-#     it { Follow.({}, "contract.default.class" => Form)["contract"].class.must_equal Form }
-#   end
-
-
-#   # contract(model, [admin: true]).validate
-#   class Create < Trailblazer::Operation
-#     include Test::ReturnProcess
-#     include Contract::Explicit
-
-#     def call(options:false)
-#       return contract(model: Object, options: { admin: true }).validate if options
-#       contract(model: Object).validate
-#     end
-#   end
-
-#   # inject class, pass in model and options when constructing.
-#   # contract(model)
-#   it { Create.({}, "contract.default.class" => Form).must_equal "ContractTest::Form: Object {}" }
-#   # contract(model, options)
-#   it { Create.({ options: true }, "contract.default.class" => Form).must_equal "ContractTest::Form: Object {:admin=>true}" }
-
-#   # ::contract Form
-#   # contract(model).validate
-#   class Update < Trailblazer::Operation
-#     include Test::ReturnProcess
-#     include Contract::Explicit
-
-#      = Form
-
-#     def call(*)
-#       contract.validate
-#     end
-
-#     include Model( :Builder
-# )    def model!(*)
-#       Object
-#     end
-#   end
-
-#   # use the class contract.
-#   it { Update.().must_equal "ContractTest::Form: Object {}" }
-#   # injected contract overrides class.
-#   it { Update.({}, "contract.default.class" => Injected = Class.new(Form)).must_equal "ContractTest::Injected: Object {}" }
-
-#   # passing Constant into #contract
-#   # contract(Object.new, { title: "Bad Feeling" }, Contract)
-#   class Operation < Trailblazer::Operation
-#     include Contract::Explicit
-
-#     class Contract < Reform::Form
-#       property :title, virtual: true
-#     end
-
-#     def process(params)
-#       contract(model: Object.new, options: { title: "Bad Feeling" }, contract_class: Contract)
-
-#       validate(params)
-#     end
-#   end
-
-#   # allow using #contract to inject model, options and class.
-#   it do
-#     contract = Operation.(id: 1)["contract"]
-#     contract.title.must_equal "Bad Feeling"
-#     contract.must_be_instance_of Operation::Contract
-#   end
-
-#   # allow using #contract before #validate.
-#   class Upsert < Trailblazer::Operation
-#     include Contract::Explicit
-
-#     contract do
-#       property :id
-#       property :title
-#       property :length
-#     end
-
-#     def process(params)
-#       self["model"] = Struct.new(:id, :title, :length).new
-#       contract.id = 1
-#       validate(params) { contract.length = 3 }
-#     end
-#   end
-
-#   it do
-#     contract = Upsert.(title: "Beethoven")["contract"]
-#     contract.id.must_equal 1
-#     contract.title.must_equal "Beethoven"
-#     contract.length.must_equal 3
-#   end
-# end
-
-#---
-#- validate
-class ValidateTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-
-    include Procedural::Validate
-    def process(options)
-      if validate(options["params"])
-        self["x"] = "works!"
-        true
-      else
-        self["x"] = "try again"
-        false
-      end
-    end
-
-    step Model( Song, :new ) # FIXME.
-    step Contract::Build()
-    step :process
-  end
-
-  # validate returns the #validate result
-  it do
-    Create.(title: nil)["x"].must_equal "try again"
-    Create.(title: nil).success?.must_equal false
-  end
-  it { Create.(title: "SVG")["x"].must_equal "works!" }
-  it { Create.(title: "SVG").success?.must_equal true }
-
-  # result object from validation.
-  #- result object, contract
-  it { Create.(title: 1)["result.contract.default"].success?.must_equal true }
-  it { Create.(title: 1)["result.contract.default"].errors.messages.must_equal({}) } # FIXME: change API with Fran.
-  it { Create.(title: nil)["result.contract.default"].success?.must_equal false }
-  it { Create.(title: nil)["result.contract.default"].errors.messages.must_equal({:title=>["can't be blank"]}) } # FIXME: change API with Fran.
-#   #---
-#   # validate with block returns result.
-#   class Update < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract Form
-
-#     def process(params)
-#       self["x"] = validate(params) { }
-#     end
-#   end
-
-#   it { Update.(false)["x"].must_equal false}
-#   it { Update.(true)["x"]. must_equal true}
-
-  #---
-  # Contract::Validate[]
-  class Update < Trailblazer::Operation
-    extend Contract::DSL
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-    step Model( Song, :new ) # FIXME.
-    step Contract::Build()
-    step Contract::Validate() # generic validate call for you.
-
-    # include Procedural::Validate
-    ->(*) { validate(options["params"][:song]) } # <-- TODO
-  end
-
-  # success
-  it do
-    result = Update.(title: "SVG")
-    result.success?.must_equal true
-    result["result.contract.default"].success?.must_equal true
-    result["result.contract.default"].errors.messages.must_equal({})
-  end
-
-  # failure
-  it do
-    result = Update.(title: nil)
-    result.success?.must_equal false
-    result["result.contract.default"].success?.must_equal false
-    result["result.contract.default"].errors.messages.must_equal({:title=>["can't be blank"]})
-  end
-
-  #---
-  # Contract::Validate[key: :song]
-  class Upsert < Trailblazer::Operation
-    extend Contract::DSL
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-    step Model( Song, :new ) # FIXME.
-    step Contract::Build()
-    step Contract::Validate( key: :song) # generic validate call for you.
-    # ->(*) { validate(options["params"][:song]) } # <-- TODO
-    step Contract::Persist( method: :sync )
-  end
-
-  # success
-  it { Upsert.(song: { title: "SVG" }).success?.must_equal true }
-  # failure
-  it { Upsert.(song: { title: nil }).success?.must_equal false }
-  # key not found
-  it { Upsert.().success?.must_equal false }
-
-  #---
-  # 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" })["contract.default.params"].must_equal({:title=>"SVG"}) }
-
-  #---
-  #- inheritance
-  class New < Upsert
-  end
-
-  it { New["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>persist.save]} }
-
-  #- overwriting Validate
-  class NewHit < Upsert
-    step Contract::Validate( key: :hit ), override: true
-  end
-
-  it { NewHit["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>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
-
-# #---
-# # allow using #contract to inject model and arguments.
-# class OperationContractWithOptionsTest < Minitest::Spec
-#   # contract(model, title: "Bad Feeling")
-#   class Operation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       property :id
-#       property :title, virtual: true
-#     end
-
-#     def process(params)
-#       model = Struct.new(:id).new
-
-#       contract(model: model, options: { title: "Bad Feeling" })
-
-#       validate(params)
-#     end
-#   end
-
-#   it do
-#     op = Operation.(id: 1)
-#     op["contract"].id.must_equal 1
-#     op["contract"].title.must_equal "Bad Feeling"
-#   end
-
-#   # contract({ song: song, album: album }, title: "Medicine Balls")
-#   class CompositionOperation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       include Reform::Form::Composition
-#       property :song_id,    on: :song
-#       property :album_name, on: :album
-#       property :title,      virtual: true
-#     end
-
-#     def process(params)
-#       song  = Struct.new(:song_id).new(1)
-#       album = Struct.new(:album_name).new("Forever Malcom Young")
-
-#       contract(model: { song: song, album: album }, options: { title: "Medicine Balls" })
-
-#       validate(params)
-#     end
-#   end
-
-#   it do
-#     contract = CompositionOperation.({})["contract"]
-#     contract.song_id.must_equal 1
-#     contract.album_name.must_equal "Forever Malcom Young"
-#     contract.title.must_equal "Medicine Balls"
-#   end
-
-#   # validate(params, { song: song, album: album }, title: "Medicine Balls")
-#   class CompositionValidateOperation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       include Reform::Form::Composition
-#       property :song_id,    on: :song
-#       property :album_name, on: :album
-#       property :title,      virtual: true
-#     end
-
-#     def process(params)
-#       song  = Struct.new(:song_id).new(1)
-#       album = Struct.new(:album_name).new("Forever Malcom Young")
-
-#       validate(params, model: { song: song, album: album }, options: { title: "Medicine Balls" })
-#     end
-#   end
-
-#   it do
-#     contract = CompositionValidateOperation.({})["contract"]
-#     contract.song_id.must_equal 1
-#     contract.album_name.must_equal "Forever Malcom Young"
-#     contract.title.must_equal "Medicine Balls"
-#   end
-end
-
-# TODO: full stack test with validate, process, save, etc.
-          # with model!