Skip to content

Latest commit

 

History

History
175 lines (107 loc) · 5.35 KB

CHANGES.md

File metadata and controls

175 lines (107 loc) · 5.35 KB
Raw

TODO:

  • api to add your own task.

lots of work on the DSL specific parts. Graph and Sequence to make it easier to wire anything. macros can now add/modify the wiring, e.g. their end to the our end or the next task. [ use circuit for actual step_args/initialize process, too? ] You can now add an unlimited number of "your own" end events, which can then be interpreted on the outside (e.g. Endpoint)

  • Introduced the fast_track: true option for steps. If you were returning Railway.fail_fast! and the like, you now need to declare that option, e.g.

      ```ruby
  step :my_validate!, fast_track: true
  ```

params:, rest: ..

0.4.1

  • Use activity-0.7.1.

0.4.0

  • Use activity-0.7.0.

0.3.1

  • Moved VariableMapping to the activity gem.

0.3.0

  • Use activity 0.6.0.

  • Remove Operation::__call__ in favor of one call that dispatches to either

    • call_with_public_interface this implements the complicated public Operation.() semantic and will be faded out with the rise of workflow engines.
    • call_with_circuit_interface is the circuit-compatible version that will be invoked on nested operations.

    This might seem a bit "magical" but simplifies the interface a lot. In better languages, you could use method overloading for that, in Ruby, we have to do that ourselves. This decision was made with the deprecation of Operation.() in mind. In the future, operations will mostly be invoked from workflow engines and not directly, where the engine takes care of applying the correct interface.

0.2.5

  • Minor fixes for activity 0.5.2.

0.2.4

  • Use Activity::FastTrack signals.

0.2.2

  • Use activity-0.4.2.

0.2.1

  • Use activity-0.4.1.

0.2.0

  • Cleanly separate Activity and Operation responsibilities. An operation is nothing more but a class around an activity, hosting instance methods and implementing inheritance.

0.1.4

  • TaskWrap.arguments_for_call now returns the correct circuit_options where the :runner etc.'s already merged.

0.1.3

  • New taskWrap API for activity 0.3.2.

0.1.2

  • Add @mensfeld's "Macaroni" step style for a keyword-only signature for steps.

0.1.0

inspect: failure is << and success is >>

call vs call: it's now designed to be run in a composition where the skills stuff is done only once, and the reslt object is not necessary

FastTrack optional
Wrapped optional

  • Add pass and fail as four-character aliases for success and failure.

  • Remove Uber::Callable requirement and treat all non-:symbol steps as callable objects.

  • Remove non-kw options for steps. All steps receive keyword args now:

    def model(options)

    now must have a minimal signature as follows.

    def model(options, **)

  • Remove Operation#[] and Operation#[]=. Please only change state in options.

  • API change for step Macro(): the macro's return value is now called with the low-level "Task API" signature (direction, options, flow_options). You need to return [direction, options, flow_options]. There's a soft-deprecation warning.

  • Remove support for Ruby 1.9.3 for now. This can be re-introduced on demand.

  • Remove pipetree in favor of trailblazer-circuit. This allows rich workflows and state machines in an operation.

  • Remove uber dependency.

0.0.13

  • Rename Operation::New to :Instantiate to avoid name clashes with New operations in applications.
  • Fix Ruby > 2.3.3's Forwardable issue.

0.0.12

  • Allow passing tmp options into KW::Option that will be merged with options and then transformed into kw args, but only locally for the step scope (or wherever you do Option.()). The API:

    Option::KW.(proc).(input, options, some: "more", ...)

    Note that KW::Option could be massively sped up with simple optimizations.

0.0.11

  • Use Forwardable instead of Uber::Delegates.

0.0.10

  • Flow is now Railway.
  • Any Right subclass will now be interpreted as success.
  • Add fail!, fail_fast!, pass!, and pass_fast!.
  • The only semi-public method to modify the pipe is Railway#add
  • Removed &, >, < and % "operators" in favor of #add.
  • Extremely simplified the macro API. Macros now return a callable step with the interface ->(input, options) and their pipe options, e.g. [ step, name: "my.macro"].

0.0.9

Removing Operation::consider, which is now step. We now have three methods, only.

  • step import macro or add step with the & operator, meaning its result is always evaluated and decides about left or right.
  • success always adds to right track.
  • failure always adds to left track.

This was heavily inspired by a discussion with @dnd, so, thanks! 🍻

0.0.8

  • Introduce a new keyword signature for steps:

    step ->(options, params:, **) { options["x"] = params[:id] }

    The same API works for instance methods and Callables.

    Note that the implementation of Option and Skills#to_hash are improveable, but work just fine for now.

0.0.7

  • Simplify inheritance by basically removing it.

0.0.6

  • Improvements with the pipe DSL.

0.0.5

  • _insert provides better API now.

0.0.4

  • Don't pass the operation into Result, but the Skill options hash, only.

0.0.3

  • Add #inspect(slices).

0.0.2

  • Works.