poro_validator 0.0.1

data/lib/poro_validator.rb

@@ -0,0 +1,54 @@
+# PoroValidator::Validator is a lightweight Plain Old Ruby Object
+# validator.
+#
+# @since 0.0.1
+module PoroValidator
+  # Allow access to the anonymouse validator module
+  #
+  # @example
+  # class FoodValidator
+  #   include PoroValidator.validator
+  #
+  # end
+
+  def self.validator
+    mod = Module.new
+    mod.define_singleton_method(:included) do |base|
+      base.send(:include, ::PoroValidator::Validator)
+    end
+    mod
+  end
+
+  def self.configuration
+    @configuration || Configuration.new
+  end
+end
+
+# Base Classes
+require "poro_validator/version"
+require "poro_validator/error_store"
+require "poro_validator/errors"
+require "poro_validator/exceptions"
+require "poro_validator/configuration"
+require "poro_validator/validator/base_class"
+require "poro_validator/validator/validation"
+require "poro_validator/validator/validations"
+require "poro_validator/validator/conditions"
+require "poro_validator/validator/factory"
+require "poro_validator/validator/context"
+
+# Validators
+require "poro_validator/validators/base_class"
+require "poro_validator/validators/presence_validator"
+require "poro_validator/validators/format_validator"
+require "poro_validator/validators/with_validator"
+require "poro_validator/validators/range_array_validator"
+require "poro_validator/validators/inclusion_validator"
+require "poro_validator/validators/exclusion_validator"
+require "poro_validator/validators/integer_validator"
+require "poro_validator/validators/float_validator"
+require "poro_validator/validators/length_validator"
+require "poro_validator/validators/numeric_validator"
+
+# Modules
+require "poro_validator/validator"

data/lib/poro_validator/configuration.rb

@@ -0,0 +1,63 @@
+module PoroValidator
+  class Configuration
+    class Message
+      # @private_const
+      DEFAULT_MESSAGES = {
+        default:  lambda { "is not valid" },
+        presence: lambda { "is not present" },
+        integer:  lambda { "is not an integer" },
+        float:    lambda { "is not a float" },
+
+        inclusion: lambda do |range|
+          "is not within the range of #{range.inspect}"
+        end,
+
+        exclusion: lambda do |range|
+          "is not outside the range of #{range.inspect}"
+        end,
+
+        format: lambda do |pattern|
+          "does not match the pattern: #{pattern.inspect}"
+        end,
+
+        length: lambda do |length|
+          "does not match the length options: #{length.inspect}"
+        end,
+
+        numeric: lambda do |numeric|
+          "does not match the numeric options: #{numeric.inspect}"
+        end
+      }
+
+      def initialize
+        @messages = {}
+      end
+
+      def get(validator, *args)
+        args.compact.length > 0 ? message(validator).call(*args) : message(validator).call
+      end
+
+      def set(validator, message)
+        unless message.is_a?(::Proc)
+          raise PoroValidator::ConfigError.new(
+            "A proc/lambda is required to configure validator messages"
+          )
+        end
+        @messages[validator] = message
+      end
+
+      private
+
+      def message(validator)
+        @messages[validator] || DEFAULT_MESSAGES[validator] ||
+          DEFAULT_MESSAGES[:default]
+      end
+    end
+
+    attr_reader :message
+
+    def initialize
+      @message = Message.new
+    end
+  end
+end

data/lib/poro_validator/error_store.rb

@@ -0,0 +1,52 @@
+module PoroValidator
+  class ErrorStore
+    attr_reader :data
+
+    def initialize(data = {})
+      @data = {}
+      self.load(data)
+    end
+
+    def get(key)
+      validate_key!(key)
+      @data[key.to_s]
+    end
+
+    def set(key, value = nil, &block)
+      validate_key!(key)
+      if key.is_a?(::Array)
+        key = key.flatten.reverse.inject do |a,n|
+          { n => a }
+        end
+      end
+      @data[key.to_s] = block_given? ? yield : value
+    end
+
+    def set?(key)
+      validate_key!(key)
+      @data.keys.include?(key.to_s)
+    end
+
+    def load(data)
+      data.each do |key, value|
+        validate_key!(key)
+        @data[key.to_s] = value
+      end
+    end
+
+    def reset
+      @data = {}
+    end
+
+    private
+
+    def validate_key!(key)
+      unless key.is_a?(::String) || key.is_a?(::Symbol) || key.is_a?(::Array) \
+        || key.is_a?(::Hash)
+        raise ::PoroValidator::InvalidType.new(
+          "only String, Symbol, Array or Hash are allowed! invalid key: #{key.inspect}"
+        )
+      end
+    end
+  end
+end

data/lib/poro_validator/errors.rb

@@ -0,0 +1,56 @@
+module PoroValidator
+  class Errors
+
+    attr_reader :store
+
+    def initialize
+      @store = ErrorStore.new
+    end
+
+    def add(attr, validator, *msg_opts)
+      if store.set?(attr)
+        store.get(attr) << message_lookup(validator, *msg_opts)
+      else
+        store.set(attr, [message_lookup(validator, *msg_opts)])
+      end
+    end
+
+    def count
+      store.data.inject(0) do |m, kv|
+        _, errors = *kv
+        m + errors.length
+      end
+    end
+
+    def empty?
+      count == 0
+    end
+
+    def full_messages
+      store.data.inject([]) do |m, kv|
+        attr, errors = *kv
+        errors.each { |e| m << "#{attr} #{e}" }
+        m
+      end
+    end
+
+    def on(attr)
+      return unless store.set?(attr)
+      store.get(attr)
+    end
+
+    def clear_errors
+      store.reset
+    end
+
+    alias_method :[], :on
+
+    private
+
+    def message_lookup(validator, *msg_opts)
+      validator.is_a?(Symbol) ? ::PoroValidator.configuration.message.get(
+        validator, *msg_opts
+      ) : validator
+    end
+  end
+end

