validation_hints 6.0.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f43f9338ea91967565859b93f7a0f884cf4d3999d83abda9d23ac55673a77ec
-  data.tar.gz: 399657680fb3f0a005aea6034c41a52c1f96b21c051e811b7dbe6f2c0d24fc0c
+  metadata.gz: 417c0455d8dedf1c33c7cf608af48ec92ecb6b1d913f60f58ac0d7b91d0eb58d
+  data.tar.gz: 216254f45fa84b4370828da2830d79689fbd3971da68fa0e4e891873ed40029f
 SHA512:
-  metadata.gz: 0c3e3a58ea45b2620e516216d8d5267fefe2bff0c43c2de1956ab2bb3c15174418ed68f867c9d05bb56fa280107b8095afc9520b03f7dc93e231f445edad52cb
-  data.tar.gz: 602bbff26e2aea34e3117f9223063a8ba461608d8f51da3b9bb357418260dc8abe9e9455772bfbfbed4404e80133cfa2714c67ed3347bb031aed6527d5efc951
+  metadata.gz: 2a961271d6a978a874745411c8251e8fb255c974917da3dbcaad7e469caada854ef7f9437d0de8972d266348a3d054e5952bb81cd42f5ed3515d1c45d1a435e6
+  data.tar.gz: 974c699d5c1acaf13dd0494156cd8d46f5628f6b9ef9d874c873804d33d75d6df745fd62fc5fa8db41210cca236f9a5642df2da571dd55ecb5e245527417326d

data/CHANGELOG.md

@@ -2,7 +2,47 @@
 
 All notable changes to this project are documented here.
 
-## 6.0.0 (unreleased)
+## 6.2.0
+
+I18n lookup chain and documentation (Phase 2).
+
+### Added
+
+- `activemodel.hints` and `activerecord.hints` locale scopes (format + lookup chain).
+- `test/active_model/i18n_test.rb` — app override and `human_attribute_name` coverage.
+- README: requirements, API, I18n lookup order, and `config/locales` override examples.
+
+### Changed
+
+- `generate_message` / `full_message` I18n fallback chain mirrors Rails errors (with `hints` namespace).
+- `full_message` passes `base: @base` to `human_attribute_name` and resolves format via scoped `hints.format` keys.
+
+## 6.1.0
+
+Rails 7 compatibility for `ActiveModel::Hints` and expanded test coverage (Phase 1).
+
+### Added
+
+- `test/active_model/hints_test.rb` — presence, length, numericality, inclusion, virtual attributes, `empty?`, `add`/`added?`.
+- In-memory SQLite ActiveRecord setup in `test/test_helper.rb`.
+- `normalize_message` for mutable hint APIs (`add`, `added?`).
+- `length.within` locale key with `%{minimum}` / `%{maximum}` interpolation.
+- Default hint messages: `invalid`, `blank`, `empty`.
+
+### Changed
+
+- `ActiveModel::Hints` modernized for Rails 7:
+  - plain `Hash` instead of `OrderedHash`
+  - fixed `empty?` / `blank?`
+  - `generate_message` aligned with Rails 7 I18n chain and interpolation
+  - validator keys via `demodulize.underscore.delete_suffix("_validator")`
+  - attribute discovery includes virtual attributes from validators
+  - length min+max combined into a single `within` hint
+  - presence hint suppressed when validator has `allow_blank: true`
+- `locale/en.yml` cleaned up (removed stray keys; format copy → “must match the required format”).
+- Documented behavior: conditional validators (`:if`, `:unless`, `:on`) are not evaluated.
+
+## 6.0.0
 
 Modernize the gem for **Ruby 3.2+** and **Rails 7.0.x**, targeting use with **inline_forms 7.x**.
 
@@ -14,20 +54,19 @@ Modernize the gem for **Ruby 3.2+** and **Rails 7.0.x**, targeting use with **in
 
 ### Added
 
-- `ValidationHints::Railtie` — registers I18n and patches `ActiveModel::Validations` via `ActiveSupport.on_load(:active_model)` (Rails apps no longer need a manual `require`).
+- `ValidationHints::Railtie` — registers I18n and patches `ActiveModel::Validations` via `ActiveSupport.on_load(:active_model)`.
 - `ValidationHints::ValidationsPatch` — extracted module for `has_validations*` and `hints`.
 - `ValidationHints.load_i18n!` — idempotent locale registration.
 - Runtime dependency on `activerecord` 7.0.x.
 - Minitest harness (`test/`) and `rake test` as the default Rake task.
 - `CHANGELOG.md`.
