decouplio 1.0.0alpha2 → 1.0.0alpha5

data/docs/pass.md

@@ -1,309 +0,0 @@
-# Pass
-
-`pass` is the step type that always moves to success track `logic` steps
-
-## Signature
-
-```ruby
-pass(step_name, **options)
-```
-
-## Behavior
-
- - when step method(`#pass_one`) returns truthy or falsy value then it goes to success track(`step_two` step)
-
-<details><summary><b>EXAMPLE (CLICK ME)</b></summary>
-<p>
-
-  ```ruby
-    require 'decouplio'
-
-    class SomeAction < Decouplio::Action
-      logic do
-        pass :pass_one
-        step :step_two
-        fail :fail_one
-      end
-
-      def pass_one(param_for_pass:, **)
-        ctx[:pass_one] = param_for_pass
-      end
-
-      def step_two(**)
-        ctx[:step_two] = 'Success'
-      end
-
-      def fail_one(**)
-        ctx[:fail_one] = 'Failure'
-      end
-    end
-
-    pass_success = SomeAction.call(param_for_pass: true)
-    pass_failure = SomeAction.call(param_for_pass: false)
-
-    pass_success # =>
-    # Result: success
-
-    # Railway Flow:
-    #   pass_one -> step_two
-
-    # Context:
-    #   {:param_for_pass=>true, :pass_one=>true, :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-
-    pass_failure # =>
-    # Result: success
-
-    # Railway Flow:
-    #   pass_one -> step_two
-
-    # Context:
-    #   {:param_for_pass=>false, :pass_one=>false, :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-  ```
-
-  ```mermaid
-    flowchart LR
-        1(start)-->2(pass_one success);
-        1(start)-->3(pass_one failure);
-        2(pass_one success)-->|success track|4(step_two);
-        3(pass_one failure)-->|success track|4(step_two);
-        4(step_two)-->|success track|5(finish_success)
-  ```
-
-</p>
-</details>
-
-***
-
-## Options
-
-### if: condition method name
-Can be used in case if for some reason step shouldn't be executed
-
-<details><summary><b>EXAMPLE (CLICK ME)</b></summary>
-<p>
-
-  ```ruby
-    require 'decouplio'
-
-    class SomeActionIfCondition < Decouplio::Action
-      logic do
-        step :step_one
-        pass :pass_one, if: :some_condition?
-        step :step_two
-      end
-
-      def step_one(**)
-        ctx[:step_one] = 'Success'
-      end
-
-      def pass_one(**)
-        ctx[:pass_one] = 'Success'
-      end
-
-      def step_two(**)
-        ctx[:step_two] = 'Success'
-      end
-
-      def some_condition?(condition_param:, **)
-        condition_param
-      end
-    end
-
-    condition_positive = SomeActionIfCondition.call(condition_param: true)
-    condition_negative = SomeActionIfCondition.call(condition_param: false)
-
-    condition_positive # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> pass_one -> step_two
-
-    # Context:
-    #   {:condition_param=>true, :step_one=>"Success", :pass_one=>"Success", :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-
-
-    condition_negative # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> step_two
-
-    # Context:
-    #   {:condition_param=>false, :step_one=>"Success", :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-  ```
-
-  ```mermaid
-  flowchart LR
-      1(start)-->2(step_one);
-      2(step_one)-->|condition positive|3(pass_one);
-      3(pass_one)-->|success track|4(step_two);
-      2(step_one)-->|condition negative|4(step_two);
-      4(step_two)-->|success track|5(finish_success);
-  ```
-</p>
-</details>
-
-***
-
-### unless: condition method name
-Can be used in case if for some reason step shouldn't be executed
-
-<details><summary><b>EXAMPLE (CLICK ME)</b></summary>
-<p>
-
-  ```ruby
-    require 'decouplio'
-
-    class SomeActionUnlessCondition < Decouplio::Action
-      logic do
-        step :step_one
-        pass :pass_one, unless: :some_condition?
-        step :step_two
-      end
-
-      def step_one(**)
-        ctx[:step_one] = 'Success'
-      end
-
-      def pass_one(**)
-        ctx[:pass_one] = 'Success'
-      end
-
-      def step_two(**)
-        ctx[:step_two] = 'Success'
-      end
-
-      def some_condition?(condition_param:, **)
-        condition_param
-      end
-    end
-
-    condition_positive = SomeActionUnlessCondition.call(condition_param: false)
-    condition_negative = SomeActionUnlessCondition.call(condition_param: true)
-
-    condition_positive # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> pass_one -> step_two
-
-    # Context:
-    #   {:condition_param=>false, :step_one=>"Success", :pass_one=>"Success", :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-
-    condition_negative # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> step_two
-
-    # Context:
-    #   {:condition_param=>true, :step_one=>"Success", :step_two=>"Success"}
-
-    # Errors:
-    #   {}
-  ```
-
-  ```mermaid
-  flowchart LR
-      1(start)-->2(step_one);
-      2(step_one)-->|condition positive|3(pass_one);
-      3(pass_one)-->|success track|4(step_two);
-      2(step_one)-->|condition negative|4(step_two);
-      4(step_two)-->|success track|5(finish_success);
-  ```
-</p>
-</details>
-
-***
-
-### finish_him: true
-
-Can be used in case if for some reason step shouldn't be executed
-
-<details><summary><b>EXAMPLE (CLICK ME)</b></summary>
-<p>
-
-  ```ruby
-    require 'decouplio'
-
-    class SomeActionFinishHim < Decouplio::Action
-      logic do
-        step :step_one, on_success: :step_two, on_failure: :pass_one
-        pass :pass_one, finish_him: true
-        step :step_two
-        step :step_three
-      end
-
-      def step_one(param_for_step:, **)
-        ctx[:step_one] = param_for_step
-      end
-
-      def pass_one(**)
-        ctx[:pass_one] = 'Success'
-      end
-
-      def step_two(**)
-        ctx[:step_two] = 'Success'
-      end
-
-      def step_three(**)
-        ctx[:step_three] = 'Success'
-      end
-    end
-
-    success_track = SomeActionFinishHim.call(param_for_step: true)
-    failure_track = SomeActionFinishHim.call(param_for_step: false)
-
-    success_track # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> step_two -> step_three
-
-    # Context:
-    #   {:param_for_step=>true, :step_one=>true, :step_two=>"Success", :step_three=>"Success"}
-
-    # Errors:
-    #   {}
-
-    failure_track # =>
-    # Result: success
-
-    # Railway Flow:
-    #   step_one -> pass_one
-
-    # Context:
-    #   {:param_for_step=>false, :step_one=>false, :pass_one=>"Success"}
-
-    # Errors:
-    #   {}
-  ```
-
-  ```mermaid
-  flowchart LR
-      1(start)-->2(step_one);
-      2(step_one)-->|success track|3(step_two);
-      3(step_two)-->|success track|4(step_three);
-      2(step_one)-->|failure track|5(pass_one);
-      4(step_three)-->|success track|6(finish success);
-      5(pass_one)-->|success track|6(finish success);
-  ```
-</p>
-</details>
-
-***

