trailblazer 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 239150501ea57b15601c6e0a79ea03f383b0a0c8
-  data.tar.gz: 8bae46c25cd0f90ca228020c9e0344ddfb0bcaea
+  metadata.gz: a1f0c47cf26109508aa2f58b38a69f0a4b5f9b07
+  data.tar.gz: 98cddf35489a1ea61a95e01237d459682d9ab3df
 SHA512:
-  metadata.gz: a347bb971628f17168ba9d4ba826939da82d0a5bc536e837bbc97a413e64244526ac65de1be1c3da3e9054a5b2acd98e5481cca542aebca35c272e87af3e7629
-  data.tar.gz: a9fd02ed273e2ab581a053b1b3772a1035cef6e2e8f7f9810f0d7d32112c41c335bbae1e928547d4601f66378f59ac30c42a69b2b8ec5f2d07843399867883fa
+  metadata.gz: 60ef0796bcfa0c12255595c47b514f4a0cbfbac1d90091172459cd4a23b7250d444bff6ecb90d74504c216bebca893bab5cfbe6643d9779ecddd0f7bfc093f2f
+  data.tar.gz: 212e3134780b3146cd25e713b5b83beadd4219f291a772e31cdcb766b745fd334ec765b01f70b085c9fa999ca0e062ae7cff88064a86b65139e73d257241f2d2

data/CHANGES.md

@@ -1,3 +1,10 @@
+# 2.0.3
+
+* `Guard` now allows kw args for its option.
+* Fix a bug where `Nested( ->{} )` wouldn't `_call` the nested operation and did too much work on re-nested the already nested params. Thanks to @eliranf for spotting this.
+* Add `Nested(..., input: )` to dynamically decide the input to the nested operation. http://trailblazer.to/gems/operation/2.0/api.html#nested-input
+* Add `Nested(..., output: )`: http://localhost:4000/gems/operation/2.0/api.html#nested-output
+
 # 2.0.2
 
 * Remove `uber` dependency as we use our own `Option::KW` now.

data/lib/trailblazer/operation/guard.rb

@@ -8,7 +8,7 @@ class Trailblazer::Operation
 
     module Guard
       def self.build(callable)
-        value = Option.(callable) # Operation::Option
+        value = Option::KW.(callable) # Operation::Option
 
         # this gets wrapped in a Operation::Result object.
         ->(input, options) { Result.new( !!value.(input, options), {} ) }

data/lib/trailblazer/operation/nested.rb

@@ -1,32 +1,107 @@
 class Trailblazer::Operation
-  def self.Nested(step)
-    step = Nested.for(step)
+  def self.Nested(step, input:nil, output:nil)
+    step = Nested.for(step, input, output)
 
-    [ step, {} ]
+    [ step, { name: "Nested(#{step})" } ]
   end
 
-  module Nested
-    def self.proc_for(step)
-      if step.is_a?(Class) && step <= Trailblazer::Operation # interestingly, with < we get a weird nil exception. bug in Ruby?
-        proc = ->(input, options) { step._call(*options.to_runtime_data) }
-      else
-        option = Option::KW.(step)
-        proc = ->(input, options) { option.(input, options).(*options.to_runtime_data) }
+  # WARNING: this is experimental API, but it will end up with something like that.
+  module Element
+    # DISCUSS: add builders here.
+    def initialize(wrapped=nil)
+      @wrapped = wrapped
+    end
+
+    module Dynamic
+      def initialize(wrapped)
+        @wrapped = Option::KW.(wrapped)
       end
     end
+  end
 
+  module Nested
     # Please note that the instance_variable_get are here on purpose since the
     # superinternal API is not entirely decided, yet.
-    def self.for(step)
-      proc = proc_for(step)
+    def self.for(step, input, output) # DISCUSS: use builders here?
+      invoker            = Caller::Dynamic.new(step)
+      invoker            = Caller.new(step) if step.is_a?(Class) && step <= Trailblazer::Operation # interestingly, with < we get a weird nil exception. bug in Ruby?
+
+      options_for_nested = Options.new
+      options_for_nested = Options::Dynamic.new(input) if input
+
+      options_for_composer = Options::Output.new
+      options_for_composer = Options::Output::Dynamic.new(output) if output
+
+      # This lambda is the strut added on the track, executed at runtime.
+      ->(operation, options) do
+        result = invoker.(operation, options, options_for_nested.(operation, options)) # TODO: what about containers?
 
