trailblazer-activity 0.10.1 → 0.11.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c94f3dbe368043f005ec5d68fc099246c8f302dd6e1b366989b321665d5f2b98
-  data.tar.gz: 28f0b58b9d2de3b7adffd543860baed3e47eb25945161cbe7cc5f45a8f907abd
+  metadata.gz: c765281f7fa2902f9cc47fb4a2045b54de89fb48ef536d4696a497f947b3f9bb
+  data.tar.gz: 8a4f24aacb4da6b80e12a3edcd3698cb7583e014b489293d29938a003a27d084
 SHA512:
-  metadata.gz: 78eaabeff700dd6b22ff61efe8efe993287875c02e7a80197ca6880c435bba2732d61ebaa41acc4da3737ad556ae669b8dc03f6dad445394486e7a1298d62569
-  data.tar.gz: '08b7cbeea9a42fc99a8d38f95439d6e265f0fe4051ccfa8e95a18f18c117e34bf6ae2824e07a8eb139db32e4559bd094c30d621e1fb82cc2c8e80916e7c6ee88'
+  metadata.gz: 4388f3be8e6c4f902537b5febdec0b36b5a15e143f2da5f1a9b0aba4a0cb73e0066ef825ca4f285e040e36d25ff77ce9031114f85198e70779dee9359e75df2d
+  data.tar.gz: 71c58c25da986267e69c37e50a5a1b0de0083c58cf47def17b2c63eb44af7f8498d0f4f2b121be1d46b545b7c937bb85cf0156e32d642c73750e086232b96c98

data/.travis.yml

@@ -1,10 +1,12 @@
-sudo: false
 language: ruby
-rvm:
-  - 2.6.0
-  - 2.5.1
-  - 2.4.4
-  # - 2.3.7
-  # - 2.2.10
-  # - 2.1.10
 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/CHANGES.md

@@ -1,3 +1,28 @@
+# 0.11.5
+
+* Bug fix: `:output` filter from `TaskWrap::VariableMapping` wasn't returning the correct `flow_options`. If the wrapped task changed
+  its `flow_options`, the original one was still returned from the taskWrap run, not the updated one.
+
+# 0.11.4
+
+* Introduce the `config_wrap:` option in `Intermediate.call(intermediate, implementation, config_merge: {})` to allow injecting data into the activity's `:config` field.
+
+# 0.11.3
+
+* Allow `Testing.def_task` & `Testing.def_tasks` to return custom signals
+
+# 0.11.2
+
+* Updrading `trailblazer-context` version :drum:
+
+# 0.11.1
+
+* Internal warning fixes.
+
+# 0.11.0
+
+* Support for Ruby 2.7. Most warnings are gone.
+
 # 0.10.1
 
 * Update IllegalSignalError exception for more clarity

data/Gemfile

@@ -6,8 +6,5 @@ gemspec
 gem "benchmark-ips"
 gem "minitest-line"
 
-gem "rubocop", require: false
-
 # gem "trailblazer-context", path: "../trailblazer-context"
 # gem "trailblazer-developer", path: "../trailblazer-developer"
-# gem "trailblazer-developer", github: "trailblazer/trailblazer-developer", branch: "exception-tracing"

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 Trailblazer GmbH
+Copyright (c) 2018-2020 Trailblazer GmbH
 
 Trailblazer is an Open Source project licensed under the terms of
 the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>

data/Rakefile

@@ -1,13 +1,10 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rubocop/rake_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["**/*_test.rb"] - FileList["test/docs/*"] + ["test/docs/activity_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"] - FileList["test/docs/*"] + ["test/docs/activity_test.rb"]
 end
 
-RuboCop::RakeTask.new
-
-task :default => :test
+task default: %i[test]

data/lib/trailblazer/activity.rb

@@ -7,10 +7,10 @@ module Trailblazer
       @schema = schema
     end
 
-    def call(args, circuit_options={})
+    def call(args, **circuit_options)
       @schema[:circuit].(
         args,
-        circuit_options.merge(activity: self)
+        **(circuit_options.merge(activity: self))
       )
     end
 
@@ -34,24 +34,15 @@ module Trailblazer
   end # Activity
 end
 
-# require "trailblazer/activity/interface"
 require "trailblazer/activity/structures"
 require "trailblazer/activity/schema"
-require "trailblazer/activity/schema/implementation"
-require "trailblazer/activity/schema/intermediate"
 require "trailblazer/activity/circuit"
 require "trailblazer/activity/config"
 require "trailblazer/activity/introspect"
-
 require "trailblazer/activity/task_wrap"
-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"
+require "trailblazer/activity/task_builder"
 
 require "trailblazer/option"
 require "trailblazer/context"
-require "trailblazer/activity/task_builder"
 
 

data/lib/trailblazer/activity/circuit.rb

@@ -45,7 +45,7 @@ module Trailblazer
           last_signal, args, _discarded_circuit_options = runner.(
             task,
             args,
-            circuit_options
+            **circuit_options
           )
 
           # Stop execution of the circuit when we hit a stop event (< End). This could be an task's End or Suspend.

data/lib/trailblazer/activity/config.rb

@@ -28,6 +28,7 @@ module Trailblazer
 
         return state[directive] if args.size == 1
         return state[directive][key] if state.key?(directive)
+
         nil
       end
     end

data/lib/trailblazer/activity/introspect.rb

@@ -4,10 +4,6 @@ module Trailblazer
     # It abstracts internals about circuits and provides a convenient API to third-parties such as
     # tracing, rendering an activity, or finding particular tasks.
     module Introspect
-      def self.Graph(*args)
-        Graph.new(*args)
-      end
-
       # TODO: order of step/fail/pass in Node would be cool to have
 
       # @private This API is still under construction.
@@ -20,13 +16,14 @@ module Trailblazer
           @configs  = @schema[:nodes]
         end
 
-        def find(id=nil, &block)
+        def find(id = nil, &block)
           return find_by_id(id) unless block_given?
+
           find_with_block(&block)
         end
 
-        def collect(strategy: :circuit, &block)
-          @map.keys.each_with_index.collect { |task, i| yield find_with_block { |node| node.task==task }, i }
+        def collect(strategy: :circuit)
+          @map.keys.each_with_index.collect { |task, i| yield find_with_block { |node| node.task == task }, i }
         end
 
         def stop_events
@@ -36,11 +33,11 @@ module Trailblazer
         private
 
         def find_by_id(id)
-          node = @configs.find { |node| node.id == id } or return
+          node = @configs.find { |_node| _node.id == id } or return
           node_for(node)
         end
 
-        def find_with_block(&block)
+        def find_with_block
           existing = @configs.find { |node| yield Node(node.task, node.id, node.outputs, node.data) } or return
 
           node_for(existing)
@@ -67,6 +64,10 @@ module Trailblazer
           end
         end
       end
-    end #Introspect
+
+      def self.Graph(*args)
+        Graph.new(*args)
+      end
+    end # Introspect
   end
 end

data/lib/trailblazer/activity/schema.rb

@@ -11,3 +11,5 @@ module Trailblazer
     end # Schema
   end
 end
+require "trailblazer/activity/schema/implementation"
+require "trailblazer/activity/schema/intermediate"

data/lib/trailblazer/activity/schema/intermediate.rb

@@ -12,15 +12,17 @@ class Trailblazer::Activity
       # Compiles a {Schema} instance from an {intermediate} structure and
       # the {implementation} object references.
       #
-      # Intermediate structure, Implementation, calls extensions, passes {}config # TODO
-      def self.call(intermediate, implementation)
-        config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)}.freeze # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
+      # Intermediate structure, Implementation, calls extensions, passes {config} # TODO
+      def self.call(intermediate, implementation, config_merge: {})
+        config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
+        config         = config_default.merge(config_merge)
+        config.freeze
 
         circuit = circuit(intermediate, implementation)
         nodes   = node_attributes(intermediate, implementation)
         outputs = outputs(intermediate.stop_task_ids, nodes)
