trailblazer-activity 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 656825c80059310cf4a2d89a2214a20618bbd688c182285e8d3c24c8475b8233
-  data.tar.gz: 4fb358255fe07a12fcb94172a05f466ce3ac0cb66d3b9502a3622d2a4392a71f
+  metadata.gz: 7dbf0f6f475965ca903f16b2a584bc82131c21d91ed9a8897bf78c2c2abe91fb
+  data.tar.gz: f78fb64dbd9ff29f50be67f569548826f38f50186b8b63c3d6f16b8138a9edad
 SHA512:
-  metadata.gz: 74361dffc29b0108e198a3a2bee9637b6519b2ad56b4fb9172aceffc92bee1bcb5dc5e1417dab33d9ba48340749bd5f4306bd16a2c22a1f5eb66cfea4991f04b
-  data.tar.gz: ad2fd6a2d6d4df1a2c8e167fd395ef05899f7389b95f8219239d4533c75632001992ff38eb240b300d1b2260544b85abd276372783f8a4c2480afc2a3e45a1a5
+  metadata.gz: c32b52c355f304c8dc0bc4e167e89ce0915a342ed985027879b42f9ffba327f49d74e14dc3b740d7f263276b78940f17557560a03b57ac8bf85b54a2fc7407aa
+  data.tar.gz: 5917d86ee194c90052e5568593090a5de90684f3438d736c766ddae5b055bbf9a00191286a27bf16bae159a95068caa6994bdf17d7a1b8cfe10b1c5694d81891

data/CHANGES.md

@@ -1,3 +1,7 @@
+# 0.6.1
+
+* Make `:input` and `:output` standard options of the DSL to create variable mappings.
+
 # 0.6.0
 
 * The `:task` option in `Circuit::call` is now named `:start_task` for consistency.

data/lib/trailblazer/activity/dsl/magnetic/builder/normalizer.rb

@@ -100,6 +100,9 @@ module Trailblazer
 
         task Activity::TaskBuilder::Binary( method(:initialize_extension_option) ), id: "initialize_extension_option"
         task Activity::TaskBuilder::Binary( method(:normalize_for_macro) ),        id: "normalize_for_macro"
+
+        task Activity::TaskBuilder::Binary( Activity::TaskWrap::VariableMapping.method(:normalizer_step_for_input_output) )
+
         task Activity::TaskBuilder::Binary( method(:split_options) ),              id: "split_options"
         task Activity::TaskBuilder::Binary( method(:initialize_plus_poles) ),      id: "initialize_plus_poles"
         # task ->((ctx, _), **) { pp ctx; [Activity::Right, [ctx, _]] }

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

