trailblazer-macro-contract 2.1.0 → 2.1.3.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3603305c22954cb6b53e94057b4b25c4ae98d1286d5a32b0b0a2292325156086
-  data.tar.gz: 952c4060256225918cfbd41939f2b6fb479cd153b4416967f8ef03682033cb42
+  metadata.gz: c9c3c0092a4bd1f8b71d4506ed24e77af326b28d2991a88bdb45d67586dad746
+  data.tar.gz: 6de99c14b4bc553a0e32e568a9c31a74abf839f0d82f36dac33884300d979777
 SHA512:
-  metadata.gz: 2f1118cf2e91af6c8a95c9c7050ae6bf43a82ebe7fca82b15255b53f7ace0c3a46e76a02efcaaa94195d6003fdba8c4acaeeb8fb30580c7eb09a5c765b44c690
-  data.tar.gz: 55ee53d0e937672aee52552167ad987f4c36f99f669966dd5f2a417c9bfc047c897b6981b4eebceb4dc1e9e1136c0adfa6efb5fea962e1a860abbc2edd01cd51
+  metadata.gz: 15de139140c545de9ab6d1b6d19a83053815b78b7e4ae990a9b5a57dea89e77566524d2eb84326694f5399f41d3d7f367a761572badf465fdaa58cd32c2e1a79
+  data.tar.gz: 4b9fc7eb3a4f30a7f57f2ec95c6b0459ad5ccff8e4adbfd3ddc324570d8647b1046277e61f7f1b402bbbb663e28fbe3b1161d649db5036e74c91da66b9e6b8c1

data/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
+        ruby: [2.6, 2.7, '3.0', jruby]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - run: bundle exec rake

data/CHANGES.md

@@ -1,3 +1,18 @@
+# 2.1.3
+
+* Use `trailblazer-activity-dsl-linear` >= 1.0.0.
+* Use Inject() API instead of `:inject`, `:input` etc in macros.
+
+# 2.1.2
+
+* Refactor `Contract::Build` to use TRB mechanics:
+    * `:input` and `:inject` to allow injection of the contract class.
+    * an `Option()` to wrap the builder code.
+
+# 2.1.1
+
+* Support for Ruby 3.0.
+
 # 2.1.0
 
 * Finally.

data/Gemfile

@@ -9,6 +9,8 @@ gem "dry-matcher"
 # gem "trailblazer-macro", path: "../trailblazer-macro"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
 # gem "trailblazer-activity-dsl-linear", path: "../trailblazer-activity-dsl-linear"
+# gem "trailblazer-errors", path: "../trailblazer-errors"
+# gem "trailblazer-developer", path: "../trailblazer-developer"
 
 gem "minitest-line"
 

data/Rakefile

@@ -2,7 +2,7 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 require "rubocop/rake_task"
 
-task :default => %i[test rubocop]
+task :default => %i[test]
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'

data/lib/trailblazer/macro/contract/build.rb

@@ -0,0 +1,87 @@
+require "reform"
+
+module Trailblazer
+  module Macro
+    # This Circuit-task calls the {task} Option, then allows
+    # to run an arbitary block to process the option's result.
+    # @private
+    class CircuitTaskWithResultProcessing < Activity::TaskBuilder::Task # DISCUSS: extract to public?
+      def initialize(task, user_proc, block)
+        @block = block
+        super(task, user_proc)
+      end
+
+      def call_option(task_with_option_interface, (ctx, flow_options), **circuit_options)
+        result = super
+
+        @block.call(result, ctx)
+      end
+    end
+
+    module Contract
+      def self.Build(name: "default", constant: nil, builder: nil)
+        contract_path     = :"contract.#{name}"
+
+        injections = {
+          Activity::Railway.Inject() => {
+            "#{contract_path}.class": ->(*) { constant }, # default to {constant} if not injected.
+          }
+        }
+
+        # DISCUSS: can we force-default this via Inject()?
+        input = {
+          Activity::Railway.In() => ->(ctx, **) do
+            ctx.to_hash.merge(
+              constant: constant,
+              name:     contract_path
+            )
+          end
+        }
+
+        output = {
+          Activity::Railway.Out() => [contract_path]
+        }
+
+        default_contract_builder = ->(ctx, model: nil, **) { ctx[:"#{contract_path}.class"].new(model) }
+
+        # proc is called via {Option()}.
+        task_option_proc = builder ? builder : default_contract_builder
+
+        # after the builder proc is run, assign its result to {:"contract.default"}.
+        ctx_assign_block = ->(result, ctx) { ctx[contract_path] = result }
+
+        task = CircuitTaskWithResultProcessing.new(Trailblazer::Option(task_option_proc), task_option_proc, ctx_assign_block)
+
+        {
+          task:   task, id: "contract.build",
+        }.
+          merge(injections).
+          merge(input).
+          merge(output)
+      end
+
+      module DSL
+        def self.extended(extender)
+          extender.extend(ClassDependencies)
+          warn "[Trailblazer] Using `contract do...end` is deprecated. Please use a form class and the Builder( constant: <Form> ) option."
+        end
+
+        # 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
+          )
+
+          self[path] = form_class
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/{operation → macro/contract}/persist.rb