data/docs/pass.rb

@@ -1,213 +0,0 @@
-require_relative '../lib/decouplio'
-
-# Behavior
-class SomeAction < Decouplio::Action
-  logic do
-    pass :pass_one
-    step :step_two
-    fail :fail_one
-  end
-
-  def pass_one(param_for_pass:, **)
-    ctx[:pass_one] = param_for_pass
-  end
-
-  def step_two(**)
-    ctx[:step_two] = 'Success'
-  end
-
-  def fail_one(**)
-    ctx[:fail_one] = 'Failure'
-  end
-end
-
-pass_success = SomeAction.call(param_for_pass: true)
-pass_failure = SomeAction.call(param_for_pass: false)
-
-puts pass_success # =>
-# Result: success
-
-# Railway Flow:
-#   pass_one -> step_two
-
-# Context:
-#   {:param_for_pass=>true, :pass_one=>true, :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-puts pass_failure # =>
-# Result: success
-
-# Railway Flow:
-#   pass_one -> step_two
-
-# Context:
-#   {:param_for_pass=>false, :pass_one=>false, :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-
-
-# if: condition method name
-class SomeActionIfCondition < Decouplio::Action
-  logic do
-    step :step_one
-    pass :pass_one, if: :some_condition?
-    step :step_two
-  end
-
-  def step_one(**)
-    ctx[:step_one] = 'Success'
-  end
-
-  def pass_one(**)
-    ctx[:pass_one] = 'Success'
-  end
-
-  def step_two(**)
-    ctx[:step_two] = 'Success'
-  end
-
-  def some_condition?(condition_param:, **)
-    condition_param
-  end
-end
-
-condition_positive = SomeActionIfCondition.call(condition_param: true)
-condition_negative = SomeActionIfCondition.call(condition_param: false)
-
-puts condition_positive # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> pass_one -> step_two
-
-# Context:
-#   {:condition_param=>true, :step_one=>"Success", :pass_one=>"Success", :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-
-puts condition_negative # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> step_two
-
-# Context:
-#   {:condition_param=>false, :step_one=>"Success", :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-
-
-# unless: condition method name
-class SomeActionUnlessCondition < Decouplio::Action
-  logic do
-    step :step_one
-    pass :pass_one, unless: :some_condition?
-    step :step_two
-  end
-
-  def step_one(**)
-    ctx[:step_one] = 'Success'
-  end
-
-  def pass_one(**)
-    ctx[:pass_one] = 'Success'
-  end
-
-  def step_two(**)
-    ctx[:step_two] = 'Success'
-  end
-
-  def some_condition?(condition_param:, **)
-    condition_param
-  end
-end
-
-condition_positive = SomeActionUnlessCondition.call(condition_param: false)
-condition_negative = SomeActionUnlessCondition.call(condition_param: true)
-
-puts condition_positive # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> pass_one -> step_two
-
-# Context:
-#   {:condition_param=>false, :step_one=>"Success", :pass_one=>"Success", :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-puts condition_negative # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> step_two
-
-# Context:
-#   {:condition_param=>true, :step_one=>"Success", :step_two=>"Success"}
-
-# Errors:
-#   {}
-
-
-
-# finish_him: true
-class SomeActionFinishHim < Decouplio::Action
-  logic do
-    step :step_one, on_success: :step_two, on_failure: :pass_one
-    pass :pass_one, finish_him: true
-    step :step_two
-    step :step_three
-  end
-
-  def step_one(param_for_step:, **)
-    ctx[:step_one] = param_for_step
-  end
-
-  def pass_one(**)
-    ctx[:pass_one] = 'Success'
-  end
-
-  def step_two(**)
-    ctx[:step_two] = 'Success'
-  end
-
-  def step_three(**)
-    ctx[:step_three] = 'Success'
-  end
-end
-
-success_track = SomeActionFinishHim.call(param_for_step: true)
-failure_track = SomeActionFinishHim.call(param_for_step: false)
-
-puts success_track # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> step_two -> step_three
-
-# Context:
-#   {:param_for_step=>true, :step_one=>true, :step_two=>"Success", :step_three=>"Success"}
-
-# Errors:
-#   {}
-
-puts failure_track # =>
-# Result: success
-
-# Railway Flow:
-#   step_one -> pass_one
-
-# Context:
-#   {:param_for_step=>false, :step_one=>false, :pass_one=>"Success"}
-
-# Errors:
-#   {}