+- `rake release` / gem packaging tasks via `Bundler::GemHelper`.
 
 ### Changed
 
-- `ValidationHints::VERSION` set to `6.0.0`.
-- Gemspec rewritten for current RubyGems / Bundler (Ruby version, dependencies, file list with non-git fallback).
+- Gemspec rewritten for current RubyGems / Bundler.
 - `Gemfile` source updated to `https://rubygems.org`.
-- Entry point (`lib/validation_hints.rb`) refactored: Railtie in Rails, direct `active_model` load outside Rails.
-- I18n locale registration moved behind `ValidationHints.load_i18n!` (was unconditional append at load time).
+- Entry point refactored: Railtie in Rails, direct `active_model` load outside Rails.
 
 ### Removed
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    validation_hints (6.0.0)
+    validation_hints (6.2.0)
       activerecord (>= 7.0, < 7.1)
 
 GEM
@@ -264,7 +264,7 @@ CHECKSUMS
   thor (1.5.0) sha256=e3a9e55fe857e44859ce104a84675ab6e8cd59c650a49106a05f55f136425e73
   timeout (0.6.1) sha256=78f57368a7e7bbadec56971f78a3f5ecbcfb59b7fcbb0a3ed6ddc08a5094accb
   tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
-  validation_hints (6.0.0)
+  validation_hints (6.2.0)
   websocket-driver (0.8.0) sha256=ed0dba4b943c22f17f9a734817e808bc84cdce6a7e22045f5315aa57676d4962
   websocket-extensions (0.1.5) sha256=1c6ba63092cda343eb53fc657110c71c754c56484aad42578495227d717a8241
   zeitwerk (2.7.5) sha256=d8da92128c09ea6ec62c949011b00ed4a20242b255293dd66bf41545398f73dd

data/README.md

@@ -1,34 +1,93 @@
+# validation_hints
 
-## Validation Hints
+Proactive validation hints derived from model validators — complementary to Rails `errors` (which react after `valid?` fails).
 
-Delivers hints derived from the validation on a model.
+**Requirements:** Ruby >= 3.2, Rails / Active Record 7.0.x (`>= 7.0`, `< 7.1`). Used by [inline_forms](https://github.com/acesuares/inline_forms).
 
-### Install
+## Install
 
 ```ruby
-gem 'validation_hints'
+# Gemfile
+gem "validation_hints", "~> 6.2"
 ```
 
-### Example
+Rails apps load the gem via `ValidationHints::Railtie` (no manual `require`).
+
+## Example
 
 ```ruby
-class Person < ActiveRecord::Base
-  validates :name, :presence => true
-  validates :password, :length => { :within => 1...5 }
+class Person < ApplicationRecord
+  validates :name, presence: true
+  validates :password, length: { within: 1...5 }
 end
+
+Person.new.hints[:name]      # => ["can't be blank"]
+Person.new.hints[:password]  # => ["must be between 1 and 4 characters"]
+
+Person.new.hints.full_messages_for(:name)  # => ["Name can't be blank"]
+Person.new.has_validations_for?(:name)     # => true
 ```
 
-```ruby
-Person.new.hints[:name] => ["can't be blank"]
-Person.new.hints[:password] => ["must not be shorter than 1 characters", "must not be longer than 4 characters"]
-Person.new.hints.messages => {:id=>[], :password=>["must not be shorter than 1 characters", "must not be longer than 4 characters"], :name => ["can't be blank"] }
+## API (stable)
+
+| Method | Description |
+|--------|-------------|
+| `model.hints` | `ActiveModel::Hints` for the instance |
+| `hints[:attribute]` | Short hint strings for an attribute |
+| `hints.full_messages_for(attr)` | Attribute label + hint (used by inline_forms tooltips) |
+| `has_validations?` / `has_validations_for?(attr)` | Whether to show hint UI |
+
+## I18n
+
+Default copy lives in the gem at `lib/validation_hints/locale/en.yml` under the `hints` namespace.
+
+Lookup order mirrors Rails **errors**, but uses **`hints`** instead of `errors`:
+
+1. `activerecord.hints.models.<model>.attributes.<attr>.<type>`
+2. `activerecord.hints.models.<model>.<type>`
+3. `activerecord.hints.messages.<type>`
+4. `activemodel.hints.messages.<type>`
+5. `hints.attributes.<attr>.<type>`
+6. `hints.messages.<type>`
+
+Full messages (`full_messages_for`) use `hints.format` with the same scoping (`activerecord.hints.format`, `activemodel.hints.format`, `hints.format`).
+
+### App overrides
+
+Add a locale file, e.g. `config/locales/validation_hints.en.yml`:
+
+```yaml
+en:
+  activerecord:
+    hints:
+      format: "%{attribute}: %{message}"
+      messages:
+        presence: "is required"
+      models:
+        apartment:
+          attributes:
+            name:
+              presence: "enter a name for this apartment"
 ```
 
-### Disclaimer
+Per-attribute overrides without a model block:
+
+```yaml
+en:
+  hints:
+    attributes:
+      name:
+        presence: "is required"
+```
 
-It's work in progress.
-validation_hints was for the most part derived from activerecord-3.2.3/lib/active_record/errors.rb
+Attribute labels in full messages come from the normal Rails path (`activerecord.attributes.<model>.<attr>`), same as errors.
 
+## Tests
 
+```bash
+bundle exec rake test
+```
 
+## History
 
+See [CHANGELOG.md](CHANGELOG.md).

data/lib/active_model/hints.rb

@@ -1,67 +1,37 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # == Active Model Hints
+  # Introspects declared validators and builds proactive hint messages (before +valid?+ fails).
   #
-  # p = Person.new
-  # p.hints
-  # p.hints[:name]
-  # 
-  # more documentation needed
-
+  # Conditional options (+:if+, +:unless+, +:on+) are not evaluated; hints reflect static rules.
+  # For +format+ validators, prefer a custom +message:+ or per-attribute I18n keys.
   class Hints
     include Enumerable
 
-    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
-    MESSAGES_FOR_VALIDATORS = %w(confirmation acceptance presence uniqueness format associated numericality)
-    VALIDATORS_WITHOUT_MAIN_KEYS = %w(exclusion format inclusion length numericality)
-    # and these? validates_with validates_each
-    MESSAGES_FOR_OPTIONS = %w(within in is minimum maximum greater_than greater_than_or_equal_to equal_to less_than less_than_or_equal_to odd even only_integer)
-    OPTIONS_THAT_WE_DONT_USE_YET = {
-      :acceptance => :acceptance
+    MESSAGES_FOR_OPTIONS = %w[
+      within in is minimum maximum greater_than greater_than_or_equal_to
+      equal_to less_than less_than_or_equal_to odd even only_integer
+    ].freeze
 
-    }
-    VALIDATORS_THAT_WE_DONT_KNOW_WHAT_TO_DO_WITH = %w(validates_associated)
+    VALIDATORS_WITHOUT_MAIN_KEYS = %w[exclusion format inclusion length numericality].freeze
 
-    # Should virtual element for
-    #  validates :email, :confirmation => true
-    #  validates :email_confirmation, :presence => true
-    # also have a hint?
+    RANGE_OPTIONS = %w[within in].freeze
 
     attr_reader :messages
 
-    # Pass in the instance of the object that is using the errors object.
-    #
-    #   class Person
-    #     def initialize
-    #       @errors = ActiveModel::Errors.new(self)
-    #     end
-    #   end
     def initialize(base)
-      @base     = base
-      @messages = ActiveSupport::OrderedHash.new
-      @base.attributes.keys.each do |a|
-        @messages[a.to_sym] = hints_for(a.to_sym)
+      @base = base
+      @messages = {}
+      attribute_names_for_hints.each do |attribute|
+        @messages[attribute] = hints_for(attribute)
       end
     end
 
     def hints_for(attribute)
-      result = Array.new
-      @base.class.validators_on(attribute).map do |v|
-        validator = v.class.to_s.split('::').last.underscore.gsub('_validator','')
-        if v.options[:message].is_a?(Symbol)
-          message_key =  [validator, v.options[:message]].join('.') # if a message was supplied as a symbol, we use it instead
-          result << generate_message(attribute, message_key, v.options)
-        else
-          message_key =  validator
-          message_key =  [validator, ".must_be_a_number"].join('.') if validator == 'numericality' # create an option for numericality; the way YAML works a key (numericality) with subkeys (greater_than, etc etc) can not have a string itself. So we create a subkey for numericality
-          result << generate_message(attribute, message_key, v.options) unless VALIDATORS_WITHOUT_MAIN_KEYS.include?(validator)
-          v.options.each do |o|
-            if MESSAGES_FOR_OPTIONS.include?(o.first.to_s)
-              count = o.last
-              count = (o.last.to_sentence if %w(inclusion exclusion).include?(validator)) rescue o.last
-              result << generate_message(attribute, [ validator, o.first.to_s ].join('.'), { :count => count } )
-            end
-          end
-        end
+      attribute = attribute.to_sym
+      result = []
+      @base.class.validators_on(attribute).each do |validator|
+        result.concat(messages_for_validator(attribute, validator))
       end
       result
     end
@@ -71,143 +41,74 @@ module ActiveModel
     end
 
     def initialize_dup(other)
-      @messages = other.messages.dup
+      @messages = other.messages.transform_values(&:dup)
     end
 
-    # Backport dup from 1.9 so that #initialize_dup gets called
-    unless Object.respond_to?(:initialize_dup)
-      def dup # :nodoc:
-        copy = super
-        copy.initialize_dup(self)
-        copy
-      end
-    end
-
-    # Clear the messages
     def clear
       messages.clear
     end
 
-    # Do the hint messages include an hint with key +hint+?
-    def include?(hint)
-      (v = messages[hint]) && v.any?
+    def include?(attribute)
+      (value = messages[attribute.to_sym]) && value.any?
     end
-    alias :has_key? :include?
+    alias has_key? include?
 
-    # Get messages for +key+
     def get(key)
       messages[key]
     end
 
-    # Set messages for +key+ to +value+
     def set(key, value)
       messages[key] = value
     end
 
-    # Delete messages for +key+
     def delete(key)
       messages.delete(key)
     end
 
-    # When passed a symbol or a name of a method, returns an array of hints
-    # for the method.
-    #
-    #   p.hints[:name]   # => ["can not be nil"]
-    #   p.hints['name']  # => ["can not be nil"]
     def [](attribute)
       get(attribute.to_sym) || set(attribute.to_sym, [])
     end
 
-    # Adds to the supplied attribute the supplied hint message.
-    #
-    #   p.hints[:name] = "must be set"
-    #   p.hints[:name] # => ['must be set']
     def []=(attribute, hint)
       self[attribute] << hint
     end
 
-    # Iterates through each hint key, value pair in the hint messages hash.
-    # Yields the attribute and the hint for that attribute. If the attribute
-    # has more than one hint message, yields once for each hint message.
-    #
-    #   p.hints.add(:name, "can't be blank")
-    #   p.hints.each do |attribute, hints_array|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    #
-    #   p.hints.add(:name, "must be specified")
-    #   p.hints.each do |attribute, hints_array|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
     def each
       messages.each_key do |attribute|
         self[attribute].each { |hint| yield attribute, hint }
       end
     end
 
-    # Returns the number of error messages.
-    #
-    #   p.hints.add(:name, "can't be blank")
-    #   p.hints.size # => 1
-    #   p.hints.add(:name, "must be specified")
-    #   p.hints.size # => 2
     def size
       values.flatten.size
     end
 
-    # Returns all message values
     def values
       messages.values
     end
 
-    # Returns all message keys
     def keys
       messages.keys
     end
 
-    # Returns an array of hint messages, with the attribute name included
-    #
-    #   p.hints.add(:name, "can't be blank")
-    #   p.hints.add(:name, "must be specified")
-    #   p.hints.to_a # => ["name can't be blank", "name must be specified"]
     def to_a
       full_messages
     end
 
-    # Returns the number of hint messages.
-    #   p.hints.add(:name, "can't be blank")
-    #   p.hints.count # => 1
-    #   p.hints.add(:name, "must be specified")
-    #   p.hints.count # => 2
     def count
       to_a.size
     end
 
-    # Returns true if no hints are found, false otherwise.
-    # If the hint message is a string it can be empty.
     def empty?
-      all? { |k, v| v && v.empty? && !v.is_a?(String) }
+      messages.values.all?(&:empty?)
     end
     alias_method :blank?, :empty?
 
-    # Returns an xml formatted representation of the hints hash.
-    #
-    #   p.hints.add(:name, "can't be blank")
-    #   p.hints.add(:name, "must be specified")
-    #   p.hints.to_xml
-    #   # =>
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <hints>
-    #   #    <hint>name can't be blank</hint>
-    #   #    <hint>name must be specified</hint>
-    #   #  </hints>
-    def to_xml(options={})
-      to_a.to_xml options.reverse_merge(:root => "hints", :skip_types => true)
-    end
-
-    # Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.
-    def as_json(options=nil)
+    def to_xml(options = {})
+      to_a.to_xml(options.reverse_merge(root: "hints", skip_types: true))
+    end
+
+    def as_json(_options = nil)
       to_hash
     end
 
@@ -215,13 +116,7 @@ module ActiveModel
       messages.dup
     end
 
-    # Adds +message+ to the hint messages on +attribute+. More than one hint can be added to the same
-    # +attribute+.
-    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
-    #
-    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_hint+).
-    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an hint.
-    def add(attribute, message = nil, options = {})
+    def add(attribute, message = :invalid, options = {})
       message = normalize_message(attribute, message, options)
       if options[:strict]
         raise ActiveModel::StrictValidationFailed, full_message(attribute, message)
@@ -230,95 +125,213 @@ module ActiveModel
       self[attribute] << message
     end
 
-    # Will add an hint message to each of the attributes in +attributes+ that is empty.
     def add_on_empty(attributes, options = {})
-      [attributes].flatten.each do |attribute|
+      Array(attributes).each do |attribute|
         value = @base.send(:read_attribute_for_validation, attribute)
         is_empty = value.respond_to?(:empty?) ? value.empty? : false
         add(attribute, :empty, options) if value.nil? || is_empty
       end
     end
 
-    # Will add an hint message to each of the attributes in +attributes+ that is blank (using Object#blank?).
     def add_on_blank(attributes, options = {})
-      [attributes].flatten.each do |attribute|
+      Array(attributes).each do |attribute|
         value = @base.send(:read_attribute_for_validation, attribute)
         add(attribute, :blank, options) if value.blank?
       end
     end
 
-    # Returns true if an hint on the attribute with the given message is present, false otherwise.
-    # +message+ is treated the same as for +add+.
-    #   p.hints.add :name, :blank
-    #   p.hints.added? :name, :blank # => true
-    def added?(attribute, message = nil, options = {})
+    def added?(attribute, message = :invalid, options = {})
       message = normalize_message(attribute, message, options)
-      self[attribute].include? message
-    end
-
-    # Returns all the full hint messages in an array.
-    #
-    #   class Company
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.hints.full_messages # =>
-    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+      self[attribute].include?(message)
+    end
+
     def full_messages
       map { |attribute, message| full_message(attribute, message) }
     end
 
-    # Returns a full message for a given attribute.
-    #
-    #   company.hints.full_message(:name, "is invalid")  # =>
-    #     "Name is invalid"
     def full_message(attribute, message)
       return message if attribute == :base
-      attr_name = attribute.to_s.gsub('.', '_').humanize
-      attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
-      I18n.t(:"hints.format", 
-          :default   => "%{attribute} %{message}",
-          :attribute => attr_name,
-          :message   => message
-          )
+
+      attr_name = attribute.to_s.tr(".", "_").humanize
+      attr_name = @base.class.human_attribute_name(attribute, default: attr_name, base: @base)
+
+      format_defaults = i18n_format_defaults
+      format_key = format_defaults.shift
+
+      I18n.t(
+        format_key,
+        default: format_defaults,
+        attribute: attr_name,
+        message: message
+      )
     end
 
     def generate_message(attribute, type, options = {})
-      #options.delete(:message) if options[:message].is_a?(Symbol)
-      if @base.class.respond_to?(:i18n_scope)
-        defaults = @base.class.lookup_ancestors.map do |klass|
-          [ :"#{@base.class.i18n_scope}.hints.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-            :"#{@base.class.i18n_scope}.hints.models.#{klass.model_name.i18n_key}.#{type}" ]
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+      value = (attribute != :base ? @base.read_attribute_for_validation(attribute) : nil)
+
+      interpolation = {
+        model: @base.model_name.human,
+        attribute: @base.class.human_attribute_name(attribute, base: @base),
+        value: value,
+        object: @base,
+        count: options[:count],
+        minimum: options[:minimum],
+        maximum: options[:maximum]
+      }.compact
+
+      defaults = i18n_defaults(attribute, type, options)
+      key = defaults.shift
+
+      I18n.translate(key, **interpolation.merge(default: defaults))
+    end
+
+    private
+
+    def attribute_names_for_hints
+      from_record =
+        if @base.respond_to?(:attributes)
+          @base.attributes.keys
+        else
+          []
+        end
+
+      from_validators = @base.class.validators.flat_map(&:attributes).map(&:to_s)
+      (from_record + from_validators).map(&:to_sym).uniq
+    end
+
+    def messages_for_validator(attribute, validator)
+      key = validator_key(validator)
+      options = validator.options
+      result = []
+
+      if options[:allow_blank] && key == "presence"
+        return result
+      end
+
+      if options[:message].is_a?(Symbol)
+        message_key = "#{key}.#{options[:message]}"
+        result << generate_message(attribute, message_key, options)
+        return result
+      end
+
+      message_key = key
+      message_key = "numericality.must_be_a_number" if key == "numericality"
+      unless VALIDATORS_WITHOUT_MAIN_KEYS.include?(key)
+        result << generate_message(attribute, message_key, options)
+      end
+
+      if key == "length" && options[:minimum] && options[:maximum]
+        result << generate_message(
+          attribute,
+          "length.within",
+          minimum: options[:minimum],
+          maximum: options[:maximum]
+        )
+        return result
+      end
+
+      options.each do |option, value|
+        next unless MESSAGES_FOR_OPTIONS.include?(option.to_s)
+
+        if RANGE_OPTIONS.include?(option.to_s) && value.is_a?(Range)
+          result.concat(range_hint_messages(attribute, key, value))
+        else
+          count = inclusion_exclusion_count(key, value)
+          result << generate_message(
+            attribute,
+            "#{key}.#{option}",
+            options.merge(count: count)
+          )
         end
+      end
+
+      result
+    end
+
+    def range_hint_messages(attribute, validator_key, range)
+      minimum = range.min
+      maximum = range.max
+      maximum -= 1 if range.exclude_end?
+
+      if validator_key == "length"
+        [
+          generate_message(attribute, "#{validator_key}.within", minimum: minimum, maximum: maximum),
+        ]
       else
-        defaults = []
+        [
+          generate_message(attribute, "#{validator_key}.minimum", count: minimum),
+          generate_message(attribute, "#{validator_key}.maximum", count: maximum)
+        ]
+      end
+    end
+
+    def inclusion_exclusion_count(validator_key, value)
+      return value.to_sentence if %w[inclusion exclusion].include?(validator_key) && value.respond_to?(:to_sentence)
+
+      value
+    end
+
+    def validator_key(validator)
+      validator.class.name.demodulize.underscore.delete_suffix("_validator")
+    end
+
+    def i18n_defaults(attribute, type, options)
+      attribute_name = attribute.to_s.remove(/\[\d+\]/)
+
+      defaults = model_hint_defaults(attribute_name, type)
+      defaults << options[:message] if options[:message]
+
+      if @base.class.respond_to?(:i18n_scope)
+        scope = @base.class.i18n_scope
+        defaults << :"#{scope}.hints.messages.#{type}"
       end
 
-      defaults << options[:message] # defaults << options.delete(:message)
-      defaults << :"#{@base.class.i18n_scope}.hints.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
-      defaults << :"hints.attributes.#{attribute}.#{type}"
+      defaults << :"activemodel.hints.messages.#{type}"
+      defaults << :"hints.attributes.#{attribute_name}.#{type}"
       defaults << :"hints.messages.#{type}"
+      defaults.compact.flatten
+    end
 
-      defaults.compact!
-      defaults.flatten!
+    def model_hint_defaults(attribute_name, type)
+      return [] unless @base.class.respond_to?(:i18n_scope)
 
-      key = defaults.shift
+      scope = @base.class.i18n_scope
+      @base.class.lookup_ancestors.flat_map do |klass|
+        [
+          :"#{scope}.hints.models.#{klass.model_name.i18n_key}.attributes.#{attribute_name}.#{type}",
+          :"#{scope}.hints.models.#{klass.model_name.i18n_key}.#{type}"
+        ]
+      end
+    end
+
+    def i18n_format_defaults
+      defaults = []
 
-      # options = {
-      #   :default => defaults,
-      #   :model => @base.class.model_name.human,
-      #   :attribute => @base.class.human_attribute_name(attribute),
-      # }.merge(options)
-      I18n.translate( key,  
-                      default:   defaults,
-                      model:     @base.class.model_name.human,
-                      attribute: @base.class.human_attribute_name(attribute),
-                      count:     options[:count],
-                      )
+      if @base.class.respond_to?(:i18n_scope)
+        scope = @base.class.i18n_scope
+        @base.class.lookup_ancestors.each do |klass|
+          defaults << :"#{scope}.hints.models.#{klass.model_name.i18n_key}.format"
+        end
+        defaults << :"#{scope}.hints.format"
+      end
+
+      defaults << :"activemodel.hints.format"
+      defaults << :"hints.format"
+      defaults << "%{attribute} %{message}"
     end
 
+    def normalize_message(attribute, message, options = {})
+      case message
+      when Symbol
+        generate_message(attribute, message, options)
+      when Proc
+        message.call
+      when nil
+        generate_message(attribute, :invalid, options)
+      else
+        message
+      end
+    end
   end
-
 end

data/lib/validation_hints/locale/en.yml

@@ -1,21 +1,25 @@
-## YAML Template.
 ---
 en:
+  activemodel:
+    hints:
+      format: "%{attribute} %{message}"
+
   activerecord:
-                less_than_or_equal_to: "must be less than or equal to %{count}"
+    hints:
+      format: "%{attribute} %{message}"
+
   hints:
-    # The default format to use in full error messages.
     format: "%{attribute} %{message}"
 
-    # The values :model, :attribute and :value are always available for interpolation
-    # The value :count is available when applicable. Can be used for pluralization.
     messages:
-      is_a_curacao_id_number: 'hello world!'
+      invalid: "is invalid"
+      blank: "can't be blank"
+      empty: "can't be empty"
       inclusion:
         in: "must be one of %{count}"
       exclusion:
         in: "must not be one of %{count}"
-      format: "what's this"
+      format: "must match the required format"
       associated: "is invalid"
       uniqueness: "must be unique"
       confirmation: "doesn't match confirmation"
@@ -25,7 +29,7 @@ en:
         maximum: "must not be longer than %{count} characters"
         minimum: "must not be shorter than %{count} characters"
         is: "must be exactly %{count} characters"
-        radiolaria: "must be between %{minimum} and %{maximum} characters"
+        within: "must be between %{minimum} and %{maximum} characters"
       numericality:
         must_be_a_number: "must be a number"
         only_integer: "must be an integer"
@@ -36,4 +40,3 @@ en:
         less_than_or_equal_to: "must be less than or equal to %{count}"
         odd: "must be odd"
         even: "must be even"
-

data/lib/validation_hints/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module ValidationHints
-  VERSION = "6.0.0"
+  VERSION = "6.2.0"
 end

data/test/active_model/hints_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveModelHintsTest < Minitest::Test
+  def setup
+    @person = Person.new
+    @profile = Profile.new
+  end
+
+  def test_presence_hint
+    assert_includes @person.hints[:name], "can't be blank"
+  end
+
+  def test_full_messages_for_includes_human_attribute_name
+    messages = @person.hints.full_messages_for(:name)
+    assert_equal ["Name can't be blank"], messages
+  end
+
+  def test_has_validations_for
+    assert @person.has_validations_for?(:name)
+    refute @person.has_validations_for?(:missing)
+  end
+
+  def test_has_validations_on_class_and_instance
+    assert Person.has_validations?
+    assert @person.has_validations?
+  end
+
+  def test_length_within_hint
+    hints = @person.hints[:password]
+    assert_includes hints, "must be between 1 and 4 characters"
+  end
+
+  def test_numericality_option_hints
+    hints = @person.hints[:age]
+    assert_includes hints, "must be an integer"
+    assert_includes hints, "must be greater than 19"
+  end
+
+  def test_inclusion_hint_uses_list
+    hints = @person.hints[:status]
+    assert_equal 1, hints.size
+    assert_match(/must be one of/, hints.first)
+    assert_match(/active/, hints.first)
+    assert_match(/inactive/, hints.first)
+  end
+
+  def test_virtual_attribute_with_validators_is_included
+    assert_includes @profile.hints.keys, :nickname
+    assert_includes @profile.hints[:nickname], "can't be blank"
+  end
+
+  def test_empty_returns_true_when_no_hint_messages
+    person = Class.new do
+      include ActiveModel::Model
+      include ActiveModel::Validations
+
+      def self.name
+        "EmptyModel"
+      end
+    end.new
+
+    assert person.hints.empty?
+  end
+
+  def test_add_and_added_with_symbol_message
+    person = Person.new
+    person.hints.add(:name, :blank)
+    assert person.hints.added?(:name, :blank)
+  end
+
+  def test_validator_keys_for_rails_7_validators
+    validators = Person.validators_on(:name).map { |v| v.class.name.demodulize }
+    assert_includes validators, "PresenceValidator"
+  end
+end

data/test/active_model/i18n_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveModelHintsI18nTest < Minitest::Test
+  def setup
+    @person = Person.new
+    @backend = I18n.backend
+    @kv = I18n::Backend::KeyValue.new({})
+    I18n.backend = I18n::Backend::Chain.new(@kv, @backend)
+  end
+
+  def teardown
+    I18n.backend = @backend
+  end
+
+  def test_activerecord_hints_messages_override
+    @kv.store_translations(:en, activerecord: { hints: { messages: { presence: "is required" } } })
+
+    assert_includes @person.hints[:name], "is required"
+  end
+
+  def test_activerecord_hints_model_attribute_override
+    @kv.store_translations(
+      :en,
+      activerecord: {
+        hints: {
+          models: {
+            person: {
+              attributes: {
+                name: { presence: "needs a name" }
+              }
+            }
+          }
+        }
+      }
+    )
+
+    assert_equal ["needs a name"], @person.hints[:name]
+  end
+
+  def test_hints_attributes_override
+    @kv.store_translations(:en, hints: { attributes: { name: { presence: "name hint" } } })
+
+    assert_equal ["name hint"], @person.hints[:name]
+  end
+
+  def test_top_level_hints_messages_override
+    @kv.store_translations(:en, hints: { messages: { presence: "fill this in" } })
+
+    assert_includes @person.hints[:name], "fill this in"
+  end
+
+  def test_full_message_uses_activerecord_human_attribute_name
+    @kv.store_translations(:en, activerecord: { attributes: { person: { name: "Your name" } } })
+
+    assert_equal ["Your name can't be blank"], @person.hints.full_messages_for(:name)
+  end
+
+  def test_full_message_format_override
+    @kv.store_translations(:en, activerecord: { hints: { format: "%{attribute}: %{message}" } })
+
+    assert_equal ["Name: can't be blank"], @person.hints.full_messages_for(:name)
+  end
+end

data/test/test_helper.rb

@@ -2,5 +2,33 @@
 
 require "bundler/setup"
 require "minitest/autorun"
+require "active_record"
+require "active_model"
 
 require "validation_hints"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+ActiveRecord::Schema.define do
+  create_table :people, force: true do |t|
+    t.string :name
+    t.string :password
+    t.integer :age
+    t.string :status
+  end
+end
+
+class Person < ActiveRecord::Base
+  validates :name, presence: true
+  validates :password, length: { within: 1...5 }
+  validates :age, numericality: { only_integer: true, greater_than: 19 }
+  validates :status, inclusion: { in: %w[active inactive] }
+end
+
+class Profile < ActiveRecord::Base
+  self.table_name = "people"
+
+  attr_accessor :nickname
+
+  validates :nickname, presence: true
+end

data/test/validation_hints_test.rb

@@ -4,11 +4,10 @@ require "test_helper"
 
 class ValidationHintsTest < Minitest::Test
   def test_version
-    assert_equal "6.0.0", ValidationHints::VERSION
+    assert_equal "6.2.0", ValidationHints::VERSION
   end
 
   def test_locale_path_exists
-    assert File.file?(ValidationHints::LOCALE_PATH),
-           "expected locale at #{ValidationHints::LOCALE_PATH}"
+    assert File.file?(ValidationHints::LOCALE_PATH)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validation_hints
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.2.0
 platform: ruby
 authors:
 - Ace Suares
@@ -113,6 +113,8 @@ files:
 - lib/validation_hints/railtie.rb
 - lib/validation_hints/validations_patch.rb
 - lib/validation_hints/version.rb
+- test/active_model/hints_test.rb
+- test/active_model/i18n_test.rb
 - test/test_helper.rb
 - test/validation_hints_test.rb
 - validation_hints.gemspec