domain_extractor 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08132eca3d279a11cf379a83f5288cbf1de6dfe50f62dce4592091c7dfd0195f'
-  data.tar.gz: 22bb6ffd2c8b71271eb0c0a7a26faecfd1faad1b834b26ddbdea921712c8ebed
+  metadata.gz: b770e3c09383122b5cae3baa952127a0f616ee721c2a241f1facd9ddc42a4762
+  data.tar.gz: de6e3561bba3d457da8a4cd9aee88c5f6c76aedaf233c3bda4930cb8402b2871
 SHA512:
-  metadata.gz: a93a94135442996433fb0bee204e78a9d07fb1da7628cad8bdc7c5e4fd8477c7dd28e63a9e3ed4e6b4784027f35fe9c8402c16c5ea4be639dc90f5ae78dd6c7a
-  data.tar.gz: fcc7cd325ceda6d08a598cca43af970ea1867125722958ebe2f652042c02b322888ac7071b5f99fcce076b81444c4ff4b98a41625c00e9d8ccfd3dd143ce0675
+  metadata.gz: 342694e42f321dbea6b197a99909afba2fc4de4d13d01e6e92e66f54fa7d286c1abdfbc1713c56709783d1d05a840523c8f0b202c89528bdeca754eade68cf60
+  data.tar.gz: e23a61526b995375057f34b6a87053c9a26e1f6b6699a521332829921ecb28d1fa6fcf13802fdb9f79637a45200bc1ff98fa47fb8179671fbaed27500e9c16e9

data/CHANGELOG.md

@@ -5,24 +5,65 @@ 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).
 
-## [0.2.5] - 2025-11-09
+## [0.2.6] - 2025-11-09
 
-### Added Rails Integration - Custom ActiveModel Validator
+### Fixed - Rails Validator Registration
 
-Added a comprehensive custom ActiveModel validator for declarative URL and domain validation in Rails applications. The validator integrates seamlessly with Rails 6, 7, and 8.
+**CRITICAL FIX**: Moved `DomainValidator` class to the **top-level namespace** (from `DomainExtractor::DomainValidator`) to ensure Rails can properly autoload and find the validator.
 
-#### Features
+#### The Problem
+
+Version 0.2.5 defined the validator as `DomainExtractor::DomainValidator`, which caused Rails to fail with:
+
+```
+ArgumentError: Unknown validator: 'DomainValidator'
+NameError: uninitialized constant Website::DomainValidator
+```
+
+This occurred because when using `validates :url, domain: { ... }`, Rails searches for `DomainValidator` in:
+
+1. The model's namespace (e.g., `Website::DomainValidator`)
+2. The top-level namespace (`::DomainValidator`)
+3. ActiveModel::Validations namespace
+
+It does **not** search module namespaces like `DomainExtractor::`.
+
+#### The Solution
+
+- Moved `DomainValidator` to top-level namespace where Rails can find it
+- Added `DomainExtractor::DomainValidator` as an alias for backward compatibility
+- All functionality remains identical; only the class location changed
+
+#### Verification
+
+- All 151 tests pass including 35 validator-specific tests
+- RuboCop clean with zero offenses
+- Verified in production Rails 8 application
+- Confirmed working with `validates :url, domain: { validation: :root_or_custom_subdomain }`
+
+## [0.2.5] - 2025-11-09 [YANKED]
+
+**This version was yanked due to validator registration issue. Use 0.2.6 instead.**
+
+### Added Rails Integration - Custom ActiveModel Validator (BROKEN)
+
+Added a comprehensive custom ActiveModel validator for declarative URL and domain validation in Rails applications. However, the validator was incorrectly namespaced and did not work in Rails applications.
+
+#### Features (Broken in 0.2.5)
 
 **Validation Modes:**
+
 - `:standard` - Validates any parseable URL (default mode)
 - `:root_domain` - Only allows root domains without subdomains (e.g., `example.com` ✅, `shop.example.com` ❌)
 - `:root_or_custom_subdomain` - Allows root or custom subdomains but excludes `www` subdomain (e.g., `example.com` ✅, `shop.example.com` ✅, `www.example.com` ❌)
 
 **Protocol Options:**
