trailblazer-activity-dsl-linear 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7b19b59ebf1ee26717edb3a9d5e797eec4a4796bc567bdc21ee92ba13fd4a04
-  data.tar.gz: 782a283ddf31bdebc6575323c7fcdae0958f301802793c5d193b2c42494f1076
+  metadata.gz: 74aa92e841b1cec015946ecabf0a7dde756df34adf30820db522223be3452870
+  data.tar.gz: 438194ab7ef0f1ad3f17a63e6306d426ae8e8a3544f33e78bb9e8292af7c7408
 SHA512:
-  metadata.gz: bc097663260f945545c68f4f7f9c8e6023631b5ff67552ec0baf0ee39acdf3b6c8517c31b31aecadcaf8d61b09e04ee31c033d0ae80b5019f5cc0b3392da64b1
-  data.tar.gz: cafc5c1e5dd50768986066988efac3b4fcbc37a5da13e10b2ca542fec63eb7193dee59a6379437bdd3ac69ea3a2e492065c4c076755e58432b11461e215fb01b
+  metadata.gz: 946cddafc751a2b2c9c385911080871a3f7b43231814cf2b351728cc0ae9eaf1297e30e1ed604d6d150ce4c5add9fc74820660e53a61e9b9528691ae805c15d4
+  data.tar.gz: f8218e47483f166fb9bbc3f036b86a8bde0aced4c1e34a8c3be1558d94eb54c98c7159b432d6e1c3533df5f92991cd7184cb6403806f8bb0ed8c661ffb42b42e

data/CHANGES.md

@@ -1,3 +1,7 @@
+# 0.2.6
+
+* Added `@fields` to `Linear::State` to save arbitrary data on the activity/strategy level.
+
 # 0.2.5
 
 * Patching now requires the [`:patch` option for `Subprocess`](http://2019.trailblazer.to/2.1/docs/activity.html#activity-dsl-options-patching

data/README.md

@@ -1,29 +1,93 @@
-# Trailblazer-Activity-DSL-Linear
+# Activity-DSL-Linear
 
-_The popular Railway/Fasttrack DSL for building activities._
+The `activity-dsl-linear` gem brings:
+- [Path](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-path)
+- [Railway](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)
+- [Fasttrack](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-fasttrack)
+  
+DSLs strategies for buildig activities. It is build around [`activity`](https://github.com/trailblazer/trailblazer-activity) gem.
 
+Please find the [full documentation on the Trailblazer website](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy). [Note that the docs are WIP.]
 
-# Overview
+## Example
 
-This gem allows creating activities by leveraging a handy DSL. Built-in are the strategies `Path`, the popular `Railway` and `FastTrack`. The latter is used for `Trailblazer::Operation`.
+The `activity-dsl-linear` 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)).
 
-Note that you don't need to use the DSL. You can simply create a InIm structure yourself, or use our online editor.
+```ruby
+require "trailblazer-activity"
+require "trailblazer-activity-dsl-linear"
 
-Full documentation can be found here: trailblazer.to/2.1/#dsl-linear
+class Memo::Update < Trailblazer::Activity::Railway
+  # here goes your business logic
+  #
+  def find_model(ctx, id:, **)
+    ctx[:model] = Memo.find_by(id: id)
+  end
 
-## Normalizer
+  def validate(ctx, params:, **)
+    return true if params[:body].is_a?(String) && params[:body].size > 10
+    ctx[:errors] = "body not long enough"
+    false
+  end
 
-Normalizers are itself linear activities (or "pipelines") that compute all options necessary for `DSL.insert_task`.
-For example, `FailFast.normalizer` will process your options such as `fast_track: true` and add necessary connections and outputs.
+  def save(ctx, model:, params:, **)
+    model.update_attributes(params)
+  end
 
-The different "step types" (think of `step`, `fail`, and `pass`) are again implemented as different normalizers that "inherit" generic steps.
+  def log_error(ctx, params:, **)
+    ctx[:log] = "Some idiot wrote #{params.inspect}"
+  end
 
+  # here comes the DSL describing the layout of the activity
+  #
+  step :find_model
+  step :validate, Output(:failure) => End(:validation_error)
+  step :save
+  fail :log_error
+end
+```
 
