poro_validator 0.0.1

data/lib/poro_validator/validator/context.rb

@@ -0,0 +1,19 @@
+module PoroValidator
+  module Validator
+    class Context
+      attr_reader :entity, :context, :errors
+
+      # Initializes a new validator context
+      #
+      # @param entity [Object] The entity which to be validated
+      # @param context [self] The validating/validator class
+      # @param errors [Object] Error cache
+
+      def initialize(entity, context, errors)
+        @entity  = entity
+        @context = context
+        @errors  = errors
+      end
+    end
+  end
+end

data/lib/poro_validator/validator/factory.rb

@@ -0,0 +1,32 @@
+module PoroValidator
+  module Validator
+    class Factory
+      class Validators
+        class << self
+          def set_validator(attr_name, validator, options={})
+            klass = class_name(validator)
+            begin
+              PoroValidator.const_get(klass).new(attr_name, options)
+            rescue NameError => e
+              raise(::PoroValidator::ValidatorNotFound.new(
+                "Validator not found: ::PoroValidator::#{klass} exception: #{e}"
+              ))
+            end
+          end
+
+          private
+
+          def class_name(validator)
+            "Validators::#{camel_case(validator.to_s)}Validator"
+          end
+
+          def camel_case(str)
+            str.split('_').map do |char|
+              char.capitalize
+            end.join('')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validator/validation.rb

@@ -0,0 +1,50 @@
+module PoroValidator
+  module Validator
+    class Validation
+      # Builds a validation from the params passed which is initiated first
+      # then passed into the Validators.set_validator method
+      #
+      # @params[attr_name] - name of the attribute to be validated
+      # @params[validator] - validator class to be used for validating
+      # attribute
+      # @params[options]   - arguments against validator and additional options
+      #   e.g, message:, on:, etc.
+      def self.build(attr_name, validator, options)
+        b = new(attr_name, validator, options)
+        b = Factory::Validators.set_validator(b.attr_name,
+                                              b.validator,
+                                              b.options)
+        b
+      end
+
+      def initialize(attr_name, validator, options = nil)
+        @attr_name = attr_name
+        @validator = validator
+        opts =
+          case options
+          when TrueClass
+            {}
+          when Hash
+            options
+          when Range, Array
+            { in: options }
+          else
+            { with: options }
+          end
+        @options = opts
+      end
+
+      def options
+        @options
+      end
+
+      def attr_name
+        @attr_name
+      end
+
+      def validator
+        @validator
+      end
+    end
+  end
+end

data/lib/poro_validator/validator/validations.rb

