trailblazer-activity 0.12.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64e6b7c70557dea00024b9e16b1d85ee3046589a5b759028a2178cdd6da99231
-  data.tar.gz: 2283d2744d77ca89de067f1a368c98ddc60b4e4ca39337b59066d35f642a7c65
+  metadata.gz: 36888239a75b308074977ecb9637e421940f63a53fdafbadb5a65106152fc550
+  data.tar.gz: 3aff2a8fb3da591b98f72f387555791c8273dc02968b68a5f4eb8d59a69f7e45
 SHA512:
-  metadata.gz: c9a1c011210c61b7e1ae55df77d003e4029160968093b3c71c73ccd65e460bdb911a97a016b7c524f9d3806074816f195a85f8e4e66b67245f670d7c69650417
-  data.tar.gz: cc45abe8914b199fa98e31e0e6e9e9b9582e4e097c296f3407f3e365851813a632eb45133f37bf95c71212c08c15e0deafc723d952d1f00bf6e8087035bd07cd
+  metadata.gz: bffee75027f1af8e1dd87487f07505bc5e8238e62eb67ffc1a128f90fbaeb5d4feadcbac2294991ef69febd71245292dd39128fd52e78bba11a9be8afce1cdf9
+  data.tar.gz: 8ac7bc2b36e8db2349134ce935d1da0881a749c881dca6703c1ed192862d526a734de5da8c956f59b60293300f3dd3fabb05c0e21fbd5187cf2a53b09992c368

data/CHANGES.md

@@ -1,3 +1,11 @@
+# 0.13.0
+
+* Removed `TaskWrap::Inject::Defaults`. This is now implemented through `dsl`'s `:inject` option.
+* Removed `TaskWrap::VariableMapping.Extension`.
+* Renamed private `TaskWrap::VariableMapping.merge_for` to `.merge_instructions_for` as there's no {Merge} instance, yet.
+* Extract invocation logic in `TaskBuilder::Task` into `Task#call_option`.
+* Add `TaskWrap::Pipeline::prepend`.
+
 # 0.12.2
 
 * Use extracted `trailblazer-option`.

data/README.md

@@ -2,15 +2,15 @@
 
 Implements Intermediate, Implementation and compiler
 