@@ -1,5 +1,5 @@
 module Trailblazer
-  class Operation
+  module Macro
     module Contract
       def self.Persist(method: :save, name: "default")
         path = :"contract.#{name}"

data/lib/trailblazer/macro/contract/validate.rb

@@ -0,0 +1,85 @@
+module Trailblazer
+  module Macro
+    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.
+      def self.Validate(skip_extract: false, name: "default", representer: false, key: nil, constant: nil, invalid_data_terminus: false) # DISCUSS: should we introduce something like Validate::Deserializer?
+        contract_path = :"contract.#{name}" # the contract instance
+        params_path   = :"contract.#{name}.params" # extract_params! save extracted params here.
+        key_path      = :"contract.#{name}.extract_key"
+
+        extract  = Validate::Extract.new(key_path: key_path, params_path: params_path)
+        validate = Validate.new(name: name, representer: representer, params_path: params_path, contract_path: contract_path)
+
+        # These are defaulting dependency injection, more here
+        # https://trailblazer.to/2.1/docs/activity.html#activity-dependency-injection-inject-defaulting
+        extract_injections  = {key_path => ->(*) { key }} # default to {key} if not injected.
+        validate_injections = {contract_path => ->(*) { constant }} # default the contract instance to {constant}, if not injected (or passed down from {Build()})
+
+        # Build a simple Railway {Activity} for the internal flow.
+        activity = Class.new(Activity::Railway(name: "Contract::Validate")) do
+          step extract,  id: "#{params_path}_extract", Output(:failure) => End(:extract_failure), Activity::Railway.Inject() => extract_injections unless skip_extract# || representer
+          step validate, id: "contract.#{name}.call", Activity::Railway.Inject() => validate_injections
+        end
+
+        options = activity.Subprocess(activity)
+        options = options.merge(id: "contract.#{name}.validate")
+
+        # Deviate End.extract_failure to the standard failure track as a default. This can be changed from the user side.
+        options = options.merge(activity.Output(:extract_failure) => activity.Track(:failure)) unless skip_extract
+
+        # Halt failure track to End with {contract.name.invalid}.
+        options = options.merge(activity.Output(:failure) => activity.End(:invalid_data)) if invalid_data_terminus
+
+        options
+      end
+
+      class Validate
+        # Task: extract the contract's input from params by reading `:key`.
+        class Extract
+          def initialize(key_path: nil, params_path: nil)
+            @key_path, @params_path = key_path, params_path
+          end
+
+          def call(ctx, params: {}, **)
+            key = ctx[@key_path] # e.g. {:song}.
+            ctx[@params_path] = key ? params[key] : params
+          end
+        end
+
+        def initialize(name: "default", representer: false, params_path: nil, contract_path: )
+          @name, @representer, @params_path, @contract_path = name, representer, params_path, contract_path
+        end
+
+        # Task: Validates contract `:name`.
+        def call(ctx, **)
+          validate!(
+            ctx,
+            representer: ctx[:"representer.#{@name}.class"] ||= @representer, # FIXME: maybe @representer should use DI.
+            params_path: @params_path
+          )
+        end
+
+        def validate!(ctx, representer: false, from: :document, params_path: nil)
+          contract = ctx[@contract_path] # grab contract instance from "contract.default" (usually set in {Contract::Build()})
+
+          # this is for 1.1-style compatibility and should be removed once we have Deserializer in place:
+          ctx[:"result.#{@contract_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.(ctx[from]) { |document| representer.new(contract).parse(document) }
+            else
+              # let Reform handle the deserialization.
+              contract.(ctx[params_path])
+            end
+
+          result.success?
+        end
+      end
+    end
+  end # Macro
+end

data/lib/trailblazer/macro/contract/version.rb

@@ -2,7 +2,7 @@ module Trailblazer
   module Version
     module Macro
       module Contract
-      VERSION = "2.1.0"
+        VERSION = "2.1.3.beta1"
       end
     end
   end

data/lib/trailblazer/macro/contract.rb

@@ -1,5 +1,17 @@
-require "reform"
-require "trailblazer/operation"
-require "trailblazer/operation/contract"
-require "trailblazer/operation/validate"
-require "trailblazer/operation/persist"
+require "trailblazer/activity"
+require "trailblazer/activity/dsl/linear"
+
+require "trailblazer/macro/contract/build"
+require "trailblazer/macro/contract/validate"
+require "trailblazer/macro/contract/persist"
+
+module Trailblazer
+  module Macro
+    module Contract
+    end
+  end
+
+  # All macros sit in the {Trailblazer::Macro::Contract} namespace, where we forward calls from
+  # operations and activities to.
+  Activity::DSL::Linear::Helper::Constants::Contract = Macro::Contract
+end

data/test/docs/contract_test.rb

@@ -57,17 +57,21 @@ class DocsContractOverviewTest < Minitest::Spec
   it "shows 2-level tracing" do
     result = Create.trace( params: { length: "A" } )
     result.wtf.gsub(/0x\w+/, "").must_equal %{`-- DocsContractOverviewTest::Create
-   |-- Start.default
-   |-- model.build
-   |-- contract.build
-   |-- contract.default.validate
-   |   |-- Start.default
-   |   |-- contract.default.params_extract
-   |   |-- contract.default.call
-   |   `-- End.failure
-   `-- End.failure}
-  end
+    |-- Start.default
+    |-- model.build
+    |-- contract.build
+    |-- contract.default.validate
+    |   |-- Start.default
+    |   |-- contract.default.params_extract
+    |   |-- contract.default.call
+    |   `-- End.failure
+    `-- End.failure}
+  end
+
+  # internal variables from {:builder} are excluded in public ctx.
+  it { Create.(params: {}).keys.inspect.must_equal %{[:params, :model, :\"result.model\", :\"contract.default\", :\"contract.default.params\", :\"representer.default.class\", :\"result.contract.default\"]} }
 end
+
 #---
 # contract MyContract
 class DocsContractExplicitTest < Minitest::Spec
@@ -257,6 +261,42 @@ class DocsContractKeyTest < Minitest::Spec
   end
 end
 
+#---
+#- Validate() with injected {:"contract.default.extract_key"}
+class DocsContractInjectedKeyTest < Minitest::Spec
+  Song = Class.new(ContractConstantTest::Song)
+
+  module Song::Contract
+    Create = ContractConstantTest::Song::Contract::Create
+  end
+
+  #:inject-key-op
+  class Song::Create < Trailblazer::Operation
+    #~meths
+    step Model(Song, :new)
+    step Contract::Build(constant: Song::Contract::Create)
+    #~meths end
+    step Contract::Validate() # we don't define a key here! E.g. {key: "song"}
+    step Contract::Persist()
+  end
+  #:inject-key-op end
+
+  # empty {:params}, validation fails
+  it { Song::Create.(params: {}).inspect(:model, "result.contract.default.extract").must_equal %{<Result:false [#<struct DocsContractInjectedKeyTest::Song title=nil, length=nil>, nil] >} }
+  # no {:key} injected/defined, we don't find the data in {params}.
+  it { Song::Create.(params: {"song" => { title: "SVG", length: 13 }}).inspect(:model, "result.contract.default.extract").must_equal %{<Result:false [#<struct DocsContractInjectedKeyTest::Song title=nil, length=nil>, nil] >} }
+  # {:key} defined and everything works smoothly
+  it {
+    params = {"song" => { title: "SVG", length: 13 }}
+    #:inject-key-call
+    res = Song::Create.(
+      params:                         params,
+      "contract.default.extract_key": "song"
+    )
+    #:inject-key-call end
+    res.inspect(:model).must_equal %{<Result:true [#<struct DocsContractInjectedKeyTest::Song title=\"SVG\", length=13>] >} }
+end
+
 #---
 #- Validate( key: :song ), Output(:extract_failure) => End(:my_new_end)
 class DocsContractKeyWithOutputTest < Minitest::Spec
@@ -297,6 +337,77 @@ class DocsContractKeyWithOutputTest < Minitest::Spec
   end
 end
 
+#---
+#- Validate() with injected {:"contract.default"} and no `Build()`.
+class DocsContractInjectedContractTest < Minitest::Spec
+  Song = Class.new(ContractConstantTest::Song)
+
+  module Song::Contract
+    Create = ContractConstantTest::Song::Contract::Create
+  end
+
+  #:inject-contract-op
+  class Song::Create < Trailblazer::Operation
+    # we omit the {Model()} call as the run-time contract contains the model.
+    # we don't have a {Contract::Build()} step here.
+    step Contract::Validate(key: "song") # you could use an injection here, too!
+    step Contract::Persist()
+  end
+  #:inject-contract-op end
+
+  it {
+    params = {"song" => { title: "SVG", length: 13 }}
+    #:inject-contract-call
+    res = Song::Create.(
+      params:             params,
+      "contract.default": Song::Contract::Create.new(Song.new) # we build the contract ourselves!
+    )
+    #:inject-contract-call end
+    res.inspect(:model).must_equal %{<Result:true [nil] >}
+    res[:"contract.default"].model.inspect.must_equal %{#<struct DocsContractInjectedContractTest::Song title=\"SVG\", length=13>}
+  }
+end
+
+#---
+#- Validate( name: "default", invalid_data_terminus: true )
+class DocsContractInvalidEndTest < Minitest::Spec
+  Song = Class.new(ContractConstantTest::Song)
+
+  module Song::Contract
+    Create = ContractConstantTest::Song::Contract::Create
+  end
+
+  #:invalid-end
+  class Song::Create < Trailblazer::Operation
+    step Model( Song, :new )
+    step Contract::Build( constant: Song::Contract::Create )
+    step Contract::Validate( key: :song, invalid_data_terminus: true )
+    step Contract::Persist( )
+  end
+  #:invalid-end end
+
+  it do
+    result = Song::Create.(params: {song: { title: nil, length: nil }})
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:invalid_data>}
+  end
+
+  it { Song::Create.(params: {song: { title: "SVG", length: 13 }}).inspect(:model).must_equal %{<Result:true [#<struct DocsContractInvalidEndTest::Song title=\"SVG\", length=13>] >} }
+
+  it do
+    #:invalid-end-res
+    result = Song::Create.(params: { title: "Rising Force", length: 13 })
+    result.success? #=> false
+    result.event    #=> #<Trailblazer::Activity::End semantic=:"contract.default.invalid">
+    #:invalid-end-res end
+
+    #:invalid-end-res-false
+    result = Song::Create.(params: { "song" => { title: "Rising Force", length: 13 } })
+    result.success? #=> true
+    #:invalid-end-res-false end
+  end
+end
+
+
 #- Contract::Build[ constant: XXX, name: AAA ]
 class ContractNamedConstantTest < Minitest::Spec
   Song = Class.new(ContractConstantTest::Song)
@@ -337,24 +448,24 @@ class ContractInjectConstantTest < Minitest::Spec
   end
   #:di-constant-contract end
   #:di-constant
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step Contract::Build()
+  class Song::Create < Trailblazer::Operation
+    step Model(Song, :new)
+    step Contract::Build() # no constant provided here!
     step Contract::Validate()
-    step Contract::Persist( method: :sync )
+    step Contract::Persist(method: :sync)
   end
   #:di-constant end
 
   it do
     #:di-contract-call
-    Create.(
-      params: { title: "Anthony's Song" },
-      :"contract.default.class" => MyContract
+    Song::Create.(
+      params:                   { title: "Anthony's Song" },
+      "contract.default.class": MyContract # dependency injection!
     )
     #:di-contract-call end
   end
-  it { Create.(params: { title: "A" }, :"contract.default.class" => MyContract).inspect(:model).must_equal %{<Result:false [#<struct ContractInjectConstantTest::Song id=nil, title=nil>] >} }
-  it { Create.(params: { title: "Anthony's Song" }, :"contract.default.class" => MyContract).inspect(:model).must_equal %{<Result:true [#<struct ContractInjectConstantTest::Song id=nil, title="Anthony's Song">] >} }
+  it { Song::Create.(params: { title: "A" }, :"contract.default.class" => MyContract).inspect(:model).must_equal %{<Result:false [#<struct ContractInjectConstantTest::Song id=nil, title=nil>] >} }
+  it { Song::Create.(params: { 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
@@ -367,16 +478,20 @@ class DryValidationContractTest < Minitest::Spec
   class Create < Trailblazer::Operation
     # contract to verify params formally.
     class MyContract < Reform::Form
-      feature Reform::Form::Dry
+      feature Dry
       property :id
       property :title
 
       validation name: :default do
-        required(:id).filled
+        params do
+          required(:id).filled
+        end
       end
 
       validation name: :extra, if: :default do
-        required(:title).filled(min_size?: 2)
+        params do
+          required(:title).filled(min_size?: 2)
+        end
       end
     end
     #~form end
@@ -402,28 +517,47 @@ class DryValidationContractTest < Minitest::Spec
   it { Create.(params: { id: 1, title: "Y" }).inspect(:model).must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
   it { Create.(params: { id: 1, title: "Yo" }).inspect(:model).must_equal %{<Result:true [#<struct DryValidationContractTest::Song id=1, title="Yo">] >} }
 
-  #---
+  ##---
   # Contract::Validate(constant: DrySchema)
-  class OpWithSchema < Trailblazer::Operation
-    Schema = Dry::Validation.Schema do
-      required(:title).filled
-    end
 
-    step Model( Song, :new ) # FIXME.
-    step Contract::Validate( constant: Schema, key: :song) # generic validate call for you.
+  #:dry-schema-contract
+  module Song::Operation
+    class Archive < Trailblazer::Operation
+      Schema = Dry::Validation.Contract do
+        params do
+          required(:id).filled
+        end
+      end
+
+      # step Model(Song, :new)                              # You don't need {ctx[:model]}.
+      step Contract::Validate(constant: Schema, key: :song) # Your validation.
+      #~methods
+      # step Contract::Persist()                            # this is not possible!
+      #~methods end
+    end
   end
+  #:dry-schema-contract end
 
   # success
-  it { OpWithSchema.(params: {song: { title: "SVG" }}).success?.must_equal true }
+  it { _(Song::Operation::Archive.(params: {song: {id: "SVG"}}).success?).must_equal true }
   # failure
-  it { OpWithSchema.(params: {song: { title: nil }}).success?.must_equal false }
+  it { _(Song::Operation::Archive.(params: {song: {id: nil}}).success?).must_equal false }
+  # shows error messages
   it "shows error messages" do
-    result = OpWithSchema.(params: {song: { title: nil }})
+    #:dry-contract-call
+    result = Song::Operation::Archive.(params: {song: {id: nil}})
+    #:dry-contract-call end
+
+    _(result[:"result.contract.default"].errors.inspect).must_equal %{#<Dry::Validation::MessageSet messages=[#<Dry::Schema::Message text=\"must be filled\" path=[:id] predicate=:filled? input=nil>] options={:source=>[#<Dry::Schema::Message text=\"must be filled\" path=[:id] predicate=:filled? input=nil>], :hints=>false}>}
 
-    result[:"result.contract.default"].errors.must_equal(title: ["must be filled"])
+    # raise result[:"result.contract.default"].errors.messages[0].to_s.inspect
+    assert_equal result[:"result.contract.default"].errors[:id].inspect, %{["must be filled"]}
+    #:dry-contract-result
+    result[:"result.contract.default"].errors[:id] #=> ["must be filled"]
+    #:dry-contract-result end
   end
   # key not found
-  it { OpWithSchema.(params: {}).success?.must_equal false }
+  it { _(Song::Operation::Archive.(params: {}).success?).must_equal false }
 end
 
 class DocContractBuilderTest < Minitest::Spec
@@ -459,6 +593,8 @@ class DocContractBuilderTest < Minitest::Spec
 
   it { Create.(params: {}).inspect(:model).must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
   it { Create.(params: { title: "title"}, current_user: Module).inspect(:model).must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title="title">] >} }
+  # internal variables from {:builder} are excluded in public ctx.
+  it { Create.(params: {}).keys.inspect.must_equal %{[:params, :model, :\"result.model\", :\"contract.default\", :\"contract.default.params\", :\"representer.default.class\", :\"result.contract.default\"]} }
 end
 
 class DocContractTest < Minitest::Spec
@@ -501,3 +637,20 @@ class DocContractTest < Minitest::Spec
 
   it { Break.(params: { id:1, title: "Fame" }).inspect(:model).must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title=nil>] >} }
 end
+
+class ModelMissingTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :duration, virtual: true
+    end
+
+    step Contract::Build(constant: MyContract)
+    step Contract::Validate()
+  end
+
+  it do
+    result = Create.(params: {duration: 18})
+    assert_equal true, result.success?
+    assert_equal 18, result[:"contract.default"].duration
+  end
+end

data/test/docs/dry_test.rb

@@ -1,33 +1,33 @@
-require "test_helper"
-require "dry/container"
+# require "test_helper"
+# require "dry/container"
 
-class DryContainerTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
+# class DryContainerTest < Minitest::Spec
+#   Song = Struct.new(:id, :title)
 
-  class MyContract < Reform::Form
-    property :title
-    validates :title, length: 2..33
-  end
+#   class MyContract < Reform::Form
+#     property :title
+#     validates :title, length: 2..33
+#   end
 
-  my_container = Dry::Container.new
-  my_container.register("contract.default.class", MyContract)
-  # my_container.namespace("contract") do
-  #   register("create") { Array }
-  # end
+#   my_container = Dry::Container.new
+#   my_container.register("contract.default.class", MyContract)
+#   # my_container.namespace("contract") do
+#   #   register("create") { Array }
+#   # end
 
-  #---
-  #- dependency injection
-  #- with Dry-container
-  class Create < Trailblazer::Operation
-    extend Trailblazer::Operation::Container
+#   #---
+#   #- dependency injection
+#   #- with Dry-container
+#   class Create < Trailblazer::Operation
+#     extend Trailblazer::Operation::Container
 
-    step Model(Song, :new)
-    step Contract::Build()
-    step Contract::Validate()
-    step Contract::Persist(method: :sync)
-  end
-  #:key end
+#     step Model(Song, :new)
+#     step Contract::Build()
+#     step Contract::Validate()
+#     step Contract::Persist(method: :sync)
+#   end
+#   #:key end
 
-  it { Create.({params: {title: "A" } }, my_container).inspect(:model).must_equal %{<Result:false [#<struct DryContainerTest::Song id=nil, title=nil>] >} }
-  it { Create.({params: {title: "Anthony's Song" } }, my_container).inspect(:model).must_equal %{<Result:true [#<struct DryContainerTest::Song id=nil, title="Anthony's Song">] >} }
-end
+#   it { Create.({params: {title: "A" } }, my_container).inspect(:model).must_equal %{<Result:false [#<struct DryContainerTest::Song id=nil, title=nil>] >} }
+#   it { Create.({params: {title: "Anthony's Song" } }, my_container).inspect(:model).must_equal %{<Result:true [#<struct DryContainerTest::Song id=nil, title="Anthony's Song">] >} }
+# end

data/test/operation/contract_test.rb

@@ -59,6 +59,8 @@ class ContractTest < Minitest::Spec
     it { Upsert.(params: {song: { title: nil }}).success?.must_equal false }
     # key not found
     it { Upsert.(params: {}).success?.must_equal false }
+    # no params passed
+    it { Upsert.().success?.must_equal false } 
 
     #---
     # contract.default.params gets set (TODO: change in 2.1)

data/test/test_helper.rb

@@ -1,9 +1,11 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "trailblazer-macro-contract"
+
 require "pp"
 require 'delegate'
+require "trailblazer/operation"
 require "trailblazer/developer"
 require "trailblazer/macro"
-require "trailblazer-macro-contract"
-require "trailblazer/developer/render/linear"
 require "minitest/autorun"
 
 # TODO: convert tests to non-rails.

data/trailblazer-macro-contract.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |spec|
   spec.version       = Trailblazer::Version::Macro::Contract::VERSION
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
-  spec.description   = 'Trailblazer operation form object specific macros'
-  spec.summary       = 'Macros for form-objects: Build, Validate, Persist'
+  spec.description   = 'Operation macros for form objects'
+  spec.summary       = 'Macros for form objects: Build, Validate, Persist'
   spec.homepage      = "http://trailblazer.to"
   spec.license       = "LGPL-3.0"
 
@@ -21,13 +21,16 @@ Gem::Specification.new do |spec|
   spec.add_dependency "reform", ">= 2.2.0", "< 3.0.0"
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "dry-validation", "0.11.1" # FIXME: upgrade example code
+  spec.add_development_dependency "dry-validation"
   spec.add_development_dependency "reform-rails", "~> 0.2.0.rc2"
-  spec.add_development_dependency "trailblazer-macro", ">= 2.1.0", "< 2.2.0"
+  spec.add_development_dependency "trailblazer-macro", ">= 2.1.9"
   spec.add_development_dependency "trailblazer-developer"
+  spec.add_development_dependency "activemodel", "~> 6.0.0" # FIXME: we still don't support the Rails 6.1 errors object.
 
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
 
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.0.0.beta1", "< 1.1.0"
+
   spec.required_ruby_version = ">= 2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro-contract
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.3.beta1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-23 00:00:00.000000000 Z
+date: 2022-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reform
@@ -48,16 +48,16 @@ dependencies:
   name: dry-validation
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: reform-rails
   requirement: !ruby/object:Gem::Requirement
@@ -78,20 +78,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.1.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.1.9
 - !ruby/object:Gem::Dependency
   name: trailblazer-developer
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -134,18 +142,38 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Trailblazer operation form object specific macros
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity-dsl-linear
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Operation macros for form objects
 email:
 - apotonick@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop-https---raw-githubusercontent-com-trailblazer-meta-master-rubocop-yml"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - CHANGES.md
 - COMM-LICENSE
 - Gemfile
@@ -154,10 +182,10 @@ files:
 - Rakefile
 - lib/trailblazer-macro-contract.rb
 - lib/trailblazer/macro/contract.rb
+- lib/trailblazer/macro/contract/build.rb
+- lib/trailblazer/macro/contract/persist.rb
+- lib/trailblazer/macro/contract/validate.rb
 - lib/trailblazer/macro/contract/version.rb
-- lib/trailblazer/operation/contract.rb
-- lib/trailblazer/operation/persist.rb
-- lib/trailblazer/operation/validate.rb
 - test/docs/contract_test.rb
 - test/docs/dry_test.rb
 - test/operation/contract_test.rb
@@ -179,15 +207,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: 'Macros for form-objects: Build, Validate, Persist'
+summary: 'Macros for form objects: Build, Validate, Persist'
 test_files:
 - test/docs/contract_test.rb
 - test/docs/dry_test.rb

data/.travis.yml

@@ -1,8 +0,0 @@
-sudo: false
-language: ruby
-before_install: gem install bundler
-rvm:
-  - 2.5.1
-  - 2.4.4
-  - 2.3.7
-  # - 2.2.10

data/lib/trailblazer/operation/contract.rb

@@ -1,63 +0,0 @@
-module Trailblazer
-  class Operation
-    module Contract
-      def self.Build(name: "default", constant: nil, builder: nil)
-        task = lambda do |(options, flow_options), **circuit_options|
-          result = Build.(options, circuit_options, name: name, constant: constant, builder: builder)
-
-          return Activity::TaskBuilder.binary_signal_for(result, Activity::Right, Activity::Left),
-              [options, flow_options]
-        end
-
-        {task: task, id: "contract.build"}
-      end
-
-      module Build
-        # Build contract at runtime.
-        def self.call(options, circuit_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"] # DISCUSS: Injection possible here?
-          model          = options[:model]
-          name           = :"contract.#{name}"
-
-          options[name] = if builder
-                            call_builder(options, circuit_options, builder: builder, constant: contract_class, name: name)
-                          else
-                            contract_class.new(model)
-                          end
-        end
-
-        def self.call_builder(options, circuit_options, builder: raise, constant: raise, name: raise)
-          tmp_options = options.to_hash.merge(
-            constant: constant,
-            name:     name
-          )
-          Trailblazer::Option(builder).(options, tmp_options, circuit_options)
-        end
-      end
-
-      module DSL
-        def self.extended(extender)
-          extender.extend(ClassDependencies)
-          warn "[Trailblazer] Using `contract do...end` is deprecated. Please use a form class and the Builder( constant: <Form> ) option."
-        end
-
-        # 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
-          )
-
-          self[path] = form_class
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/operation/validate.rb

@@ -1,75 +0,0 @@
-module Trailblazer
-  class 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.
-      def self.Validate(skip_extract: false, name: "default", representer: false, key: nil, constant: nil) # DISCUSS: should we introduce something like Validate::Deserializer?
-        params_path = :"contract.#{name}.params" # extract_params! save extracted params here.
-
-        extract  = Validate::Extract.new(key: key, params_path: params_path).freeze
-        validate = Validate.new(name: name, representer: representer, params_path: params_path, constant: constant).freeze
-
-        # Build a simple Railway {Activity} for the internal flow.
-        activity = Class.new(Activity::Railway(name: "Contract::Validate")) do
-          step extract,  id: "#{params_path}_extract", Output(:failure) => End(:extract_failure) unless skip_extract# || representer
-          step validate, id: "contract.#{name}.call"
-        end
-
-        options = activity.Subprocess(activity)
-        options = options.merge(id: "contract.#{name}.validate")
-
-        # Deviate End.extract_failure to the standard failure track as a default. This can be changed from the user side.
-        options = options.merge(activity.Output(:extract_failure) => activity.Track(:failure)) unless skip_extract
-
-        options
-      end
-
-      class Validate
-        # Task: extract the contract's input from params by reading `:key`.
-        class Extract
-          def initialize(key: nil, params_path: nil)
-            @key, @params_path = key, params_path
-          end
-
-          def call(ctx, params:, **)
-            ctx[@params_path] = @key ? params[@key] : params
-          end
-        end
-
-        def initialize(name: "default", representer: false, params_path: nil, constant: nil)
-          @name, @representer, @params_path, @constant = name, representer, params_path, constant
-        end
-
-        # Task: Validates contract `:name`.
-        def call(ctx, **)
-          validate!(
-            ctx,
-            representer: ctx["representer.#{@name}.class"] ||= @representer, # FIXME: maybe @representer should use DI.
-            params_path: @params_path
-          )
-        end
-
-        def validate!(options, representer: false, from: :document, params_path: nil)
-          path     = :"contract.#{@name}"
-          contract = @constant || options[path]
-
-          # this is for 1.1-style compatibility and should be removed once we have Deserializer in place:
-          options[:"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
-  end # Operation
-end