evnt 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d2cecb4f90544de842098f1f89110548ef2a2231504ac0cf47f821bf0abfbb3
-  data.tar.gz: 731c1460b90c981043850df9a5a5b6cc6b9a4d1d0b780859e2070cd0d94c8047
+  metadata.gz: 0d27e279061c1fe5534475dff8473ebd99be75598bc1d107388cba8a6c5acf8f
+  data.tar.gz: 794c7058bf25bdde40ade891d4fd8535ddddfbcf9b1c8baf5393bcfa9cf1c605
 SHA512:
-  metadata.gz: e93adc9ffeead5ee8632b41d1bee8a030376d1876f61bf6d8e5c4f077fb5efda56c7a3a92a62493a3e3f118a153be0436dc9c5eb6ee87cd335530efc7f9300c9
-  data.tar.gz: 69e531d6aa91fd78f31c75bd3eb4cc30e9848f917bde1e81e191959633736f85e4b3ae7638104df84ecaf5bdaf32f301f8ec6e1348deb44c02ffeffb7895b82d
+  metadata.gz: 680ad444595d388a62fb4de5b8426487c5b7224775c249491ca5c9b15625ff148979ca7ae21391485524d58c617b7c2395072085ff9dc54c4b43bd61fb260ff6
+  data.tar.gz: 89cf7a8bca1840914aa2338c9cc4e9b9e31d19e1e0327169f0de227161e57d6eecd2d380316d5665db2ccdbdf7fe3034ce3531f528eb30c2cb579f8316014075

data/README.md

@@ -4,18 +4,13 @@ CQRS and Event Driven Development architecture for Ruby projects.
 
 - [Installation](#installation)
 - [Structure](#structure)
-  - [Command](#command)
-  - [Event](#event)
-  - [Handler](#handler)
-- [Rails integration](#rails-integration)
-  - [Generators integration](#generators-integration)
-    - [Command generators](#command-generators)
-    - [Event generators](#event-generators)
-    - [Handler generators](#handler-generators)
-  - [Manual integration](#manual-integration)
+  - [Command](https://github.com/ideonetwork/evnt/blob/master/doc/Command.md)
+  - [Event](https://github.com/ideonetwork/evnt/blob/master/doc/Event.md)
+  - [Handler](https://github.com/ideonetwork/evnt/blob/master/doc/Handler.md)
+- [Rails integration](https://github.com/ideonetwork/evnt/blob/master/doc/RailsIntegration.md)
 - [Development](#development)
 
-Full documentation here: https://ideonetwork.github.io/evnt/
+Full class documentation here: https://ideonetwork.github.io/evnt/
 
 ## Installation
 
@@ -35,377 +30,9 @@ gem 'evnt'
 
 Evnt is developed to be used over all kinds of projects and frameworks (like Ruby on Rails or Sinatra), so it contains only three types of entities:
 
-- Command
-- Event
-- Handler
-
-### Command
-
-Commands are used to run single tasks on the system. It's like a controller on an MVC architecture.
-
-Every command has three steps to execute:
-
-- The params normalization which normalize the parameters used to run the command.
-- The params validation which validates the parameters used to run the command.
-- The logic validation which checks the command can be executed in compliance with the system rules.
-- The event intialization which initializes an event object used to save the command.
-
-An example of command should be:
-
-```ruby
-class CreateOrderCommand < Evnt::Command
-
-  validates :user_id, type: :integer, presence: true
-  validates :product_id, type: :integer, presence: true
-  validates :quantity, type: :integer, presence: true
-
-  to_normalize_params do
-    params[:quantity] = params[:quantity].to_i
-  end
-
-  to_validate_params do
-    err 'Quantity should be positive' unless params[:quantity].positive?
-  end
-
-  to_validate_logic do
-    @user = User.find_by(id: params[:user_id])
-    @product = Product.find_by(id: params[:product_id])
-
-    # check user exist
-    unless @user
-      err 'The user does not exist'
-      break
-    end
-
-    # check product exist
-    unless @product
-      err 'The product does not exist'
-      break
-    end
-
-    # check quantity exist for the product
-    err 'The requested quantity is not available' if @product.quantity < params[:quantity]
-
-    # check user has money to buy the product
-    err 'You do not have enought money' if @user.money < @product.price * params[:quantity]
-  end
-
-  to_initialize_events do
-    # generate order id
-    order_id = SecureRandom.uuid
-
-    # initialize event
-    begin
-      CreateOrderEvent.new(
-        order_id: order_id,
-        user_id: @user.id,
-        product_id: @product.id,
-        quantity: params[:quantity],
-        _user: @user,
-        _product: @product
-      )
-    rescue
-      err 'Sorry, there was an error', code: 500
-    end
-  end
-
-end
-```
-
-An example of command usage should be:
-
-```ruby
-command = CreateOrderCommand.new(
-  user_id: 128,
-  product_id: 534,
-  quantity: 10
-)
-
-if command.completed?
-  puts 'Command completed'
-  puts command.params # -> { user_id: 128, product_id: 534, quantity: 10 }
-else
-  puts command.errors # array of hashes with a { message, code } structure
-  puts command.error_messages # array of error messages
-  puts command.error_codes # array of error codes
-end
-```
-
-It's also possible to use err method inside the command to raise an exception with the option **exception: true**. An example of usage should be:
-
-```ruby
-begin
-  command = CreateOrderCommand.new(
-    user_id: 128,
-    product_id: 534,
-    quantity: 10,
-    _options: {
-      excption: true
-    }
-  )
-rescue => e
-  puts e
-end
-```
-
-### Event
-
-Events are used to save on a persistent data structure what happends on the system.
-
-Every event has three informations:
-
-- The **name** is an unique identifier of the event.
-- The **attributes** are the list of attributes required from the event to be saved.
-- The **handlers** are a list of handler objects which will be notified when the event is completed.
-
-Every event has also a single function used to write the event information on the data structure.
-
-An example of event should be:
-
-```ruby
-class CreateOrderEvent < Evnt::Event
-
-  name_is :create_order
-
-  attributes_are :order_id, :user_id, :product_id, :quantity
-
-  handlers_are [
-    ProductHandler.new,
-    UserNotifierHandler.new
-  ]
-
-  to_write_event do
-    # save event on database
-    Event.create(
-      name: name,
-      payload: payload
-    )
-  end
-
-end
-```
-
-An example of event usage should be:
-
-```ruby
-event = CreateOrderEvent.new(
-  order_id: order_id,
-  user_id: @user.id,
-  product_id: @product.id,
-  quantity: params[:quantity]
-)
-
-puts event.name # -> :create_order
-puts event.attributes # -> [:order_id, :user_id, :product_id, :quantity]
-puts event.payload # -> { order_id: 1, user_id: 128, product_id: 534, quantity: 10, evnt: { timestamp: 2017010101, name: 'create_order' } }
-```
-
-The event payload should contain all event attributes and a reserved attributes "evnt" used to store the event timestamp and the event name.
-
-It's also possible to give datas to the event without save them on the event payload, to do this you shuld only use a key with "_" as first character. An example should be:
-
-```ruby
-event = CreateOrderEvent.new(
-  order_id: order_id,
-  user_id: @user.id,
-  product_id: @product.id,
-  quantity: params[:quantity],
-  _total_price: params[:quantity] * @product.price
-)
-
-puts event.payload # -> { order_id: 1, user_id: 128, product_id: 534, quantity: 10, evnt: { timestamp: 2017010101, name: 'create_order' } }
-puts event.extras # -> { total_price: 50 }
-```
-
-After the execution of the **to_write_event** block the event object should notify all its handlers.
-
-Sometimes you need to reload an old event to notify handlers to re-build queries from events. To initialize a new event object with the payload of an old event you can pass the old event payload to the event constructor:
-
-```ruby
-events = Event.where(name: 'create_order')
-reloaded_event = CreateOrderEvent.new(events.sample.payload)
-
-puts reloaded_event.reloaded? # -> true
-```
-
-### Handler
-
-Handlers are used to listen one or more events and run tasks after their execution.
-
-Every handler event management has two steps to execute:
-
-- The queries update which updates temporary data structures used to read datas.
-- The manage event code which run other tasks like mailers, parallel executions ecc.
-
-An example of handler shuould be:
-
-```ruby
-class ProductHandler < Evnt::Handler
-
-  on :create_order do
-
-    to_update_queries do
-      # update product quantity
-      product = event.extras[:product]
-      product.update(quantity: product.quantity - event.payload[:quantity])
-    end
-
-    to_manage_event do
-      # this block is called only for not reloaded events
-    end
-
-  end
-
-end
-```
-
-The execution of **to_update_queries** block runs after every events initialization.
-The execution of **to_manage_event** block runs only for not reloaded events initialization.
-
-Sometimes you need to run some code to manage only reloaded events. To run code only for reloaded events you can use the **to_manage_reloaded_event** block:
-
-```ruby
-class ProductHandler < Evnt::Handler
-
-  on :create_order do
-
-    to_manage_reloaded_event do
-      # this block is called only for reloaded events
-    end
-
-  end
-
-end
-```
-
-## Rails integration
-
-Evnt can be used with Ruby on Rails to extends the MVC pattern.
-
-### Generators integration
-
-There's a simple generator that can be used to inizialize a Rails application with Evnt.
-
-```shell
-
-rails generate evnt:initializer
-
-```
-
-This command should:
-
-- Create an **application_command.rb** on app/commands directory.
-- Create an **application_event.rb** on app/events directory.
-- Create an **application_handler.rb** on app/handlers directory.
-- Create tests for the three new classes added on the project.
-- Added app/commands, app/events and app/handlers on config.autoload_paths setting of the application.
-
-#### Command generators
-
-Usage:
-
-```shell
-
-rails generate evnt:command Authentication::LoginCommand email:string password:string ip_address:string
-
-```
-
-Output:
-
-```ruby
-# ./app/commands/authentication/login_command.rb
-module Authentication
-  class LoginCommand < ApplicationCommand
-
-    validates :email, type: :string
-
-    validates :password, type: :string
-
-    validates :ip_address, type: :string
-
-  end
-end
-```
-
-#### Event generators
-
-Usage:
-
-```shell
-
-rails generate evnt:event Authentication::LoginEvent user_uuid ip_address
-
-```
-
-Output:
-
-```ruby
-# ./app/events/authentication/login_event.rb
-module Authentication
-  class LoginEvent < ApplicationEvent
-
-    name_is :authentication_login_event
-
-    attributes_are :user_uuid, :ip_address
-
-  end
-end
-```
-
-#### Handler generators
-
-Usage:
-
-```shell
-
-rails generate evnt:handler AuthenticationHandler authentication_login_event authentication_signup_event
-
-```
-
-Output:
-
-```ruby
-# ./app/handlers/authentication_handler.rb
-class AuthenticationHandler < ApplicationHandler
-
-  on :authentication_login_event do; end
-
-  on :authentication_signup_event do; end
-
-end
-```
-
-### Manual integration
-
-To use the gem with Rails you need to create three folders inside the ./app project's path:
-
-- **./app/commands**
-- **./app/events**
-- **./app/handlers**
-
-You also need to require all files from these folders. To do this you need to edit the ./config/application.rb file like this example:
-
-```ruby
-
-require_relative 'boot'
-
-require 'rails/all'
-
-# Require the gems listed in Gemfile, including any gems
-# you've limited to :test, :development, or :production.
-Bundler.require(*Rails.groups)
-
-module MyApplicationName
-  class Application < Rails::Application
-
-    config.autoload_paths << Rails.root.join('app/commands')
-    config.autoload_paths << Rails.root.join('app/events')
-    config.autoload_paths << Rails.root.join('app/handlers')
-
-  end
-end
-
-```
+- [Command](https://github.com/ideonetwork/evnt/blob/master/doc/Command.md)
+- [Event](https://github.com/ideonetwork/evnt/blob/master/doc/Event.md)
+- [Handler](https://github.com/ideonetwork/evnt/blob/master/doc/Handler.md)
 
 ## Development
 

data/lib/evnt/command.rb

@@ -136,13 +136,13 @@ module Evnt
       return if self.class._validations.nil? || self.class._validations.empty?
 
       self.class._validations.each do |val|
-        result = Evnt::Validator.validates(params[val[:param]], val[:options])
+        validator = Evnt::Validator.new(params[val[:param]], val[:options])
 
-        if result == :ERROR
+        if validator.passed?
+          @params[val[:param]] = validator.value
+        else
           err "#{val[:param].capitalize} value not accepted"
           break
-        else
-          @params[val[:param]] = result
         end
       end
 

data/lib/evnt/validator.rb

@@ -7,233 +7,186 @@ module Evnt
   ##
   class Validator
 
-    # Class functions:
-    ############################################################################
-
-    class << self
-
-      ##
-      # This function is used to validates a parameter with some validation
-      # options.
-      #
-      # ==== Attributes
-      #
-      # * +param+ - The parameter to be validated.
-      # * +options+ - The list of options for the validations.
-      #
-      # ==== Options
-      #
-      # * +type+ - Symbol value used to tells the correct parameter type.
-      # * +presence+ - Boolean value used to tells if the presence is required.
-      ##
-      def validates(param, options)
-        result = param
-        options.each do |key, value|
-          result = validate_option(result, key, value)
-          break if result == :ERROR
-        end
-
-        result
-      rescue StandardError => e
-        puts e
-        :ERROR
-      end
+    attr_reader :value
+
+    TYPES = %i[boolean string integer symbol float hash array
+               date datetime time].freeze
+
+    ##
+    # The constructor is used to initialize a new validator.
+    #
+    # ==== Attributes
+    #
+    # * +value+ - The value that should be validated.
+    # * +options+ - The list of options for the validation.
+    #
+    # ==== Options
+    #
+    # * +presence+ - Boolean value used to not accept nil values.
+    # * +type+ - Symbol or String value used to set the type of the value.
+    # * +custom_options+ - Other options that can change for every type.
+    ##
+    def initialize(value, options)
+      @value = value
+
+      @_options = options
+      @_result = true
+
+      _validates_presence if @_result
+      _validates_type if @_result
+      _validates_custom if @_result
+    end
 
-      ##
-      # This function calls the correct validate function for a specific option.
-      #
-      # ==== Attributes
-      #
-      # * +param+ - The parameter to be validated.
-      # * +option_key+ - The key of the option that should be used.
-      # * +option_value+ - The value of the option that should be used.
-      ##
-      def validate_option(param, option_key, option_value)
-        case option_key
-        when :type
-          validate_type(param, option_value)
-        when :presence
-          validate_presence(param, option_value)
-        when :blank
-          validate_blank(param, option_value)
-        else
-          raise 'Validator option not accepted'
-        end
-      rescue StandardError => e
-        puts e
-        :ERROR
-      end
+    ##
+    # This function tells if the validation is passed or not.
+    ##
+    def passed?
+      @_result
+    end
 
-      ##
-      # This function validates the type of the parameter.
-      #
-      # ==== Attributes
-      #
-      # * +param+ - The parameter to be validated.
-      # * +value+ - The value of the type option that should be used.
-      ##
-      def validate_type(param, value)
-        return param if param.nil?
-
-        if value.instance_of?(Symbol)
-          validate_type_general(param, value)
-        elsif value.instance_of?(String)
-          validate_type_custom(param, value)
-        else
-          raise 'Validator type option not accepted'
-        end
-      rescue StandardError => e
-        puts e
-        :ERROR
-      end
+    private
 
-      ##
-      # This function validates the presence of the prameter.
-      # A parameter is present when its value is not nil.
-      #
-      # ==== Attributes
-      #
-      # * +param+ - The parameter to be validated.
-      # * +value+ - The value of the presence option that should be used.
-      ##
-      def validate_presence(param, value)
-        is_nil = param.nil?
-        result = value ? !is_nil : is_nil
-        return param if result
-
-        :ERROR
-      rescue StandardError => e
-        puts e
-        :ERROR
-      end
+    def _validates_presence
+      return if @_options[:presence].nil?
+      @_result = @_options[:presence] ? !@value.nil? : @value.nil?
+    end
 
-      ##
-      # This function validates the blank of the prameter.
-      # A parameter is blank when its value is nil, false, or empty.
-      #
-      # ==== Attributes
-      #
-      # * +param+ - The parameter to be validated.
-      # * +value+ - The value of the presence option that should be used.
-      ##
-      def validate_blank(param, value)
-        blank = (!param || param.empty?)
-        result = value ? blank : !blank
-        return param if result
-
-        :ERROR
-      rescue StandardError => e
-        puts e
-        :ERROR
-      end
+    def _validates_type
+      return if @value.nil? || @_options[:type].nil?
 
-      # Private functions:
-      ##########################################################################
-
-      private
-
-      # Types validations:
-      ##########################################################################
-
-      # This function validates a param type for general types.
-      def validate_type_general(param, value)
-        case value
-        when :boolean
-          validate_type_boolean(param)
-        when :string
-          validate_type_string(param)
-        when :integer
-          validate_type_integer(param)
-        when :symbol
-          validate_type_symbol(param)
-        when :float
-          validates_type_float(param)
-        when :hash
-          validates_type_hash(param)
-        when :array
-          validates_type_array(param)
-        when :date
-          validates_type_date(param)
-        when :datetime
-          validates_type_datetime(param)
-        else
-          raise 'Validator type option not accepted'
-        end
+      if @_options[:type].instance_of?(Symbol) && TYPES.include?(@_options[:type])
+        send("_validates_type_#{@_options[:type]}")
+      elsif @_options[:type].instance_of?(String)
+        _validates_type_custom
+      else
+        raise 'Validator type option not accepted'
       end
+    end
 
-      # This function validates a param type for custom types.
-      def validate_type_custom(param, value)
-        return param if param.instance_of?(Object.const_get(value))
-        :ERROR
+    def _validates_custom
+      _validates_global_in if @_result
+      _validates_global_out if @_result
+
+      case @_options[:type]
+      when :string
+        _validates_string_blank if @_result
+        _validates_string_length if @_result
+      when :integer
+        _validates_number_min if @_result
+        _validates_number_max if @_result
+      when :float
+        _validates_number_min if @_result
+        _validates_number_max if @_result
       end
+    end
 
-      def validate_type_symbol(param)
-        return param if param.instance_of?(Symbol)
-        :ERROR
-      end
+    # Types validations:
+    ##########################################################################
 
-      def validate_type_boolean(param)
-        return param if param.instance_of?(TrueClass) || param.instance_of?(FalseClass)
-        return true if [1, 'true'].include? param
-        return false if [0, 'false'].include? param
-        :ERROR
-      end
+    def _validates_type_custom
+      @_result = @value.instance_of?(Object.const_get(@_options[:type]))
+    end
 
-      def validate_type_integer(param)
-        return param if param.instance_of?(Integer)
-        begin
-          return param.to_i
-        rescue StandardError
-          return :ERROR
-        end
-      end
+    def _validates_type_symbol
+      @_result = @value.instance_of?(Symbol)
+    end
 
-      def validates_type_float(param)
-        return param if param.instance_of?(Float)
-        begin
-          return param.to_f
-        rescue StandardError
-          return :ERROR
-        end
-      end
+    def _validates_type_hash
+      @_result = @value.instance_of?(Hash)
+    end
 
-      def validate_type_string(param)
-        return param if param.instance_of?(String)
-        begin
-          return param.to_s
-        rescue StandardError
-          return :ERROR
-        end
-      end
+    def _validates_type_array
+      @_result = @value.instance_of?(Array)
+    end
 
-      def validates_type_date(param)
-        return param if param.instance_of?(Date)
-        begin
-          return Date.parse(param)
-        rescue StandardError
-          return :ERROR
-        end
-      end
+    def _validates_type_boolean
+      return if @value.instance_of?(TrueClass) || @value.instance_of?(FalseClass)
 
-      def validates_type_datetime(param)
-        return param if param.instance_of?(DateTime)
-        begin
-          return DateTime.parse(param)
-        rescue StandardError
-          return :ERROR
-        end
-      end
+      @value = true && return if [1, 'true'].include?(@value)
+      @value = false && return if [0, 'false'].include?(@value)
 
-      def validates_type_hash(param)
-        return param if param.instance_of?(Hash)
-        :ERROR
-      end
+      @_result = false
+    end
 
-      def validates_type_array(param)
-        return param if param.instance_of?(Array)
-        :ERROR
-      end
+    def _validates_type_integer
+      return if @value.instance_of?(Integer)
+      @value = @value.to_i
+    rescue StandardError
+      @_result = false
+    end
+
+    def _validates_type_float
+      return if @value.instance_of?(Float)
+      @value = @value.to_f
+    rescue StandardError
+      @_result = false
+    end
+
+    def _validates_type_string
+      return if @value.instance_of?(String)
+      @value = @value.to_s
+    rescue StandardError
+      @_result = false
+    end
+
+    def _validates_type_date
+      return if @value.instance_of?(Date)
+      @value = Date.parse(@value)
+    rescue StandardError
+      @_result = false
+    end
+
+    def _validates_type_datetime
+      return if @value.instance_of?(DateTime)
+      @value = DateTime.parse(@value)
+    rescue StandardError
+      @_result = false
+    end
+
+    def _validates_type_time
+      return if @value.instance_of?(Time)
+      @value = Time.parse(@value)
+    rescue StandardError
+      @_result = false
+    end
+
+    # Global validations:
+    ##########################################################################
+
+    def _validates_global_in
+      return if @value.nil? || @_options[:in].nil?
+      @_result = @_options[:in].include?(@value)
+    end
+
+    def _validates_global_out
+      return if @value.nil? || @_options[:out].nil?
+      @_result = !@_options[:out].include?(@value)
+    end
+
+    # String validations:
+    ##########################################################################
+
+    def _validates_string_blank
+      return if @value.nil? || @_options[:blank].nil?
+      @_result = @_options[:blank] ? @value.empty? : !@value.empty?
+    end
+
+    def _validates_string_length
+      return if @value.nil? || @_options[:length].nil?
+      @_result = @value.length == @_options[:length]
+    end
+
+    # Number validations:
+    ##########################################################################
+
+    def _validates_number_min
+      return if @value.nil? || @_options[:min].nil?
+      @_result = @value >= @_options[:min]
+    end
 
+    def _validates_number_max
+      return if @value.nil? || @_options[:max].nil?
+      @_result = @value <= @_options[:max]
     end
 
   end

data/lib/evnt/version.rb

@@ -3,6 +3,6 @@
 # Evnt.
 module Evnt
 
-  VERSION = '3.0.2'
+  VERSION = '3.1.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evnt
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Ideonetwork
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-17 00:00:00.000000000 Z
+date: 2018-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler