rule_box 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 329170f893810594f25f10974e41e1955e5b53d96864233bfe63351fc075f41f
-  data.tar.gz: 9970c839c1d7ab16076c9abd5d851d85b9ea9ca6fe8591e89d891926c0cdb62a
+  metadata.gz: 27b80b3f8ec0341fbd5540a97820428a7473fb2efe3bc6d9120f485cd481c878
+  data.tar.gz: 4b44f91e618f1e77e830bb9853d9b1fc6cd066aea51505b04491a3684f866b53
 SHA512:
-  metadata.gz: bf1c291c01a00d47ee38c4231eee1012bded36a983c688038e56bb962e85174600b7a1d7155cbeea9978960cd92a0e8942b9413582d5cf24b3a2fa9e52fd30b2
-  data.tar.gz: 86606f7fede5d0a29beb1bd58a7c920a1c336061ff4500052fdc7fd206633026930e32146d9f4a9cd3a8e8f3b52565dfe45009963ebf581d7f3851175dfb25c9
+  metadata.gz: ad5848afa5b2b38485f7a4eff85dccca01e8f67fea7bbe42516b23c6e57a0c8bfec265881fcc14783297740bcbf611c2d8feb8ec10c489a13f4bfbe43e1e5ab5
+  data.tar.gz: 1d597a2071d512d353a2b0c0a8d9e5e301297a4d447c054c72ca6286d489452bdfe0966a35e4ce7deb3b16366f2b34aa105a3b727b4ef06cc4f3dc899ccdac23

data/Gemfile

@@ -6,4 +6,10 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'rake', '~> 12.0'
-gem 'rspec', '~> 3.0'
+
+group :development, :test do
+  gem 'byebug', '~> 11.1', '>= 11.1.3'
+  gem 'rspec', '~> 3.0'
+  gem 'rubocop', '~> 1.28', '>= 1.28.2', require: false
+  gem 'simplecov', '~> 0.21.2', require: false
+end

data/Gemfile.lock

@@ -1,34 +1,65 @@
 PATH
   remote: .
   specs:
-    rule_box (0.1.3)
+    rule_box (0.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.4.4)
+    ast (2.4.2)
+    byebug (11.1.3)
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
     rake (12.3.3)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