-      ->(input, options) do
-        result = proc.(input, options) # TODO: what about containers?
+        options_for_composer.(operation, options, result).each { |k,v| options[k] = v }
 
-        result.instance_variable_get(:@data).to_mutable_data.each { |k,v| options[k] = v }
         result.success? # DISCUSS: what if we could simply return the result object here?
       end
     end
+
+    # Is executed at runtime and calls the nested operation.
+    class Caller
+      include Element
+
+      def call(input, options, options_for_nested)
+        call_nested(nested(input, options), options_for_nested)
+      end
+
+    private
+      def call_nested(operation, options)
+        operation._call(options)
+      end
+
+      def nested(*); @wrapped end
+
+      class Dynamic < Caller
+        include Element::Dynamic
+
+        def nested(input, options)
+          @wrapped.(input, options)
+        end
+      end
+    end
+
+    class Options
+      include Element
+
+      # Per default, only runtime data for nested operation.
+      def call(input, options)
+        options.to_runtime_data[0]
+      end
+
+      class Dynamic
+        include Element::Dynamic
+
+        def call(operation, options)
+          @wrapped.(operation, options, runtime_data: options.to_runtime_data[0], mutable_data: options.to_mutable_data )
+        end
+      end
+
+      class Output
+        include Element
+
+        def call(input, options, result)
+          mutable_data_for(result).each { |k,v| options[k] = v }
+        end
+
+        def mutable_data_for(result)
+          result.instance_variable_get(:@data).to_mutable_data
+        end
+
+        class Dynamic < Output
+          include Element::Dynamic
+
+          def call(input, options, result)
+            @wrapped.(input, options, mutable_data: mutable_data_for(result))
+          end
+        end
+      end
+    end
   end
 end
 

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

data/test/docs/guard_test.rb

@@ -3,11 +3,21 @@ require "test_helper"
 #--
 # with proc
 class DocsGuardProcTest < Minitest::Spec
+  # test without KWs, only options.
+  class Update < Trailblazer::Operation
+    step Policy::Guard( ->(options) { options["params"][:pass] } )
+    step ->(options, *) { options["x"] = true }
+  end
+
+  it { Update.(pass: false)["x"].must_equal nil }
+  it { Update.(pass: true)["x"].must_equal true }
+  # TODO: test excp when current_user not available
+
   #:proc
   class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["params"][:pass] } )
-    step :process
+    step Policy::Guard( ->(options, params:, **) { params[:pass] } )
     #~pipeonly
+    step :process
 
     def process(*)
       self["x"] = true
@@ -29,7 +39,7 @@ class DocsGuardProcTest < Minitest::Spec
    #---
   #- Guard inheritance
   class New < Create
-    step Policy::Guard( ->(options) { options["current_user"] } ), override: true
+    step Policy::Guard( ->(options, current_user:, **) { current_user } ), override: true
   end
 
   it { New["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>process]} }
@@ -42,8 +52,8 @@ class DocsGuardTest < Minitest::Spec
   class MyGuard
     include Uber::Callable
 
-    def call(options)
-      options["params"][:pass]
+    def call(options, params:, **)
+      params[:pass]
     end
   end
   #:callable end
@@ -51,8 +61,8 @@ class DocsGuardTest < Minitest::Spec
   #:callable-op
   class Create < Trailblazer::Operation
     step Policy::Guard( MyGuard.new )
-    step :process
     #~pipe-only
+    step :process
     def process(*); self[:x] = true; end
     #~pipe-only end
   end
@@ -68,11 +78,14 @@ class DocsGuardMethodTest < Minitest::Spec
   #:method
   class Create < Trailblazer::Operation
     step Policy::Guard( :pass? )
+
+    def pass?(options, params:, **)
+      params[:pass]
+    end
+    #~pipe-onlyy
     step :process
-    #~pipe-only
-    def pass?(options, *); options["params"][:pass] end
     def process(*); self["x"] = true; end
-    #~pipe-only end
+    #~pipe-onlyy end
   end
   #:method end
 
@@ -85,12 +98,12 @@ end
 class DocsGuardNamedTest < Minitest::Spec
   #:name
   class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["current_user"] }, name: :user )
+    step Policy::Guard( ->(options, current_user:, **) { current_user }, name: :user )
     # ...
   end
   #:name end
 
-  it { Create.()["result.policy.user"].success?.must_equal false }
+  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 {
@@ -101,30 +114,12 @@ class DocsGuardNamedTest < Minitest::Spec
   }
 end
 
-#---
-# class-level guard
-class DocsGuardClassLevelTest < Minitest::Spec
-  #:class-level
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["current_user"] == Module } ),
-      before: "operation.new"
-    #~pipe--only
-    step ->(options) { options["x"] = true }
-    #~pipe--only end
-  end
-  #:class-level end
-
-  it { Create.(); Create["result.policy"].must_equal nil }
-  it { Create.({}, "current_user" => Module)["x"].must_equal true }
-  it { Create.({}                          )["x"].must_equal nil }
-end
-
 #---
 # dependency injection
 class DocsGuardInjectionTest < Minitest::Spec
   #:di-op
   class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["current_user"] == Module } )
+    step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
   end
   #:di-op end
 
@@ -140,6 +135,35 @@ class DocsGuardInjectionTest < Minitest::Spec
     result.inspect("").must_equal %{<Result:false [nil] >} }
 end
 
+#---
+# missing current_user throws exception
+class DocsGuardMissingKeywordTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
+  end
+
+  it { assert_raises(ArgumentError) { Create.() } }
+  it { Create.({}, "current_user" => Module).success?.must_equal true }
+end
 
-# TODO:
-#policy.default
+#---
+# before:
+class DocsGuardPositionTest < Minitest::Spec
+  #:before
+  class Create < Trailblazer::Operation
+    step :model!
+    step Policy::Guard( :authorize! ),
+      before: :model!
+  end
+  #:before end
+
+  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>model!]} }
+  it do
+    #:before-pipe
+      puts Create["pipetree"].inspect(style: :rows) #=>
+       # 0 ========================>operation.new
+       # 1 ==================>policy.default.eval
+       # 2 ===============================>model!
+    #:before-pipe end
+  end
+end

data/test/docs/nested_test.rb

@@ -71,6 +71,7 @@ class DocsNestedOperationTest < Minitest::Spec
     Update.(id: 2).inspect("model").must_equal %{<Result:false [nil] >}
   end
 
+  #---
   #- shared data
   class B < Trailblazer::Operation
     success ->(options) { options["can.B.see.it?"] = options["this.should.not.be.visible.in.B"] }
@@ -82,7 +83,7 @@ class DocsNestedOperationTest < Minitest::Spec
     self["A.class.data"] = true
 
     success ->(options) { options["this.should.not.be.visible.in.B"] = true }
-    step Nested B
+    step Nested( B )
   end
 
   # mutual data from A doesn't bleed into B.
@@ -97,6 +98,103 @@ class DocsNestedOperationTest < Minitest::Spec
   # cr_result = Create.({}, "result" => result)
   # puts cr_result["model"]
   # puts cr_result["contract.default"]
+
+  #---
+  #- Nested( .., input: )
+  class C < Trailblazer::Operation
+    self["C.class.data"] = true
+
+    success ->(options) { options["this.should.not.be.visible.in.B"] = true }
+
+    step Nested( B, input: ->(options, runtime_data:, mutable_data:, **) {
+      runtime_data.merge( "this.should.not.be.visible.in.B" => mutable_data["this.should.not.be.visible.in.B"] )
+    } )
+  end
+
+  it { C.()["can.B.see.it?"].must_equal true }
+  it { C.()["this.should.not.be.visible.in.B"].must_equal true } # this IS visible since we use :input!
+  it { C.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
+  it { C.()["can.B.see.A.class.data?"].must_equal nil }
+end
+
+class NestedInput < Minitest::Spec
+  #:input-multiply
+  class Multiplier < Trailblazer::Operation
+    step ->(options, x:, y:, **) { options["product"] = x*y }
+  end
+  #:input-multiply end
+
+  #:input-pi
+  class MultiplyByPi < Trailblazer::Operation
+    step ->(options) { options["pi_constant"] = 3.14159 }
+    step Nested( Multiplier, input: ->(options, mutable_data:, runtime_data:, **) do
+      { "y" => mutable_data["pi_constant"],
+        "x" => runtime_data["x"] }
+    end )
+  end
+  #:input-pi end
+
+  it { MultiplyByPi.({}, "x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
+
+  it do
+    #:input-result
+    result = MultiplyByPi.({}, "x" => 9)
+    result["product"] #=> [28.27431]
+    #:input-result end
+  end
+end
+
+class NestedInputCallable < Minitest::Spec
+  Multiplier = NestedInput::Multiplier
+
+  #:input-callable
+  class MyInput
+    extend Uber::Callable
+
+    def self.call(options, mutable_data:, runtime_data:, **)
+      {
+        "y" => mutable_data["pi_constant"],
+        "x" => runtime_data["x"]
+      }
+    end
+  end
+  #:input-callable end
+
+  #:input-callable-op
+  class MultiplyByPi < Trailblazer::Operation
+    step ->(options) { options["pi_constant"] = 3.14159 }
+    step Nested( Multiplier, input: MyInput )
+  end
+  #:input-callable-op end
+
+  it { MultiplyByPi.({}, "x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
+end
+
+#---
+#- Nested( .., output: )
+class NestedOutput < Minitest::Spec
+  Edit = DocsNestedOperationTest::Edit
+
+  #:output
+  class Update < Trailblazer::Operation
+    step Nested( Edit, output: ->(options, mutable_data:, **) do
+      {
+        "contract.my" => mutable_data["contract.default"],
+        "model"       => mutable_data["model"]
+      }
+    end )
+    step Contract::Validate( name: "my" )
+    step Contract::Persist( method: :sync, name: "my" )
+  end
+  #:output end
+
+  it { Update.( id: 1, title: "Call It A Night" ).inspect("model", "contract.default").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">, nil] >} }
+
+  it do
+    result = Update.( id: 1, title: "Call It A Night" )
+
+    result["model"]            #=> #<Song id=1 , title=\"Call It A Night\">
+  end
 end
 
 class NestedClassLevelTest < Minitest::Spec
@@ -107,7 +205,7 @@ class NestedClassLevelTest < Minitest::Spec
   end
 
   class Create < Trailblazer::Operation
-    step Nested New
+    step Nested( New )
     step ->(options) { options["y"] = true }
   end
   #:class-level end
@@ -116,10 +214,13 @@ class NestedClassLevelTest < Minitest::Spec
   it { Create.(); Create["class"].must_equal nil }
 end
 
+#---
+# Nested( ->{} )
 class NestedWithCallableTest < Minitest::Spec
   Song = Struct.new(:id, :title)
 
   class X < Trailblazer::Operation
+    step ->(options, params:, **) { options["params.original"] = params }
     step ->(options) { options["x"] = true }
   end
 
@@ -132,7 +233,7 @@ class NestedWithCallableTest < Minitest::Spec
     step Nested( ->(options, *) { options["class"] } )
   end
 
-  it { A.({}, "class" => X).inspect("x", "y", "z").must_equal "<Result:true [true, nil, true] >" }
+  it { A.({ a: 1 }, "class" => X).inspect("x", "y", "z", "params.original").must_equal "<Result:true [true, nil, true, {:a=>1}] >" }
   it { A.({}, "class" => Y).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
   # it { Create.({}).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
 
@@ -177,6 +278,7 @@ class NestedWithCallableTest < Minitest::Spec
   it { Create.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
   it { Create.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
 
+  #---
   #:method
   class Update < Trailblazer::Operation
     step Nested( :build! )
@@ -190,6 +292,7 @@ class NestedWithCallableTest < Minitest::Spec
   it { Update.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
   it { Update.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
 
+  #---
   #:callable-builder
   class MyBuilder
     extend Uber::Callable

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-21 00:00:00.000000000 Z
+date: 2017-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation