trailblazer-activity 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f50cd0494bec7054e6dda24aaf8d2a2aff9575aa4c6a0e5a4ee2a526ba01eb3
-  data.tar.gz: 0ed8764ab5f77fceeae9c097c151514e797146f755672434ea38dfcf521c95ef
+  metadata.gz: e3223f3eba8cc3fecb792e693dbba7da7f2941a3703b953ccc61c5044916ae5f
+  data.tar.gz: e449258dd404bfeb40516f00b44548fdae0cb59af9b7fc4695c02c649fa71bf8
 SHA512:
-  metadata.gz: 40da5dd6bd2ff3379609261e4270e4071cee4cac78d710300d043e11b8780b90dff4bd898fb8b0972410d0d19f92967c90e1141931e96737e35bbe510a925092
-  data.tar.gz: '00863321ebfb71d0b2799e88c0c7b9af9bc7781b44887bbbc5566720633f5c650de8992332eac6b75cf25438d9d6204da89c7d1d118d166b1a30da41da1b1aa2'
+  metadata.gz: 3bc812315aeff872392b12b9c7094ad851c0192f3cf340d822d4c460309574737aaabb93eb192b1e130075b711cf2b548942fe7a2cad5a1ef860b4d31b78dbde
+  data.tar.gz: 88361f9bc83de278ea1e144276d8167c9b04f82605209ef240877e33900dc8c9480954c092a55fc1e57f516a03bbb81b8499c4488701e95b54f64343a684fc55

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,35 @@
+# 0.11.0
+
+* Support for Ruby 2.7. All warnings are gone.
+
+# 0.10.1
+
+* Update IllegalSignalError exception for more clarity
+
+# 0.10.0
+
+* Require `developer` >= 0.0.7.
+* Move `Activity::Introspect` back to this very gem.
+* This is hopefully the last release before 2.1.0. :trollface:
+
+# 0.9.4
+
+* Move some test helpers to `Activity::Testing` to export them to other gems
+* Remove introspection modules, it'll also be part of the `Dev` tools now.
+* Remove tracing modules, it'll be part of the `Dev` tools now.
+
+# 0.9.3
+
+Unreleased.
+
+# 0.9.2
+
+Unreleased.
+
+# 0.9.1
+
+* Use `context-0.9.1`.
+
 # 0.9.0
 
 * Change API of `Input`/`Output` filters. Instead of calling them with `original_ctx, circuit_options` they're now called with the complete (original!) circuit interface. This simplifies calling and provides all circuit arguments to the filter which can then filter-out what is not needed.

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-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,27 +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/trace"
-require "trailblazer/activity/present"
+require "trailblazer/activity/task_builder"
 
-require "trailblazer/activity/introspect"
 require "trailblazer/option"
 require "trailblazer/context"
-require "trailblazer/activity/task_builder"
 
 

data/lib/trailblazer/activity/circuit.rb

@@ -51,7 +51,16 @@ module Trailblazer
           # 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

@@ -20,7 +20,7 @@ class Trailblazer::Activity
         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)
+        Schema.new(circuit, outputs, nodes, config)
       end
 
       # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
@@ -83,10 +83,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"