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

trailblazer 2.1.0.beta4 → 2.1.0.beta5

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