hanami-validations 0.0.0 → 0.5.0

data/lib/hanami/validations/blank_value_checker.rb

@@ -0,0 +1,55 @@
+module Hanami
+  module Validations
+    # @since 0.2.2
+    # @api private
+    class BlankValueChecker
+      # @since 0.2.2
+      # @api private
+      BLANK_STRING_MATCHER = /\A[[:space:]]*\z/.freeze
+
+      def initialize(value)
+        @value = value
+      end
+
+      # Checks if the value is "blank".
+      #
+      # @since 0.2.2
+      # @api private
+      def blank_value?
+        _nil_value? || _blank_string? || _empty_value?
+      end
+
+      private
+
+      # Checks if the value is `nil`.
+      #
+      # @since 0.2.2
+      # @api private
+      def _nil_value?
+        @value.nil?
+      end
+
+      # @since 0.2.2
+      # @api private
+      def _blank_string?
+        (@value.respond_to?(:match) and @value.match(BLANK_STRING_MATCHER))
+      end
+
+      # @since 0.2.2
+      # @api private
+      def _empty_value?
+        return false if _enumerable?
+        (@value.respond_to?(:empty?) and @value.empty?)
+      end
+
+      # Collectable classes should not be considered as blank value
+      # even if it's responds _true_ to its own `empty?` method.
+      #
+      # @since 0.4.0
+      # @api private
+      def _enumerable?
+        @value.respond_to?(:each)
+      end
+    end
+  end
+end

data/lib/hanami/validations/coercions.rb

@@ -0,0 +1,31 @@
+require 'hanami/utils/kernel'
+
+module Hanami
+  module Validations
+    # Coercions for attribute's values.
+    #
+    # @since 0.1.0
+    # @api private
+    module Coercions
+      # Coerces the given values with the given type
+      #
+      # @param coercer [Class] the type
+      # @param value [Array] of objects to be coerced
+      # @param blk [Proc] an optional block to pass to the custom coercer
+      #
+      # @return [Object,nil] The result of the coercion, if possible
+      #
+      # @raise [ArgumentError] if the custom coercer's `#initialize` has a wrong arity.
+      #
+      # @since 0.1.0
+      # @api private
+      def self.coerce(coercer, value, &blk)
+        if ::Hanami::Utils::Kernel.respond_to?(coercer.to_s)
+          ::Hanami::Utils::Kernel.__send__(coercer.to_s, value, &blk) rescue nil
+        else
+          coercer.new(value, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/validations/error.rb

@@ -0,0 +1,95 @@
+module Hanami
+  module Validations
+    # A single validation error for an attribute
+    #
+    # @since 0.1.0
+    class Error
+      # @since 0.2.4
+      # @api private
+      NAMESPACE_SEPARATOR = '.'.freeze
+
+      # The name of the attribute
+      #
+      # @return [Symbol] the name of the attribute
+      #
+      # @since 0.2.4
+      #
+      # @see Hanami::Validations::Error#attribute
+      #
+      # @example
+      #   error = Error.new(:name, :presence, true, nil, 'author')
+      #
+      #   error.attribute      # => "author.name"
+      #   error.attribute_name # => "name"
+      attr_reader :attribute_name
+
+      # The name of the validation
+      #
+      # @return [Symbol] the name of the validation
+      #
+      # @since 0.1.0
+      attr_reader :validation
+
+      # The expected value
+      #
+      # @return [Object] the expected value
+      #
+      # @since 0.1.0
+      attr_reader :expected
+
+      # The actual value
+      #
+      # @return [Object] the actual value
+      #
+      # @since 0.1.0
+      attr_reader :actual
+
+      # Returns the namespaced attribute name
+      #
+      # In cases where the error was pulled up from nested validators,
+      # `attribute` will be a namespaced string containing
+      # parent attribute names separated by a period.
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Validations::Error#attribute_name
+      #
+      # @example
+      #   error = Error.new(:name, :presence, true, nil, 'author')
+      #
+      #   error.attribute      # => "author.name"
+      #   error.attribute_name # => "name"
+      attr_accessor :attribute
+
+      # Initialize a validation error
+      #
+      # @param attribute_name [Symbol] the name of the attribute
+      # @param validation [Symbol] the name of the validation
+      # @param expected [Object] the expected value
+      # @param actual [Object] the actual value
+      # @param namespace [String] the optional namespace
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize(attribute_name, validation, expected, actual, namespace = nil)
+        @attribute_name = attribute_name.to_s
+        @validation = validation
+        @expected = expected
+        @actual = actual
+        @namespace = namespace
+        @attribute = [@namespace, attribute_name].compact.join(NAMESPACE_SEPARATOR)
+      end
+
+      # Check if self equals to `other`
+      #
+      # @since 0.1.0
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.attribute  == attribute  &&
+          other.validation == validation &&
+          other.expected   == expected   &&
+          other.actual     == actual
+      end
+    end
+  end
+end

data/lib/hanami/validations/errors.rb

@@ -0,0 +1,155 @@
+require 'hanami/validations/error'
+
+module Hanami
+  module Validations
+    # A set of errors for a validator
+    #
+    # This is the result of calling `#valid?` on a validator.
+    #
+    # @see Hanami::Validations::Error
+    #
+    # @since 0.1.0
+    class Errors
+      # Initialize the errors
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize
+        @errors = Hash.new
+      end
+
+      # Check if the set is empty
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Validations::Errors#any?
+      def empty?
+        @errors.empty?
+      end
+
+      # Check if the set has any entry
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.2.0
+      #
+      # @see Hanami::Validations::Errors#empty?
+      def any?
+        @errors.any?
+      end
+
+      # Returns how many validations have failed
+      #
+      # @return [Fixnum] the count
+      #
+      # @since 0.1.0
+      def count
+        errors.count
+      end
+
+      alias_method :size, :count
+
+      # Clears the internal state of the errors
+      #
+      # @since 0.1.0
+      # @api private
+      def clear
+        @errors.clear
+      end
+
+      # Iterate thru the errors and yields the given block
+      #
+      # @param blk [Proc] the given block
+      # @yield [error] a Hanami::Validations::Error
+      #
+      # @see Hanami::Validations::Error
+      #
+      # @since 0.1.0
+      def each(&blk)
+        errors.each(&blk)
+      end
+
+      # Iterate thru the errors, yields the given block and collect the
+      # returning value.
+      #
+      # @param blk [Proc] the given block
+      # @yield [error] a Hanami::Validations::Error
+      #
+      # @see Hanami::Validations::Error
+      #
+      # @since 0.1.0
+      def map(&blk)
+        errors.map(&blk)
+      end
+
+      # Add an error to the set
+      #
+      # @param attribute [Symbol] the name of the attribute
+      # @param errors [Array] a collection of errors
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Validations::Error
+      def add(attribute, *errors)
+        if errors.any?
+          @errors[attribute] ||= []
+          @errors[attribute].push(*errors)
+        end
+      end
+
+      # Return the errors for the given attribute
+      #
+      # @param attribute [Symbol] the name of the attribute
+      #
+      # @since 0.1.0
+      def for(attribute)
+        @errors.fetch(attribute) { [] }
+      end
+
+      # Check if the current set of errors equals to the one who belongs to
+      # `other`.
+      #
+      # @param other [Object] the other term of comparison
+      #
+      # @return [TrueClass,FalseClass] the result of comparison
+      #
+      # @since 0.1.0
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.errors == errors
+      end
+
+      alias_method :eql?, :==
+
+      # Return a serializable Hash representation of the errors.
+      #
+      # @return [Hanami::Utils::Hash] the Hash
+      #
+      # @since 0.2.1
+      def to_h
+        Utils::Hash.new(@errors).deep_dup
+      end
+
+      # Return a flat collection of errors.
+      #
+      # @return [Array]
+      #
+      # @since 0.2.1
+      def to_a
+        errors.dup
+      end
+
+      protected
+      # A flatten set of errors for all the attributes
+      #
+      # @since 0.1.0
+      # @api private
+      def errors
+        @errors.values.flatten
+      end
+    end
+  end
+end

data/lib/hanami/validations/nested_attributes.rb

@@ -0,0 +1,22 @@
+module Hanami
+  module Validations
+    # @since 0.3.1
+    # @api private
+    class NestedAttributes
+      # @since 0.3.1
+      # @api private
+      def self.fabricate(&blk)
+        dup.tap do |klass|
+          klass.class_eval { include Hanami::Validations }
+          klass.class_eval(&blk)
+        end
+      end
+
+      # @since 0.3.1
+      # @api private
+      def hanami_nested_attributes?
+        true
+      end
+    end
+  end
+end

data/lib/hanami/validations/validation_set.rb

@@ -0,0 +1,81 @@
+module Hanami
+  module Validations
+    # A set of validations defined on an object
+    #
+    # @since 0.2.2
+    # @api private
+    class ValidationSet
+      # Allowed validations
+      #
+      # @since 0.2.2
+      # @api private
+      VALIDATIONS = [
+        :presence,
+        :acceptance,
+        :format,
+        :inclusion,
+        :exclusion,
+        :confirmation,
+        :size,
+        :type,
+        :nested
+      ].freeze
+
+      # @since 0.2.2
+      # @api private
+      def initialize
+        @validations = Hash.new {|h,k| h[k] = {} }
+      end
+
+      # @since 0.2.2
+      # @api private
+      def add(name, options)
+        @validations[name.to_sym].merge!(
+          validate_options!(name, options)
+        )
+      end
+
+      # @since 0.2.2
+      # @api private
+      def each(&blk)
+        @validations.each(&blk)
+      end
+
+      # @since 0.2.2
+      # @api private
+      def each_key(&blk)
+        @validations.each_key(&blk)
+      end
+
+      # @since 0.2.3
+      # @api private
+      def names
+        @validations.keys
+      end
+
+      private
+      # Checks at the loading time if the user defined validations are recognized
+      #
+      # @param name [Symbol] the attribute name
+      # @param options [Hash] the set of validations associated with the given attribute
+      #
+      # @raise [ArgumentError] if at least one of the validations are not
+      #   recognized
+      #
+      # @since 0.2.2
+      # @api private
+      def validate_options!(name, options)
+        if (unknown = (options.keys - VALIDATIONS)) && unknown.any?
+          raise ArgumentError.new(%(Unknown validation(s): #{ unknown.join ', ' } for "#{ name }" attribute))
+        end
+
+        # FIXME remove
+        if options[:confirmation]
+          add(:"#{ name }_confirmation", {})
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/hanami/validations/validator.rb

@@ -0,0 +1,29 @@
+module Hanami
+  module Validations
+    # Validate given validations and return a set of errors
+    #
+    # @since 0.2.2
+    # @api private
+    class Validator
+      def initialize(validation_set, attributes, errors)
+        @validation_set = validation_set
+        @attributes = attributes
+        @errors = errors
+      end
+
+      # @since 0.2.2
+      # @api private
+      def validate
+        @errors.clear
+        @validation_set.each do |name, validations|
+          value = @attributes[name]
+          value = @attributes[name.to_s] if value.nil?
+
+          attribute = Attribute.new(@attributes, name, value, validations, @errors)
+          attribute.validate
+        end
+        @errors
+      end
+    end
+  end
+end