data/docs/quick_start.md

@@ -1,71 +0,0 @@
-## Quick start
-
-### Installation
-
-Regular installation
-```
-gem install decouplio
-```
-
-Gemfile
-```ruby
-gem 'decouplio'
-```
-
-### Usage
-
-All you need to do is to create new class and inherit it from `Decouplio::Action`, define your action logic and implement methods.
-
-```ruby
-require 'decouplio'
-
-class ProcessNumber < Decouplio::Action
-  logic do
-    step :multiply
-    step :divide
-  end
-
-  def multiply(number:, multiplier:, **)
-    ctx[:result] = number * multiplier
-  end
-
-  def divide(result:, divider:, **)
-    ctx[:result] = result / divider
-  end
-end
-
-action = ProcessNumber.call(number: 5, multiplier: 4, divider: 10) # =>
-# Result: success
-
-# Railway Flow:
-#   multiply -> divide
-
-# Context:
-#   {:number=>5, :multiplier=>4, :divider=>10, :result=>2}
-
-# Errors:
-#   {}
-
-action[:number] # => 5
-action[:multiplier] # => 4
-action[:divider] # => 10
-action[:result] # => 2
-
-action.success? # => true
-action.failure? # => false
-
-action.railway_flow # => [:multiply, :divide]
-```
-Learn more about all features:
-- [Logic block](https://github.com/differencialx/decouplio/blob/master/docs/logic_block.md)
-  - [Context](https://github.com/differencialx/decouplio/blob/master/docs/context.md)
-  - [Step](https://github.com/differencialx/decouplio/blob/master/docs/step.md)
-  - [Fail](https://github.com/differencialx/decouplio/blob/master/docs/fail.md)
-  - [Pass](https://github.com/differencialx/decouplio/blob/master/docs/pass.md)
-  - [Octo](https://github.com/differencialx/decouplio/blob/master/docs/octo.md)
-  - [Wrap](https://github.com/differencialx/decouplio/blob/master/docs/wrap.md)
-  - [Resq](https://github.com/differencialx/decouplio/blob/master/docs/resq.md)
-  - [Inner action](https://github.com/differencialx/decouplio/blob/master/docs/inner_action.md)
-  - [Doby](https://github.com/differencialx/decouplio/blob/master/docs/doby.md)
-  - [Step as a service](https://github.com/differencialx/decouplio/blob/master/docs/step_as_a_service.md)
-- [Error store](https://github.com/differencialx/decouplio/blob/master/docs/error_store.md)

data/docs/quick_start.rb

@@ -1,38 +0,0 @@
-require_relative '../lib/decouplio'
-
-class ProcessNumber < Decouplio::Action
-  logic do
-    step :multiply
-    step :divide
-  end
-
-  def multiply(number:, multiplier:, **)
-    ctx[:result] = number * multiplier
-  end
-
-  def divide(result:, divider:, **)
-    ctx[:result] = result / divider
-  end
-end
-
-action = ProcessNumber.call(number: 5, multiplier: 4, divider: 10) # =>
-# Result: success
-
-# Railway Flow:
-#   multiply -> divide
-
-# Context:
-#   {:number=>5, :multiplier=>4, :divider=>10, :result=>2}
-
-# Errors:
-#   {}
-puts action
-puts action[:number]# => 5
-puts action[:multiplier]# => 4
-puts action[:divider]# => 10
-puts action[:result]# => 2
-
-puts action.success? # => true
-puts action.failure? # => false
-
-puts action.railway_flow.to_s # => [:multiply, :divide]