+
 - `use_protocol` (default: `true`) - Controls whether protocol (http/https) is required in the URL
 - `use_https` (default: `true`) - Controls whether HTTPS is required (only relevant when `use_protocol` is true)
 
 **Usage Examples:**
+
 ```ruby
 # Standard validation - any valid URL
 validates :url, domain: { validation: :standard }
@@ -77,6 +118,7 @@ validates :domain, domain: {
 #### Use Cases
 
 Perfect for Rails applications requiring:
+
 - Multi-tenant custom domain validation
 - Secure URL validation (HTTPS enforcement)
 - Subdomain-based architecture validation

data/lib/domain_extractor/domain_validator.rb

@@ -16,151 +16,160 @@ rescue LoadError
   end
 end
 
-module DomainExtractor
-  # DomainValidator is a custom ActiveModel validator for URL/domain validation.
-  #
-  # Validation modes:
-  # - :standard - Validates any valid URL using DomainExtractor.valid?
-  # - :root_domain - Only allows root domains (no subdomains) like https://mysite.com
-  # - :root_or_custom_subdomain - Allows root or custom subdomains, but excludes 'www'
-  #
-  # Optional flags:
-  # - use_protocol (default: true) - Whether protocol (http/https) is required
-  # - use_https (default: true) - Whether https is required (only if use_protocol is true)
-  #
-  # @example Standard validation
-  #   validates :url, domain: { validation: :standard }
-  #
-  # @example Root domain only, no protocol required
-  #   validates :url, domain: { validation: :root_domain, use_protocol: false }
-  #
-  # @example Root or custom subdomain with https required
-  #   validates :url, domain: { validation: :root_or_custom_subdomain, use_https: true }
-  class DomainValidator < ActiveModel::EachValidator
-    VALIDATION_MODES = %i[standard root_domain root_or_custom_subdomain].freeze
-    WWW_SUBDOMAIN = 'www'
-
-    def validate_each(record, attribute, value)
-      return if blank?(value)
-
-      validation_mode = extract_validation_mode
-      use_protocol = options.fetch(:use_protocol, true)
-      use_https = options.fetch(:use_https, true)
-
-      normalized_url = normalize_url(value, use_protocol, use_https)
-
-      return unless protocol_valid?(record, attribute, normalized_url, use_protocol, use_https)
-
-      parsed = parse_and_validate_url(record, attribute, normalized_url)
-      return unless parsed
+# DomainValidator is a custom ActiveModel validator for URL/domain validation.
+#
+# This validator is defined at the top level so Rails can find it when using:
+#   validates :url, domain: { validation: :standard }
+#
+# Validation modes:
+# - :standard - Validates any valid URL using DomainExtractor.valid?
+# - :root_domain - Only allows root domains (no subdomains) like https://mysite.com
+# - :root_or_custom_subdomain - Allows root or custom subdomains but excludes 'www'
+#
+# Optional flags:
+# - use_protocol (default: true) - Whether protocol (http/https) is required
+# - use_https (default: true) - Whether https is required (only if use_protocol is true)
+#
+# @example Standard validation
+#   validates :url, domain: { validation: :standard }
+#
+# @example Root domain only, no protocol required
+#   validates :url, domain: { validation: :root_domain, use_protocol: false }
+#
+# @example Root or custom subdomain with https required
+#   validates :url, domain: { validation: :root_or_custom_subdomain, use_https: true }
+class DomainValidator < ActiveModel::EachValidator
+  VALIDATION_MODES = %i[standard root_domain root_or_custom_subdomain].freeze
+  WWW_SUBDOMAIN = 'www'
+
+  def validate_each(record, attribute, value)
+    return if blank?(value)
+
+    validation_mode = extract_validation_mode
+    use_protocol = options.fetch(:use_protocol, true)
+    use_https = options.fetch(:use_https, true)
+
+    normalized_url = normalize_url(value, use_protocol, use_https)
+
+    return unless protocol_valid?(record, attribute, normalized_url, use_protocol, use_https)
+
+    parsed = parse_and_validate_url(record, attribute, normalized_url)
+    return unless parsed
+
+    apply_validation_mode(record, attribute, parsed, validation_mode)
+  end
 
-      apply_validation_mode(record, attribute, parsed, validation_mode)
-    end
+  private
 
-    private
+  # Extract and validate the validation mode option
+  def extract_validation_mode
+    validation_mode = options.fetch(:validation, :standard)
+    return validation_mode if VALIDATION_MODES.include?(validation_mode)
 
-    # Extract and validate the validation mode option
-    def extract_validation_mode
-      validation_mode = options.fetch(:validation, :standard)
-      return validation_mode if VALIDATION_MODES.include?(validation_mode)
+    raise ArgumentError, "Invalid validation mode: #{validation_mode}. " \
+                         "Must be one of: #{VALIDATION_MODES.join(', ')}"
+  end
 
-      raise ArgumentError, "Invalid validation mode: #{validation_mode}. " \
-                           "Must be one of: #{VALIDATION_MODES.join(', ')}"
-    end
+  # Check protocol requirements
+  def protocol_valid?(record, attribute, url, use_protocol, use_https)
+    return true unless use_protocol
+    return true if valid_protocol?(url, use_https)
 
-    # Check protocol requirements
-    def protocol_valid?(record, attribute, url, use_protocol, use_https)
-      return true unless use_protocol
-      return true if valid_protocol?(url, use_https)
+    protocol = use_https ? 'https://' : 'http:// or https://'
+    record.errors.add(attribute, "must use #{protocol}")
+    false
+  end
 
-      protocol = use_https ? 'https://' : 'http:// or https://'
-      record.errors.add(attribute, "must use #{protocol}")
-      false
-    end
+  # Parse URL and validate it's valid
+  def parse_and_validate_url(record, attribute, url)
+    parsed = DomainExtractor.parse(url)
+    return parsed if parsed.valid?
 
-    # Parse URL and validate it's valid
-    def parse_and_validate_url(record, attribute, url)
-      parsed = DomainExtractor.parse(url)
-      return parsed if parsed.valid?
+    record.errors.add(attribute, 'is not a valid URL')
+    nil
+  end
 
-      record.errors.add(attribute, 'is not a valid URL')
+  # Apply the validation mode rules
+  def apply_validation_mode(record, attribute, parsed, validation_mode)
+    case validation_mode
+    when :standard
+      # Already validated - any valid URL passes
       nil
+    when :root_domain
+      validate_root_domain(record, attribute, parsed)
+    when :root_or_custom_subdomain
+      validate_root_or_custom_subdomain(record, attribute, parsed)
     end
+  end
 
-    # Apply the validation mode rules
-    def apply_validation_mode(record, attribute, parsed, validation_mode)
-      case validation_mode
-      when :standard
-        # Already validated - any valid URL passes
-        nil
-      when :root_domain
-        validate_root_domain(record, attribute, parsed)
-      when :root_or_custom_subdomain
-        validate_root_or_custom_subdomain(record, attribute, parsed)
-      end
-    end
-
-    # Check if value is blank (nil, empty string, or whitespace-only)
-    def blank?(value)
-      value.nil? || (value.respond_to?(:empty?) && value.empty?) ||
-        (value.is_a?(String) && value.strip.empty?)
-    end
-
-    # Normalize URL for validation based on protocol requirements
-    def normalize_url(url, use_protocol, use_https)
-      return url if blank?(url)
+  # Check if value is blank (nil, empty string, or whitespace-only)
+  def blank?(value)
+    value.nil? || (value.respond_to?(:empty?) && value.empty?) ||
+      (value.is_a?(String) && value.strip.empty?)
+  end
 
-      url = url.strip
+  # Normalize URL for validation based on protocol requirements
+  def normalize_url(url, use_protocol, use_https)
+    return url if blank?(url)
 
-      # If protocol is not required, strip any existing protocol
-      url = url.gsub(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://}, '') unless use_protocol
+    url = url.strip
 
-      # Add protocol if needed for parsing
-      unless url.match?(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://})
-        scheme = use_https ? 'https://' : 'http://'
-        url = scheme + url
-      end
+    # If protocol is not required, strip any existing protocol
+    url = url.gsub(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://}, '') unless use_protocol
 
-      url
+    # Add protocol if needed for parsing
+    unless url.match?(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://})
+      scheme = use_https ? 'https://' : 'http://'
+      url = scheme + url
     end
 
-    # Check if URL has valid protocol
-    def valid_protocol?(url, use_https)
-      return true unless url.match?(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://})
+    url
+  end
+
+  # Check if URL has valid protocol
+  def valid_protocol?(url, use_https)
+    return true unless url.match?(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://})
 
-      if use_https
-        url.start_with?('https://')
-      else
-        url.start_with?('http://', 'https://')
-      end
+    if use_https
+      url.start_with?('https://')
+    else
+      url.start_with?('http://', 'https://')
     end
+  end
 
-    # Validate that URL is a root domain (no subdomain)
-    def validate_root_domain(record, attribute, parsed)
-      return unless parsed.subdomain?
+  # Validate that URL is a root domain (no subdomain)
+  def validate_root_domain(record, attribute, parsed)
+    return unless parsed.subdomain?
 
-      record.errors.add(attribute, 'must be a root domain (no subdomains allowed)')
-    end
+    record.errors.add(attribute, 'must be a root domain (no subdomains allowed)')
+  end
 
-    # Validate that URL is either root domain or has custom subdomain (not 'www')
-    def validate_root_or_custom_subdomain(record, attribute, parsed)
-      return unless parsed.subdomain == WWW_SUBDOMAIN
+  # Validate that URL is either root domain or has custom subdomain (not 'www')
+  def validate_root_or_custom_subdomain(record, attribute, parsed)
+    return unless parsed.subdomain == WWW_SUBDOMAIN
 
-      record.errors.add(attribute, 'cannot use www subdomain')
-    end
+    record.errors.add(attribute, 'cannot use www subdomain')
   end
 end
 
-# Register the validator with ActiveModel if it's available
-if defined?(ActiveModel::Validations)
-  module ActiveModel
-    module Validations
-      # Enable usage via validates :url, domain: { validation: :standard }
-      module HelperMethods
-        def validates_domain(*attr_names)
-          validates_with DomainExtractor::DomainValidator, _merge_attributes(attr_names)
-        end
-      end
-    end
-  end
+# Also register in DomainExtractor namespace for backwards compatibility
+module DomainExtractor
+  # DomainValidator is now defined at the top level for Rails autoloading.
+  # This constant provides a reference for explicit usage.
+  #
+  # Validation modes:
+  # - :standard - Validates any valid URL using DomainExtractor.valid?
+  # - :root_domain - Only allows root domains (no subdomains) like https://mysite.com
+  # - :root_or_custom_subdomain - Allows root or custom subdomains, but excludes 'www'
+  #
+  # Optional flags:
+  # - use_protocol (default: true) - Whether protocol (http/https) is required
+  # - use_https (default: true) - Whether https is required (only if use_protocol is true)
+  #
+  # @example Standard validation
+  #   validates :url, domain: { validation: :standard }
+  #
+  # @example Root domain only, no protocol required
+  #   validates :url, domain: { validation: :root_domain, use_protocol: false }
+  DomainValidator = ::DomainValidator
 end

data/lib/domain_extractor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DomainExtractor
-  VERSION = '0.2.5'
+  VERSION = '0.2.6'
 end

data/spec/domain_validator_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe DomainExtractor::DomainValidator do
+RSpec.describe DomainValidator do
   # Mock record class for testing
   let(:record_class) do
     Class.new do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: domain_extractor
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - OpenSite AI