-The `activity` gem brings a light-weight DSL to define business processes, and the runtime logic to run those activities.
+The `activity` gem implements the runtime logic to invoke a new abstraction called "activities". Ideally, activities are defined using the [`dsl-linear` DSL gem](https://github.com/trailblazer/trailblazer-activity-dsl-linear).
 
 A process is a set of arbitrary pieces of logic you define, chained together and put into a meaningful context by an activity. Activity lets you focus on the implementation of steps while Trailblazer takes care of the control flow.
 
-Please find the [full documentation on the Trailblazer website](https://2019.trailblazer.to/2.1/docs/activity.html). [Note that the docs are WIP.]
+Please find the [full documentation on the Trailblazer website](https://trailblazer.to/2.1/docs/activity.html).
 
 ## Example
 
-In conjunction with [`dsl-linear`](https://github.com/trailblazer/trailblazer-activity-dsl-linear), the `activity` gem provides three default patterns to model processes: `Path`, `Railway` and `FastTrack`. Here's an example of what a railway activity could look like, along with some more complex connections (you can read more about Railway strategy in the [docs](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)).
+In conjunction with [`dsl-linear`](https://github.com/trailblazer/trailblazer-activity-dsl-linear), the `activity` gem provides three default patterns to model processes: `Path`, `Railway` and `FastTrack`. Here's an example of what a railway activity could look like, along with some more complex connections (you can read more about Railway strategy in the [docs](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)).
 
 ```ruby
 require "trailblazer-activity"
@@ -78,15 +78,15 @@ With Activity, modeling business processes turns out to be ridiculously simple:
 
 ## Operation
 
-Trailblazer's [`Operation`](https://2019.trailblazer.to/2.1/docs/operation.html#operation-overview) internally uses an activity to model the processes.
+Trailblazer's [`Operation`](https://trailblazer.to/2.1/docs/operation.html#operation-overview) internally uses an activity to model the processes.
 
 ## Workflow
-Activities can be formed into bigger compounds and using workflow, you can build long-running processes such as a moderated blog post or a parcel delivery. Also, you don't have to use the DSL but can use the [`editor`](https://2019.trailblazer.to/2.1/docs/pro.html#pro-editor)instead(cool for more complex, long-running flows). Here comes a sample screenshot.
+Activities can be formed into bigger compounds and using workflow, you can build long-running processes such as a moderated blog post or a parcel delivery. Also, you don't have to use the DSL but can use the [`editor`](https://trailblazer.to/2.1/docs/pro.html#pro-editor)instead(cool for more complex, long-running flows). Here comes a sample screenshot.
 
-<img src="http://2019.trailblazer.to/2.1/dist/img/flow.png">
+<img src="http://trailblazer.to/2.1/dist/img/flow.png">
 
 ## License
 
 © Copyright 2018, Trailblazer GmbH
 
-Licensed under the LGPLv3 license. We also offer a commercial-friendly [license](https://2019.trailblazer.to/2.1/docs/pro.html#pro-license).
+Licensed under the LGPLv3 license. We also offer a commercial-friendly [license](https://trailblazer.to/2.1/docs/pro.html#pro-license).

data/lib/trailblazer/activity/task_builder.rb

@@ -18,17 +18,20 @@ module Trailblazer
       end
     end
 
+    # Wraps a {task} (that usually expects the task interface) into a circuit interface
+    # that can be used directly in a {Circuit}.
+    # We expect {task} to be exposing an {Option()} interface when calling it.
     class Task
       def initialize(task, user_proc)
         @task            = task
         @user_proc       = user_proc
-
         freeze
       end
 
-      def call( (ctx, flow_options), **circuit_options )
+      def call((ctx, flow_options), **circuit_options)
         # Execute the user step with TRB's kw args.
-        result = @task.(ctx, keyword_arguments: ctx.to_hash, **circuit_options) # circuit_options contains :exec_context.
+        # {@task} is/implements {Trailblazer::Option} interface.
+        result = call_option(@task, [ctx, flow_options], **circuit_options)
 
         # Return an appropriate signal which direction to go next.
         signal = Activity::TaskBuilder.binary_signal_for(result, Activity::Right, Activity::Left)
@@ -36,6 +39,11 @@ module Trailblazer
         return signal, [ctx, flow_options]
       end
 
+      # Invoke the original {user_proc} that is wrapped in an {Option()}.
+      private def call_option(task_with_option_interface, (ctx, _flow_options), **circuit_options)
+        task_with_option_interface.(ctx, keyword_arguments: ctx.to_hash, **circuit_options) # circuit_options contains :exec_context.
+      end
+
       def inspect # TODO: make me private!
         %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=#{Trailblazer::Activity::Introspect.render_task(@user_proc)}>}
       end

data/lib/trailblazer/activity/task_wrap/pipeline.rb

@@ -17,7 +17,7 @@ class Trailblazer::Activity
       attr_reader :sequence
 
       def self.insert_before(pipe, before_id, insertion)
-        index = pipe.sequence.find_index { |(id, _)| id == before_id }
+        index = find_index(pipe, before_id)
 
         seq = pipe.sequence.dup
 
@@ -25,18 +25,32 @@ class Trailblazer::Activity
       end
 
       def self.insert_after(pipe, after_id, insertion)
-        index = pipe.sequence.find_index { |(id, _)| id == after_id }
+        index = find_index(pipe, after_id)
 
         seq = pipe.sequence.dup
 
         Pipeline.new(seq.insert(index+1, insertion))
       end
 
-      def self.append(pipe, _, insertion) # TODO: test me.
+      def self.append(pipe, _, insertion)
         Pipeline.new(pipe.sequence + [insertion])
       end
 
-      # Merges {extension_rows} into the {task_wrap_pipeline}.
+      def self.prepend(pipe, insertion_id, insertion, replace: 0)
+        return Pipeline.new(insertion.to_a + pipe.sequence) if insertion_id.nil?
+
+        index = find_index(pipe, insertion_id)
+
+        Pipeline.new(pipe.sequence[0..index-1] + insertion.to_a + pipe.sequence[index+replace..-1])
+      end
+
+      # @private
+      def self.find_index(pipe, id)
+        index = pipe.sequence.find_index { |(seq_id, _)| seq_id == id }
+      end
+
+
+      # Merges {extension_rows} into the {Pipeline} instance.
       # This is usually used in step extensions or at runtime for {wrap_runtime}.
       #
       # {Extension} API

data/lib/trailblazer/activity/task_wrap/variable_mapping.rb

@@ -5,17 +5,11 @@ class Trailblazer::Activity
     # translate them into a {DSL::Extension}.
     #
     # Note that the two options are not the only way to create filters, you can use the
-    # more low-level {Scoped()} etc., too, and write your own filter logic.
+    # more low-level {Scoped()} from the `dsl` gem, too, and write your own filter logic.
     module VariableMapping
-      # The taskWrap extension that's included into the static taskWrap for a task.
-      def self.Extension(input, output, id: input.object_id)
-        Trailblazer::Activity::TaskWrap::Extension(
-          merge: merge_for(input, output, id: id),
-        )
-      end
-
-      # DISCUSS: do we want the automatic wrapping of {input} and {output}?
-      def self.merge_for(input, output, id:) # TODO: rename
+      # Places filters before/after the {call_task}.
+      # Note that {input} and {output} are automatically wrapped.
+      def self.merge_instructions_for(input, output, id:)
         [
           [TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["task_wrap.input", TaskWrap::Input.new(input, id: id)]],
           [TaskWrap::Pipeline.method(:insert_after),  "task_wrap.call_task", ["task_wrap.output", TaskWrap::Output.new(output, id: id)]],
@@ -37,9 +31,10 @@ class Trailblazer::Activity
         @id     = id
       end
 
-      # {input.call()} is invoked in the circuit.
-      # `original_args` are the actual args passed to the wrapped task: [ [ctx, ..], circuit_options ]
-      #
+      # {input.call()} is invoked in the taskWrap pipeline.
+      # {original_args} are the actual args passed to the wrapped task: [ [ctx, ..], circuit_options ]
+      # We now swap the ctx in {original_args} and our filtered one. The original "outside" ctx is keyed in
+      # {wrap_ctx} with the filter ID.
       def call(wrap_ctx, original_args)
         # let user compute new ctx for the wrapped task.
         input_ctx = apply_filter(*original_args)
@@ -71,9 +66,7 @@ class Trailblazer::Activity
 
       # Runs your filter and replaces the ctx in `wrap_ctx[:return_args]` with the filtered one.
       def call(wrap_ctx, original_args)
-        (original_ctx, original_flow_options), original_circuit_options = original_args
-
-        return_args = wrap_ctx[:return_args]
+        (original_ctx, _original_flow_options), original_circuit_options = original_args
 
         returned_ctx, returned_flow_options = wrap_ctx[:return_args]  # this is the Context returned from {call}ing the wrapped user task.
         original_ctx                        = wrap_ctx[@id]           # grab the original ctx from before which was set in the {:input} filter.

data/lib/trailblazer/activity/task_wrap.rb

@@ -14,7 +14,8 @@ module Trailblazer
 
       # Compute runtime arguments necessary to execute a taskWrap per task of the activity.
       # This method is the top-level entry, called only once for the entire activity graph.
-      def invoke(activity, args, wrap_runtime: {}, wrap_static: initial_wrap_static, **circuit_options)
+      # [:wrap_static] The taskWrap used for the topmost activity/operation.
+      def invoke(activity, args, wrap_runtime: {}, wrap_static: initial_wrap_static, **circuit_options) # FIXME: why do we need this method?
         circuit_options = circuit_options.merge(
           runner:       TaskWrap::Runner,
           wrap_runtime: wrap_runtime,
@@ -24,7 +25,7 @@ module Trailblazer
         )
 
         # signal, (ctx, flow), circuit_options =
-        Runner.(activity, args, **circuit_options)
+        TaskWrap::Runner.(activity, args, **circuit_options)
       end
 
       # {:extension} API
@@ -62,4 +63,3 @@ require "trailblazer/activity/task_wrap/pipeline"
 require "trailblazer/activity/task_wrap/call_task"
 require "trailblazer/activity/task_wrap/runner"
 require "trailblazer/activity/task_wrap/variable_mapping"
-require "trailblazer/activity/task_wrap/inject"

data/lib/trailblazer/activity/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Activity
-      VERSION = '0.12.2'.freeze
+      VERSION = '0.13.0'.freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Nick Sutterer
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-12 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-context
@@ -108,7 +108,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.7
-description:
+description: 
 email:
 - apotonick@gmail.com
 executables: []
@@ -135,7 +135,6 @@ files:
 - lib/trailblazer/activity/task_builder.rb
 - lib/trailblazer/activity/task_wrap.rb
 - lib/trailblazer/activity/task_wrap/call_task.rb
-- lib/trailblazer/activity/task_wrap/inject.rb
 - lib/trailblazer/activity/task_wrap/pipeline.rb
 - lib/trailblazer/activity/task_wrap/runner.rb
 - lib/trailblazer/activity/task_wrap/variable_mapping.rb
@@ -146,7 +145,7 @@ homepage: http://trailblazer.to
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -161,8 +160,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: Runtime code for Trailblazer activities.
 test_files: []

data/lib/trailblazer/activity/task_wrap/inject.rb

@@ -1,39 +0,0 @@
-class Trailblazer::Activity
-  module TaskWrap
-    # Allows to inject attributes for a task and defaults them if not.
-    # Per default, the defaulting is scoped, meaning only the task will see it.
-    module Inject
-      module Defaults
-        module_function
-
-        def Extension(defaults)
-          # Returns new ctx.
-          input  = ->((original_ctx, flow_options), circuit_options) do
-            defaulted_options = defaults_for(defaults, original_ctx)
-
-            ctx = original_ctx.merge(defaulted_options)
-
-            Trailblazer::Context(ctx, {}, flow_options[:context_options])
-          end
-
-          output = ->(new_ctx, (original_ctx, _flow_options), _circuit_options) { # FIXME: use Unscope
-            _, mutable_data = new_ctx.decompose
-
-            # we are only interested in the {mutable_data} part since the disposed part
-            # represents the injected/defaulted data.
-            original_ctx.merge(mutable_data)
-          }
-
-          VariableMapping::Extension(input, output, id: input)
-        end
-
-        # go through all defaultable options and default them if appropriate.
-        def defaults_for(defaults, original_ctx)
-          Hash[
-            defaults.collect { |k, v| [k, original_ctx[k] || v] } # FIXME: doesn't allow {false/nil} currently.
-          ]
-        end
-      end
-    end # Inject
-  end
-end