trailblazer-activity-dsl-linear 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91482f9f8f3191ea94fccb525e24e55b95edb1f089ee24dd7748364af140476b
-  data.tar.gz: f85598f3e6796e6df4aa6a3927654dc882dae26e2e8c39eff4ea2b4a86db98f7
+  metadata.gz: 555d1c8af700e756c437e913546c302f4630cb0ba3066b97cae7deb67e25f055
+  data.tar.gz: e0fc5141498776365ff62c873d9d379bbd2f3bbfebc177939e7e18057503ee6c
 SHA512:
-  metadata.gz: 88644ff777e10df4e7e6337742f4684e487bdac3e2899d5168f9f4769563171c68638608b2d3de495b66467d9046c2d3f2c12c94ebd4d046c9ec66bbb364cce6
-  data.tar.gz: 53279e4799c2e08909e4a60e55a139c8455faf1d12b8f2fa78a5c80eef6446981e5468e0f962569be1538ce87a4567aef3ef271923be56e8cb17a83ae11610c9
+  metadata.gz: 7d57fa76cde08343769eb8d5feba10f830635738db77c6c732c3df1adadd13e0a6b865a3e5ff2ba6b6cdb3f4adce898f163fb8614e318d9070c98ef896c7322e
+  data.tar.gz: d2691ec2bf75287fd88b089d3764baccdfb2eaa0234b11a2954afae891e63e7262979004eb81d8fc7b204ba2c415f70a75177594400acb1a2ef736050b008864

data/.github/workflows/ci.yml

@@ -5,11 +5,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
-        ruby: [2.5, 2.6, 2.7, '3.0', head, jruby]
+        ruby: [2.5, 2.6, 2.7, '3.0', '3.1', '3.2', 'head', 'jruby']
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}

data/CHANGES.md

@@ -1,3 +1,103 @@
+# 1.2
+
+## Introspect
+
+* As `Activity::Introspect::TaskMap` got removed, use `Activity::Introspect.Nodes(activity)` for introspecting. See https://trailblazer.to/2.1/docs/activity#activity-internals-introspection-api
+
+## Normalizer
+
+* Extract `normalizer/extension.rb` to implement `Extension() => myext`
+* Extract `normalizer/inherit.rb` to implement `inherit: true`.
+* Extract `normalizer/output_tuples.rb` which represents code for the Wiring API.
+* Connectors (`Track()`, `Id()` and `End()`) now contain the logic that returns the search builder. This used to sit in `#normalize_connections_from_dsl`.
+* What used to be the `"path.outputs"` step is now a separate, nested pipeline named `"activity.default_outputs"`. See https://trailblazer.to/2.1/docs/internals#internals-wiring-api-outputs-defaulting
+    Basically, The default step's outputs are set in that separate pipeline under `"activity.default_outputs"`.
+* Rename `"path.connections"` to `"path.step.add_success_connector"` for consistency.
+* Move `Railway::DSL::NormalizerForPass` to `Railway::DSL::Pass::Normalizer` (same for `Fail`).
+* Move `FastTrack::DSL::NormalizerForPass` to `FastTrack::DSL::Pass::Normalizer` (same for `Fail`).
+* Remove `"activity.normalize_outputs_from_dsl"` as this all happens in `#compile_wirings` now.
+
+## Various
+
+* Deprecate `Path(end_id:, end_task:)` options in favor of `Path(terminus: :semantic)`.
+* `FastTrack` outputs for non-`Subprocess()` are only added when `fast_track: true` is set.
+    As a result, this will throw an exception `No `pass_fast` output found for :find_model`.
+
+    ```ruby
+    step :find_model, Output(:pass_fast) # throws "no output" exception.
+    ```
+
+    and needs to be changed to
+
+    ```ruby
+    step :find_model,
+      fast_track: true,
+      Output(:pass_fast)
+    ```
+* Fixed a bug where `Subprocess(Path)` would accidentially add a `:failure` connection.
+    As a result, this doesn't work anymore
+
+    ```ruby
+    step Subprocess(Path), Output(:failure) => ...
+    ```
+* Allow inheriting of `:fail_fast`, `:pass_fast` and `:fast_track`.
+* The `:outputs` option for `#step` is now a private concept.  When passed explicitely to the normalizer (as it happens with `Subprocess()`) it's no longer extended or defaulted.
+* `Strategy.End()` now returns an `OutputTuples::End` instance. Use `Activity.End()` for the original behavior.
+* Removed the `:connections` option in favor of simply using output tuples for setting connections. We also don't inherit `:connections` anymore, but the output tuples.
+* Removed the `VariableMapping::Inherit` module as we can use generic inheritance logic.
+* Finally add the `Extension() => my_ext` option to painlessly add extensions. This means you don't have to manually merge `:extensions` anymore.
+* Extensions are now properly inherited (if `generic?` is false) using the universal inheritance mechanism.
+* `Strategy.invoke` now passes on keyword arguments, too.
+* A terminus step no longer maintains any wirings (as per `trailblazer-activity-0.16.0`), resulting in a terminus `Sequence` row as follows.
+
+    ```ruby
+    [
+      :success,
+      implementing::Success,
+      [], # no outputs anymore!
+      {id: "End.success", stop_event: true, semantic: :success}, # instead, {:semantic} is passed as a data option.
+    ]
+    ```
+* Remove `Search::Noop` as an empty wirings array in `Sequence` are allowed now.
+
+# 1.1.1
+
+* When using `step ..., inherit: true, replace: :find_model` you can now omit `:id`. The ID from
+  `:replace` is used automatically in that case.
+* Deprecate `:override` option for `#step`.
+* Simplify `inherit: [:variable_mapping]` by recording the `:in_filters` and `:out_filters` variables
+instead of the compiled pipelines. This fixes #61.
+* Introduce `#patch` to simplify modifying nested activities. Instead of `Subprocess(<activity>, patch: ...)` you can use
+  the dedicated DSL function.
+
+# 1.1.0
+
+* Use `trailblazer-activity` 0.15.0.
+* Remove `Path::DSL.OptionsForSequenceBuilder` and move concrete code to `Path::DSL.options_for_sequence_build`
+  which returns a set:
+
+  1. default termini instructions for the concrete strategy
+  2. options specific for this strategy subclass.
+
+  Everything else, such as merging user options, computing and adding termini, etc, now happens in
+  `Strategy::DSL.OptionsForSequenceBuilder`.
+* Adding `Subprocess(Create, strict: true)` to wire all outputs of `Create` automatically.
+  Each output will be wired to its same named Track(semantic).
+* Adding `Strategy(termini: )`
+* For `output:` in combination with `:output_with_outer_ctx`, deprecate the second positional argument and make it
+  the `:outer_ctx` keyword argument instead.
+* Introduce `Linear.Patch` as the public entry point for patching activities.
+* Remove `Runtime.initial_aggregate` step for the input and output pipelines which results in slightly better runtime performance and less code.
+
+## Variable Mapping
+
+* Simplify the architecture in `VariableMapping`, filters are now added directly into the `Pipeline`.
+  Performance increase from 17k to 25k from 1.0.0 to this version.
+* Introduce `Inject(:variable)` to supersede the version receiving a big mapping hash.
+* Add `Inject(:variable, override: true)` to always write a variable to ctx, regardless of its presence.
+* Fix a bug where `Inject()` would override `In()` filters even though the latter was added latest. This
+  is fixed by treating both filter types equally and in the order they were added by the user (and the macro).
+
 # 1.0.0
 
 ## Additions

data/Gemfile

@@ -5,11 +5,14 @@ gemspec
 
 gem "minitest-line"
 
-gem "rubocop", require: false
-
-gem "trailblazer-developer", path: "../trailblazer-developer"
+# gem "trailblazer-developer",      path: "../trailblazer-developer"
 # gem "trailblazer-developer", github: "trailblazer/trailblazer-developer"
 # gem "trailblazer-declarative", path: "../trailblazer-declarative"
-# gem "trailblazer-activity", path: "../trailblazer-activity"
+# gem "trailblazer-activity",       path: "../trailblazer-activity"
 # gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-activity", path: "../circuit"
+
+# gem "benchmark-ips"
+# gem "stackprof"
+# gem "standard"
+# gem "trailblazer-core-utils", path: "../trailblazer-core-utils"

data/Rakefile

@@ -4,7 +4,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"] - FileList["test/docs/autogenerated/*"]
 end
 
 task :default => :test

data/lib/trailblazer/activity/dsl/linear/feature/merge.rb

@@ -21,14 +21,14 @@ class Trailblazer::Activity
 
           _seq = Adds.apply_adds(
             old_seq,
-            new_seq.collect { |row| {insert: [Adds::Insert.method(:Prepend), end_id], row: row } }
+            new_seq.collect { |row| {insert: [Adds::Insert.method(:Prepend), end_id], row: row} }
           )
         end
 
         def self.strip_start_and_ends(seq, end_id:)
           cut_off_index = end_id.nil? ? seq.size : Adds::Insert.find_index(seq, end_id) # find the "first" end.
 
-          seq[1..cut_off_index-1]
+          seq[1..cut_off_index - 1]
         end
       end # Merge
     end

data/lib/trailblazer/activity/dsl/linear/feature/patch.rb

@@ -2,11 +2,10 @@ class Trailblazer::Activity
   module DSL
     module Linear
       module Patch
-      # DISCUSS: we could make this a generic DSL option, not just for Subprocess().
         # Currently, this is called from the Subprocess() helper.
         def self.customize(activity, options:)
           options = options.is_a?(Proc) ?
-            { [] => options } : # hash-wrapping with empty path, for patching given activity itself
+            {[] => options} : # hash-wrapping with empty path, for patching given activity itself
             options
 
           options.each do |path, patch|
@@ -16,12 +15,12 @@ class Trailblazer::Activity
           activity
         end
 
-        def self.call(activity, path, customization)
+        def self.call(activity, path, customization, patched_activity: Class.new(activity))
           task_id, *path = path
 
           patch =
             if task_id
-              segment_activity = Introspect::Graph(activity).find(task_id).task
+              segment_activity = Introspect.Nodes(activity, id: task_id).task
               patched_segment_activity = call(segment_activity, path, customization)
 
               # Replace the patched subprocess.
@@ -30,10 +29,15 @@ class Trailblazer::Activity
               customization # apply the *actual* patch from the Subprocess() call.
             end
 
-          patched_activity = Class.new(activity)
           patched_activity.class_exec(&patch)
           patched_activity
         end
+
+        module DSL
+          def patch(*path, &block)
+            Patch.call(self, path, block, patched_activity: self)
+          end
+        end
       end # Patch
     end
   end