evnt 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 925a6536209233a9ceb61eb39c74c54af602a092
-  data.tar.gz: 737caa953fd925d6bbb1b10cf30c3f4f761b0ea9
+  metadata.gz: b87af903c38d1e3c2e654750badc4eac551177f0
+  data.tar.gz: 435ae2a3ba9288673f3773a7cdec993117eba6a6
 SHA512:
-  metadata.gz: fd4b06d8b794027913273a7c89971f8c45f877c80e8dc520a06dbd409230cc1e60ad014c2482392f320717250d4f50b32289bff14f99c4afb69ee4debf086447
-  data.tar.gz: 8c9ea6e51c7650f2496edfd3d8f7c5851ae2ccd45126742db83febe6b17ab940255e796bd87bdf9ca897a90f15288c9347488e4b323445f684d499fce82c0272
+  metadata.gz: 77fa759d80d7357d7f597fe1d1e8987f3f0155af567bbb39eb2ac1fd4514b2a247e7e27cb2d41dc6e2c9135ee7bf16221d4ec388247fd487098d07e9e8e38a32
+  data.tar.gz: 69125321d1a8de3c3a48a9fe92539c9fb632f62f562d5a88dc62ba72d61380682ab213960f5b83f7965b835e1e36e2011334757747eb42641331bc538a6d51c5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Ideo SRL
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,319 @@
+# Evnt
+
+CQRS and Event Driven Development architecture for Ruby projects.
+
+- [Installation](#installation)
+- [Structure](#structure)
+  - [Command](#command)
+  - [Event](#event)
+  - [Handler](#handler)
+- [Rails integration](#rails-integration)
+- [Development](#development)
+
+Full documentation here: https://ideonetwork.github.io/ruby-evnt/
+
+## Installation
+
+To use the gem you need to add it on your Gemfile
+
+```ruby
+gem 'evnt'
+```
+
+## Structure
+
+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 without the communication with the client.
+
+Every command has three steps to execute:
+
+- 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
+
+  to_validate_params do
+    # check params presence
+    err 'User should be present' if params[:user_id].blank?
+    err 'Product should be present' if params[:product_id].blank?
+    err 'Quantity should be present' if params[:quantity].blank?
+  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
+```
+
+Some validations are similar for every command (like presence or paramter type), so you can also use general validations instead of **to_validate_params** block. An example of general validations 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
+
+  # ...
+
+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 reserver 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.
+
+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
+
+```
+
+## Development
+
+To update the documentation run:
+
+```console
+
+rdoc --op docs
+
+```

data/lib/evnt.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'evnt/version'
+require 'evnt/command'
+require 'evnt/event'
+require 'evnt/handler'
+require 'evnt/validator'
+
+##
+# Evnt is a gem developed to integrate a test driven development
+# and CQRS pattern inside a ruby project.
+# 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
+##
+module Evnt; end

data/lib/evnt/command.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Evnt
+
+  ##
+  # Commands are used to run single tasks on the system.
+  # It's like a controller on an MVC architecture without the
+  # communication with the client.
+  ##
+  class Command
+
+    ##
+    # Attribute containings the list of command parameters.
+    ##
+    attr_reader :params
+
+    ##
+    # The constructor is used to run a new command.
+    #
+    # ==== Attributes
+    #
+    # * +params+ - The list of parameters for the command.
+    # * +_options+ - The list of options for the command.
+    #
+    # ==== Options
+    #
+    # * +exceptions+ - Boolean value used to activate the throw of excetions.
+    ##
+    def initialize(params, _options: {})
+      _init_command_data(params, _options)
+      _run_command_steps
+    end
+
+    # Public functions:
+    ############################################################################
+
+    ##
+    # This function returns the list of errors of the command.
+    # The returned object should be an array of hashes with a message and
+    # a code value.
+    # The code value of hashes should be nil if code is not defined using
+    # the stop() function.
+    ##
+    def errors
+      @state[:errors]
+    end
+
+    ##
+    # This function returns the list of error messages of the command.
+    # The returned object should be an array of strings.
+    ##
+    def error_messages
+      @state[:errors].map { |e| e[:message] }
+    end
+
+    ##
+    # This function returns the list of error codes of the command.
+    # The returned object should be an array of integers.
+    ##
+    def error_codes
+      @state[:errors].map { |e| e[:code] }
+    end
+
+    ##
+    # This function tells if the command is completed or not.
+    # The returned object should be a boolean value.
+    ##
+    def completed?
+      @state[:result]
+    end
+
+    # Protected functions:
+    ############################################################################
+
+    protected
+
+    ##
+    # This function can be used to stop the command execution and
+    # add a new error.
+    # Using err inside a callback should not stop the execution but
+    # should avoid the call of the next callback.
+    # Every time you call this function, a new error should be added
+    # to the errors list.
+    # If the exceptions option is active, it should raise a new error.
+    #
+    # ==== Attributes
+    #
+    # * +message+ - The message string of the error.
+    # * +code+ - The error code.
+    ##
+    def err(message, code: nil)
+      @state[:result] = false
+      @state[:errors].push(
+        message: message,
+        code: code
+      )
+
+      # raise error if command needs exceptions
+      raise error if @options[:exceptions]
+    end
+
+    # Private functions:
+    ############################################################################
+
+    private
+
+    # This function initializes the command required data.
+    def _init_command_data(params, options)
+      # set state
+      @state = {
+        result: true,
+        errors: []
+      }
+
+      # set options
+      @options = {
+        exceptions: options[:exceptions] || false
+      }
+
+      # set other data
+      @params = params.freeze
+    end
+
+    # This function calls requested steps (callback) for the command.
+    def _run_command_steps
+      _validate_single_params
+      _validate_params if @state[:result] && defined?(_validate_params)
+      _validate_logic if @state[:result] && defined?(_validate_logic)
+      _initialize_events if @state[:result] && defined?(_initialize_events)
+    end
+
+    # This function validates the single parameters sets with the "validates" method.
+    def _validate_single_params
+      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])
+        unless result
+          err "#{val[:param].capitalize} value not accepted"
+          break
+        end
+      end
+    end
+
+    # Class functions:
+    ############################################################################
+
+    # This class contain the list of settings for the command.
+    class << self
+
+      attr_accessor :_validations
+
+      # This function sets the single validation request for a command parameter.
+      def validates(param, options)
+        validations = instance_variable_get(:@_validations) || []
+        validations.push(param: param, options: options)
+        instance_variable_set(:@_validations, validations)
+      end
+
+      # This function sets the validate params function for the command.
+      def to_validate_params(&block)
+        define_method('_validate_params', &block)
+      end
+
+      # This function sets the validate logic function for the command.
+      def to_validate_logic(&block)
+        define_method('_validate_logic', &block)
+      end
+
+      # This function sets the intitialize events function for the command.
+      def to_initialize_events(&block)
+        define_method('_initialize_events', &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/evnt/event.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Evnt
+
+  ##
+  # Events are used to save on a persistent data structure what
+  # happends on the system.
+  ##
+  class Event
+
+    ##
+    # Attribute containings the name of the event.
+    ##
+    attr_reader :name
+
+    ##
+    # Attribute containings the list of attributes of the event.
+    ##
+    attr_reader :attributes
+
+    ##
+    # Attribute containings the payload of the event.
+    ##
+    attr_reader :payload
+
+    ##
+    # Attribute containings the extra parameters of the event.
+    ##
+    attr_reader :extras
+
+    ##
+    # The constructor is used to initialize a new event.
+    # The parameters are validated and added to the payload
+    # of the event. The parameters with the _ in their name
+    # are not saved on the payload.
+    #
+    # ==== Attributes
+    #
+    # * +params+ - The list of parameters for the command.
+    ##
+    def initialize(params)
+      _init_event_data(params)
+      _validate_payload
+      _run_event_steps
+      _notify_handlers
+    end
+
+    # Public functions:
+    ############################################################################
+
+    ##
+    # This function tells if the event is reloaded or not.
+    # The returned object should be a boolean value corresponding to the
+    # presence of evnt value inside the event params.
+    ##
+    def reloaded?
+      @state[:reloaded]
+    end
+
+    # Private functions:
+    ############################################################################
+
+    private
+
+    # This function initializes the event required data.
+    def _init_event_data(params)
+      # set state
+      @state = {
+        reloaded: !params[:evnt].nil?
+      }
+
+      # set payload
+      payload = params.reject { |k, _v| k[0] == '_' }
+      @payload = @state[:reloaded] ? payload : _generate_payload(payload)
+
+      # set other datas
+      @name = self.class._name
+      @attributes = self.class._attributes
+      @extras = params.select { |k, _v| k[0] == '_' }
+    end
+
+    # This function generates the complete event payload.
+    def _generate_payload(params)
+      # add evnt informations
+      params[:evnt] = {
+        timestamp: Time.now.to_i,
+        name: self.class._name
+      }
+      # return payload
+      params
+    end
+
+    # This function validates all payload and check they are completed.
+    def _validate_payload
+      return unless self.class._attributes
+
+      # check all attributes are present
+      check_attr = (@payload.keys - [:evnt]) == self.class._attributes
+      raise 'Event parameters are not correct' unless check_attr
+    end
+
+    # This function calls requested steps for the event.
+    def _run_event_steps
+      _write_event if defined?(_write_event)
+    end
+
+    # This function notify all handlers for the event.
+    def _notify_handlers
+      return unless self.class._handlers
+
+      # notify every handler
+      self.class._handlers.each do |handler|
+        handler.notify(self)
+      end
+    end
+
+    # Class functions:
+    ############################################################################
+
+    # This class contain the list of settings for the event.
+    class << self
+
+      attr_accessor :_name, :_attributes, :_handlers
+
+      # This function sets the name for the event.
+      def name_is(event_name)
+        instance_variable_set(:@_name, event_name)
+      end
+
+      # This function sets the list of attributes for the event.
+      def attributes_are(*attributes)
+        instance_variable_set(:@_attributes, attributes)
+      end
+
+      # This function sets the list of handlers for the event.
+      def handlers_are(handlers)
+        instance_variable_set(:@_handlers, handlers)
+      end
+
+      # This function sets the write event function for the event.
+      def to_write_event(&block)
+        define_method('_write_event', &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/evnt/handler.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Evnt
+
+  ##
+  # Handlers are used to listen one or more events and run tasks after their execution.
+  ##
+  class Handler
+
+    ##
+    # Attribute containings the event that notify the handler.
+    ##
+    attr_reader :event
+
+    ##
+    # This function is called from an event to notify an handler.
+    #
+    # ==== Attributes
+    #
+    # * +event+ - The event object that call the function.
+    ##
+    def notify(event)
+      _init_handler_data(event)
+      _init_handler_steps
+      _run_handler_steps
+    end
+
+    # Private functions:
+    ############################################################################
+
+    private
+
+    # This function initializes the handler required data.
+    def _init_handler_data(event)
+      @event = event
+    end
+
+    # This function init the handler steps.
+    def _init_handler_steps
+      self.class._events[@event.name].call
+    end
+
+    # This function calls requested steps for the handler.
+    def _run_handler_steps
+      _update_queries if defined?(_update_queries)
+
+      # manage event reloaded
+      if event.reloaded?
+        _manage_reloaded_event if defined?(_manage_reloaded_event)
+        return
+      end
+
+      # manage normal event
+      _manage_event if defined?(_manage_event)
+    end
+
+    # Class functions:
+    ############################################################################
+
+    # This class contain the list of settings for the handler.
+    class << self
+
+      attr_accessor :_events
+
+      # This function sets the blocks executed for a specific event.
+      def on(event_name, &block)
+        instance_variable_set(:@_events, {}) unless @_events
+        @_events[event_name] = block
+      end
+
+      # This function sets the update queries function for the event.
+      def to_update_queries(&block)
+        define_method('_update_queries', &block)
+      end
+
+      # This function sets the manage event function for the event.
+      def to_manage_event(&block)
+        define_method('_manage_event', &block)
+      end
+
+      # This function sets the manage reloaded event function for the event.
+      def to_manage_reloaded_event(&block)
+        define_method('_manage_reloaded_event', &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/evnt/validator.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Evnt
+
+  ##
+  # Validator is a class used to validates params and attributes automatically.
+  ##
+  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)
+        options.each do |key, value|
+          return false unless validate_option(param, key, value)
+        end
+
+        true
+      rescue StandardError => e
+        puts e
+        false
+      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)
+        when :numeric
+          validate_numeric(param, option_value)
+        else
+          raise 'Validator option not accepted'
+        end
+      rescue StandardError => e
+        puts e
+        false
+      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 true 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
+        false
+      end
+
+      ##
+      # 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?
+        value ? !is_nil : is_nil
+      rescue StandardError => e
+        puts e
+        false
+      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?)
+        value ? blank : !blank
+      rescue StandardError => e
+        puts e
+        false
+      end
+
+      ##
+      # This function validates some numeric options for the parameter.
+      #
+      # ==== Attributes
+      #
+      # * +param+ - The parameter to be validated.
+      # * +value+ - The value object with validation specs.
+      ##
+      def validate_numeric(param, value)
+        # TODO: Continue
+      rescue StandardError => e
+        puts e
+        false
+      end
+
+      # 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)
+        else
+          raise 'Validator type option not accepted'
+        end
+      end
+
+      # This function validates a param type for custom types.
+      def validate_type_custom(param, value)
+        param.instance_of?(Object.const_get(value))
+      end
+
+      def validate_type_boolean(param)
+        param.instance_of?(TrueClass) || param.instance_of?(FalseClass)
+      end
+
+      def validate_type_string(param)
+        param.instance_of?(String)
+      end
+
+      def validate_type_integer(param)
+        param.instance_of?(Integer)
+      end
+
+      def validate_type_symbol(param)
+        param.instance_of?(Symbol)
+      end
+
+      def validates_type_float(param)
+        param.instance_of?(Float)
+      end
+
+      def validates_type_hash(param)
+        param.instance_of?(Hash)
+      end
+
+      def validates_type_array(param)
+        param.instance_of?(Array)
+      end
+
+    end
+
+  end
+
+end

data/lib/evnt/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Evnt
+
+  ##
+  # Constant containing the current gem version.
+  ##
+  VERSION = '2.1.1'
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evnt
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Ideonetwork
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-27 00:00:00.000000000 Z
+date: 2017-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,40 +25,48 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.0'
 description: CQRS and Event Driven Development architecture for Ruby
 email:
 - dev@ideonetwork.it
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/evnt.rb
+- lib/evnt/command.rb
+- lib/evnt/event.rb
+- lib/evnt/handler.rb
+- lib/evnt/validator.rb
+- lib/evnt/version.rb
 homepage: http://ideonetwork.it/
 licenses:
 - MIT
@@ -79,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: CQRS and Event Driven Development architecture for Ruby