trailblazer-activity 0.10.0 → 0.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7bfa65d9c33030f9512d1d465cbb47862336c4cff11be999ea64845bc8d8dff
-  data.tar.gz: a28d2c3bd407fbc5db2cf0d250e68e13f169ae62297d50c51e0507bb743d641b
+  metadata.gz: 05447b3e4a4957abae7548719bc6b33500621fc6801860c8aaeaa06c33532c21
+  data.tar.gz: d7f55a424263aaffb829a9772fd8cff3d2e93e15691ae091a1eb72570d2136b3
 SHA512:
-  metadata.gz: 64a06dd8ff913d4ad708de7bcca3e846f81333eb1c70aaf1a2de132de6ac4044cee55fb6715865fd8580989ce5f944bb4e331e3e758ab925102330bb09397cd6
-  data.tar.gz: 1e00a9ee8523d21901f7a912a02afc8e25038c13111775b367226cf792796da2edbbef6853e5a4ead885858021b92a4eb9d48e466bf94a84126956b716a3397a
+  metadata.gz: 43fc2e829e8c1c3de9493a6b1ef8dd4bacc77a1136d8efbb1f9c08d2260e381debc733df7f6d5e4e1b53bb0cefaebf76d54caceeaf786b6056f56878adc1cc6d
+  data.tar.gz: 98ff3aca3a7b3fe102ce9bd368cdfc962cc68687c432c087750f64a36d34ef258a338abc32dc2d3d228d8982a0211b5c6de8efe051dbb4576bbe740bc860d13a

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,27 @@
+# 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
+
 # 0.10.0
 
 * Require `developer` >= 0.0.7.

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/README.md

@@ -1,22 +1,22 @@
 # Activity
 
-implements Intermediate, Implementation, compiler and `Activity::Implementation`, Activity::Interface
+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.
 
 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](http://trailblazer.to/api-docs). [Note that the docs are WIP.]
+Please find the [full documentation on the Trailblazer website](https://2019.trailblazer.to/2.1/docs/activity.html). [Note that the docs are WIP.]
 
 ## Example
 
-The `activity` gem provides three default patterns to model processes: `Path`, `Railway` and `FastTrack`. Here's an example what a railway activity could look like, along with some more complex connections.
+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)).
 
 ```ruby
-module Memo::Update
-  extend Trailblazer::Activity::Railway()
-  module_function
+require "trailblazer-activity"
+require "trailblazer-activity-dsl-linear"
 
+class Memo::Update < Trailblazer::Activity::Railway
   # here goes your business logic
   #
   def find_model(ctx, id:, **)
@@ -39,10 +39,10 @@ module Memo::Update
 
   # here comes the DSL describing the layout of the activity
   #
-  step method(:find_model)
-  step method(:validate), Output(:failure) => End(:validation_error)
-  step method(:save)
-  fail method(:log_error)
+  step :find_model
+  step :validate, Output(:failure) => End(:validation_error)
+  step :save
+  fail :log_error
 end
 ```
 
@@ -71,17 +71,22 @@ With Activity, modeling business processes turns out to be ridiculously simple:
 ## Features
 
 * Activities can model any process with arbitrary flow and connections.
-* Nesting and compositions are allowed and encouraged.
+* Nesting and compositions are allowed and encouraged (via Trailblazer's [`dsl-linear`](https://github.com/trailblazer/trailblazer-activity-dsl-linear) gem).
 * Different step interfaces, manual processing of DSL options, etc is all possible.
 * Steps can be any kind of callable objects.
-* Tracing!
+* Tracing! (via Trailblazer's [`developer`](https://github.com/trailblazer/trailblazer-developer) gem)
 
 ## Operation
 
-Trailblazer's [`Operation`](http://trailblazer.to/2.1/operation) internally uses an activity to model the processes.
+Trailblazer's [`Operation`](https://2019.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.
+
+<img src="http://2019.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](http://trailblazer.to/pro).
+Licensed under the LGPLv3 license. We also offer a commercial-friendly [license](https://2019.trailblazer.to/2.1/docs/pro.html#pro-license).

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,13 +45,22 @@ 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.
           return [ last_signal, args ] if @stop_events.include?(task) # DISCUSS: return circuit_options here?
 
-          task = next_for(task, last_signal) or raise IllegalSignalError.new("<#{@name}>[#{task}][ #{last_signal.inspect} ]")
+          if (next_task = next_for(task, last_signal))
+            task = next_task
+          else
+            raise IllegalSignalError.new(
+              task,
+              signal: last_signal,
+              outputs: @map[task],
+              exec_context: circuit_options[:exec_context], # passed at run-time from DSL
+            )
+          end
         end
       end
 
@@ -67,7 +76,26 @@ module Trailblazer
         outputs[signal]
       end
 
+      # Common reasons to raise IllegalSignalError are
+      #   * Returning invalid signal from custom Macros
+      #   * Returning invalid signal from steps which are not taskWrapped, for example: `step task: method(:validate)`
+      #
+      # Rest assured, it won't be raised in case of below scenarios where they can return any value,
+      #   * Steps with instance method signature, for example, `step :load_user`
+      #   * Steps with proc signature, for example `step ->(ctx, **){}`
       class IllegalSignalError < RuntimeError
+        attr_reader :task, :signal
+
+        def initialize(task, signal:, outputs:, exec_context:)
+          @task = task
+          @signal = signal
+
+          message = "#{exec_context.class}: \n\t" \
+            "\sUnrecognized Signal `#{signal.inspect}` returned from #{task.inspect}. Registered signals are, \n" \
+            "- #{outputs.keys.join("\n- ")}"
+
+          super(message)
+        end
       end
     end
   end

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"