-        config  = config(implementation, config: config_default)
-        schema  = Schema.new(circuit, outputs, nodes, config)
+        config  = config(implementation, config: config)
+        Schema.new(circuit, outputs, nodes, config)
       end
 
       # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
@@ -83,10 +85,10 @@ class Trailblazer::Activity
         config
       end
 
-      private
+
 
       # Apply to any array.
-      def self.for_semantic(outputs, semantic)
+      private_class_method def self.for_semantic(outputs, semantic)
         outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found"
       end
     end # Intermediate

data/lib/trailblazer/activity/structures.rb

@@ -2,13 +2,7 @@ module Trailblazer
   class Activity
     # Generic run-time structures that are built via the DSL.
 
-    # Builds an {Activity::End} instance.
-    def self.End(semantic)
-      End.new(semantic: semantic)
-    end
-
     # Any instance of subclass of End will halt the circuit's execution when hit.
-
     # An End event is a simple structure typically found as the last task invoked
     # in an activity. The special behavior is that it
     # a) maintains a semantic that is used to further connect that very event
@@ -18,8 +12,8 @@ module Trailblazer
         @options = options.merge(semantic: semantic)
       end
 
-      def call(args, circuit_options)
-        return self, args, circuit_options
+      def call(args, **circuit_options)
+        return self, args, **circuit_options
       end
 
       def to_h
@@ -27,15 +21,15 @@ module Trailblazer
       end
 
       def to_s
-        %{#<#{self.class.name} #{@options.collect{ |k,v| "#{k}=#{v.inspect}" }.join(" ")}>}
+        %{#<#{self.class.name} #{@options.collect { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>}
       end
 
-      alias_method :inspect, :to_s
+      alias inspect to_s
     end
 
     class Start < End
-      def call(args, circuit_options)
-        return Activity::Right, args, circuit_options
+      def call(args, **circuit_options)
+        return Activity::Right, args, **circuit_options
       end
     end
 
@@ -53,5 +47,10 @@ module Trailblazer
     def self.Output(signal, semantic)
       Output.new(signal, semantic).freeze
     end
+
+    # Builds an {Activity::End} instance.
+    def self.End(semantic)
+      End.new(semantic: semantic)
+    end
   end
 end

data/lib/trailblazer/activity/task_builder.rb

@@ -11,7 +11,11 @@ module Trailblazer
     # Translates the return value of the user step into a valid signal.
     # Note that it passes through subclasses of {Signal}.
     def self.binary_signal_for(result, on_true, on_false)
-      result.is_a?(Class) && result < Activity::Signal ? result : (result ? on_true : on_false)
+      if result.is_a?(Class) && result < Activity::Signal
+        result
+      else
+        result ? on_true : on_false
+      end
     end
 
     class Task

data/lib/trailblazer/activity/task_wrap.rb

@@ -3,12 +3,12 @@ module Trailblazer
     #
     # Example with tracing:
     #
-          # Call the task_wrap circuit:
-        #   |-- Start
-        #   |-- Trace.capture_args   [optional]
-        #   |-- Call (call actual task) id: "task_wrap.call_task"
-        #   |-- Trace.capture_return [optional]
-        #   |-- Wrap::End
+    # Call the task_wrap circuit:
+    #   |-- Start
+    #   |-- Trace.capture_args   [optional]
+    #   |-- Call (call actual task) id: "task_wrap.call_task"
+    #   |-- Trace.capture_return [optional]
+    #   |-- Wrap::End
     module TaskWrap
       module_function
 
@@ -21,7 +21,7 @@ module Trailblazer
         )
 
         # signal, (ctx, flow), circuit_options =
-        Runner.(activity, args, circuit_options)
+        Runner.(activity, args, **circuit_options)
       end
 
       # {:extension} API
@@ -29,7 +29,8 @@ module Trailblazer
       # Gets executed in {Intermediate.call} which also provides {config}.
 
       def initial_wrap_static(*)
-        initial_sequence = TaskWrap::Pipeline.new([["task_wrap.call_task", TaskWrap.method(:call_task)]])
+        # return initial_sequence
+        TaskWrap::Pipeline.new([["task_wrap.call_task", TaskWrap.method(:call_task)]])
       end
 
       # Use this in your macros if you want to extend the {taskWrap}.
@@ -51,3 +52,8 @@ module Trailblazer
     end # TaskWrap
   end
 end
+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/task_wrap/inject.rb

@@ -13,10 +13,10 @@ class Trailblazer::Activity
 
             ctx = original_ctx.merge(defaulted_options)
 
-            Trailblazer::Context.for_circuit(ctx, {}, [original_ctx, flow_options], circuit_options) # TODO: test if Inject and :context_class work.
+            Trailblazer::Context(ctx, {}, flow_options[:context_options])
           end
 
-          output = ->(new_ctx, (original_ctx, flow_options), circuit_options) { # FIXME: use Unscope
+          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

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

@@ -9,7 +9,7 @@ class Trailblazer::Activity
       end
 
       def call(wrap_ctx, original_args)
-        @sequence.each { |(id, task)| wrap_ctx, original_args = task.(wrap_ctx, original_args) }
+        @sequence.each { |(_id, task)| wrap_ctx, original_args = task.(wrap_ctx, original_args) }
 
         return wrap_ctx, original_args
       end

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

@@ -9,11 +9,11 @@ class Trailblazer::Activity
       #
       # @api private
       # @interface Runner
-      def self.call(task, args, circuit_options)
+      def self.call(task, args, **circuit_options)
         wrap_ctx = { task: task }
 
         # this pipeline is "wrapped around" the actual `task`.
-        task_wrap_pipeline = merge_static_with_runtime(task, circuit_options) || raise
+        task_wrap_pipeline = merge_static_with_runtime(task, **circuit_options) || raise
 
         # We save all original args passed into this Runner.call, because we want to return them later after this wrap
         # is finished.
@@ -28,15 +28,14 @@ class Trailblazer::Activity
         return wrap_ctx[:return_signal], wrap_ctx[:return_args]
       end
 
-      private
 
       # Compute the task's wrap by applying alterations both static and from runtime.
       #
       # NOTE: this is for performance reasons: we could have only one hash containing everything but that'd mean
       # unnecessary computations at `call`-time since steps might not even be executed.
       # TODO: make this faster.
-      def self.merge_static_with_runtime(task, wrap_runtime:, **circuit_options)
-        static_wrap = TaskWrap.wrap_static_for(task, circuit_options) # find static wrap for this specific task [, or default wrap activity].
+      private_class_method def self.merge_static_with_runtime(task, wrap_runtime:, **circuit_options)
+        static_wrap = TaskWrap.wrap_static_for(task, **circuit_options) # find static wrap for this specific task [, or default wrap activity].
 
         # Apply runtime alterations.
         # Grab the additional wirings for the particular `task` from `wrap_runtime`.

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

@@ -38,7 +38,7 @@ class Trailblazer::Activity
       end
 
       # {input.call()} is invoked in the circuit.
-      # `original_args` are the actual args passed to the wrapped task: [ [options, ..], circuit_options ]
+      # `original_args` are the actual args passed to the wrapped task: [ [ctx, ..], circuit_options ]
       #
       def call(wrap_ctx, original_args)
         # let user compute new ctx for the wrapped task.
@@ -73,12 +73,14 @@ class Trailblazer::Activity
       def call(wrap_ctx, original_args)
         (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 wrapped user task.
-        original_ctx    = wrap_ctx[@id]           # grab the original ctx from before which was set in the {:input} filter.
+        return_args = wrap_ctx[:return_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, original_flow_options], original_circuit_options)
+        output_ctx = @filter.(returned_ctx, [original_ctx, returned_flow_options], original_circuit_options) # FIXME: shouldn't we pass {returned_ctx} instead of {original_ctx}?
 
-        wrap_ctx = wrap_ctx.merge( return_args: [output_ctx, original_flow_options] )
+        wrap_ctx = wrap_ctx.merge( return_args: [output_ctx, returned_flow_options] )
 
         # and then pass on the "new" context.
         return wrap_ctx, original_args