RubyGems - trailblazer - Versions diffs - 2.1.0.beta4 → 2.1.0.beta5 - Mend

trailblazer 2.1.0.beta4 → 2.1.0.beta5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

checksums.yaml +4 -4
data/.rubocop_todo.yml +194 -502
data/CHANGES.md +4 -0
data/CONTRIBUTING.md +170 -0
data/Gemfile +4 -1
data/README.md +183 -40
data/Rakefile +6 -2
data/lib/trailblazer/version.rb +1 -1
data/lib/trailblazer.rb +3 -12
data/test/{operation/dsl → dsl}/contract_test.rb +2 -2
data/trailblazer.gemspec +3 -3
metadata +17 -63
data/lib/trailblazer/operation/contract.rb +0 -82
data/lib/trailblazer/operation/guard.rb +0 -18
data/lib/trailblazer/operation/model.rb +0 -65
data/lib/trailblazer/operation/nested.rb +0 -91
data/lib/trailblazer/operation/persist.rb +0 -14
data/lib/trailblazer/operation/policy.rb +0 -44
data/lib/trailblazer/operation/pundit.rb +0 -38
data/lib/trailblazer/operation/representer.rb +0 -36
data/lib/trailblazer/operation/rescue.rb +0 -24
data/lib/trailblazer/operation/validate.rb +0 -74
data/lib/trailblazer/operation/wrap.rb +0 -64
data/test/docs/contract_test.rb +0 -545
data/test/docs/dry_test.rb +0 -31
data/test/docs/guard_test.rb +0 -162
data/test/docs/macro_test.rb +0 -36
data/test/docs/model_test.rb +0 -75
data/test/docs/nested_test.rb +0 -300
data/test/docs/policy_test.rb +0 -2
data/test/docs/pundit_test.rb +0 -133
data/test/docs/representer_test.rb +0 -268
data/test/docs/rescue_test.rb +0 -154
data/test/docs/wrap_test.rb +0 -219
data/test/nested_test.rb +0 -293
data/test/operation/contract_test.rb +0 -290
data/test/operation/dsl/representer_test.rb +0 -169
data/test/operation/model_test.rb +0 -54
data/test/operation/persist_test.rb +0 -51
data/test/operation/pundit_test.rb +0 -106
data/test/operation/representer_test.rb +0 -254

data/test/docs/representer_test.rb DELETED Viewed

