trailblazer-activity 0.11.5 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c765281f7fa2902f9cc47fb4a2045b54de89fb48ef536d4696a497f947b3f9bb
-  data.tar.gz: 8a4f24aacb4da6b80e12a3edcd3698cb7583e014b489293d29938a003a27d084
+  metadata.gz: 36888239a75b308074977ecb9637e421940f63a53fdafbadb5a65106152fc550
+  data.tar.gz: 3aff2a8fb3da591b98f72f387555791c8273dc02968b68a5f4eb8d59a69f7e45
 SHA512:
-  metadata.gz: 4388f3be8e6c4f902537b5febdec0b36b5a15e143f2da5f1a9b0aba4a0cb73e0066ef825ca4f285e040e36d25ff77ce9031114f85198e70779dee9359e75df2d
-  data.tar.gz: 71c58c25da986267e69c37e50a5a1b0de0083c58cf47def17b2c63eb44af7f8498d0f4f2b121be1d46b545b7c937bb85cf0156e32d642c73750e086232b96c98
+  metadata.gz: bffee75027f1af8e1dd87487f07505bc5e8238e62eb67ffc1a128f90fbaeb5d4feadcbac2294991ef69febd71245292dd39128fd52e78bba11a9be8afce1cdf9
+  data.tar.gz: 8ac7bc2b36e8db2349134ce935d1da0881a749c881dca6703c1ed192862d526a734de5da8c956f59b60293300f3dd3fabb05c0e21fbd5187cf2a53b09992c368

data/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    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, jruby-head]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - run: bundle exec rake

data/CHANGES.md

@@ -1,3 +1,23 @@
+# 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`.
+
+# 0.12.1
+
+* Allow injecting `:wrap_static` into `TaskWrap.invoke`.
+
+# 0.12.0
+
+* Support for Ruby 3.0.
+
 # 0.11.5
 
 * Bug fix: `:output` filter from `TaskWrap::VariableMapping` wasn't returning the correct `flow_options`. If the wrapped task changed

data/Gemfile

@@ -1,10 +1,5 @@
 source "https://rubygems.org"
-
-# Specify your gem's dependencies in workflow.gemspec
 gemspec
 
-gem "benchmark-ips"
-gem "minitest-line"
-
-# gem "trailblazer-context", path: "../trailblazer-context"
 # gem "trailblazer-developer", path: "../trailblazer-developer"
+# gem "trailblazer-context", github: "trailblazer/trailblazer-context", branch: "ruby-3"

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/introspect.rb

@@ -68,6 +68,20 @@ module Trailblazer
       def self.Graph(*args)
         Graph.new(*args)
       end
+
+      def self.render_task(proc)
+        if proc.is_a?(Method)
+
+          receiver = proc.receiver
+          receiver = receiver.is_a?(Class) ? (receiver.name || "#<Class:0x>") : (receiver.name || "#<Module:0x>") #"#<Class:0x>"
+
+          return "#<Method: #{receiver}.#{proc.name}>"
+        elsif proc.is_a?(Symbol)
+          return proc.to_s
+        end
+
+        proc.inspect
+      end
     end # Introspect
   end
 end

data/lib/trailblazer/activity/task_builder.rb

@@ -5,7 +5,7 @@ module Trailblazer
     # Output signal binary: true=>Right, false=>Left.
     # Passes through all subclasses of Direction.~~~~~~~~~~~~~~~~~
     def self.Binary(user_proc)
-      Task.new(Trailblazer::Option::KW( user_proc ), user_proc)
+      Task.new(Trailblazer::Option(user_proc), user_proc)
     end
 
     # Translates the return value of the user step into a valid signal.
@@ -18,26 +18,34 @@ 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, **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 )
+        signal = Activity::TaskBuilder.binary_signal_for(result, Activity::Right, Activity::Left)
+
+        return signal, [ctx, flow_options]
+      end
 
-        return signal, [ ctx, flow_options ]
+      # 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
-        %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=#{@user_proc}>}
+      def inspect # TODO: make me private!
+        %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=#{Trailblazer::Activity::Introspect.render_task(@user_proc)}>}
       end
       alias_method :to_s, :inspect
     end

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

@@ -6,9 +6,11 @@ class Trailblazer::Activity
     def self.call_task(wrap_ctx, original_args)
       task = wrap_ctx[:task]
 
+      original_arguments, original_circuit_options = original_args
+
       # Call the actual task we're wrapping here.
       # puts "~~~~wrap.call: #{task}"
-      return_signal, return_args = task.(*original_args)
+      return_signal, return_args = task.(original_arguments, **original_circuit_options)
 
       # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
       wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )

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/runner.rb