+    regexp_parser (2.4.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.29.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.17.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.17.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (2.1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  byebug (~> 11.1, >= 11.1.3)
   rake (~> 12.0)
   rspec (~> 3.0)
+  rubocop (~> 1.28, >= 1.28.2)
   rule_box!
+  simplecov (~> 0.21.2)
 
 BUNDLED WITH
-   2.1.4
+   2.3.13

data/README.pt-br.md

@@ -59,7 +59,7 @@ Existem alguns *helpers* na classe *Strategy* que irão ajudá-lo.
 
 ```ruby
 strategy.model # Retorna o "Model"
-strategy.set_status # Seta o valor semáforo: [:red, :yellow, :green] 
+strategy.set_status # Seta o valor status: [:red, :yellow, :green] 
 strategy.add_error # Adiciona uma mensagem de erro
 ```
 
@@ -92,7 +92,7 @@ class User
   attr_accessor :name
 
   # lista de regras de negócio
-  rules_of_insert Rules::CheckName
+  rules Rules::CheckName
 
 end
 ```
@@ -103,21 +103,21 @@ require 'rule_box/facade'
 
 user = User.new
 facade = Rulebox::Facade.new
-facade.insert user
+facade.exec user
 puts facade.status # :red
 puts facade.errors # ["Nome não pode ficar em branco"]
 
 user = User.new
 user.name = 'Ana'
 facade =  Rulebox::Facade.new
-facade.insert user
+facade.exec user
 puts facade.status # :red
 puts facade.errors  # ["Nome deve conter pelo menos 4 caracteres"]
 
 user = User.new
 user.name = 'Alex'
 facade =  Rulebox::Facade.new
-facade.insert user
+facade.exec user
 puts facade.status # :green
 puts facade.errors # []
 
@@ -167,35 +167,68 @@ class User
   include RuleBox::Mapper
   attr_accessor :name, :age
 
-  rules_of_insert Rules::CheckName, Rules::CheckAge, Rules::SaveModel
+  rules Rules::CheckName, Rules::CheckAge, Rules::SaveModel
 
 end
 
 ```
 
  
-## Desenvolvimento
+## Hooks
+
+Existem alguns hooks que podem auxiliar na chamadas das regras de negócio
+
+| Hook             | Descrição                        |
+|------------------|----------------------------------|
+| after_rule       | depois de cada regra             |
+| after_rules      | depois de todas as regras        |
+| around_rule      | na execução de cada regra        |
+| around_rules     | na execução de todas as regras   |
+| customize_result | customiza o retorno do resultado |
+| before_rule      | antes de cada regra              |
+| before_rules     | antes de todas as regras         |
+| rescue_from      | captura uma exeção               |
+
+Exemplo
+```ruby
+
+User.before_rules { puts 'before all' }
+User.before_rule do |facade|
+  puts 'before'
+  puts facade.steps.last
+end
+User.after_rule do |facade|
+  puts facade.steps.last
+  puts 'after'
+end
+User.before_rules { puts 'after all' }
 
-Uma vez no modo de desenvolvimento, ele pode exibir as etapas (steps) que ocorreram no Facade.
 
-```ruby
 user = User.new
 user.name = 'Carlos'
 user.age = 19
 
 facade = RuleBox::Facade.new
-facade.show_steps = true
-facade.insert user
+facade.exec user
 
 # Saída do Log
-# [2020-07-29T08:09:00.212-03:00] { method: insert, model: User, args: {} }
-# [2020-07-29T08:09:00.212-03:00] amount of rules 3
+# before all
+# before
 # [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::CheckName.
+# [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::CheckName.
+# after
+# before
+# [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::CheckAge.
 # [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::CheckAge.
+# after
+# before
 # [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::SaveModel.
-# [2020-07-29T08:09:00.212-03:00] finalized the process on the facade.
+# [2020-07-29T08:09:00.212-03:00] executing of rule: Rules::SaveModel.
+# after
+# after all
 ```
 
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/rule_box/execution_hook.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuleBox
+  module ExecutionHook
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      new_hooks = %i[
+        after_rule after_rules around_rule around_rules
+        customize_result
+        before_rule before_rules
+      ]
+
+      new_hooks.each do |rule|
+        define_method rule do |&block|
+          hooks[rule] = block
+        end
+      end
+
+      def call_hook(type, arg = nil)
+        block = hooks[type.to_sym]
+        return nil unless block.is_a? Proc
+
+        block.call(arg)
+      end
+
+      def clear_hooks!
+        @rescue_handlers = []
+        @hooks = {}
+      end
+
+      def has_hook?(name)
+        hooks[name.to_sym].is_a? Proc
+      end
+
+      def rescue_from(*klasses, &block)
+        klasses.each do |klass|
+          match = klass < Exception || klass == Exception
+          raise ArgumentError, "#{klass.inspect} must be an Exception class" unless match
+
+          rescue_handlers.concat [[klass, block]]
+        end
+      end
+
+      def rescue_handlers
+        @rescue_handlers ||= []
+      end
+
+      def resolve_exception!(facade)
+        rescue_handlers.each do |exception, block|
+          next unless facade.exception.is_a? exception
+
+          block.call facade
+          return true
+        end
+
+        nil
+      end
+
+      private
+
+      def hooks
+        @hooks ||= {}
+      end
+    end
+  end
+end

data/lib/rule_box/facade.rb

@@ -1,201 +1,257 @@
 # frozen_string_literal: true
 
-class RuleBox::Facade
-  attr_reader :model, :status, :data, :bucket, :errors, :steps, :executed, :_current_method
-  attr_accessor :show_steps
-
-  def initialize(**dependencies)
-    errors = []
-    settings.dependencies.each do |key, block|
-      begin
-        if dependencies.key? key
-          value = dependencies[key]
-          block&.call(value, errors)
-        else
-          errors << "missing keyword: #{key}"
-        end
-      rescue StandardError => e
-        errors << e.message
+module RuleBox
+  class Facade
+    include RuleBox::MethodHelper
+    include RuleBox::ExecutionHook
+
+    attr_reader :entity, :exception, :strategies, :current_strategy, :current_method, :bucket, :executed, :last_result,
+                :status
+
+    attr_clones :errors, :steps
+
+    def initialize(**dependencies)
+      set_dependencies! dependencies
+      @executed = false
+    end
+
+    def add_error(msg)
+      if msg.is_a? Array
+        msg.each { |message| add_error(message) }
+      else
+        @errors << msg
       end
     end
 
-    raise errors.join("\n") unless errors.empty?
+    def exec(method = :perform, entity, **args)
+      perform method, entity, **args
+    end
 
-    dependencies.each { |key, value| keys["current_#{key}".to_sym] = value }
-    @executed = false
-    @show_steps = settings.show_steps
-  end
+    def get(key)
+      keys[key.to_s].clone
+    end
 
-  def insert(model, **args)
-    execute(:insert, model, args)
-  end
+    def run
+      return unless @next_run
 
-  def select(model, **args)
-    execute(:select, model, args)
-  end
+      send @next_run
+      true
+    end
 
-  def update(model, **args)
-    execute(:update, model, args)
-  end
+    def set_status(status)
+      @status = status
+    end
 
-  def delete(model, **args)
-    execute(:delete, model, args)
-  end
+    def instance_values
+      hash = {
+        current_strategy: @current_strategy&.instance_values,
+        strategies: (@strategies || []).map(&:instance_values)
+      }
 
-  def _current_class
-    @_current_class ||=
-      if model.nil?
-        nil
-      elsif model.is_a?(Class) || model.is_a?(Module)
-        model
-      elsif model.is_a?(Symbol) || model.is_a?(String)
-        Object.const_get RuleBox::Util.camelize(model.to_s)
-      else
-        Object.const_get model.class.name
-      end
-  end
+      keys.each { |k, v| hash[k.to_sym] = v.clone }
 
-  def attributes
-    attrs = {}
-    %i[model status data bucket executed errors steps _current_method].each do |key|
-      value = send key
-      attrs[key] = value
+      %i[
+        entity exception current_class current_method bucket
+        executed last_result status errors steps
+      ].each { |key| hash[key] = send(key).clone }
+
+      hash
     end
-    attrs
-  end
 
-  def to_json(**args)
-    JSON.generate(as_json(args), args)
-  end
+    private
 
-  def as_json(**options)
-    options.key?(:root) ? { self.class.name.to_sym => attributes } : attributes
-  end
+    def add_step(value)
+      new_value = "[#{DateTime.now.strftime('%FT%T.%L%:z')}] #{value}"
+      @steps << new_value
+    end
 
-  def to_s
-    as_json(root: true).to_s
-  end
+    def around(around_method, current_method)
+      @next_run = current_method
+      hooks.each { |hook| hook.call_hook around_method, self }
+      @next_run = nil
+    end
 
-  private
+    def build_bucket
+      {}
+    end
 
-  def method_missing(method, *parameters)
-    super if parameters.empty?
-    super if method.to_s.end_with? '='
+    def check_executed!
+      raise 'Process already executed' if @executed
+    end
 
-    model = parameters[0]
-    args = parameters[1] || {}
-    execute(method, model, args)
-  end
+    def check_strategies!(class_strategies)
+      raise "class [#{current_class}] without mapped rules to [#{current_method}]'" if class_strategies.empty?
 
-  def respond_to_missing?(method, _include_private = false)
-    return false if @executed || method.to_s.end_with?('=')
+      classes = class_strategies.reject { |strategy| strategy < RuleBox::Strategy }
+      unless classes.size.zero?
+        raise "class [#{classes.map(&:name).join(', ')}] must extends RuleBox::Strategy or your subclass."
+      end
+    end
 
-    super
-  end
+    def current_class
+      entity.class
+    end
 
-  def execute(method, model, args = {})
-    raise 'Process already executed' if @executed
+    def execute_all
+      hooks.each { |h| h.call_hook(:before_rules, self) }
 
-    @executed = true
-    @status = :green
-    @bucket = RuleBox::Hash.new
-    args.each { |key, value| bucket[key] = value } if args.is_a? Hash
-    pre_process(method, model)
-  end
+      if hooks.any? { |h| h.has_hook? :around_rules }
+        around :around_rules, :execute_strategies
+      else
+        execute_strategies
+      end
+      hooks.each { |h| h.call_hook(:after_rules, self) }
+    end
 
-  def pre_process(method, model)
-    @model = model
-    @_current_method = method
-    class_name = _current_class
-    @errors = []
-    @steps = []
+    def execute_one
+      hooks.each { |h| h.call_hook(:before_rule, self) }
 
-    add_step "{ method: #{method}, model: #{class_name}, args: #{bucket} }"
-    strategies = class_name.strategies(method)&.map { |strategy| strategy.new(self) }
-    unless strategies
-      raise "class [#{class_name}] without mapped rules to [#{method}]'"
+      if hooks.any? { |h| h.has_hook? :around_rule }
+        around :around_rule, :execute_strategy
+      else
+        execute_strategy
+      end
+      hooks.each { |h| h.call_hook(:after_rule, self) }
     end
 
-    process(strategies)
-  end
+    def execute_strategies
+      @strategies.each do |strategy|
+        @current_strategy = strategy
+        execute_one
+        break if status == failure_status
+      end
+    rescue Exception => e
+      @exception = e
+    ensure
+      add_step 'finalized the process on the facade.'
+    end
 
-  def process(strategies)
-    add_step "amount of rules #{strategies.count}"
+    def execute_strategy
+      add_step "executing of rule: #{@current_strategy.class.name}."
 
-    strategies.each do |strategy|
-      add_step "executing of rule: #{strategy.class.name}."
-      strategy.process
+      strategy_method = @current_strategy.method(:perform)
 
-      break if status == :red
+      @last_result =
+        if strategy_method.parameters.empty?
+          strategy_method.call
+        else
+          strategy_method.call(@last_result)
+        end
     end
-  rescue Exception => e
-    errors << settings.default_error_message
-    @status = :red
-    block = settings.resolve
-    block.call(e, RuleBox::Proxy.new(self)) if block.is_a? Proc
-  ensure
-    add_step 'finalized the process on the facade.'
-    return self
-  end
 
-  def settings
-    RuleBox::Facade.settings
-  end
+    def failure_status
+      :red
+    end
 
-  def add_step(value)
-    new_value = "[#{DateTime.now.strftime('%FT%T.%L%:z')}] #{value}"
-    puts new_value if show_steps || settings.show_steps
-    steps << new_value
-  end
+    def has_hook?(hook_method)
+      entity.class.has_hook? hook_method
+    end
 
-  def marshal_dump
-    instance_variables.map { |name| [name, instance_variable_get(name)] }.to_h
-  end
+    def hooks
+      [current_class, self.class, RuleBox]
+    end
 
-  def marshal_load(variables)
-    variables.each { |key, value| instance_variable_set(key, value) }
-  end
+    def initialize_variables!(method, entity, args)
+      @executed = true
+      @entity = entity
+      @current_method = method
+      @status = start_status
+      @bucket = build_bucket
+      @steps = []
+      @errors = []
+      args.each { |key, value| bucket[key] = value }
+    end
 
-  def keys
-    @keys ||= {}
-  end
+    def initialize_strategies!(method, entity)
+      class_strategies = entity.class.strategies(method)
+      check_strategies!(class_strategies)
+      @strategies = class_strategies.map { |klass| klass.new(self) }
+    end
 
-  # class Methods
-  class << self
-    def configure
-      yield(settings) if block_given?
+    def keys
+      @keys ||= {}
     end
 
-    def clear_configuration
-      @settings = Settings.new
+    def perform(method, entity, **args)
+      check_executed!
+      initialize_variables!(method, entity, args)
+      initialize_strategies!(method, entity)
+      add_step "initialize { method: #{method}, entity: #{current_class}, rules: #{@strategies.count} }"
+      execute_all
+      resolve_exception!
+      return_result
     end
 
-    def settings
-      @settings ||= Settings.new
+    def return_result
+      result = nil
+      hooks.each do |hook|
+        result = hook.call_hook(:customize_result, self)
+        break if result
+      end
+
+      result || last_result
     end
 
-    private
+    def resolve_exception!
+      return unless @exception.is_a?(Exception)
 
-    class Settings
-      attr_reader :dependencies, :resolve
-      attr_writer :default_error_message
-      attr_accessor :show_steps
+      resolved = hooks.map { |hook| hook.resolve_exception!(self) }.compact
+      raise @exception if resolved.length.zero?
+    end
 
-      def initialize
-        @dependencies = {}
-        @show_steps = false
-      end
+    def set(key, value)
+      keys[key.to_s] = value
+    end
 
+    def set_dependencies!(dependencies)
+      self.class.set_dependencies(self, dependencies)
+    end
+
+    def start_status
+      :green
+    end
+
+    # class Methods
+    class << self
       def add_dependency(key, &block)
         dependencies[key.to_sym] = block
       end
 
-      def resolver_exception(&block)
-        @resolve = block
+      def configure(&block)
+        block.call(self)
       end
 
-      def default_error_message
-        @default_error_message || 'unhandled error'
+      def clear_configuration!
+        @dependencies = {}
+        clear_hooks!
+      end
+
+      def set_dependencies(facade, dependencies)
+        errors = []
+
+        self.dependencies.each do |key, block|
+          if dependencies.key? key
+            value = dependencies[key]
+            block&.call(value, errors)
+            facade.send(:set, key, value)
+          else
+            errors << "missing keyword: #{key}"
+          end
+        rescue StandardError => e
+          errors << e.message
+        end
+
+        raise errors.join("\n") unless errors.empty?
+      end
+
+      def use_case!
+        define_method(:use_case) { entity }
+      end
+
+      private
+
+      def dependencies
+        @dependencies ||= {}
       end
     end
   end

data/lib/rule_box/mapper.rb

@@ -1,62 +1,61 @@
 # frozen_string_literal: true
 
-module RuleBox::Mapper
-  def self.included(klass)
-    klass.extend(ClassMethods)
-    mapped << klass
-  end
-
-  def self.mapped
-    @mapped ||= Set.new
-  end
-
-  module ClassMethods
-    def rules_of_insert(*rules)
-      add_rules :insert, rules
-    end
-
-    def rules_of_update(*rules)
-      add_rules :update, rules
+module RuleBox
+  module Mapper
+    extend RuleBox::ExecutionHook
+
+    if const_defined? 'ActiveSupport::Concern'
+      # to Rails project
+      extend ActiveSupport::Concern
+      included { include RuleBox::ExecutionHook }
+    else
+      def self.included(klass)
+        klass.include RuleBox::ExecutionHook
+        klass.extend ClassMethods
+        mapped << klass
+      end
     end
 
-    def rules_of_delete(*rules)
-      add_rules :delete, rules
+    def self.mapped
+      @mapped ||= Set.new
     end
 
-    def rules_of_select(*rules)
-      add_rules :select, rules
-    end
+    module ClassMethods
+      def rules(*rules)
+        add_rules :perform, rules
+      end
 
-    def rules_of(method, *rules)
-      add_rules method.to_sym, rules
-    end
+      def rules_of(method, *rules)
+        add_rules method.to_sym, rules
+      end
 
-    def strategies(method)
-      current_rules[method]
-    end
+      def strategies(method)
+        current_rules[method]
+      end
 
-    def show_strategies
-      current_rules.map do |method, strategies|
-        {
-          method: method,
-          strategies: strategies.map do |strategy|
-            {
-              name: strategy.name,
-              description: strategy.description
-            }
-          end
-        }
+      def show_strategies
+        current_rules.map do |method, strategies|
+          {
+            method: method,
+            strategies: strategies.map do |strategy|
+              {
+                name: strategy.name,
+                description: strategy.description
+              }
+            end
+          }
+        end
       end
-    end
 
-    private
+      private
 
-    def add_rules(method, rules)
-      current_rules[method] = rules
-    end
+      def add_rules(method, rules)
+        current_rules[method] = rules
+      end
 
-    def current_rules
-      @current_rules ||= {}
+      def current_rules
+        @current_rules ||= {}
+      end
     end
   end
 end

data/lib/rule_box/method_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuleBox
+  module MethodHelper
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def attr_clones(*methods, to: nil)
+        methods.each do |method|
+          define_method(method) do
+            resource = to || self
+            resource.instance_variable_get("@#{method}").clone
+          end
+        end
+      end
+
+      def delegate_methods(*methods, to:, set_private: false)
+        methods.each do |method|
+          define_method method do |*rest, **restkey|
+            object = send to
+            object.send method, *rest, **restkey
+          end
+
+          private method if set_private
+        end
+      end
+    end
+  end
+end

data/lib/rule_box/strategy.rb

@@ -1,45 +1,45 @@
 # frozen_string_literal: true
 
-class RuleBox::Strategy
-  include RuleBox::Getter
+module RuleBox
+  class Strategy
+    include RuleBox::MethodHelper
+    attr_reader :facade
 
-  def process
-    raise 'Must implement this method'
-  end
+    delegate_methods :add_error, :current_method, :bucket, :entity, :errors,
+                     :executed, :last_result, :get, :set_status, :status, :steps, :use_case,
+                     to: :facade, set_private: true
 
-  def set_status(status)
-    @facade.instance_variable_set :@status, status
-  end
+    def initialize(facade = nil)
+      @facade = facade
+    end
 
-  def add_error(msg)
-    if msg.is_a? Array
-      @facade.errors.concat(msg)
-    else
-      @facade.errors << msg
+    def perform
+      raise 'Must implement this method'
     end
-  end
 
-  def model
-    @facade.model
-  end
+    def instance_values
+      hash = { strategy_name: self.class.name }
+      instance_variables.each do |name|
+        next if name == :@facade
 
-  def data
-    @facade.data
-  end
+        hash[name[1..]] = instance_variable_get(name)
+      end
 
-  def data=(data)
-    @facade.instance_variable_set :@data, data
-  end
+      hash
+    end
 
-  def bucket
-    @facade.bucket
-  end
+    class << self
+      attr_reader :description
 
-  class << self
-    attr_reader :description
+      def desc(description)
+        @description = description
+      end
 
-    def desc(description)
-      @description = description
+      def perform(&block)
+        define_method :perform do |result = nil|
+          instance_exec(result, &block)
+        end
+      end
     end
   end
 end

data/lib/rule_box/use_case_base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuleBox
+  class UseCaseBase
+    include RuleBox::Mapper
+
+    def initialize(**args)
+      args.each do |key, value|
+        key = key.to_s
+        attributes[key] = value if attribute_names.include? key
+      end
+    end
+
+    def to_s
+      names = self.class.name.split('::').reverse.join
+      names.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .downcase
+    end
+
+    def attribute_names
+      []
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    class << self
+      def attributes(*names)
+        names = names.map(&:to_s)
+        define_method(:attribute_names) { names }
+
+        names.each do |name|
+          define_method(name) { attributes[name] }
+          define_method("#{name}=") { |value| attributes[name] = value }
+        end
+      end
+    end
+  end
+end

data/lib/rule_box/version.rb

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

data/lib/rule_box.rb

@@ -2,22 +2,34 @@
 
 require 'time'
 require 'json'
+require 'set'
+
+require 'rule_box/execution_hook'
 
 module RuleBox
+  include RuleBox::ExecutionHook
   class Error < StandardError; end
 
   class << self
     def show_mapped_classes
       RuleBox::Mapper.mapped.to_a
     end
+
+    def configure
+      block_given? ? yield(settings) : settings
+    end
+
+    private
+
+    def settings
+      self
+    end
   end
 end
 
+require 'rule_box/method_helper'
 require 'rule_box/facade'
-require 'rule_box/getter'
-require 'rule_box/hash'
 require 'rule_box/mapper'
-require 'rule_box/proxy'
 require 'rule_box/strategy'
-require 'rule_box/util'
+require 'rule_box/use_case_base'
 require 'rule_box/version'

data/rule_box.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'This gem is focused in giving a strong and concrete way to manage your business rules, mixing the best of both worlds in Facade and Strategy, bringing you a simplified way to apply these Design Patterns into your project.'
   spec.homepage      = 'https://github.com/ralphsbaesso/rule_box'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.0')
 
   # spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
 
@@ -25,6 +25,8 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
+  spec.files -= %w[.gitignore .rspec .rspec_status]
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rule_box
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Ralph Baesso
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-27 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies: []
 description: This gem is focused in giving a strong and concrete way to manage your
   business rules, mixing the best of both worlds in Facade and Strategy, bringing
@@ -21,8 +21,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -34,13 +32,12 @@ files:
 - bin/console
 - bin/setup
 - lib/rule_box.rb
+- lib/rule_box/execution_hook.rb
 - lib/rule_box/facade.rb
-- lib/rule_box/getter.rb
-- lib/rule_box/hash.rb
 - lib/rule_box/mapper.rb
-- lib/rule_box/proxy.rb
+- lib/rule_box/method_helper.rb
 - lib/rule_box/strategy.rb
-- lib/rule_box/util.rb
+- lib/rule_box/use_case_base.rb
 - lib/rule_box/version.rb
 - rule_box.gemspec
 homepage: https://github.com/ralphsbaesso/rule_box
@@ -57,14 +54,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: RuleBox

data/.gitignore

@@ -1,15 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-.idea/
-
-# rspec failure tracking
-.rspec_status
-/.rakeTasks
-/*.gem

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/lib/rule_box/getter.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuleBox::Getter
-  def initialize(facade)
-    raise 'Must pass an "RFacade"' unless facade.is_a? RuleBox::Facade
-
-    @facade = facade
-  end
-
-  def model
-    model = @facade.model
-    if model.is_a?(Class) || model.is_a?(Module)
-      model.to_s
-    else
-      model.clone
-    end
-  end
-
-  def status
-    @facade.status
-  end
-
-  def data
-    @facade.data.clone
-  end
-
-  def bucket
-    @facade.bucket.clone
-  end
-
-  def errors
-    @facade.errors.clone
-  end
-
-  def steps
-    @facade.steps.clone
-  end
-
-  def _current_method
-    @facade._current_method
-  end
-
-  def executed
-    @facade.executed
-  end
-
-  def to_json(**args)
-    @facade.to_json(args)
-  end
-
-  def as_json(**options)
-    options.key?(:root) ? { self.class.name.to_sym => @facade.attributes } : @facade.attributes
-  end
-
-  def to_s
-    @facade.as_json(root: true).to_s
-  end
-
-  def respond_to_missing?(*several_variants)
-    super unless method.to_s.start_with? 'current_'
-  end
-
-  private
-
-  def method_missing(method)
-    super unless method.to_s.start_with? 'current_'
-
-    keys = @facade.send :keys
-    keys[method].clone
-  end
-end

data/lib/rule_box/hash.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-class RuleBox::Hash < Hash
-  def []=(key, value)
-    super(key.to_sym, value)
-  end
-
-  def [](key)
-    super(key.to_sym)
-  end
-end

data/lib/rule_box/proxy.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class RuleBox::Proxy
-  include RuleBox::Getter
-end

data/lib/rule_box/util.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RuleBox::Util
-  class << self
-    def camelize(string)
-      strings = string.split('_')
-      new_string = ''
-      strings.each do |word|
-        new_string += word[0].upcase + word[1..-1]
-      end
-      new_string.gsub('/', '::')
-    end
-  end
-end