hanami-validations 0.5.0 → 0.6.0

data/hanami-validations.gemspec

@@ -8,18 +8,19 @@ Gem::Specification.new do |spec|
   spec.version       = Hanami::Validations::VERSION
   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.summary       = 'Validations mixin for Ruby objects'
+  spec.description   = 'Validations mixin for Ruby objects and support for Hanami'
   spec.homepage      = 'http://hanamirb.org'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -- lib/* LICENSE.md README.md CHANGELOG.md hanami-validations.gemspec`.split($/)
+  spec.files         = `git ls-files -- lib/* LICENSE.md README.md CHANGELOG.md hanami-validations.gemspec`.split($INPUT_RECORD_SEPARATOR)
   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.required_ruby_version = '>= 2.2.0'
 
-  spec.add_dependency 'hanami-utils', '~> 0.7'
+  spec.add_dependency 'hanami-utils',   '~> 0.8'
+  spec.add_dependency 'dry-validation', '~> 0.9'
 
   spec.add_development_dependency 'bundler',  '~> 1.6'
   spec.add_development_dependency 'minitest', '~> 5'

data/lib/hanami-validations.rb

@@ -1 +1 @@
-require 'hanami/validations'
+require 'hanami/validations' # rubocop:disable Style/FileName

data/lib/hanami/validations.rb

@@ -1,17 +1,36 @@
-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'
+require 'dry-validation'
+require 'hanami/utils/class_attribute'
+require 'hanami/validations/namespace'
+require 'hanami/validations/predicates'
+require 'hanami/validations/inline_predicate'
+require 'set'
+
+Dry::Validation::Messages::Namespaced.configure do |config|
+  config.lookup_paths = config.lookup_paths + %w(
+    %{root}.%{rule}.%{predicate}
+  ).freeze
+end
 
 module Hanami
   # Hanami::Validations is a set of lightweight validations for Ruby objects.
   #
   # @since 0.1.0
+  #
+  # @example
+  #   require 'hanami/validations'
+  #
+  #   class Signup
+  #     include Hanami::Validations
+  #
+  #     validations do
+  #       # ...
+  #     end
+  #   end
   module Validations
+    # @since 0.6.0
+    # @api private
+    DEFAULT_MESSAGES_ENGINE = :yaml
+
     # Override Ruby's hook for modules.
     #
     # @param base [Class] the target action
@@ -20,250 +39,308 @@ module Hanami
     # @api private
     #
     # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+    # rubocop:disable Metrics/MethodLength
     def self.included(base)
       base.class_eval do
         extend ClassMethods
-        include AttributeDefiner
+
+        include Utils::ClassAttribute
+        class_attribute :schema
+        class_attribute :_messages
+        class_attribute :_messages_path
+        class_attribute :_namespace
+        class_attribute :_predicates_module
+
+        class_attribute :_predicates
+        self._predicates = Set.new
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
     # 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.
+      # Define validation rules from the given block.
       #
-      # @param base [Class] the target action
+      # @param blk [Proc] validation rules
       #
-      # @since 0.2.2
-      # @api private
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'hanami/validations'
+      #
+      #   class Signup
+      #     include Hanami::Validations
+      #
+      #     validations do
+      #       required(:name).filled
+      #     end
+      #   end
       #
-      # @see http://www.ruby-doc.org/core/Class.html#method-i-inherited
-      def inherited(base)
-        transfer_validations_to_base(base)
-        super
+      # rubocop:disable Metrics/AbcSize
+      def validations(&blk)
+        schema_predicates = _predicates_module || __predicates
+
+        base   = _build(predicates: schema_predicates, &_base_rules)
+        schema = _build(predicates: schema_predicates, rules: base.rules, &blk)
+        schema.configure(&_schema_config)
+        schema.configure(&_schema_predicates)
+        schema.extend(__messages) unless _predicates.empty?
+
+        self.schema = schema.new
       end
+      # rubocop:enable Metrics/AbcSize
 
-      # 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.
+      # Define an inline predicate
       #
-      # @param base [Class] the target action
+      # @param name [Symbol] inline predicate name
+      # @param message [String] optional error message
+      # @param blk [Proc] predicate implementation
       #
-      # @since 0.1.0
-      # @api private
+      # @return nil
       #
-      # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+      # @since 0.6.0
       #
-      # @example
+      # @example Without Custom Message
       #   require 'hanami/validations'
       #
-      #   module NameValidations
+      #   class Signup
       #     include Hanami::Validations
       #
-      #     attribute :name, presence: true
+      #     predicate :foo? do |actual|
+      #       actual == 'foo'
+      #     end
+      #
+      #     validations do
+      #       required(:name).filled(:foo?)
+      #     end
       #   end
       #
+      #   result = Signup.new(name: nil).call
+      #   result.messages # => { :name => ['is invalid'] }
+      #
+      # @example With Custom Message
+      #   require 'hanami/validations'
+      #
       #   class Signup
-      #     include NameValidations
-      #   end
+      #     include Hanami::Validations
       #
-      #   signup = Signup.new(name: '')
-      #   signup.valid? # => false
+      #     predicate :foo?, message: 'must be foo' do |actual|
+      #       actual == 'foo'
+      #     end
       #
-      #   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)
+      #     validations do
+      #       required(:name).filled(:foo?)
+      #     end
+      #   end
+      #
+      #   result = Signup.new(name: nil).call
+      #   result.messages # => { :name => ['must be foo'] }
+      def predicate(name, message: 'is invalid', &blk)
+        _predicates << InlinePredicate.new(name, message, &blk)
       end
 
-      # Define a validation for an existing attribute
+      # Assign a set of shared predicates wrapped in a module
+      #
+      # @param mod [Module] a module with shared predicates
       #
-      # @param name [#to_sym] the name of the attribute
-      # @param options [Hash] set of validations
+      # @since 0.6.0
       #
-      # @see Hanami::Validations::ClassMethods#validations
+      # @see Hanami::Validations::Predicates
       #
-      # @example Presence
+      # @example
       #   require 'hanami/validations'
       #
-      #   class Signup
-      #     include Hanami::Validations
+      #   module MySharedPredicates
+      #     include Hanami::Validations::Predicates
       #
-      #     def initialize(attributes = {})
-      #       @name = attributes.fetch(:name)
+      #     predicate :foo? fo |actual|
+      #       actual == 'foo'
       #     end
+      #   end
       #
-      #     attr_accessor :name
+      #   class MyValidator
+      #     include Hanami::Validations
+      #     predicates MySharedPredicates
       #
-      #     validates :name, presence: true
+      #     validations do
+      #       required(:name).filled(:foo?)
+      #     end
       #   end
+      def predicates(mod)
+        self._predicates_module = mod
+      end
+
+      # Define the type of engine for error messages.
+      #
+      # Accepted values are `:yaml` (default), `:i18n`.
+      #
+      # @param type [Symbol] the preferred engine
+      #
+      # @since 0.6.0
       #
-      #   signup = Signup.new(name: 'Luca')
-      #   signup.valid? # => true
+      # @example
+      #   require 'hanami/validations'
+      #
+      #   class Signup
+      #     include Hanami::Validations
       #
-      #   signup = Signup.new(name: nil)
-      #   signup.valid? # => false
-      def validates(name, options)
-        validations.add(name, options)
+      #     messages :i18n
+      #   end
+      def messages(type)
+        self._messages = type
       end
 
-      # Set of user defined validations
+      # Define the path where to find translation file
       #
-      # @return [Hash]
+      # @param path [String] path to translation file
       #
-      # @since 0.2.2
-      # @api private
-      def validations
-        @validations ||= ValidationSet.new
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'hanami/validations'
+      #
+      #   class Signup
+      #     include Hanami::Validations
+      #
+      #     messages :i18n
+      #   end
+      def messages_path(path)
+        self._messages_path = path
       end
 
-      # Set of user defined attributes
+      # Namespace for error messages.
       #
-      # @return [Array<String>]
+      # @param name [String] namespace
       #
-      # @since 0.2.3
-      # @api private
-      def defined_attributes
-        validations.names.map(&:to_s)
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'hanami/validations'
+      #
+      #   module MyApp
+      #     module Validators
+      #       class Signup
+      #         include Hanami::Validations
+      #
+      #         namespace 'signup'
+      #       end
+      #     end
+      #   end
+      #
+      #   # Instead of looking for error messages under the `my_app.validator.signup`
+      #   # namespace, it will look just for `signup`.
+      #   #
+      #   # This helps to simplify YAML files where are stored error messages
+      def namespace(name = nil)
+        if name.nil?
+          Namespace.new(_namespace, self)
+        else
+          self._namespace = name.to_s
+        end
       end
 
       private
 
-      # Transfers attributes to a base class
-      #
-      # @param base [Module] the base class to transfer attributes to
-      #
-      # @since 0.2.2
+      # @since 0.6.0
+      # @api private
+      def _build(options = {}, &blk)
+        options = { build: false }.merge(options)
+        Dry::Validation.__send__(_schema_type, options, &blk)
+      end
+
+      # @since 0.6.0
+      # @api private
+      def _schema_type
+        :Schema
+      end
+
+      # @since 0.6.0
       # @api private
-      def transfer_validations_to_base(base)
-        validations.each do |attribute, options|
-          base.validates attribute, options
+      def _base_rules
+        lambda do
         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
+      # @since 0.6.0
+      # @api private
+      def _schema_config
+        lambda do |config|
+          config.messages      = _messages      unless _messages.nil?
+          config.messages_file = _messages_path unless _messages_path.nil?
+          config.namespace     = namespace
+        end
+      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
+      # @since 0.6.0
+      # @api private
+      def _schema_predicates
+        return if _predicates_module.nil? && _predicates.empty?
+
+        lambda do |config|
+          config.messages      = _predicates_module && _predicates_module.messages || DEFAULT_MESSAGES_ENGINE
+          config.messages_file = _predicates_module && _predicates_module.messages_path
+        end
+      end
+
+      # @since 0.6.0
+      # @api private
+      def __predicates
+        mod = Module.new { include Hanami::Validations::Predicates }
+
+        _predicates.each do |p|
+          mod.module_eval do
+            predicate(p.name, &p.to_proc)
+          end
+        end
+
+        mod
+      end
 
-      errors.empty?
+      # @since 0.6.0
+      # @api private
+      # rubocop:disable Metrics/MethodLength
+      def __messages
+        result = _predicates.each_with_object({}) do |p, ret|
+          ret[p.name] = p.message
+        end
+
+        Module.new do
+          @@__messages = result # rubocop:disable Style/ClassVars
+
+          def self.extended(base)
+            base.instance_eval do
+              def __messages
+                Hash[en: { errors: @@__messages }]
+              end
+            end
+          end
+
+          def messages
+            super.merge(__messages)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
     end
 
-    # Checks if the current data doesn't satisfies the defined validations
+    # Initialize a new instance of a validator
     #
-    # @return [TrueClass,FalseClass] the result of the validations
+    # @param input [#to_h] a set of input data
     #
-    # @since 0.3.2
-    def invalid?
-      !valid?
+    # @since 0.6.0
+    def initialize(input = {})
+      @input = input.to_h
     end
 
     # Validates the object.
     #
-    # @return [Errors]
+    # @return [Dry::Validations::Result]
     #
     # @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)
+      self.class.schema.call(@input)
     end
 
     # Returns a Hash with the defined attributes as symbolized keys, and their
@@ -273,33 +350,7 @@ module Hanami
     #
     # @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
+      validate.output
     end
   end
 end