onuro 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba55460305728147a6a6902162062d320bb2c8f3324b7001b2177b46ef5d297f
-  data.tar.gz: 426b556b04838c980ee44fee95210322ed89eeef0e522de578e3358183b0e88d
+  metadata.gz: 69886eaf6e1ecb4acd854b3a6fdc261b768f1072b5983bacc3599654598850fd
+  data.tar.gz: 58774fa0bda58c4d715d22ca498a49d9dc97cdde01f07fbfed7e127b6ea4f308
 SHA512:
-  metadata.gz: 8e74ec30d7458cfb9f27d451181a1abd5272e4e7c0f8e715a1e080fd672f0d22b773cd48a36cca5b1047af3a0400b2b6b8eea5cbe7cbb572c32ebeb18c77cb45
-  data.tar.gz: 1c8c9b00aabdb5138095427d48eee6c7965fd69a17da7d52d616f6d758f3a1f3eafd726f146d9121364e9e354803b2e197d20c8ccabf7b251ee1643ec27b782f
+  metadata.gz: 885e050ca969163f3bdf208b09befe7977bce2e9cd8366f6fc2426a1c4f9ec17d0d5bd550e01389dc0f76da15d02213448dae56962cde5bacd08c0913e7b9906
+  data.tar.gz: 129db0caa43e8311da60330df7cbe4b71708fb28689b2d1dfeb25072d37c867e27b8cc23ba038be03aa37f077ae27fb338bba150fa92981e5a7e5693b3b979c9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    onuro (0.1.3)
+    onuro (0.1.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,14 +1,12 @@
 # Onuro
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/onuro`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Workflow Engine based in events that execute a collection of rules defined in the event configuration definition
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
+```bash
 gem 'onuro'
 ```
 
@@ -22,15 +20,17 @@ Or install it yourself as:
 
 ## Usage
 
-The easiest way to load Event + Rules configuration in the **Engine** is using the configuration blocks. Its important to mention these global pre-configured events, would be changed when in runt-time an **engine instance** is begin fetched with new events.
+The easiest way to load *Events + Rules* configuration in the **Engine** is using the configuration blocks. Its important to mention these global pre-configured events, would not be changed when in runt-time an **engine instance** is begin fetched with new events.
 
 ```ruby
 class Rule1 < Onuro::BaseRule; end
 class Rule2 < Onuro::BaseRule; end
 class Rule3 < Onuro::BaseRule; end
-class MyCustomEventStrategy < Onuro::DefaultEventStrategy; end
-
+class MyCustomEventStrategy < Onuro::DefaultEventStrategy
+  # override here the methods to execute your custom logic before/after each rule
+end
 
+# Onuro::Engine configuration block
 Onuro::Engine.configure do |config|
   config.add_event(:event_one) do |event|
     event.add_ruleset_stage [
@@ -54,23 +54,107 @@ Onuro::Engine.configure do |config|
   end
 
   config.add_event(:event_four) do |event|
-    event.add_rule_stage Onuro::RuleStage.default_ruleset_stage_factory([Rule1, Rule2, Rule3])
+    event.add_ruleset_stage Onuro::RuleStage.default_ruleset_stage_factory([Rule1, Rule2, Rule3])
   end
 end
+
+# When the *engine object is created, will fetch the pre-configured events for instant use,
+# saving the boilerplate object setup for your common events and rule sets.
+exec_result = Onuro::Engine.new.execute(:event_four)
+```
+
+### Context
+
+This is the instance object that will be passed through all the event execution process. Here you can pass key/value params that will be help you while the **Rules** are being executed. Things like *member_id*, *current_date* (you name it) will be passed from the engine to all the way down until the end of the execution. Since is a reference object, you can add new key/value states during the *ruleset* execution.
+
+One way:
+```ruby
+Onuro::Engine.new.execute(:my_event) do |context|
+  context.add(:member_id, 1)
+  context.add(:current_date, '01/01/2019')
+end
 ```
 
+Another way:
+```ruby
+context = Onuro::ContextBuilder.build do |context|
+    context.add(:member_id, 1)
+    context.add(:current_date, '01/01/2019')
+end
+
+Onuro::Engine.new.execute(:my_event, context)
+```
+
+Another way with *double splat* operators in the *Context* constructor:
+```ruby
+context = Onuro::Context.new(member_id: 1, current_date: '01/01/2019')
+
+Onuro::Engine.new.execute(:my_event, context)
+```
+
+**Note:** If you do not provide a context, an empty one will be created.
+
 ### Engine
 
-### Rule
+The **engine** is the object that can hold a list of **events**, where the desired **event** is executed and additionally, you can provide a **context** object with helpful key/value data that will help you in your **rule** processing.
+
+```ruby
+context = Onuro::Context.new(...your data..)
+engine = Onuro::Engine.new
+
+engine.add_events([event1, event2])
+engine.new.execute(:my_event, context)
+```
+
+### Rules
+
+Are the foundation building blocks of the *rulesets* and this is where you can place your **logic** divided in segments(**rules**).
+
+All the rules processed by the engine is recommended to inherith from **Onuro::BaseRule** since this base class give you access to the **logger** support and easy access to the **ExecutionResult** constants used by the engine. Basically you need to override/implement **execute** method accepting as input an **context** object. The **rule** need to return and **ExecutionResult** constant. (More about extending this later in this README)
+
+A collection of *rules* is holded by an **event** object
+
+```ruby
+class MyRule < Onuro::BaseRule
+  def execute(context)
+    context[:mul_result] = context[:first_operand] * context[:second_operand]
+    SUCCESSFUL
+  end
+end
+
+ruleset_stage = Onuro::RuleStage.default_ruleset_stage_factory([MyRule])
+event.add_ruleset_stage(ruleset_stage)
+```
+
+Also, you can execute a single rule without using the full **Onuro::Engine**
+
+```ruby
+MyRule.new.execute(context)
+```
 
 ### RuleStage
 
+Since *Onuro* allows the rule execution, you can diseable or add a particular **order** of execution to all the rules in a rulseset, the **RuleStage** class help us to do that. You cannot add the **Rule** object instances directly in the event, without adding first each rule into a **RuleStage** object.
+
+```ruby
+event.add_ruleset_stage [
+  Onuro::RuleStage.new(rule: Rule1, enabled: true, order: 1),
+  Onuro::RuleStage.new(rule: Rule3, enabled: true, order: 2)
+]
+```
+
+If you want to add all the rules enabled by default, and the execution order will be based in the order that you define the ruleset collection, you can use a **RuleStage** factory to save all these object setup:
+
+```ruby
+event.add_ruleset_stage Onuro::RuleStage.default_ruleset_stage_factory([Rule1, Rule2, Rule3])
+```
+
 ### Events
 
 Events are the component that hold an *rulset stage* composed of a list of rules and their settings for execution. The easiest way to define and event is creating the instance object always with the event name required. In order to create complex events with more settings, take a look to the *Event Builder* section.
 
 ```ruby
-event = Event.new(:my_event)
+event = Onuro::Event.new(:my_event)
 engine.add_event(event)
 engine.execute(:my_event)
 ```
@@ -80,7 +164,7 @@ engine.execute(:my_event)
 An easier way to create an event, is using the **EventBuilder** class based on the *builder pattern*. This gives a lot of flexibility when you are creating the events and avoid having a lot or parameters in the constructor and assembling  all the event internals, and easy to to be plugged in you **Engine** class instance.
 
 ```ruby
-event = EventBuilder.build(:test_ruleset) do |builder|
+event = Onuro::EventBuilder.build(:test_ruleset) do |builder|
           builder.add_ruleset_stage([rule1, rule2, rule3])
           builder.add_event_strategy(MyCustomEventStrategy.new)
           builder.exec_order(:desc)
@@ -113,6 +197,18 @@ You only need to implement the methods **before_rule_exec** and **after_rule_exe
 
 If **before_rule_exec** returns false, skip the current rule execution and move to the next one in the ruleset list.
 
+### ExecutionResult
+
+TBD
+
+### Determining succcess or failure of the event processing
+
+TBD
+
+### Logging
+
+TBD
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/onuro.rb

@@ -4,6 +4,8 @@ require 'onuro/version'
 require 'onuro/execution_result'
 require 'onuro/logging'
 require 'onuro/engine_configuration'
+require 'onuro/context_builder'
+require 'onuro/context'
 require 'onuro/engine'
 require 'onuro/default_event_strategy'
 require 'onuro/event_builder'

data/lib/onuro/context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Onuro
+  class Context
+    attr_reader :data
+
+    def initialize(**options)
+      @data = Hash.new(0)
+      @data.merge!(options)
+    end
+
+    def add(key, value)
+      data[key] = value
+    end
+  end
+end

data/lib/onuro/context_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Onuro
+  class ContextBuilder
+    attr_accessor :context
+
+    def initialize
+      self.context = Context.new
+    end
+
+    def add(key, value)
+      context.add(key, value)
+    end
+
+    def self.build
+      builder = new
+      yield builder if block_given?
+      builder.context
+    end
+  end
+end

data/lib/onuro/engine.rb

@@ -67,9 +67,10 @@ module Onuro
       raise InvalidEventNameException unless result
     end
 
-    def execute(event_name, context = {})
+    def execute(event_name, context = Context.new)
       raise InvalidEventNameException unless event?(event_name)
 
+      context.data.merge! ContextBuilder.build.data
       events[event_name].execute(context)
     end
   end

data/lib/onuro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Onuro
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onuro
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Rodrigo Reyes
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-15 00:00:00.000000000 Z
+date: 2019-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -157,6 +157,8 @@ files:
 - bin/setup
 - lib/onuro.rb
 - lib/onuro/base_rule.rb
+- lib/onuro/context.rb
+- lib/onuro/context_builder.rb
 - lib/onuro/default_event_strategy.rb
 - lib/onuro/engine.rb
 - lib/onuro/engine_configuration.rb