@@ -0,0 +1,157 @@
+require "trailblazer/context"
+
+class Trailblazer::Activity < Module
+  module TaskWrap
+    # Creates taskWrap steps to map variables before and after the actual step.
+    # We hook into the Normalizer, process `:input` and `:output` directives and
+    # 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.
+    module VariableMapping
+      # DSL step for Magnetic::Normalizer.
+      # Translates `:input` and `:output` into VariableMapping taskWrap extensions.
+      def self.normalizer_step_for_input_output(ctx, *)
+        options, io_config = Magnetic::Options.normalize( ctx[:options], [:input, :output] )
+
+        return if io_config.empty?
+
+        ctx[:options] = options # without :input and :output
+        ctx[:options] = options.merge(Trailblazer::Activity::TaskWrap::VariableMapping(io_config) => true)
+      end
+    end
+
+    # @private
+    def self.filter_for(filter)
+      if filter.is_a?(Proc)
+        filter
+      elsif filter.is_a?(Symbol)
+        filter # TODO: test this properly?
+      else
+        TaskWrap::DSL.filter_from_dsl(filter)
+      end
+    end
+
+    # Returns an Extension instance to be thrown into the `step` DSL arguments.
+    def self.VariableMapping(input:, output:)
+      input  = Input.new(
+                Input::Scoped.new(
+                  Trailblazer::Option::KW( filter_for(input) ) ) )
+
+      output = Output.new(
+                Output::Unscoped.new(
+                  Trailblazer::Option::KW( filter_for(output) ) ) )
+
+      Trailblazer::Activity::DSL::Extension.new(
+        Merge.new(
+          Module.new do
+            extend Path::Plan()
+
+            task input,  id: "task_wrap.input", before: "task_wrap.call_task"
+            task output, id: "task_wrap.output", before: "End.success", group: :end
+          end
+        )
+      )
+    end
+
+    # TaskWrap step to compute the incoming {Context} for the wrapped task.
+    # This allows renaming, filtering, hiding, of the options passed into the wrapped task.
+    #
+    # Both Input and Output are typically to be added before and after task_wrap.call_task.
+    #
+    # @note Assumption: we always have :input _and_ :output, where :input produces a Context and :output decomposes it.
+    class Input
+      def initialize(filter)
+        @filter = filter
+      end
+
+      # `original_args` are the actual args passed to the wrapped task: [ [options, ..], circuit_options ]
+      #
+      def call( (wrap_ctx, original_args), circuit_options )
+        # let user compute new ctx for the wrapped task.
+        input_ctx = apply_filter(*original_args) # FIXME: THIS SHOULD ALWAYS BE A _NEW_ Context.
+
+        wrap_ctx = wrap_ctx.merge( vm_original_ctx: original_args[0][0] ) # remember the original ctx
+
+        # decompose the original_args since we want to modify them.
+        (original_ctx, original_flow_options), original_circuit_options = original_args
+
+        # instead of the original Context, pass on the filtered `input_ctx` in the wrap.
+        return Trailblazer::Activity::Right, [ wrap_ctx, [[input_ctx, original_flow_options], original_circuit_options] ]
+      end
+
+      private
+
+      def apply_filter((ctx, original_flow_options), original_circuit_options)
+        @filter.( ctx, original_circuit_options ) # returns {new_ctx}.
+      end
+
+      class Scoped
+        def initialize(filter)
+          @filter = filter
+        end
+
+        def call(original_ctx, circuit_options)
+          Trailblazer::Context( # TODO: make this interchangeable so we can work on faster contexts?
+            @filter.(original_ctx, **circuit_options)
+          )
+        end
+      end
+    end
+
+    module DSL
+      # The returned filter compiles a new hash for Scoped/Unscoped that only contains
+      # the desired i/o variables.
+      def self.filter_from_dsl(map)
+        hsh = DSL.hash_for(map)
+
+        ->(incoming_ctx, kwargs) { Hash[hsh.collect { |from_name, to_name| [to_name, incoming_ctx[from_name]] }] }
+      end
+
+      def self.hash_for(ary)
+        return ary if ary.instance_of?(::Hash)
+        Hash[ary.collect { |name| [name, name] }]
+      end
+    end
+
+    # TaskWrap step to compute the outgoing {Context} from the wrapped task.
+    # This allows renaming, filtering, hiding, of the options returned from the wrapped task.
+    class Output
+      def initialize(filter)
+        @filter = filter
+      end
+
+      # Runs the user filter and replaces the ctx in `wrap_ctx[:return_args]` with the filtered one.
+      def call( (wrap_ctx, original_args), **circuit_options )
+        (original_ctx, original_flow_options), original_circuit_options = original_args
+
+        returned_ctx, _ = wrap_ctx[:return_args] # this is the Context returned from `call`ing the task.
+        original_ctx    = wrap_ctx[:vm_original_ctx]
+
+        # let user compute the output.
+        output_ctx = @filter.(original_ctx, returned_ctx, **original_circuit_options)
+
+        wrap_ctx = wrap_ctx.merge( return_args: [output_ctx, original_flow_options] )
+
+        # and then pass on the "new" context.
+        return Trailblazer::Activity::Right, [ wrap_ctx, original_args ]
+      end
+
+      private
+
+      # Merge the resulting {@filter.()} hash back into the original ctx.
+      # DISCUSS: do we need the original_ctx as a filter argument?
+      class Unscoped
+        def initialize(filter)
+          @filter = filter
+        end
+
+        def call(original_ctx, new_ctx, **circuit_options)
+          original_ctx.merge(
+            @filter.(new_ctx, **circuit_options)
+          )
+        end
+      end
+    end
+  end # Wrap
+end

data/lib/trailblazer/activity/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Activity < Module
-    VERSION = "0.6.0"
+    VERSION = "0.6.1"
   end
 end

data/lib/trailblazer/activity.rb

@@ -105,6 +105,7 @@ require "trailblazer/activity/task_wrap/call_task"
 require "trailblazer/activity/task_wrap/trace"
 require "trailblazer/activity/task_wrap/runner"
 require "trailblazer/activity/task_wrap/merge"
+require "trailblazer/activity/task_wrap/variable_mapping"
 
 require "trailblazer/activity/trace"
 require "trailblazer/activity/present"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-03 00:00:00.000000000 Z
+date: 2018-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hirb
@@ -149,6 +149,7 @@ files:
 - lib/trailblazer/activity/task_wrap/merge.rb
 - lib/trailblazer/activity/task_wrap/runner.rb
 - lib/trailblazer/activity/task_wrap/trace.rb
+- lib/trailblazer/activity/task_wrap/variable_mapping.rb
 - lib/trailblazer/activity/testing.rb
 - lib/trailblazer/activity/trace.rb
 - lib/trailblazer/activity/version.rb