-`:sequence_insert`
-`:connections` are callables to find the connecting tasks
+Visually, this would translate to the following circuit.
+
+<img src="http://trailblazer.to/images/2.1/activity-readme-example.png">
+
+You can run the activity by invoking its `call` method.
+
+```ruby
+ctx = { id: 1, params: { body: "Awesome!" } }
+
+signal, (ctx, *) = Update.( [ctx, {}] )
+
+pp ctx #=>
+{:id=>1,
+ :params=>{:body=>"Awesome!"},
+ :model=>#<Memo body=nil>,
+ :errors=>"body not long enough"}
+
+pp signal #=> #<struct Trailblazer::Activity::End semantic=:validation_error>
+```
+
+With Activity, modeling business processes turns out to be ridiculously simple: You define what should happen and when, and Trailblazer makes sure _that_ it happens.
+
+## Features
+
+* Activities can model any process with arbitrary flow and connections.
+* 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! (via Trailblazer's [`developer`](https://github.com/trailblazer/trailblazer-developer) gem)
+
+## Operation
+
+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/lib/trailblazer/activity/dsl/linear/state.rb

@@ -3,28 +3,40 @@ module Trailblazer
     module DSL
       module Linear
         # A {State} instance is kept per DSL client, which usually is a subclass of {Path}, {Railway}, etc.
+        # State doesn't have any immutable features - all write operations to it must guarantee they only replace
+        # instance variables.
+        #
+        # @private
+        #
+        # DISCUSS: why do we have this structure? It doesn't cover "immutable copying", that has to be done by its clients.
+        #          also, copy with to_h
         class State
             # remembers how to call normalizers (e.g. track_color), TaskBuilder
             # remembers sequence
-          def initialize(normalizers:, initial_sequence:, **normalizer_options)
+          def initialize(normalizers:, initial_sequence:, fields: {}.freeze, **normalizer_options)
             @normalizer         = normalizers # compiled normalizers.
             @sequence           = initial_sequence
             @normalizer_options = normalizer_options
+            @fields             = fields
           end
 
           # Called to "inherit" a state.
           def copy
-            self.class.new(normalizers: @normalizer, initial_sequence: @sequence, **@normalizer_options)
+            self.class.new(normalizers: @normalizer, initial_sequence: @sequence, fields: @fields, **@normalizer_options)
           end
 
           def to_h
-            {sequence: @sequence, normalizers: @normalizer, normalizer_options: @normalizer_options} # FIXME.
+            {sequence: @sequence, normalizers: @normalizer, normalizer_options: @normalizer_options, fields: @fields} # FIXME.
           end
 
           def update_sequence(&block)
             @sequence = yield(to_h)
           end
 
+          def update_options(fields)
+            @fields = fields
+          end
+
           # Compiles and maintains all final normalizers for a specific DSL.
           class Normalizer
             def compile_normalizer(normalizer_sequence)

data/lib/trailblazer/activity/dsl/linear/strategy.rb

@@ -29,7 +29,7 @@ module Trailblazer
             options = options.merge(dsl_track: type)
 
             # {#update_sequence} is the only way to mutate the state instance.
-            state.update_sequence do |sequence:, normalizers:, normalizer_options:|
+            state.update_sequence do |sequence:, normalizers:, normalizer_options:, fields:|
               # Compute the sequence rows.
               options = normalizers.(type, normalizer_options: normalizer_options, options: task, user_options: options.merge(sequence: sequence))
 

data/lib/trailblazer/activity/dsl/linear/version.rb

@@ -3,7 +3,7 @@ module Trailblazer
     module Activity
       module DSL
         module Linear
-          VERSION = "0.2.5"
+          VERSION = "0.2.6"
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity