trailblazer-macro 2.1.0.rc12 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5ce55419b3272e247bb23453c3eda1543ad0de9b7308e173fc7532ed0b3c837
-  data.tar.gz: da8e59a55b392c9220ba8038ce809d52136ee712a4f31489172176a01ef117a5
+  metadata.gz: 40b0e15f1f350730e29523549e1093931d345d118f24dfc186e201d92e674f4a
+  data.tar.gz: 07d680040a3404a155636a8998321684609ce3bdee9988ac43dafd163d96d2eb
 SHA512:
-  metadata.gz: e871c4cf8f7e11af5339a40493b7175919b3c965bc1fbeefa925f41f17d8a89e936fdc39e688725f30115370539c8fcc5cee9f5a3c69f4e411b9a1002ea63a87
-  data.tar.gz: cd97aa45a6d27af7f4f60e4ab34f80a235a73338188d7e27a48e2a12bcbc693ea1534f4075f95ceaef7918b9f5cebc0e87320bd3f69dd130b5bad814bef080e1
+  metadata.gz: c61f315deeed6243a45810a92ebfd11d4f832e86de66b7e7d6896bcc8cb5cd7bc0eb9f76985e8f632e6986c03696ad8a4ca96dd92504c05f11519abb8577e89e
+  data.tar.gz: 3c8ca095a7bf17d821d1209817604bd1416d04a8c7aff6ddc967a89248781c6fee9356db7333e1a64d7955f211b853b8b1de7a6f56a6656327bf5258b57bc149

data/.travis.yml

@@ -1,11 +1,9 @@
-sudo: false
 language: ruby
 rvm:
-  - 2.6.2
+  - 2.6.5
   - 2.5.5
   - 2.4.4
   - 2.3.7
   - 2.2
-  - 2.1
 
 cache: bundler

data/CHANGES.md

@@ -1,3 +1,25 @@
+# 2.1.2
+
+* Fix to make macros available in all Linear::DSL strategies.
+* Make `params` optional in `Model`.
+* Support for adding `End.not_found` end in `Model`.
+
+# 2.1.1
+
+* Fix case when Macros generate same id due to small entropy
+
+# 2.1.0
+
+* Finally.
+
+# 2.1.0.rc14
+
+* Remove the explicit `dsl-linear` dependency.
+
+# 2.1.0.rc13
+
+* Use symbol keys on `ctx`, only.
+
 # 2.1.0.rc12
 
 * Dependency bumps.

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2018 Trailblazer GmbH
+
+Trailblazer is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
+
+Trailblazer PRO has a commercial-friendly license allowing private forks
+and modifications of Trailblazer.  Please see http://trailblazer.to/pro for
+more detail.

data/lib/trailblazer/macro.rb

@@ -1,5 +1,6 @@
+require "forwardable"
 require "trailblazer/activity"
-require "trailblazer/activity/dsl/linear" # TODO: remove this dependency
+require "trailblazer/activity/dsl/linear"
 require "trailblazer/operation" # TODO: remove this dependency
 
 require "trailblazer/macro/model"
@@ -12,18 +13,16 @@ require "trailblazer/macro/wrap"
 
 module Trailblazer
   module Macro
-    # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
-    # operations and activities to.
-    def self.forward_macros(target)
-      target.singleton_class.def_delegators Trailblazer::Macro, :Model, :Wrap, :Rescue, :Nested
-      target.const_set(:Policy, Trailblazer::Macro::Policy)
-    end
   end
-end
 
-# TODO: Forwardable.def_delegators(Operation, Macro, :Model, :Wrap) would be amazing. It really sucks to extend a foreign class.
-# Trailblazer::Operation.singleton_class.extend Forwardable
-# Trailblazer::Macro.forward_macros(Trailblazer::Operation)
+  # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
+  # operations and activities to.
+  module Activity::DSL::Linear::Helper
+    Policy = Trailblazer::Macro::Policy
 
-Trailblazer::Activity::FastTrack.singleton_class.extend Forwardable
-Trailblazer::Macro.forward_macros(Trailblazer::Activity::FastTrack) # monkey-patching sucks.
+    module ClassMethods
+      extend Forwardable
+      def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
+    end # ClassMethods
+  end # Helper
+end