@@ -1,268 +0,0 @@
-require "test_helper"
-require "representable/json"
-#---
-# infer
-class DocsRepresenterInferTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-  #:infer
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: Representer.infer(MyContract, format: Representable::JSON) )
-    step Contract::Persist( method: :sync )
-  end
-  #:infer end
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.( params: {}, document: json ).inspect(:model).must_equal %{<Result:true [#<struct DocsRepresenterInferTest::Song id=1, title=nil>] >} }
-end
-#---
-# explicit
-class DocsRepresenterExplicitTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-  #:explicit-rep
-  class MyRepresenter < Representable::Decorator
-    include Representable::JSON
-    property :id
-  end
-  #:explicit-rep end
-  #:explicit-op
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: MyRepresenter ) # :representer
-    step Contract::Persist( method: :sync )
-  end
-  #:explicit-op end
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.(params: {}, document: json).inspect(:model).must_equal %{<Result:true [#<struct DocsRepresenterExplicitTest::Song id=1, title=nil>] >} }
-  it do
-  #:explicit-call
-  Create.(params: {}, document: '{"id": 1}')
-  #:explicit-call end
-  end
-  #- render
-  it do
-  #:render
-  result = Create.( params: {}, document: '{"id": 1}' )
-  json   = result["representer.default.class"].new(result[:model]).to_json
-  json #=> '{"id":1}'
-  #:render end
-  json.must_equal '{"id":1}'
-  end
-  #-
-  # with dependency injection
-  # overriding the JSON representer with an XML one.
-  #:di-rep
-  require "representable/xml"
-  class MyXMLRepresenter < Representable::Decorator
-    include Representable::XML
-    property :id
-  end
-  #:di-rep end
-  let (:xml) { %{<body><id>1</id></body>} }
-  it do
-  #:di-call
-  result = Create.(params: {},
-    document: '<body><id>1</id></body>',
-    "representer.default.class" => MyXMLRepresenter # injection
-  )
-  #:di-call end
-    result.inspect(:model).must_equal %{<Result:true [#<struct DocsRepresenterExplicitTest::Song id="1", title=nil>] >}
-  end
-end
-#---
-# dependency injection
-class DocsRepresenterDITest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-  class MyRepresenter < Representable::Decorator
-    include Representable::JSON
-    property :id
-  end
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  end
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.(params: {}, document: json,
-    "representer.default.class" => MyRepresenter).inspect(:model).must_equal %{<Result:true [#<struct DocsRepresenterDITest::Song id=1, title=nil>] >} }
-end
-#---
-# inline
-class DocsRepresenterInlineTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-  #:inline
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-    extend Representer::DSL
-    representer do
-      property :id
-    end
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: self["representer.default.class"] )
-    step Contract::Persist( method: :sync )
-  end
-  #:inline end
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.(params: {}, document: json).inspect(:model).must_equal %{<Result:true [#<struct DocsRepresenterInlineTest::Song id=1, title=nil>] >} }
-end
-#---
-# rendering
-class DocsRepresenterManualRenderTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      new(id)
-    end
-  end
-  class Show < Trailblazer::Operation
-    extend Representer::DSL
-    representer do
-      property :id
-    end
-    step Model( Song, :find )
-  end
-  it do
-    result =Show.(params: { id: 1 })
-    json = result["representer.default.class"].new(result[:model]).to_json
-    json.must_equal %{{"id":1}}
-  end
-end
-#---
-# naming
-class DocsRepresenterNamingTest < Minitest::Spec
-  MyRepresenter = Object
-  #:naming
-  class Create < Trailblazer::Operation
-    extend Representer::DSL
-    representer MyRepresenter
-  end
-  Create["representer.default.class"] #=> MyRepresenter
-  #:naming end
-  it { Create["representer.default.class"].must_be_kind_of MyRepresenter }
-end
-#---
-# rendering
-require "roar/json/hal"
-class DocsRepresenterFullExampleTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def initialize(*)
-      self.id = 1
-    end
-  end
-  #:errors-rep
-  class ErrorsRepresenter < Representable::Decorator
-    include Representable::JSON
-    collection :errors
-  end
-  #:errors-rep end
-  #:full
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-    extend Representer::DSL
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-    representer :parse do
-      property :title
-    end
-    representer :render do
-      include Roar::JSON::HAL
-      property :id
-      property :title
-      link(:self) { "/songs/#{represented.id}" }
-    end
-    representer :errors, ErrorsRepresenter # explicit reference.
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate( representer: self["representer.parse.class"] )
-    step Contract::Persist( method: :sync )
-  end
-  #:full end
-  it do
-    result =Create.(params: {}, document: '{"title": "Tested"}')
-    json = result["representer.render.class"].new(result[:model]).to_json
-    json.must_equal %{{"id":1,"title":"Tested","_links":{"self":{"href":"/songs/1"}}}}
-  #:full-call
-  def create
-    result = Create.(params, document: request.body.read)
-    if result.success?
-      result["representer.render.class"].new(result[:model]).to_json
-    else
-      result["representer.errors.class"].new(result["result.contract.default"]).to_json
-    end
-  end
-  #:full-call end
-  end
-  it do
-    result =Create.(params: {}, document: '{"title": ""}')
-    if result.failure?
-       json = result["representer.errors.class"].new(result["result.contract.default"]).to_json
-    end
-    json.must_equal %{{"errors":[["title","can't be blank"]]}}
-  end
-end

data/test/docs/rescue_test.rb DELETED Viewed

@@ -1,154 +0,0 @@
-require "test_helper"
-class NestedRescueTest < Minitest::Spec
-  #---
-  # nested raise (i hope people won't use this but it works)
-  A = Class.new(RuntimeError)
-  Y = Class.new(RuntimeError)
-  class NestedInsanity < Trailblazer::Operation
-    step Rescue {
-      step ->(options, **) { options["a"] = true }
-      step Rescue {
-        step ->(options, **) { options["y"] = true }
-        success ->(options, **) { raise Y if options["raise-y"] }
-        step ->(options, **) { options["z"] = true }
-      }
-      step ->(options, **) { options["b"] = true }
-      success ->(options, **) { raise A if options["raise-a"] }
-      step ->(options, **) { options["c"] = true }
-      failure ->(options, **) { options["inner-err"] = true }
-    }
-    step ->(options, **) { options["e"] = true }, name: "nested/e"
-    failure ->(options, **) { options["outer-err"] = true }, name: "nested/failure"
-  end
-  it { Trailblazer::Operation::Inspect.(NestedInsanity).must_match /\[>Rescue\(\d+\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
-  it { NestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { NestedInsanity.( "raise-y" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, nil, nil, nil, nil, true, true] >} }
-  it { NestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
-  #-
-  # inheritance
-  class UbernestedInsanity < NestedInsanity
-  end
-  it { UbernestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { UbernestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
-end
-class RescueTest < Minitest::Spec
-  RecordNotFound = Class.new(RuntimeError)
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      raise if id == "RuntimeError!"
-      id.nil? ? raise(RecordNotFound) : new(id)
-    end
-    def lock!
-      true
-    end
-  end
-  #:simple
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-    step Rescue {
-      step Model(Song, :find)
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  end
-  #:simple end
-  it { Create.( params: {id: 1, title: "Prodigal Son"} )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
-  it { Create.( params: {id: nil} ).inspect(:model).must_equal %{<Result:false [nil] >} }
-  #-
-  # Rescue ExceptionClass, handler: ->(*) { }
-  class WithExceptionNameTest < Minitest::Spec
-  #
-  class MyContract < Reform::Form
-    property :title
-  end
-  #:name
-  class Create < Trailblazer::Operation
-    step Rescue( RecordNotFound, KeyError, handler: :rollback! ) {
-      step Model( Song, :find )
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-    def rollback!(exception, options)
-      options["x"] = exception.class
-    end
-  end
-  #:name end
-    it { Create.( params: {id: 1, title: "Prodigal Son"} )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
-    it { Create.( params: {id: 1, title: "Prodigal Son"} ).inspect("x").must_equal %{<Result:true [nil] >} }
-    it { Create.( params: {id: nil} ).inspect(:model, "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
-    it { assert_raises(RuntimeError) { Create.( params: {id: "RuntimeError!"} ) } }
-  end
-  #-
-  # cdennl use-case
-  class CdennlRescueAndTransactionTest < Minitest::Spec
-    module Sequel
-      cattr_accessor :result
-      def self.transaction
-        yield.tap do |res|
-          self.result = res
-        end
-      end
-    end
-  #:example
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-    step Rescue( RecordNotFound, handler: :rollback! ) {
-      step Wrap (->(*, &block) { Sequel.transaction do block.call end }) {
-        step Model( Song, :find )
-        step ->(options, *) { options[:model].lock! } # lock the model.
-        step Contract::Build( constant: MyContract )
-        step Contract::Validate( )
-        step Contract::Persist( method: :sync )
-      }
-    }
-    failure :error! # handle all kinds of errors.
-    def rollback!(exception, options)
-      #~ex
-      options["x"] = exception.class
-      #~ex end
-    end
-    def error!(options, *)
-      #~ex
-      options["err"] = true
-      #~ex end
-    end
-  end
-  #:example end
-    it { Create.( params: {id: 1, title: "Pie"} ).inspect(:model, "x", "err").must_equal %{<Result:true [#<struct RescueTest::Song id=1, title=\"Pie\">, nil, nil] >} }
-    # raise exceptions in Model:
-    it { Create.( params: {id: nil} ).inspect(:model, "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
-    it { assert_raises(RuntimeError) { Create.( params: {id: "RuntimeError!"} ) } }
-    it do
-      Create.( params: {id: 1, title: "Pie"} )
-      Sequel.result.first.must_be_kind_of Trailblazer::Operation::Railway::End::Success
-    end
-  end
-end

data/test/docs/wrap_test.rb DELETED Viewed

@@ -1,219 +0,0 @@
-require "test_helper"
-# TODO: consume End signal from wrapped
-class WrapTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      id.nil? ? raise : new(id)
-    end
-  end
-  class DirectWiringTest < Minitest::Spec
-    class Create < Trailblazer::Operation
-      class MyContract < Reform::Form
-        property :title
-      end
-      step( Wrap( ->(options, *args, &block) {
-        begin
-          block.call
-        rescue => exception
-          options["result.model.find"] = "argh! because #{exception.class}"
-          [ Railway.fail_fast!, options, *args ]
-        end }) {
-        step ->(options, **) { options["x"] = true }
-        step Model( Song, :find )
-        step Contract::Build( constant: MyContract )
-      }.merge(fast_track: true))
-      step Contract::Validate()
-      step Contract::Persist( method: :sync )
-    end
-    it { Create.( params: {id: 1, title: "Prodigal Son"} ).inspect("x", :model).must_equal %{<Result:true [true, #<struct WrapTest::Song id=1, title=\"Prodigal Son\">] >} }
-    it "goes directly from Wrap to End.fail_fast" do
-      Create.(params: {}).inspect("x", :model, "result.model.find").must_equal %{<Result:false [true, nil, "argh! because RuntimeError"] >}
-    end
-  end
-# it allows returning legacy true/false
-  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}"
-        return false
-      end
-      true
-      }) {
-      step Model( Song, :find )
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  end
-  it { Create.( params: {id: 1, title: "Prodigal Son"} )["contract.default"].model.inspect.must_equal %{#<struct WrapTest::Song id=1, title="Prodigal Son">} }
-  it { Create.( params: {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.(params: {}).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.(params: {}).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 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.( params: {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
-    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.( params: {title: "Pie"} ).inspect(:model, "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
-  end
-  class WrapWithMethodTest < Minitest::Spec
-    class Create < Trailblazer::Operation
-      step Model( Song, :new )
-      step Wrap( ->(options, *, &block) { block.call } ) {
-        step :check_model!
-      }
-      def check_model!(options, model:, **)
-        options["x"] = model
-      end
-    end
-    it { Create.(params: {}) }
-  end
-end