@@ -0,0 +1,55 @@
+module PoroValidator
+  module Validator
+    # @private
+    class Validations < BaseClass
+      def self.build_validations(validations = [])
+        inst = new
+        unless validations.empty?
+          validations.each do |validation|
+            inst << validation
+          end
+        end
+        inst
+      end
+
+      def initialize(&block)
+        super()
+        instance_eval(&block) if block_given?
+      end
+
+      def build(attr, **options)
+        @validators = options.reject do |k,v|
+          [:if, :unless].include?(k)
+        end
+
+        @conditions = [] << options.select do |k,v|
+          [:if, :unless].include?(k)
+        end
+
+        @validators.each do |validator,options|
+          nested_conditions = {}
+          if options.is_a?(::Hash)
+            # Check if there are any nested conditions for a validator
+            # options and select if it exists.
+            #
+            # e.g
+            #   validates :foo, format: { with: "hello", unless: :foo_rule }
+            nested_conditions = options.select do |k,v|
+              [:if, :unless].include?(k)
+            end
+
+            # Remove the nested conditions from the validator options.
+            unless nested_conditions.empty?
+              options.reject! { |k,v| [:if, :unless].include?(k) }
+              @conditions << nested_conditions
+            end
+          end
+
+          self << { validator: Validation.build(attr, validator, options),
+                    conditions: @conditions.reject(&:empty?)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/base_class.rb

@@ -0,0 +1,53 @@
+module PoroValidator
+  module Validators
+    class BaseClass
+      attr_writer :attribute
+
+      def initialize(attribute, options = {})
+        @attribute = attribute
+        @options   = options
+      end
+
+      def options
+        @options
+      end
+
+      def attribute
+        @attribute
+      end
+
+      def errors
+        @errors ||= context.errors
+      end
+
+      def context
+        @context
+      end
+
+      def nested?
+        attribute.is_a?(::Array)
+      end
+
+      def validate(attribute, value, options)
+        raise ::PoroValidator::OverloadriddenRequired.new(
+          "This method needs to be overloaded/overriden."
+        )
+      end
+
+      def value
+        if nested?
+          @value = attribute.flatten.inject(context.entity, :public_send)
+        else
+          @value = context.entity.public_send(attribute)
+        end
+      end
+
+      # @private
+      def __validate__(validator_context)
+        @context = validator_context
+        @errors  = context.errors
+        validate(attribute, value, options)
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/exclusion_validator.rb

@@ -0,0 +1,26 @@
+module PoroValidator
+  module Validators
+    class ExclusionValidator < RangeArrayValidator
+      def validate(attribute, value, options)
+        in_option = options[:in]
+
+        unless validate_option(in_option)
+          raise ::PoroValidator::InvalidValidator,
+            [
+              "There was no range or array specified. Pass in a range or array.",
+              "e.g",
+              "validates :foo, exclusion: 1..10",
+              "or",
+              "validates :boo, exclusion: { in: 1..10 }"
+          ].join("\n")
+        end
+
+        message = options.fetch(:message, :exclusion)
+
+        if covered?(in_option, value) || included?(in_option, value)
+          errors.add(attribute, message, in_option)
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/float_validator.rb

@@ -0,0 +1,17 @@
+module PoroValidator
+  module Validators
+    class FloatValidator < BaseClass
+      def validate(attribute, value, options)
+        message = options.fetch(:message, :float)
+
+        begin
+          Kernel.Float(value.to_s)
+          nil
+        rescue
+          errors.add(attribute, message)
+        end
+      end
+    end
+  end
+end
+

data/lib/poro_validator/validators/format_validator.rb

@@ -0,0 +1,16 @@
+module PoroValidator
+  module Validators
+    class FormatValidator < BaseClass
+      def validate(attribute, value, options)
+        return if value.nil?
+
+        pattern = options.fetch(:with)
+        message = options.fetch(:message, :format)
+
+        unless value.to_s =~ pattern
+          errors.add(attribute, message, pattern)
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/inclusion_validator.rb

@@ -0,0 +1,26 @@
+module PoroValidator
+  module Validators
+    class InclusionValidator < RangeArrayValidator
+      def validate(attribute, value, options)
+        in_option = options[:in]
+
+        unless validate_option(in_option)
+          raise ::PoroValidator::InvalidValidator,
+            [
+              "There was no range or array specified. Pass in a range or array.",
+              "e.g",
+              "validates :foo, inclusion: 1..10",
+              "or",
+              "validates :boo, inclusion: { in: 1..10 }"
+          ].join("\n")
+        end
+
+        message = options.fetch(:message, :inclusion)
+
+        unless covered?(in_option, value) || included?(in_option, value)
+          errors.add(attribute, message, in_option)
+        end
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/integer_validator.rb

@@ -0,0 +1,17 @@
+module PoroValidator
+  module Validators
+    class IntegerValidator < BaseClass
+      def validate(attribute, value, options)
+        message = options.fetch(:message, :integer)
+
+        begin
+          Kernel.Integer(value.to_s)
+          nil
+        rescue
+          errors.add(attribute, message)
+        end
+      end
+
+    end
+  end
+end

data/lib/poro_validator/validators/length_validator.rb

@@ -0,0 +1,41 @@
+module PoroValidator
+  module Validators
+    class LengthValidator < BaseClass
+      def validate(attribute, value, options)
+        message = options.fetch(:message, :length)
+
+        options.keys.each do |key|
+          matcher = matchers(key)
+          next if matcher.nil?
+          v = value.is_a?(::String) ? value : value.to_s
+          unless matchers(key).call(v, options[key])
+            errors.add(attribute, message, key => options[key])
+          end
+        end
+      end
+
+      private
+
+      def matchers(key)
+        m = {
+          extremum: lambda do |value, length|
+            value.length == length
+          end,
+
+          max: lambda do |value, length|
+            value.length <= length
+          end,
+
+          min: lambda do |value, length|
+            value.length >= length
+          end,
+
+          in: lambda do |value, length|
+            length.cover?(value.length)
+          end
+        }
+        m.fetch(key, nil)
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/numeric_validator.rb

@@ -0,0 +1,48 @@
+module PoroValidator
+  module Validators
+    class NumericValidator < BaseClass
+      def validate(attribute, value, options)
+        message = options.fetch(:message, :numeric)
+
+        begin
+          Kernel.Integer(value.to_s)
+          nil
+        rescue
+          errors.add(attribute, :integer)
+          return
+        end
+
+        options.keys.each do |key|
+          matcher = matchers(key)
+          next if matcher.nil?
+          unless matchers(key).call(value, options[key])
+            errors.add(attribute, message, key => options[key])
+          end
+        end
+      end
+
+      private
+
+      def matchers(key)
+        m = {
+          extremum: lambda do |value, length|
+            value == length
+          end,
+
+          max: lambda do |value, length|
+            value <= length
+          end,
+
+          min: lambda do |value, length|
+            value >= length
+          end,
+
+          in: lambda do |value, length|
+            length.cover?(value)
+          end
+        }
+        m.fetch(key, nil)
+      end
+    end
+  end
+end

data/lib/poro_validator/validators/presence_validator.rb

@@ -0,0 +1,23 @@
+module PoroValidator
+  module Validators
+    class PresenceValidator < BaseClass
+      BLANK_STRING_MATCHER = /\A[[:space:]]*\z/.freeze
+
+      def validate(attribute, value, options)
+        allow_blank = options.fetch(:allow_blank, false)
+        message = options.fetch(:message, :presence)
+
+        if value.is_a?(::String)
+          if value.gsub(/\s+/, '').match(BLANK_STRING_MATCHER)
+            errors.add(attribute, message) unless allow_blank
+            return
+          end
+        end
+
+        if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          errors.add(attribute, message)
+        end
+      end
+    end
+  end
+end