data/lib/trailblazer/macro/model.rb

@@ -1,33 +1,39 @@
 module Trailblazer::Macro
-  def self.Model(model_class, action = nil, find_by_key = nil)
+
+  Linear = Trailblazer::Activity::DSL::Linear
+
+  def self.Model(model_class, action = nil, find_by_key = nil, id: 'model.build', not_found_end: false)
     task = Trailblazer::Activity::TaskBuilder::Binary(Model.new)
 
     injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
-      "model.class"          => model_class,
-      "model.action"         => action,
-      "model.find_by_key"    => find_by_key
+      :"model.class"          => model_class,
+      :"model.action"         => action,
+      :"model.find_by_key"    => find_by_key
     )
 
-    {task: task, id: "model.build", extensions: [injection]}
+    options = { task: task, id: id, extensions: [injection] }
+    options = options.merge(Linear::Output(:failure) => Linear::End(:not_found)) if not_found_end
+
+    options
   end
 
   class Model
-    def call(options, params:,  **)
+    def call(options, params: nil,  **)
       builder                 = Model::Builder.new
       options[:model]         = model = builder.call(options, params)
-      options["result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})
+      options[:"result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})
 
       result.success?
     end
 
     class Builder
       def call(options, params)
-        action        = options["model.action"] || :new
-        model_class   = options["model.class"]
-        find_by_key   = options["model.find_by_key"] || :id
+        action        = options[:"model.action"] || :new
+        model_class   = options[:"model.class"]
+        find_by_key   = options[:"model.find_by_key"] || :id
         action        = :pass_through unless %i[new find_by].include?(action)
 
-        send("#{action}!", model_class, params, options["model.action"], find_by_key)
+        send("#{action}!", model_class, params, options[:"model.action"], find_by_key)
       end
 
       def new!(model_class, params, *)

data/lib/trailblazer/macro/policy.rb

@@ -14,8 +14,8 @@ module Trailblazer::Macro
         condition = options[@path] # this allows dependency injection.
         result    = condition.([options, flow_options], **circuit_options)
 
-        options["policy.#{@name}"]        = result["policy"] # assign the policy as a skill.
-        options["result.policy.#{@name}"] = result
+        options[:"policy.#{@name}"]        = result[:policy] # assign the policy as a skill.
+        options[:"result.policy.#{@name}"] = result
 
         # flow control
         signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
@@ -28,7 +28,7 @@ module Trailblazer::Macro
     # policy-compatible  object at runtime.
     def self.step(condition, options, &block)
       name = options[:name]
-      path = "policy.#{name}.eval"
+      path = :"policy.#{name}.eval"
 
       task = Eval.new(name: name, path: path)
 

data/lib/trailblazer/macro/pundit.rb

@@ -27,8 +27,8 @@ module Trailblazer::Macro
         end
 
         def result!(success, policy)
-          data = {"policy" => policy}
-          data["message"] = "Breach" if !success # TODO: how to allow messages here?
+          data = { policy: policy }
+          data[:message] = "Breach" if !success # TODO: how to allow messages here?
 
           Trailblazer::Operation::Result.new(success, data)
         end

data/lib/trailblazer/macro/rescue.rb

@@ -20,7 +20,7 @@ module Trailblazer
         end
       end
 
-      Wrap(rescue_block, id: "Rescue(#{rand(100)})", &block)
+      Wrap(rescue_block, id: "Rescue(#{SecureRandom.hex(4)})", &block)
       # FIXME: name
       # [ step, name: "Rescue:#{block.source_location.last}" ]
     end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.0.rc12".freeze
+      VERSION = "2.1.2"
     end
   end
 end

data/lib/trailblazer/macro/wrap.rb

@@ -1,6 +1,8 @@
+require 'securerandom'
+
 module Trailblazer
   module Macro
-    def self.Wrap(user_wrap, id: "Wrap/#{rand(100)}", &block)
+    def self.Wrap(user_wrap, id: "Wrap/#{SecureRandom.hex(4)}", &block)
       activity = Class.new(Activity::FastTrack, &block) # This is currently coupled to {dsl-linear}.
 
       outputs  = activity.to_h[:outputs]

data/test/docs/guard_test.rb

@@ -6,22 +6,22 @@ class DocsGuardProcTest < Minitest::Spec
   #:proc
   class Create < Trailblazer::Operation
     step Policy::Guard(->(options, pass:, **) { pass })
-    #~pipeonly
+    #:pipeonly
     step :process
 
     def process(options, **)
-      options["x"] = true
+      options[:x] = true
     end
-    #~pipeonly end
+    #:pipeonly end
   end
   #:proc end
 
-  it { Create.(pass: false)["x"].must_be_nil }
-  it { Create.(pass: true)["x"].must_equal true }
+  it { Create.(pass: false)[:x].must_be_nil }
+  it { Create.(pass: true)[:x].must_equal true }
 
   #- result object, guard
-  it { Create.(pass: true)["result.policy.default"].success?.must_equal true }
-  it { Create.(pass: false)["result.policy.default"].success?.must_equal false }
+  it { Create.(pass: true)[:"result.policy.default"].success?.must_equal true }
+  it { Create.(pass: false)[:"result.policy.default"].success?.must_equal false }
 
   #---
   #- Guard inheritance
@@ -46,13 +46,15 @@ class DocsGuardTest < Minitest::Spec
   #:callable-op
   class Create < Trailblazer::Operation
     step Policy::Guard( MyGuard.new )
-    #~pipe-only
+    #:pipe-only
     step :process
 
+    #~methods
     def process(options, **)
       options[:x] = true
     end
-    #~pipe-only end
+    #~methods end
+    #:pipe-only end
   end
   #:callable-op end
 
@@ -72,16 +74,17 @@ class DocsGuardMethodTest < Minitest::Spec
     end
     #~pipe-onlyy
     step :process
-
+    #~methods
     def process(options, **)
-      options["x"] = true
+      options[:x] = true
     end
+    #~methods end
     #~pipe-onlyy end
   end
   #:method end
 
-  it { Create.(pass: false).inspect("x").must_equal %{<Result:false [nil] >} }
-  it { Create.(pass: true).inspect("x").must_equal %{<Result:true [true] >} }
+  it { Create.(pass: false).inspect(:x).must_equal %{<Result:false [nil] >} }
+  it { Create.(pass: true).inspect(:x).must_equal %{<Result:true [true] >} }
 end
 
 #---
@@ -94,13 +97,13 @@ class DocsGuardNamedTest < Minitest::Spec
   end
   #:name end
 
-  it { Create.(:current_user => nil   )["result.policy.user"].success?.must_equal false }
-  it { Create.(:current_user => Module)["result.policy.user"].success?.must_equal true }
+  it { Create.(:current_user => nil   )[:"result.policy.user"].success?.must_equal false }
+  it { Create.(:current_user => Module)[:"result.policy.user"].success?.must_equal true }
 
   it {
   #:name-result
   result = Create.(:current_user => true)
-  result["result.policy.user"].success? #=> true
+  result[:"result.policy.user"].success? #=> true
   #:name-result end
   }
 end
@@ -123,7 +126,7 @@ class DocsGuardInjectionTest < Minitest::Spec
   Create.(
     {},
     :current_user        => Module,
-    "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options, **) { false })
+    :"policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options, **) { false })
   )
   #:di-call end
     result.inspect("").must_equal %{<Result:false [nil] >} }

data/test/docs/model_test.rb

@@ -45,6 +45,13 @@ class DocsModelTest < Minitest::Spec
   end
   #:update-with-find-by-key end
 
+  #:update-with-not-found-end
+  class UpdateFailureWithModelNotFound < Trailblazer::Operation
+    step Model( Song, :find_by, not_found_end: true )
+    # ..
+  end
+  #:update-with-not-found-end end
+
   it do
     #:update-ok
     result = Update.(params: { id: 1 })
@@ -83,6 +90,19 @@ class DocsModelTest < Minitest::Spec
     result.success?.must_equal false
   end
 
+  it do
+    #:update-with-not-found-end-use
+    result = UpdateFailureWithModelNotFound.(params: {title: nil})
+    result[:model] #=> nil
+    result.success? #=> false
+    result.event #=> #<Trailblazer::Activity::End semantic=:not_found>
+    #:update-with-not-found-end-use end
+
+    result[:model].must_be_nil
+    result.success?.must_equal false
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:not_found>}
+  end
+
   #:show
   class Show < Trailblazer::Operation
     step Model( Song, :[] )

data/test/docs/nested_test.rb

@@ -16,22 +16,33 @@ class NestedInput < Minitest::Spec
     end
   end
 
-  it "Nested(Edit), without any options" do
-    edit = self.edit
-
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested( edit )
-      step :b
-
-      include T.def_steps(:a, :b)
-    end
+  class Validate < Trailblazer::Operation
+    step :validate
+    # ... more steps ...
+    include T.def_steps(:validate)
+  end
 
-    # this will print a DEPRECATION warning.
-  # success
-    create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
-  # failure in Nested
-    create.(seq: [], c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+  it "Nested(Edit), without any options" do
+      module A
+
+        create =
+        #:nested
+        class Create < Trailblazer::Operation
+          step :create
+          step Nested(Validate)
+          step :save
+          #~meths
+          include T.def_steps(:create, :save)
+          #~meths end
+        end
+        #:nested end
+
+        # this will print a DEPRECATION warning.
+      # success
+        create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+      # failure in Nested
+        create.(seq: [], validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
+      end
   end
 
   it "Nested(Edit), with Output rewiring" do
@@ -52,32 +63,102 @@ class NestedInput < Minitest::Spec
   end
 
   it "Nested(:method)" do
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested(:compute_edit)
-      step :b
-
-      def compute_edit(ctx, what:, **)
-        what
+    module B
+      create =
+      #:nested-dynamic
+      class Create < Trailblazer::Operation
+        step :create
+        step Nested(:compute_nested)
+        step :save
+
+        def compute_nested(ctx, params:, **)
+          params.is_a?(Hash) ? Validate : JsonValidate
+        end
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
       end
+      #:nested-dynamic end
 
-      include T.def_steps(:a, :b)
-    end
-
+      class JsonValidate < Validate
+        step :json
+        include T.def_steps(:json)
+      end
     # `edit` and `update` can be called from Nested()
 
   # edit/success
-    create.(seq: [], what: edit).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
+    create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
 
   # update/success
-    create.(seq: [], what: update).inspect(:seq).must_equal %{<Result:true [[:a, :d, :b]] >}
+    create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
 
 
 # wiring of fail:
   # edit/failure
-    create.(seq: [], what: edit, c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+    create.(seq: [], params: {}, validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
   # update/failure
-    create.(seq: [], what: update, d: false).inspect(:seq).must_equal %{<Result:false [[:a, :d]] >}
+    create.(seq: [], params: nil, json: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate, :json]] >}
+    end
+  end
+
+  it "Nested(:method), input: :my_input" do
+    module C
+      #:nested-dynamic
+      class Create < Trailblazer::Operation
+        step :create
+        step Nested(:compute_nested), input: ->(ctx, *) {{foo: :bar, seq: ctx[:seq]}}
+        step :save
+
+        def compute_nested(ctx, params:, **)
+          params.is_a?(Hash) ? Validate : JsonValidate
+        end
+
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
+      end
+      #:nested-dynamic end
+
+      class JsonValidate < Validate
+        step :json
+        include T.def_steps(:json)
+      end
+
+    # `edit` and `update` can be called from Nested()
+    end
+
+    C::Create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+    C::Create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
+  end
+
+  it "Nested(:method), with pass_fast returned from nested" do
+    class JustPassFast < Trailblazer::Operation
+      step :just_pass_fast, pass_fast: true
+      include T.def_steps(:just_pass_fast)
+    end
+
+    module D
+
+      create =
+      #:nested-with-pass-fast
+      class Create < Trailblazer::Operation
+
+        def compute_nested(ctx, **)
+          JustPassFast
+        end
+
+        step :create
+        step Nested(:compute_nested)
+        step :save
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
+      end
+      #:nested-with-pass-fast end
+
+      # pass fast
+      create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :just_pass_fast, :save]] >}
+    end
   end
 
   let(:compute_edit) {