data/lib/poro_validator/exceptions.rb

@@ -0,0 +1,14 @@
+module PoroValidator
+  class Exceptions < StandardError
+    def initialize(message = nil, object = nil)
+      super(message)
+    end
+  end
+
+  class ConfigError < Exceptions; end
+  class ValidatorNotFound < Exceptions; end
+  class InvalidCondition < Exceptions; end
+  class InvalidType < Exceptions; end
+  class OverloadriddenRequired < Exceptions; end
+  class InvalidValidator < Exceptions; end
+end

data/lib/poro_validator/validator.rb

@@ -0,0 +1,82 @@
+module PoroValidator
+  module Validator
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def validates(attr_name, **options, &block)
+        if block_given?
+          nested_validations = build_nested_validations(attr_name, &block)
+          nested_validations.each do |nested_validation|
+            validations << nested_validation
+          end
+        else
+          validations.build(attr_name, **options)
+        end
+      end
+
+      def validations
+        @validations ||= build_validations
+      end
+
+      private
+
+      def build_validations(validations = [])
+        Validations.build_validations(validations)
+      end
+
+      def validates_with(vals)
+        @validations = vals
+      end
+
+      def build_nested_validations(attr_name, &block)
+        nested_validator = Class.new do
+          include PoroValidator.validator
+        end
+        nested_validator.instance_eval(&block)
+        nested_validations = nested_validator.validations.validations
+        nested_validations.each do |nv|
+          nv[:validator].attribute = [attr_name, nv[:validator].attribute]
+        end
+      end
+
+      # Ensures that when a Validator class is subclassed, the
+      # validation rules will be carried into the subclass as well.
+      #
+      # @example
+      #   class PersonValidator
+      #     include Veto.validator
+      #     validates :name, presence: true
+      #   end
+      #
+      #   class CustomerValidator < PersonValidator
+      #     validates :customer_id, presence: true
+      #   end
+      #
+      #   customer = Customer.new
+      #   validator = CustomerValidator.new
+      #   validator.validate!(customer) # => ["name is not present", "customer_id is not present"]
+      def inherited(descendant)
+        descendant.send(:validates_with, (build_validations(validations.validations.dup)))
+      end
+    end
+
+    def errors
+      @errors ||= ::PoroValidator::Errors.new
+    end
+
+    def valid?(entity)
+      validate_entity(entity)
+      errors.empty?
+    end
+
+    private
+
+    def validate_entity(entity)
+      errors.clear_errors
+      context = Context.new(entity, self, errors)
+      self.class.validations.run_validations(context)
+    end
+  end
+end

data/lib/poro_validator/validator/base_class.rb

@@ -0,0 +1,55 @@
+module PoroValidator
+  module Validator
+    class BaseClass
+      # Public - Initializes the base class that creates a default value for
+      # the @validations variable with an empty array
+      #
+      # @validations - Stores all the validations intended for a Ruby object
+      #   (entity)
+      def initialize
+        @validations = []
+      end
+
+      # Public - Calls the internal #__run_validations__ method to perform the
+      # validations stored in the @validations instance array against a
+      # validator context if the conditions are truthy.
+      def run_validations(context)
+        __run_validations__(context)
+      end
+
+      # Adds/appends validations to the validations array
+      #
+      # @params[validation] - Validator Object to be stored to the array of
+      # validations.
+      def <<(validation)
+        @validations << validation
+      end
+
+      # @return array of hashes of validations and conditions
+      def validations
+        @validations
+      end
+
+      # @return array of validators
+      def validators
+        @validators
+      end
+
+      private
+
+      # @private
+      def __run_validations__(context)
+        validations.each do |validation|
+          validator  = validation[:validator]
+          conditions = validation[:conditions] || {}
+
+          unless conditions.empty?
+            next unless Conditions.matched?(conditions, context)
+          end
+
+          validator.__validate__(context)
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validator/conditions.rb

@@ -0,0 +1,71 @@
+module PoroValidator
+  module Validator
+    class Conditions
+      def self.matched?(conditions, context)
+        results = []
+        inst    = new(context)
+
+        conditions.each do |condition|
+          condition.each do |type, value|
+            unless [:if, :unless].include?(type)
+              raise ::PoroValidator::InvalidCondition.new(
+                "Unimplemented conditional key: #{type}"
+              )
+            end
+
+            if value.is_a?(::Array)
+              value.each do |v|
+                results << inst.match_condition(type, v)
+              end
+              next
+            end
+
+            results << inst.match_condition(type, value)
+            next
+          end
+        end
+
+        return false if results.include?(false)
+        true
+      end
+
+      def initialize(context)
+        @context = context
+      end
+
+      def match_condition(type, condition)
+        result =
+          case condition
+          when String
+            condition_type[String].call(context, condition)
+          when Symbol
+            condition_type[Symbol].call(context, condition)
+          when Proc
+            condition.call(context)
+          else
+            raise ::PoroValidator::InvalidCondition.new(
+              "Unimplemented condition: #{condition.inspect}"
+            )
+          end
+
+        if type == :unless
+          return !result
+        end
+        result
+      end
+
+      private
+
+      def context
+        @context
+      end
+
+      def condition_type
+        {
+          String => lambda { |context, string| context.entity.instance_eval(string) },
+          Symbol => lambda { |context, method| context.send(method, context.entity) },
+        }
+      end
+    end
+  end
+end