trailblazer 2.1.0.beta1 → 2.1.0.beta2

data/CHANGES.md

@@ -29,6 +29,10 @@ document Task API and define step API
 deprecate step->(options) ?
 injectable, per-operation step arguments strategy?
 
+# 2.1.0.beta2
+
+* Simplify `Nested` and several other internals by using the new `Activity` API.
+
 # 2.1.0.beta1
 
 * Add `deprecation/call` and `deprecation/context` that help with the new `call` API and symbols for `options` keys.

data/Gemfile

@@ -14,12 +14,15 @@ gem "dry-auto_inject"
 gem "dry-matcher"
 gem "dry-validation"
 
-gem "trailblazer-operation", path: "../operation"
+# gem "trailblazer-operation", path: "../operation"
 # gem "trailblazer-operation", github: "trailblazer/trailblazer-operation"
 
 gem "minitest-line"
 
-gem "trailblazer-activity", path: "../trailblazer-circuit"
+gem "rubocop", require: false
+# gem "trailblazer-activity", path: "../trailblazer-circuit"
+# gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
+# gem "trailblazer-activity", path: "../trailblazer-circuit"
 # gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 
 # gem "trailblazer-context", path: "../trailblazer-context"

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "rubocop/rake_task"
 
 task :default => [:test]
 
@@ -14,3 +15,5 @@ Rake::TestTask.new(:testdep) do |test|
   test.test_files = FileList["test/deprecation/*_test.rb"]
   test.verbose = true
 end
+
+RuboCop::RakeTask.new

data/lib/trailblazer.rb

@@ -19,3 +19,4 @@ require "trailblazer/operation/nested"
 require "trailblazer/operation/wrap"
 require "trailblazer/operation/rescue"
 require "trailblazer/operation/inject"
+require "trailblazer/operation/input_output"

data/lib/trailblazer/operation/contract.rb

@@ -6,72 +6,77 @@
 #
 # Needs Operation#model.
 # Needs #[], #[]= skill dependency.
-class Trailblazer::Operation
-  module Contract
-    def self.Build(name: "default", constant: nil, builder: nil)
-      step = ->((options, flow_options), **circuit_options) { Build.(options, circuit_options, name: name, constant: constant, builder: builder) }
-
-      task = Trailblazer::Activity::Task::Binary( step )
-
-      { 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
+module Trailblazer
+  class Operation
+    module Contract
+      def self.Build(name: "default", constant: nil, builder: nil)
+        task = ->((options, flow_options), **circuit_options) do
+          result = Build.(options, circuit_options, name: name, constant: constant, builder: builder)
+
+          return Activity::TaskBuilder::Binary.binary_direction_for( result, Activity::Right, Activity::Left ),
+            [options, flow_options]
+        end
+
+        { task: task, id: "contract.build" }
       end
 
-      def self.call_builder(options, circuit_options, builder:raise, constant:raise, name:raise)
-        # builder_options = Trailblazer::Context( options, constant: constant, name: name ) # options.merge( .. )
-
-        # Trailblazer::Option::KW(builder).(builder_options, circuit_options)
+      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)
+          # builder_options = Trailblazer::Context( options, constant: constant, name: name ) # options.merge( .. )
 
+          # Trailblazer::Option::KW(builder).(builder_options, circuit_options)
 
 
 
 
 
-        # FIXME: almost identical with Option::KW.
-        # FIXME: see Nested::Options::Dynamic, the same shit
-        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)
+          # FIXME: almost identical with Option::KW.
+          # FIXME: see Nested::Options::Dynamic, the same shit
+          tmp_options =  options.to_hash.merge(
+            constant: constant,
+            name:     name
+          )
 
-        self[path] = form_class
+          Trailblazer::Option(builder).( options, tmp_options, circuit_options )
+        end
       end
-    end # Contract
+
+      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 # Contract
+    end
   end
 end

data/lib/trailblazer/operation/input_output.rb

@@ -0,0 +1,28 @@
+module Trailblazer
+  # Add an input and output filter for a task, allowing to control what a task "sees"
+  # (receives as input) and returns (or, what the outer caller "sees").
+  #
+  # This works by adding two variable mappers to the taskWrap.
+  # One before the actual task gets called (input) and one before the end (output).
+  module Operation::InputOutput
+  # naming: Macaroni, VariableMapping
+    def self.plan(input, output)
+      default_input_filter  = ->(options, *) { ctx = options }
+      default_output_filter = ->(options, *) { options }
+
+      input  ||= default_input_filter
+      output ||= default_output_filter
+
+      input_filter  = Activity::TaskWrap::Input.new(input)
+      output_filter = Activity::TaskWrap::Output.new(output)
+
+      # taskWrap extensions
+      Module.new do
+        extend Activity::Path::Plan()
+
+        task input_filter,  id: ".input",  before: "task_wrap.call_task"
+        task output_filter, id: ".output", before: "End.success", group: :end # DISCUSS: position
+      end
+    end
+  end
+end

data/lib/trailblazer/operation/model.rb

@@ -2,16 +2,16 @@ class Trailblazer::Operation
   def self.Model(model_class, action=nil)
     # step = Pipetree::Step.new(step, "model.class" => model_class, "model.action" => action)
 
-    task = Railway::TaskBuilder.( Model.new )
+    task = Trailblazer::Activity::TaskBuilder::Binary.( Model.new )
 
-    runner_options = {
-      merge: Wrap::Inject::Defaults(
+    extension = Trailblazer::Activity::TaskWrap::Merge.new(
+      Wrap::Inject::Defaults(
         "model.class"  => model_class,
         "model.action" => action
       )
-    }
+    )
 
-    { task: task, id: "model.build", runner_options: runner_options }
+    { task: task, id: "model.build", extension: [extension] }
   end
 
   class Model

data/lib/trailblazer/operation/nested.rb

@@ -2,43 +2,40 @@
 module Trailblazer
   class Operation
     def self.Nested(callable, input:nil, output:nil, id: "Nested(#{callable})")
-      task_wrap_wirings = []
-      task, operation = Nested.build(callable, input, output)
-
-      # @needs operation#outputs
-
-      # TODO: move this to the generic step DSL
-      task_wrap_extensions = []
-
-      if input || output
-        default_input_filter  = ->(options, *) { ctx = options }
-        default_output_filter = ->(options, *) { options }
+      task_wrap_extensions        = Module.new do
+        extend Activity::Path::Plan()
+      end
 
-        input  ||= default_input_filter
-        output ||= default_output_filter
+      task, operation, is_dynamic = Nested.build(callable)
 
-        input_filter  = Activity::Wrap::Input.new(input)
-        output_filter = Activity::Wrap::Output.new(output)
+      if input || output # TODO: move this to the generic step DSL
+        task_wrap_extensions = InputOutput.plan( input, output )
+      end
 
-        task_wrap_extensions = Activity::Magnetic::Builder::Path.plan do
-          task input_filter,  id: ".input",  before: "task_wrap.call_task"
-          task output_filter, id: ".output", before: "End.success", group: :end # DISCUSS: position
-        end
+      if is_dynamic
+        # task_wrap_extensions += Activity::Magnetic::Builder::Path.plan do
+          task_wrap_extensions.task task.method(:compute_nested_activity), id: ".compute_nested_activity",  after: "Start.default", group: :start
+          task_wrap_extensions.task task.method(:compute_return_signal),   id: ".compute_return_signal",    after: "task_wrap.call_task"
+        # end
       end
-        # Default {Output} copies the mutable data from the nested activity into the original.
 
-      { task: task, id: id, runner_options: { merge: task_wrap_extensions }, plus_poles: Activity::Magnetic::DSL::PlusPoles.from_outputs(operation.outputs) }
+      {
+        task:           task,
+        id:             id,
+        extension:      [ Trailblazer::Activity::TaskWrap::Merge.new(task_wrap_extensions) ],
+        plus_poles:     Activity::Magnetic::DSL::PlusPoles.from_outputs(operation.outputs) # @needs operation#outputs
+      }
     end
 
     # @private
     module Nested
-      def self.build(nested_operation, input, output) # DISCUSS: use builders here?
-        return dynamic = Dynamic.new(nested_operation), dynamic unless nestable_object?(nested_operation)
+      def self.build(nested_operation) # DISCUSS: use builders here?
+        return dynamic = Dynamic.new(nested_operation), dynamic, true unless nestable_object?(nested_operation)
 
         # The returned {Nested} instance is a valid circuit element and will be `call`ed in the circuit.
         # It simply returns the nested activity's `signal,options,flow_options` return set.
         # The actual wiring - where to go with that - is done by the step DSL.
-        return Trailblazer::Activity::Subprocess(nested_operation, call: :__call__), nested_operation
+        return Trailblazer::Activity::Subprocess(nested_operation, call: :__call__), nested_operation, false
       end
 
       def self.nestable_object?(object)
@@ -56,9 +53,9 @@ module Trailblazer
       #
       # This is what {Nested} in 2.0 used to do, where the outcome could only be true/false (or success/failure).
       class Dynamic
-        def initialize(wrapped)
-          @wrapped = Trailblazer::Option::KW(wrapped)
-          @outputs = {
+        def initialize(nested_activity)
+          @nested_activity = Trailblazer::Option::KW(nested_activity)
+          @outputs         = {
             :success => Activity::Output( Railway::End::Success.new(:success), :success ),
             :failure => Activity::Output( Railway::End::Failure.new(:failure), :failure ),
           }
@@ -66,17 +63,26 @@ module Trailblazer
 
         attr_reader :outputs
 
-        def call( (options, flow_options), **circuit_options )
-          activity = @wrapped.(options, circuit_options) # evaluate the option to get the actual "object" to call.
+        # TaskWrap step.
+        def compute_nested_activity( (wrap_ctx, original_args), **circuit_options )
+          (ctx, _), original_circuit_options = original_args
+
+          activity = @nested_activity.( ctx, original_circuit_options ) # evaluate the option to get the actual "object" to call.
 
-          signal, args = activity.__call__( [options, flow_options], **circuit_options )
+          # overwrite :task so task_wrap.call_task will call this activity. This is a trick so we don't have to repeat
+          # logic from #call_task here.
+          wrap_ctx[:task] = Trailblazer::Activity::Subprocess( activity, call: :__call__ )
 
+          return Activity::Right, [ wrap_ctx, original_args ]
+        end
+
+        def compute_return_signal( (wrap_ctx, original_args), **circuit_options )
           # Translate the genuine nested signal to the generic Dynamic end (success/failure, only).
           # Note that here we lose information about what specific event was emitted.
-          [
-            signal.kind_of?(Railway::End::Success) ? @outputs[:success].signal : @outputs[:failure].signal,
-            args
-          ]
+          wrap_ctx[:return_signal] = wrap_ctx[:return_signal].kind_of?(Railway::End::Success) ?
+            @outputs[:success].signal : @outputs[:failure].signal
+
+          return Activity::Right, [ wrap_ctx, original_args ]
         end
       end
     end

data/lib/trailblazer/operation/persist.rb

@@ -1,12 +1,14 @@
-class Trailblazer::Operation
-  module Contract
-    def self.Persist(method: :save, name: "default")
-      path = "contract.#{name}"
-      step = ->(options, **) { options[path].send(method) }
+module Trailblazer
+  class Operation
+    module Contract
+      def self.Persist(method: :save, name: "default")
+        path = "contract.#{name}"
+        step = ->(options, **) { options[path].send(method) }
 
-      task = Railway::TaskBuilder.( step )
+        task = Activity::TaskBuilder::Binary.( step )
 
-      { task: task, id: "persist.save" }
+        { task: task, id: "persist.save" }
+      end
     end
   end
 end

data/lib/trailblazer/operation/policy.rb

@@ -32,13 +32,13 @@ class Trailblazer::Operation
 
       task = Eval.new( name: name, path: path )
 
-      runner_options = {
-        merge: Trailblazer::Operation::Wrap::Inject::Defaults(
+      extension = Trailblazer::Activity::TaskWrap::Merge.new(
+        Trailblazer::Operation::Wrap::Inject::Defaults(
           path => condition
         )
-      }
+      )
 
-      { task: task, id: path, runner_options: runner_options }
+      { task: task, id: path, extension: [extension] }
     end
   end
 end

data/lib/trailblazer/operation/validate.rb

@@ -1,75 +1,74 @@
-class Trailblazer::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) # DISCUSS: should we introduce something like Validate::Deserializer?
-      params_path = "contract.#{name}.params" # extract_params! save extracted params here.
+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) # 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 ).freeze
+        extract  = Validate::Extract.new( key: key, params_path: params_path ).freeze
+        validate = Validate.new( name: name, representer: representer, params_path: params_path ).freeze
 
-      # Return the Validate::Call task if the first step, the params extraction, is not desired.
-      if skip_extract || representer
-        return { task: Trailblazer::Activity::Task::Binary( validate ), id: "contract.#{name}.call" }
-      end
+        # Build a simple Railway {Activity} for the internal flow.
+        activity = Module.new do
+          extend Activity::Railway()
+
+          step extract,  id: "#{params_path}_extract" unless skip_extract || representer
+          step validate, id: "contract.#{name}.call"
+        end
 
+        # activity, _ = activity.decompose
 
-      # Build a simple Railway {Activity} for the internal flow.
-      activity = Trailblazer::Activity::Railway.build do # FIXME: make Activity.build(builder: Railway) do end an <Activity>
-        step Trailblazer::Activity::Task::Binary( extract ),  id: "#{params_path}_extract"
-        step Trailblazer::Activity::Task::Binary( validate ), id: "contract.#{name}.call"
+        # DISCUSS: use Nested here?
+        { task: activity, id: "contract.#{name}.validate", plus_poles: Activity::Magnetic::DSL::PlusPoles.from_outputs(activity.outputs) }
       end
 
-      # DISCUSS: use Nested here?
-      # Nested.operation_class.Nested( activity, id: "contract.#{name}.validate" )
-      { task: activity, id: "contract.#{name}.validate", plus_poles: Trailblazer::Activity::Magnetic::DSL::PlusPoles.from_outputs(activity.outputs) }
-    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
 
-    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
+          def call( ctx, params:, ** )
+            ctx[@params_path] = @key ? params[@key] : params
+          end
         end
 
-        def call( (options, flow_options), **circuit_options )
-          options[@params_path] = @key ? options[:params][@key] : options[:params]
+        def initialize(name:"default", representer:false, params_path:nil)
+          @name, @representer, @params_path = name, representer, params_path
         end
-      end
 
-      def initialize(name:"default", representer:false, params_path:nil)
-        @name, @representer, @params_path = name, representer, params_path
-      end
-
-      # Task: Validates contract `:name`.
-      def call( (options, flow_options), **circuit_options )
-        validate!(
-          options,
-          representer: options["representer.#{@name}.class"] ||= @representer, # FIXME: maybe @representer should use DI.
-          params_path: @params_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!(options, representer:false, from: :document, params_path:nil)
-        path     = "contract.#{@name}"
-        contract = options[path]
+        def validate!(options, representer:false, from: :document, params_path:nil)
+          path     = "contract.#{@name}"
+          contract = 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
+          # 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?
+          result.success?
+        end
       end
     end
-  end
+  end # Operation
 end