rails_validates_nested_uniqueness 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 69a42a6cd773ea23d09f09a9168245ab05056af092cbeed9de15c765b67b7dd0
+  data.tar.gz: 81ff8b04934c18ae5f4a6c74ae8a90e56bedc5fc281d46880ee329d3a0a91949
+SHA512:
+  metadata.gz: 6187525c8ca0575c4535d53dcd458f95f40779b6f9159199a86dc952b29a7a0c7a8e831efae3b6b18745eafb7c95faa3d407d50869c80a0555ffc2aefa795539
+  data.tar.gz: d5e11e33a59a39725ebb2fe3506d8a044e37c61a9be979d9c7e24921f239739b02b2d83278d300e743b628d22e622480480dae10d9218d916eeccaa4cb280acd

data/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.3.0] - 2025-11-13
+
+### Added
+- **New `:comparison` option** for custom value normalization logic
+- Enhanced input validation with better error messages
+- Required `:attribute` parameter validation
+- Comprehensive edge case handling
+- Extensive test coverage for edge cases
+
+### Changed
+- **Gem name changed to `rails_validates_nested_uniqueness`** for RubyGems publication
+- Refactored validator logic into smaller, focused methods
+- Improved code organization and maintainability
+- Enhanced documentation with more examples
+- Better nil and empty value handling
+- More robust error handling throughout
+
+### Fixed
+- Safer method calls with proper existence checks
+- Better handling of non-string values with case sensitivity
+
+## [1.2.0] - 2024-11-13
+### Added
+- Updated minimal supported versions (Ruby >= 3.2.0, ActiveModel >= 7.2.0)
+- Support for Rails 8.0 and 8.1
+- Enhanced Ruby 3.4 support
+
+### Changed
+- Updated CI workflow to test with latest Rails versions
+
+## [1.1.1] - 2024-11-13
+### Fixed
+- Added missing `require 'logger'` statement
+
+## [1.1.0] - 2024-12-18
+### Added
+- Ruby 3.4 support
+- Comprehensive test matrix for different Rails versions
+
+## [1.0.0] - 2024-03-15
+### Added
+- Initial stable release
+- Core nested uniqueness validation functionality
+- Support for `:attribute`, `:scope`, `:case_sensitive`, `:message`, `:error_key` options
+- Support for Rails 6.1+ and Ruby 2.7+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2025 Anton Maminov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+# Validates Nested Uniqueness
+
+[![Ruby](https://github.com/mamantoha/validates_nested_uniqueness/actions/workflows/ruby.yml/badge.svg)](https://github.com/mamantoha/validates_nested_uniqueness/actions/workflows/ruby.yml)
+[![GitHub release](https://img.shields.io/github/release/mamantoha/validates_nested_uniqueness.svg)](https://github.com/mamantoha/validates_nested_uniqueness/releases)
+[![License](https://img.shields.io/github/license/mamantoha/validates_nested_uniqueness.svg)](https://github.com/mamantoha/validates_nested_uniqueness/blob/main/LICENSE)
+
+Validates whether associations are uniqueness when using `accepts_nested_attributes_for`.
+
+Solves the original Rails issue [#20676](https://github.com/rails/rails/issues/20676).
+
+This issue is very annoying and still open after years. And probably this will never be fixed.
+
+This code is based on solutions proposed in the thread. Thanks everyone ❤️.
+
+## Installation
+
+`rails_validates_nested_uniqueness` works with Rails 7.2 onwards.
+
+Add this to your Rails project's `Gemfile`:
+
+```ruby
+gem 'rails_validates_nested_uniqueness'
+```
+
+Or install directly:
+
+```bash
+gem install rails_validates_nested_uniqueness
+```
+
+## Usage
+
+Making sure that only one `city` of the `country` can be named "NY".
+
+```ruby
+class City < ActiveRecord::Base
+  belongs_to :country
+end
+
+class Country < ActiveRecord::Base
+  has_many :cities, dependent: :destroy
+  accepts_nested_attributes_for :cities, allow_destroy: true
+
+  validates :cities, nested_uniqueness: {
+    attribute: :name,
+    scope: [:country_id],
+    case_sensitive: false
+  }
+end
+
+country = Country.new(name: 'US', cities: [City.new(name: 'NY'), City.new(name: 'NY')])
+country.save
+# => false
+
+country.errors
+# => #<ActiveModel::Errors [#<ActiveModel::NestedError attribute=cities.name, type=taken, options={:value=>"NY", :message=>nil}>]>
+
+country.errors.messages
+# => {"cities.name"=>["has already been taken"]}
+```
+
+## Advanced Usage
+
+### Custom Comparison Logic
+
+For more complex validation scenarios, you can provide custom comparison logic:
+
+```ruby
+validates :cities, nested_uniqueness: {
+  attribute: :name,
+  scope: [:country_id],
+  comparison: ->(value) { value.to_s.strip.downcase }
+}
+```
+
+This is useful when you need to normalize values before comparison (e.g., trimming whitespace, handling special characters, etc.).
+
+Configuration options:
+
+- `:attribute` - (Required) Specify the attribute name of associated model to validate.
+- `:scope` - One or more columns by which to limit the scope of the uniqueness constraint.
+- `:case_sensitive` - Looks for an exact match. Ignored by non-text columns (`true` by default).
+- `:message` - A custom error message (default is: "has already been taken").
+- `:error_key` - A custom error key to use (default is: `:taken`).
+- `:comparison` - A callable object (Proc/lambda) for custom value comparison logic.
+
+## Sponsorship
+
+This library is sponsored by [Faria Education Group](https://github.com/eduvo), where it was originally developed and utilized in a production project. It has been extracted and refined for open-source use.
+
+## Contributing
+
+1. Fork it (<https://github.com/mamantoha/validates_nested_uniqueness/fork>)
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create a new Pull Request
+
+## Contributors
+
+- [mamantoha](https://github.com/mamantoha) Anton Maminov - creator, maintainer
+
+## License
+
+Copyright: 2021-2025 Anton Maminov (anton.maminov@gmail.com)
+
+This library is distributed under the MIT license. Please see the LICENSE file.

data/lib/validates_nested_uniqueness.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'active_model'
+
+module ActiveRecord
+  module Validations
+    # ::nodoc
+    class NestedUniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        unless options[:attribute]
+          raise ArgumentError, ':attribute option is required. ' \
+                               'Specify the attribute name to validate: `attribute: :name`'
+        end
+
+        unless Array(options[:scope]).all? { |scope| scope.respond_to?(:to_sym) }
+          raise ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
+                               'Pass a symbol or an array of symbols instead: `scope: :user_id`'
+        end
+
+        if options[:comparison] && !options[:comparison].respond_to?(:call)
+          raise ArgumentError, ':comparison option must be a callable object (Proc or lambda)'
+        end
+
+        super
+
+        @attribute_name = options[:attribute]
+        @case_sensitive = options[:case_sensitive]
+        @scope = options[:scope] || []
+        @error_key = options[:error_key] || :taken
+        @message = options[:message] || nil
+        @comparison = options[:comparison]
+      end
+
+      def validate_each(record, association_name, value)
+        return if value.blank? || !value.respond_to?(:reject)
+
+        track_values = Set.new
+
+        reflection = record.class.reflections[association_name.to_s]
+        return unless reflection
+
+        indexed_attribute = reflection.options[:index_errors] || ActiveRecord::Base.try(:index_nested_attribute_errors)
+
+        value.reject(&:marked_for_destruction?).select(&:changed_for_autosave?).each_with_index do |nested_value, index|
+          next unless nested_value.respond_to?(@attribute_name)
+
+          normalized_attribute = normalize_attribute(association_name, indexed_attribute:, index:)
+
+          track_value = build_track_value(nested_value)
+
+          if track_values.member?(track_value)
+            add_validation_error(record, nested_value, normalized_attribute)
+          else
+            track_values.add(track_value)
+          end
+        end
+      end
+
+      private
+
+      def build_track_value(nested_value)
+        track_value = @scope.each_with_object({}) do |scope_key, memo|
+          memo[scope_key] = nested_value.try(scope_key)
+        end
+
+        attribute_value = nested_value.try(@attribute_name)
+        track_value[@attribute_name] = normalize_value(attribute_value)
+        track_value
+      end
+
+      def normalize_value(value)
+        return value if value.nil?
+        return @comparison.call(value) if @comparison
+        return value if @case_sensitive != false
+        return value unless value.respond_to?(:downcase)
+
+        value.downcase
+      end
+
+      def add_validation_error(record, nested_value, normalized_attribute)
+        inner_error = ActiveModel::Error.new(
+          nested_value,
+          @attribute_name,
+          @error_key,
+          value: nested_value[@attribute_name],
+          message: @message
+        )
+
+        error = ActiveModel::NestedError.new(record, inner_error, attribute: normalized_attribute)
+        record.errors.import(error)
+      end
+
+      def normalize_attribute(association_name, indexed_attribute: false, index: nil)
+        if indexed_attribute
+          "#{association_name}[#{index}].#{@attribute_name}"
+        else
+          "#{association_name}.#{@attribute_name}"
+        end
+      end
+    end
+
+    # :nodoc:
+    module ClassMethods
+      # Validates whether associations are uniqueness when using accepts_nested_attributes_for.
+      #
+      # This validator ensures that nested attributes maintain uniqueness constraints
+      # within the scope of their parent record and any additional specified scopes.
+      #
+      # @example Basic usage
+      #   class Country < ActiveRecord::Base
+      #     has_many :cities, dependent: :destroy
+      #     accepts_nested_attributes_for :cities, allow_destroy: true
+      #
+      #     validates :cities, nested_uniqueness: {
+      #       attribute: :name,
+      #       scope: [:country_id]
+      #     }
+      #   end
+      #
+      # @example With case-insensitive validation
+      #   validates :cities, nested_uniqueness: {
+      #     attribute: :name,
+      #     scope: [:country_id],
+      #     case_sensitive: false
+      #   }
+      #
+      # @example With custom error message
+      #   validates :cities, nested_uniqueness: {
+      #     attribute: :name,
+      #     scope: [:country_id],
+      #     message: "must be unique within this country"
+      #   }
+      #
+      # @example With custom comparison logic
+      #   validates :cities, nested_uniqueness: {
+      #     attribute: :name,
+      #     scope: [:country_id],
+      #     comparison: ->(value) { value.to_s.strip.downcase }
+      #   }
+      #
+      # Configuration options:
+      # * <tt>:attribute</tt> - (Required) Specify the attribute name of associated model to validate.
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of
+      #   the uniqueness constraint. Can be a symbol or array of symbols.
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+      #   non-text columns (+true+ by default).
+      # * <tt>:message</tt> - A custom error message (default is: "has already been taken").
+      # * <tt>:error_key</tt> - A custom error key to use (default is: +:taken+).
+      # * <tt>:comparison</tt> - A callable object (Proc/lambda) for custom value comparison logic.
+      def validates_nested_uniqueness_of(*attr_names)
+        validates_with NestedUniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rails_validates_nested_uniqueness
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Anton Maminov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+description: Validates whether associations are uniqueness when using accepts_nested_attributes_for.
+email: anton.maminov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/validates_nested_uniqueness.rb
+homepage: https://github.com/mamantoha/validates_nested_uniqueness
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Rails library for validating nested uniqueness with accepts_nested_attributes_for.
+test_files: []