hanami-validations 0.0.0 → 0.5.0

data/hanami-validations.gemspec

@@ -4,20 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hanami/validations/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "hanami-validations"
+  spec.name          = 'hanami-validations'
   spec.version       = Hanami::Validations::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
+  spec.authors       = ['Luca Guidi', 'Trung Lê', 'Alfonso Uceda']
+  spec.email         = ['me@lucaguidi.com', 'trung.le@ruby-journal.com', 'uceda73@gmail.com']
+  spec.summary       = %q{Validations mixin for Ruby objects}
+  spec.description   = %q{Validations mixin for Ruby objects and support for Hanami}
+  spec.homepage      = 'http://hanamirb.org'
+  spec.license       = 'MIT'
 
-  spec.summary       = %q{The web, with simplicity}
-  spec.description   = %q{Hanami is a web framework for Ruby}
-  spec.homepage      = "http://hanamirb.org"
+  spec.files         = `git ls-files -- lib/* LICENSE.md README.md CHANGELOG.md hanami-validations.gemspec`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.0.0'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.add_dependency 'hanami-utils', '~> 0.7'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler',  '~> 1.6'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'rake',     '~> 10'
 end

data/lib/hanami-validations.rb

@@ -0,0 +1 @@
+require 'hanami/validations'

data/lib/hanami/validations.rb

@@ -1,7 +1,305 @@
-require "hanami/validations/version"
+require 'hanami/utils/hash'
+require 'hanami/validations/version'
+require 'hanami/validations/blank_value_checker'
+require 'hanami/validations/attribute_definer'
+require 'hanami/validations/validation_set'
+require 'hanami/validations/validator'
+require 'hanami/validations/attribute'
+require 'hanami/validations/errors'
 
 module Hanami
+  # Hanami::Validations is a set of lightweight validations for Ruby objects.
+  #
+  # @since 0.1.0
   module Validations