@@ -17,7 +17,7 @@ class Trailblazer::Activity
 
         # We save all original args passed into this Runner.call, because we want to return them later after this wrap
         # is finished.
-        original_args = [ args, circuit_options ]
+        original_args = [args, circuit_options]
 
         # call the wrap {Activity} around the task.
         wrap_ctx, _ = task_wrap_pipeline.(wrap_ctx, original_args) # we omit circuit_options here on purpose, so the wrapping activity uses the default, plain Runner.

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)
@@ -57,7 +52,7 @@ class Trailblazer::Activity
 
       # Invoke the @filter callable with the original circuit interface.
       def apply_filter((ctx, original_flow_options), original_circuit_options)
-        @filter.([ctx, original_flow_options], original_circuit_options) # returns {new_ctx}.
+        @filter.([ctx, original_flow_options], **original_circuit_options) # returns {new_ctx}.
       end
     end
 
@@ -71,14 +66,12 @@ 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.
         # let user compute the output.
-        output_ctx = @filter.(returned_ctx, [original_ctx, returned_flow_options], original_circuit_options) # FIXME: shouldn't we pass {returned_ctx} instead of {original_ctx}?
+        output_ctx = @filter.(returned_ctx, [original_ctx, returned_flow_options], **original_circuit_options)
 
         wrap_ctx = wrap_ctx.merge( return_args: [output_ctx, returned_flow_options] )
 

data/lib/trailblazer/activity/task_wrap.rb

@@ -13,15 +13,19 @@ module Trailblazer
       module_function
 
       # Compute runtime arguments necessary to execute a taskWrap per task of the activity.
-      def invoke(activity, args, wrap_runtime: {}, **circuit_options)
+      # This method is the top-level entry, called only once for the entire activity graph.
+      # [: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,
-          activity:     {wrap_static: {activity => initial_wrap_static}, nodes: {}}, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
+          # This {:activity} structure is currently (?) only needed in {TaskWrap.wrap_static_for}, where we
+          # access {activity[:wrap_static]} to compile the effective taskWrap.
+          activity:     {wrap_static: {activity => wrap_static}, nodes: {}}, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
         )
 
         # signal, (ctx, flow), circuit_options =
-        Runner.(activity, args, **circuit_options)
+        TaskWrap::Runner.(activity, args, **circuit_options)
       end
 
       # {:extension} API
@@ -43,6 +47,9 @@ module Trailblazer
           @merge = merge
         end
 
+        # Compile-time:
+        # Gets called via the {Normalizer} and represents an {:extensions} item.
+        # Adds/alters the activity's {wrap_static}.
         def call(config:, task:, **)
           before_pipe = State::Config.get(config, :wrap_static, task.circuit_task)
 
@@ -56,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/testing.rb

@@ -62,10 +62,6 @@ module Trailblazer
           Success = Activity::End(:success)
         end
 
-        def Cct(activity)
-          Trailblazer::Developer::Render::Circuit.(activity)
-        end
-
         # TODO: Remove this once all it's references are removed
         def implementing
           Implementing
@@ -143,9 +139,19 @@ module Trailblazer
 
         def assert_circuit(schema, circuit)
           cct = Cct(schema)
+
           cct = cct.gsub("#<Trailblazer::Activity::TaskBuilder::Task user_proc=", "<*")
           assert_equal %{#{circuit}}, cct
         end
+
+      def Cct(activity)
+        Trailblazer::Developer::Render::Circuit.(activity, inspect_task: Trailblazer::Activity::Testing.method(:render_task))
+      end
+    end
+
+    # Use this in {#Cct}.
+    def self.render_task(proc)
+      Activity::Introspect.render_task(proc)
     end
   end
 end

data/lib/trailblazer/activity/version.rb

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

data/trailblazer-activity.gemspec

@@ -17,10 +17,12 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-context", ">= 0.3.1", "< 0.4.0"
+  spec.add_dependency "trailblazer-context", "~> 0.5.0"
+  spec.add_dependency "trailblazer-option", "~> 0.1.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-line"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "trailblazer-developer", ">= 0.0.7"
 

metadata

@@ -1,35 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.11.5
+  version: 0.13.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-03 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-context
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.3.1
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: trailblazer-option
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
-    - - "<"
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -93,8 +115,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -113,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
@@ -139,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Runtime code for Trailblazer activities.

data/.travis.yml

@@ -1,12 +0,0 @@
-language: ruby
-before_install: gem install bundler
-cache: bundler
-rvm:
-  - ruby-head
-  - 2.7
-  - 2.6
-  - 2.5
-  - 2.4
-jobs:
-  allow_failures:
-    - rvm: ruby-head

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