-    # Your code goes here...
+    # Override Ruby's hook for modules.
+    #
+    # @param base [Class] the target action
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include AttributeDefiner
+      end
+    end
+
+    # Validations DSL
+    #
+    # @since 0.1.0
+    module ClassMethods
+      # Override Ruby's hook for class inheritance. When a class includes
+      # Hanami::Validations and it is subclassed, this passes
+      # the attributes from the superclass to the subclass.
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.2.2
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core/Class.html#method-i-inherited
+      def inherited(base)
+        transfer_validations_to_base(base)
+        super
+      end
+
+      # Override Ruby's hook for modules. When a module includes
+      # Hanami::Validations and it is included in a class or module, this passes
+      # the validations from the module to the base.
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+      #
+      # @example
+      #   require 'hanami/validations'
+      #
+      #   module NameValidations
+      #     include Hanami::Validations
+      #
+      #     attribute :name, presence: true
+      #   end
+      #
+      #   class Signup
+      #     include NameValidations
+      #   end
+      #
+      #   signup = Signup.new(name: '')
+      #   signup.valid? # => false
+      #
+      #   signup = Signup.new(name: 'Luca')
+      #   signup.valid? # => true
+      def included(base)
+        base.class_eval do
+          include Hanami::Validations
+        end
+
+        super
+
+        transfer_validations_to_base(base)
+      end
+
+      # Define a validation for an existing attribute
+      #
+      # @param name [#to_sym] the name of the attribute
+      # @param options [Hash] set of validations
+      #
+      # @see Hanami::Validations::ClassMethods#validations
+      #
+      # @example Presence
+      #   require 'hanami/validations'
+      #
+      #   class Signup
+      #     include Hanami::Validations
+      #
+      #     def initialize(attributes = {})
+      #       @name = attributes.fetch(:name)
+      #     end
+      #
+      #     attr_accessor :name
+      #
+      #     validates :name, presence: true
+      #   end
+      #
+      #   signup = Signup.new(name: 'Luca')
+      #   signup.valid? # => true
+      #
+      #   signup = Signup.new(name: nil)
+      #   signup.valid? # => false
+      def validates(name, options)
+        validations.add(name, options)
+      end
+
+      # Set of user defined validations
+      #
+      # @return [Hash]
+      #
+      # @since 0.2.2
+      # @api private
+      def validations
+        @validations ||= ValidationSet.new
+      end
+
+      # Set of user defined attributes
+      #
+      # @return [Array<String>]
+      #
+      # @since 0.2.3
+      # @api private
+      def defined_attributes
+        validations.names.map(&:to_s)
+      end
+
+      private
+
+      # Transfers attributes to a base class
+      #
+      # @param base [Module] the base class to transfer attributes to
+      #
+      # @since 0.2.2
+      # @api private
+      def transfer_validations_to_base(base)
+        validations.each do |attribute, options|
+          base.validates attribute, options
+        end
+      end
+    end
+
+    # Validation errors
+    #
+    # @return [Hanami::Validations::Errors] the set of validation errors
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Validations::Errors
+    #
+    # @example Valid attributes
+    #   require 'hanami/validations'
+    #
+    #   class Signup
+    #     include Hanami::Validations
+    #
+    #     attribute :email, presence: true, format: /\A(.*)@(.*)\.(.*)\z/
+    #   end
+    #
+    #   signup = Signup.new(email: 'user@example.org')
+    #   signup.valid? # => true
+    #
+    #   signup.errors
+    #     # => #<Hanami::Validations::Errors:0x007fd594ba9228 @errors={}>
+    #
+    # @example Invalid attributes
+    #   require 'hanami/validations'
+    #
+    #   class Signup
+    #     include Hanami::Validations
+    #
+    #     attribute :email, presence: true, format: /\A(.*)@(.*)\.(.*)\z/
+    #     attribute :age, size: 18..99
+    #   end
+    #
+    #   signup = Signup.new(email: '', age: 17)
+    #   signup.valid? # => false
+    #
+    #   signup.errors
+    #     # => #<Hanami::Validations::Errors:0x007fe00ced9b78
+    #     # @errors={
+    #     #   :email=>[
+    #     #     #<Hanami::Validations::Error:0x007fe00cee3290 @attribute=:email, @validation=:presence, @expected=true, @actual="">,
+    #     #     #<Hanami::Validations::Error:0x007fe00cee31f0 @attribute=:email, @validation=:format, @expected=/\A(.*)@(.*)\.(.*)\z/, @actual="">
+    #     #   ],
+    #     #   :age=>[
+    #     #     #<Hanami::Validations::Error:0x007fe00cee30d8 @attribute=:age, @validation=:size, @expected=18..99, @actual=17>
+    #     #   ]
+    #     # }>
+    #
+    # @example Invalid attributes
+    #   require 'hanami/validations'
+    #
+    #   class Post
+    #     include Hanami::Validations
+    #
+    #     attribute :title, presence: true
+    #   end
+    #
+    #   post = Post.new
+    #   post.invalid? # => true
+    #
+    #   post.errors
+    #     # => #<Hanami::Validations::Errors:0x2931522b
+    #     # @errors={
+    #     #   :title=>[
+    #     #     #<Hanami::Validations::Error:0x662706a7 @actual=nil, @attribute_name="title", @validation=:presence, @expected=true, @namespace=nil, @attribute="title">
+    #     #   ]
+    #     # }>
+    def errors
+      @errors ||= Errors.new
+    end
+
+    # Checks if the current data satisfies the defined validations
+    #
+    # @return [TrueClass,FalseClass] the result of the validations
+    #
+    # @since 0.1.0
+    def valid?
+      validate
+
+      errors.empty?
+    end
+
+    # Checks if the current data doesn't satisfies the defined validations
+    #
+    # @return [TrueClass,FalseClass] the result of the validations
+    #
+    # @since 0.3.2
+    def invalid?
+      !valid?
+    end
+
+    # Validates the object.
+    #
+    # @return [Errors]
+    #
+    # @since 0.2.4
+    # @api private
+    #
+    # @see Hanami::Attribute#nested
+    def validate
+      validator = Validator.new(defined_validations, read_attributes, errors)
+      validator.validate
+    end
+
+    # Iterates thru the defined attributes and their values
+    #
+    # @param blk [Proc] a block
+    # @yieldparam attribute [Symbol] the name of the attribute
+    # @yieldparam value [Object,nil] the value of the attribute
+    #
+    # @since 0.2.0
+    def each(&blk)
+      to_h.each(&blk)
+    end
+
+    # Returns a Hash with the defined attributes as symbolized keys, and their
+    # relative values.
+    #
+    # @return [Hash]
+    #
+    # @since 0.1.0
+    def to_h
+      # TODO remove this symbolization when we'll support Ruby 2.2+ only
+      Utils::Hash.new(
+        @attributes
+      ).deep_dup.symbolize!.to_h
+    end
+
+    private
+    # The set of user defined validations.
+    #
+    # @since 0.2.2
+    # @api private
+    #
+    # @see Hanami::Validations::ClassMethods#validations
+    def defined_validations
+      self.class.__send__(:validations)
+    end
+
+    # Builds a Hash of current attribute values.
+    #
+    # @since 0.2.2
+    # @api private
+    def read_attributes
+      {}.tap do |attributes|
+        defined_validations.each_key do |attribute|
+          attributes[attribute] = public_send(attribute)
+        end
+      end
+    end
   end
 end

data/lib/hanami/validations/attribute.rb

@@ -0,0 +1,252 @@
+require 'hanami/validations/coercions'
+
+# Quick fix for non MRI VMs that don't implement Range#size
+#
+# @since 0.1.0
+class Range
+  def size
+    to_a.size
+  end unless instance_methods.include?(:size)
+end
+
+module Hanami
+  module Validations
+    # A validable attribute
+    #
+    # @since 0.1.0
+    # @api private
+    class Attribute
+      # Attribute naming convention for "confirmation" validation
+      #
+      # @see Hanami::Validations::Attribute#confirmation
+      #
+      # @since 0.2.0
+      # @api private
+      CONFIRMATION_TEMPLATE = '%{name}_confirmation'.freeze
+
+      # Instantiate an attribute
+      #
+      # @param attributes [Hash] a set of attributes and values coming from the
+      #   input
+      # @param name [Symbol] the name of the attribute
+      # @param value [Object,nil] the value coming from the input
+      # @param validations [Hash] a set of validation rules
+      #
+      # @since 0.2.0
+      # @api private
+      def initialize(attributes, name, value, validations, errors)
+        @attributes  = attributes
+        @name        = name
+        @value       = value
+        @validations = validations
+        @errors      = errors
+      end
+
+      # @api private
+      # @since 0.2.0
+      def validate
+        presence
+        acceptance
+
+        return if skip?
+
+        format
+        inclusion
+        exclusion
+        size
+        confirmation
+        nested
+
+        @errors
+      end
+
+      # @api private
+      # @since 0.2.0
+      attr_reader :value
+
+      private
+      # Validates presence of the value.
+      # This fails with `nil` and "blank" values.
+      #
+      # An object is blank if it isn't `nil`, but doesn't hold a value.
+      # Empty strings and enumerables are an example.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      # @see Hanami::Validations::Attribute#nil_value?
+      #
+      # @since 0.2.0
+      # @api private
+      def presence
+        _validate(__method__) { !blank_value? }
+      end
+
+      # Validates acceptance of the value.
+      #
+      # This passes if the value is "truthy", it fails if not.
+      #
+      # Truthy examples: `Object.new`, `1`, `"1"`, `true`.
+      # Falsy examples: `nil`, `0`, `"0"`, `false`, `""`.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      # @see http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/Kernel#Boolean-class_method
+      #
+      # @since 0.2.0
+      # @api private
+      def acceptance
+        _validate(__method__) do
+          !blank_value? && Hanami::Utils::Kernel.Boolean(@value)
+        end
+      end
+
+      # Validates format of the value.
+      #
+      # Coerces the value to a string and then check if it satisfies the defined
+      # matcher.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      #
+      # @since 0.2.0
+      # @api private
+      def format
+        _validate(__method__) {|matcher| @value.to_s.match(matcher) } unless blank_value?
+      end
+
+      # Validates inclusion of the value in the defined collection.
+      #
+      # The collection is an objects which implements `#include?`.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      #
+      # @since 0.2.0
+      # @api private
+      def inclusion
+        _validate(__method__) {|collection| collection.include?(value) }
+      end
+
+      # Validates exclusion of the value in the defined collection.
+      #
+      # The collection is an objects which implements `#include?`.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      #
+      # @since 0.2.0
+      # @api private
+      def exclusion
+        _validate(__method__) {|collection| !collection.include?(value) }
+      end
+
+      # Validates confirmation of the value with another corresponding value.
+      #
+      # Given a `:password` attribute, it passes if the corresponding attribute
+      # `:password_confirmation` has the same value.
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      # @see Hanami::Validations::Attribute::CONFIRMATION_TEMPLATE
+      #
+      # @since 0.2.0
+      # @api private
+      def confirmation
+        _validate(__method__) do
+          _attribute == _attribute(CONFIRMATION_TEMPLATE % { name: @name })
+        end
+      end
+
+      # Validates if value's size matches the defined quantity.
+      #
+      # The quantity can be a Ruby Numeric:
+      #
+      #   * `Integer`
+      #   * `Fixnum`
+      #   * `Float`
+      #   * `BigNum`
+      #   * `BigDecimal`
+      #   * `Complex`
+      #   * `Rational`
+      #   * Octal literals
+      #   * Hex literals
+      #   * `#to_int`
+      #
+      # The quantity can be also any object which implements `#include?`.
+      #
+      # If the quantity is a Numeric, the size of the value MUST be exactly the
+      # same.
+      #
+      # If the quantity is a Range, the size of the value MUST be included.
+      #
+      # If the attribute's value is blank, the size will not be considered
+      #
+      # The value is an object which implements `#size`.
+      #
+      # @raise [ArgumentError] if the defined quantity isn't a Numeric or a
+      #   collection
+      #
+      # @see Hanami::Validations::ClassMethods#attribute
+      #
+      # @since 0.2.0
+      # @api private
+      def size
+        return if blank_value?
+
+        _validate(__method__) do |validator|
+          case validator
+          when Numeric, ->(v) { v.respond_to?(:to_int) }
+            value.size == validator.to_int
+          when Range
+            validator.include?(value.size)
+          else
+            raise ArgumentError.new("Size validator must be a number or a range, it was: #{ validator }")
+          end
+        end
+      end
+
+      # Validates nested Hanami Validations objects
+      #
+      # @since 0.2.4
+      # @api private
+      def nested
+        _validate(__method__) do |validator|
+          errors = value.validate
+          errors.each do |error|
+            new_error = Error.new(error.attribute, error.validation, error.expected, error.actual, @name)
+            @errors.add new_error.attribute, new_error
+          end
+          true
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def skip?
+        @value.nil?
+      end
+
+      # Checks if the value is "blank".
+      #
+      # @see Hanami::Validations::BlankValueChecker
+      #
+      # @since 0.2.0
+      # @api private
+      def blank_value?
+        BlankValueChecker.new(@value).blank_value?
+      end
+
+      # Reads an attribute from the validator.
+      #
+      # @since 0.2.0
+      # @api private
+      def _attribute(name = @name)
+        @attributes[name.to_sym]
+      end
+
+      # Run a single validation and collects the results.
+      #
+      # @since 0.2.0
+      # @api private
+      def _validate(validation)
+        if (validator = @validations[validation]) && !(yield validator)
+          @errors.add(@name, Error.new(@name, validation, @validations.fetch(validation), @value))
+        end
+      end
+    end
+  end
+end