url_validation 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0fae744847fddf375172f64d9e40a200982b3d8c
-  data.tar.gz: fab400c0e41670a2ffeefa1fcb03a398f3712792
+SHA256:
+  metadata.gz: 3060391d73d4937f667c371401a15591f538001c9db4c9e60457646b31625ffb
+  data.tar.gz: 3450f357cf02db8279a324e369beeb69eeb1842242d2ff6cc59102fdd1006ad3
 SHA512:
-  metadata.gz: e15971f514c8b53fb1af82b1bc751cc4bc1dd8da092e68e27984eff755494be750edfda5e2d88c2ab7584ce59433bf05aed115f06b2d5cc6dbfa58b0a488605f
-  data.tar.gz: b98920d33b63e3792b63f8bc8bfbeb1798478f09c97d47a6e451fc62921904eb0d5887959d5dc8943149626bb381205670752b2d827a2e0b97bbf67a3bf61cde
+  metadata.gz: 7111f507cf4f8f06f1e8c182846aed69633e404d0b4f5a1530ee2822ec165714de37850a243dc0b9616d262dc389c44bed9beba9c34b8e2a57f7cb84b0f0e97d
+  data.tar.gz: 5e58055eadde1913e32045b4f4f52efc838dbb6c88affafcba75c541b032dfc7c8635cbcca90c8201854f228f401c567428f65ab38c9f53b4ee6eac73f154721

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.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0.0] - 2026-05-14
+
+### Breaking
+
+- Drops the runtime dependency on `activerecord`. The gem only ever needed
+  `ActiveModel::EachValidator`, so it now depends on `activemodel` (and
+  `activesupport`) directly. Apps that pulled `activerecord` in transitively
+  through this gem will need to declare it themselves if required.
+- Bumps `required_ruby_version` to `>= 3.1`.
+- Bumps `activemodel` / `activesupport` minimum to `>= 6.1`.
+
+### Added
+
+- New `:http_method` option (default `:head`) lets callers choose the HTTP
+  verb used for accessibility checks. Useful for servers that do not handle
+  `HEAD` correctly.
+- `webmock` is wired into the spec suite and `WebMock.disable_net_connect!`
+  is enabled, so the test suite no longer makes live network calls.
+- GitHub Actions workflow tests Ruby 3.1-3.4 against ActiveModel 7.0-8.0.
+- `bin/console`, `bin/setup`, modern `Rakefile`, hand-written gemspec.
+- `CHANGELOG.md`.
+
+### Fixed
+
+- **Accessibility check now uses `HEAD` requests, as documented.** Previously
+  the code called `HTTPI.get`, contradicting the README. It now calls
+  `HTTPI.request(:head, ...)` by default.
+- **`allow_blank: false` is now honored.** Previously the validator's
+  `return if value.blank?` short-circuit overrode an explicit
+  `allow_blank: false` option. Blank values now flow through to
+  format validation when `allow_blank` is false.
+- **Rescue branch no longer references a re-parsed URI.** When the
+  `default_scheme` re-parse raised, the rescue branch could call
+  `url_format_valid?` against a previously-set URI in an inconsistent
+  state. The rescue branch now adds `:invalid_url` unconditionally and
+  returns, which matches the documented behavior.
+
+### Removed
+
+- `.travis.yml`, juwelier-generated gemspec, `VERSION` text file.
+- Runtime `activerecord` dependency.
+
+## [1.2.0]
+
+- Last juwelier-managed release.

data/README.md

@@ -1,40 +1,143 @@
 # url_validation
 
-Simple URL validator for Rails 3.
+[![CI](https://github.com/RISCfuture/url_validation/actions/workflows/ci.yml/badge.svg)](https://github.com/RISCfuture/url_validation/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/url_validation.svg)](https://rubygems.org/gems/url_validation)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A simple, localizable `ActiveModel::EachValidator` for URL fields.
 
 |             |                                 |
 |:------------|:--------------------------------|
 | **Author**  | Tim Morgan                      |
-| **Version** | 1.0 (May 9, 2011)               |
 | **License** | Released under the MIT license. |
 
 ## About
 
-This gem adds a very simple URL format validator to be used with Active Record
-models in Rails 3.0. It supports localized error messages. It can validate many
-different kinds of URLs, including HTTP and HTTPS. It supports advanced
-validation features like sending `HEAD` requests to URLS to verify that they are
-valid endpoints.
+`url_validation` adds a URL validator usable in any `ActiveModel` (or `ActiveRecord`)
+class. It supports localized error messages, multiple schemes, and optional
+over-the-network reachability checks (`HEAD` by default, configurable).
 
 ## Installation
 
-Add the gem to your project's Gemfile:
+Add to your `Gemfile`:
 
-``` ruby
-gem 'url_validation'
+```ruby
+gem "url_validation"
 ```
 
+Then `bundle install`.
+
+This gem depends on `activemodel >= 6.1`. It does not require `activerecord`.
+
 ## Usage
 
-This gem is an `EachValidator`, and thus is used with the `validates` method:
+It's an `EachValidator`, so use it with `validates`:
 
-``` ruby
-class User < ActiveRecord::Base
-  validates :terms_of_service_link,
-            presence: true,
-            url: true
+```ruby
+class User
+  include ActiveModel::Model
+  include ActiveModel::Validations
+
+  attr_accessor :terms_of_service_link
+  validates :terms_of_service_link, presence: true, url: true
 end
 ```
 
-There are other options to fine-tune your validation; see the {UrlValidator}
-class for more, and for a list of error message localization keys.
+### Examples
+
+```ruby
+# Format only (no network)
+validates :link, url: true
+
+# Restrict to a specific scheme (or list)
+validates :link, url: {scheme: "https"}
+validates :link, url: {scheme: %w[http https ftp]}
+
+# If the user types "example.com", treat it as "http://example.com"
+validates :link, url: {default_scheme: "http"}
+
+# Verify host is reachable (sends a HEAD request)
+validates :link, url: {check_host: true}
+
+# Verify the path resolves to something other than 4xx/5xx
+validates :link, url: {check_path: true}
+validates :link, url: {check_path: [300..399, 400..499, 500..599]}
+
+# Use GET instead of HEAD (for servers that don't handle HEAD properly)
+validates :link, url: {check_host: true, http_method: :get}
+
+# Customize the HTTPI request (timeouts, headers, etc.)
+validates :link, url: {
+  check_host:       true,
+  request_callback: ->(request) { request.open_timeout = 5; request.read_timeout = 5 }
+}
+```
+
+## Options
+
+### Basic
+
+| Option         | Description                                                              |
+|:---------------|:-------------------------------------------------------------------------|
+| `:allow_nil`   | If `true`, `nil` values are allowed.                                     |
+| `:allow_blank` | If `true` (the default), `nil` or empty values are allowed without running format checks. Set to `false` to flag blank values as `:invalid_url`. |
+
+### Error messages
+
+Override the I18n key the validator uses when adding errors:
+
+| Option                          | Replaces I18n key       |
+|:--------------------------------|:------------------------|
+| `:invalid_url_message`          | `:invalid_url`          |
+| `:url_not_accessible_message`   | `:url_not_accessible`   |
+| `:url_invalid_response_message` | `:url_invalid_response` |
+
+### Format checks (no network)
+
+| Option            | Description                                                                                                                          |
+|:------------------|:-------------------------------------------------------------------------------------------------------------------------------------|
+| `:scheme`         | A string or array of strings indicating acceptable URL schemes. Defaults to `%w[http https]`.                                        |
+| `:default_scheme` | If set (e.g., `"http"`), a URL without a scheme will have this scheme prepended before validation, so `"example.com"` parses fine.   |
+
+### Network checks
+
+`url_validation` uses [HTTPI](https://rubygems.org/gems/httpi) to issue requests,
+so you can pick your underlying HTTP client.
+
+| Option            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+|:------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `:check_host`     | If `true`, perform a request to the host to verify connectivity. Only runs for HTTP(S) URLs unless overridden.                                                                                                                                                                                                                                                                                                                                                                    |
+| `:check_path`     | Treat specific response codes as invalid. Pass an Integer, a Symbol (e.g. `:not_found`), a Range (`400..499`), or an Array of these. `true` means "4xx or 5xx is invalid." Implies `:check_host`.                                                                                                                                                                                                                                                                                 |
+| `:httpi_adapter`  | The HTTPI adapter to use (default: HTTPI's default).                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `:http_method`    | The HTTP verb used for the accessibility check, as a Symbol. Defaults to `:head`. Use `:get` for servers that mis-handle `HEAD`.                                                                                                                                                                                                                                                                                                                                                  |
+| `:request_callback` | A `Proc`/lambda invoked with the `HTTPI::Request` before it executes. Use for custom timeouts, headers, auth, etc.                                                                                                                                                                                                                                                                                                                                                              |
+
+## Localization
+
+The validator emits the standard ActiveModel error symbols (`:invalid_url`,
+`:url_not_accessible`, `:url_invalid_response`). Provide translations under the
+usual `activemodel.errors.messages` namespace (or use the `Model.errors.messages`
+fallback). Example `config/locales/en.yml`:
+
+```yaml
+en:
+  errors:
+    messages:
+      invalid_url:          "is not a valid URL"
+      url_not_accessible:   "is not reachable"
+      url_invalid_response: "returned a bad response"
+```
+
+## Development
+
+```sh
+bin/setup
+bundle exec rspec
+```
+
+The spec suite uses [webmock](https://rubygems.org/gems/webmock) with
+`disable_net_connect!`, so tests never touch the network.
+
+## License
+
+MIT. See `LICENSE`.

data/Rakefile

@@ -1,38 +1,8 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
+# frozen_string_literal: true
 
-require 'juwelier'
-Juwelier::Tasks.new do |gem|
-  gem.name = 'url_validation'
-  gem.summary = %Q{Simple URL validation in Rails 3+}
-  gem.description = %Q{A simple, localizable EachValidator for URL fields in ActiveRecord 3.0.}
-  gem.email = 'git@timothymorgan.info'
-  gem.homepage = 'http://github.com/riscfuture/url_validation'
-  gem.authors = ['Tim Morgan']
-  gem.required_ruby_version = '>= 2.0.0'
-end
-Juwelier::RubygemsDotOrgTasks.new
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-require 'yard'
-YARD::Rake::YardocTask.new('doc') do |doc|
-  doc.options << '-m' << 'markdown' << '-M' << 'redcarpet'
-  doc.options << '--protected' << '--no-private'
-  doc.options << '-r' << 'README.md'
-  doc.options << '-o' << 'doc'
-  doc.options << '--title' << 'url_validation Documentation'.inspect
-
-  doc.files = %w(lib/**/*.rb README.md)
-end
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec

data/lib/url_validation/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# UrlValidator's version. Lives in its own module so the gemspec can
+# `require_relative "lib/url_validation/version"` without forcing ActiveModel
+# to load at gem-spec-evaluation time. The UrlValidator class picks the
+# constant up and assigns it as `UrlValidator::VERSION`.
+module UrlValidation
+  VERSION = "2.0.0"
+end

data/lib/url_validation.rb

@@ -1,8 +1,12 @@
-require 'addressable/uri'
-require 'httpi'
-require 'active_support/core_ext/hash/except'
-require 'active_model/validator'
-require 'active_support/core_ext/array/wrap'
+# frozen_string_literal: true
+
+require "addressable/uri"
+require "httpi"
+require "active_support/core_ext/hash/except"
+require "active_model/validator"
+require "active_support/core_ext/array/wrap"
+
+require "url_validation/version"
 
 # Validates URLs. Uses the following I18n error message keys:
 #
@@ -30,6 +34,9 @@ require 'active_support/core_ext/array/wrap'
 #     request_callback: ->(request) { request.timeout = 30 }
 #   }
 #
+# @example Uses a GET request instead of the default HEAD request
+#   validates :link, url: {check_host: true, http_method: :get}
+#
 # ## Options
 #
 # ### Basic options
@@ -61,11 +68,16 @@ require 'active_support/core_ext/array/wrap'
 # you wish to use. This allows you to drop in, e.g., a Curl client if you want.
 # You can set the HTTPI adapter with the `:httpi_adapter` option.
 #
+# By default, HEAD requests are used for accessibility checks. If a server does
+# not support HEAD requests, you can set `:http_method` to `:get` (or any other
+# verb supported by HTTPI).
+#
 # |                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 # |:-----------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 # | `:check_host`    | If `true`, the validator will perform a network test to verify that it can connect to the server and access the host (at the "/" path). This check will only be performed for HTTP(S) URLs.                                                                                                                                                                                                                                                            |
 # | `:check_path`    | An integer or symbol (or array of integers or symbols), such as 301 or `:moved_permanently`, indicating what response codes are unacceptable. You can also use ranges, and include them in an array, such as `[:moved_permanently, 400..404, 500..599]`. By default, this is `nil`, and therefore only host accessibility is checked. If `true` is given, uses a default set of invalid error codes (4xx and 5xx). Implies `:check_host` is also true. |
 # | `:httpi_adapter` | The HTTPI adapter to use for checking HTTP and HTTPS URLs (default set by the HTTPI gem).                                                                                                                                                                                                                                                                                                                                                              |
+# | `:http_method`   | The HTTP verb (as a Symbol) to use for the accessibility check. Defaults to `:head`. Set to `:get` for servers that do not support HEAD.                                                                                                                                                                                                                                                                                                               |
 #
 # ### Other options
 #
@@ -74,6 +86,8 @@ require 'active_support/core_ext/array/wrap'
 # | `:request_callback` | A proc that receives the request object (for HTTP(S) requests, the `HTTPI::Request` object) before it is executed. You can use this proc to set, e.g., custom headers or timeouts on the request. |
 
 class UrlValidator < ActiveModel::EachValidator
+  VERSION = UrlValidation::VERSION
+
   # @private
   CODES = {
       continue:                        100,
@@ -127,35 +141,36 @@ class UrlValidator < ActiveModel::EachValidator
       variant_also_negotiates:         506,
       insufficient_storage:            507,
       not_extended:                    510
-  }
+  }.freeze
 
   # @private
   def validate_each(record, attribute, value)
-    return if value.blank?
+    return if value.blank? && options.fetch(:allow_blank, true)
 
+    uri = nil
     begin
       uri = Addressable::URI.parse(value)
 
-      if uri.scheme.nil? and options[:default_scheme]
+      if uri.scheme.nil? && options[:default_scheme]
         uri = Addressable::URI.parse("#{options[:default_scheme]}://#{value}")
       end
     rescue Addressable::URI::InvalidURIError
-      record.errors.add(attribute, options[:invalid_url_message] || :invalid_url) if uri.nil? || !url_format_valid?(uri, options)
+      record.errors.add(attribute, options[:invalid_url_message] || :invalid_url)
       return
     end
 
     record.errors.add(attribute, options[:invalid_url_message] || :invalid_url) unless url_format_valid?(uri, options)
-    record.errors.add(attribute, options[:url_not_accessible_message] || :url_not_accessible) unless response = url_accessible?(uri, options)
+    record.errors.add(attribute, options[:url_not_accessible_message] || :url_not_accessible) unless (response = url_accessible?(uri, options))
     record.errors.add(attribute, options[:url_invalid_response_message] || :url_invalid_response) unless url_response_valid?(response, options)
   end
 
   private
 
   def url_format_valid?(uri, options)
-    return false unless Array.wrap(options[:scheme] || %w(http https)).include?(uri.scheme)
+    return false unless Array.wrap(options[:scheme] || %w[http https]).include?(uri.scheme)
 
     case uri.scheme
-      when 'http', 'https'
+      when "http", "https"
         return http_url_format_valid?(uri)
       else
         return true
@@ -163,20 +178,20 @@ class UrlValidator < ActiveModel::EachValidator
   end
 
   def http_url_format_valid?(uri)
-    uri.host.present? and not uri.path.nil?
+    uri.host.present? && !uri.path.nil?
   end
 
   def url_accessible?(uri, options)
-    return true unless options[:check_host] or options[:check_path]
+    return true unless options[:check_host] || options[:check_path]
 
     check_host = options[:check_host]
-    check_host ||= %w(http https) if options[:check_path]
-    if (schemes = Array.wrap(check_host)) and schemes.all? { |scheme| scheme.kind_of?(String) }
-      return true unless schemes.include?(uri.scheme)
+    check_host ||= %w[http https] if options[:check_path]
+    if (schemes = Array.wrap(check_host)) && schemes.all?(String) && !schemes.include?(uri.scheme)
+      return true
     end
 
     case uri.scheme
-      when 'http', 'https'
+      when "http", "https"
         return http_url_accessible?(uri, options)
       else
         return true
@@ -186,14 +201,16 @@ class UrlValidator < ActiveModel::EachValidator
   def http_url_accessible?(uri, options)
     request = HTTPI::Request.new(uri.to_s)
     options[:request_callback].call(request) if options[:request_callback].respond_to?(:call)
-    return HTTPI.get(request, options[:httpi_adapter])
-  rescue
+    method = options[:http_method] || :head
+    return HTTPI.request(method, request, options[:httpi_adapter])
+  rescue StandardError
     return false
   end
 
   def url_response_valid?(response, options)
-    return true unless response.kind_of?(HTTPI::Response) and options[:check_path]
-    response_codes = options[:check_path] == true ? [400..499, 500..599] : Array.wrap(options[:check_path]).flatten
+    return true unless response.kind_of?(HTTPI::Response) && options[:check_path]
+
+    response_codes = (options[:check_path] == true) ? [400..499, 500..599] : Array.wrap(options[:check_path]).flatten
     return response_codes.none? do |code| # it's good if it's not a bad response
       case code # and it's a bad response if...
         when Range

data/url_validation.gemspec

@@ -1,75 +1,49 @@
-# Generated by juwelier
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: url_validation 1.2.0 ruby lib
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name = "url_validation".freeze
-  s.version = "1.2.0"
+require_relative "lib/url_validation/version"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib".freeze]
-  s.authors = ["Tim Morgan".freeze]
-  s.date = "2017-05-31"
-  s.description = "A simple, localizable EachValidator for URL fields in ActiveRecord 3.0.".freeze
-  s.email = "git@timothymorgan.info".freeze
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    ".ruby-gemset",
-    ".ruby-version",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/url_validation.rb",
-    "spec/spec_helper.rb",
-    "spec/url_validator_spec.rb",
-    "url_validation.gemspec"
-  ]
-  s.homepage = "http://github.com/riscfuture/url_validation".freeze
-  s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
-  s.rubygems_version = "2.6.12".freeze
-  s.summary = "Simple URL validation in Rails 3+".freeze
+Gem::Specification.new do |spec|
+  spec.name        = "url_validation"
+  spec.version     = UrlValidation::VERSION
+  spec.authors     = ["Tim Morgan"]
+  spec.email       = ["git@timothymorgan.info"]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
+  spec.summary     = "Simple URL validation for ActiveModel."
+  spec.description = "A simple, localizable ActiveModel::EachValidator for URL fields. " \
+                     "Supports format validation as well as optional network reachability " \
+                     "checks via HEAD (or any other HTTP verb) requests."
+  spec.homepage    = "https://github.com/riscfuture/url_validation"
+  spec.license     = "MIT"
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<addressable>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<activesupport>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<httpi>.freeze, [">= 0"])
-      s.add_development_dependency(%q<juwelier>.freeze, [">= 0"])
-      s.add_development_dependency(%q<yard>.freeze, [">= 0"])
-      s.add_development_dependency(%q<redcarpet>.freeze, [">= 0"])
-      s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
-    else
-      s.add_dependency(%q<addressable>.freeze, [">= 0"])
-      s.add_dependency(%q<activesupport>.freeze, [">= 0"])
-      s.add_dependency(%q<activerecord>.freeze, [">= 0"])
-      s.add_dependency(%q<httpi>.freeze, [">= 0"])
-      s.add_dependency(%q<juwelier>.freeze, [">= 0"])
-      s.add_dependency(%q<yard>.freeze, [">= 0"])
-      s.add_dependency(%q<redcarpet>.freeze, [">= 0"])
-      s.add_dependency(%q<rspec>.freeze, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<addressable>.freeze, [">= 0"])
-    s.add_dependency(%q<activesupport>.freeze, [">= 0"])
-    s.add_dependency(%q<activerecord>.freeze, [">= 0"])
-    s.add_dependency(%q<httpi>.freeze, [">= 0"])
-    s.add_dependency(%q<juwelier>.freeze, [">= 0"])
-    s.add_dependency(%q<yard>.freeze, [">= 0"])
-    s.add_dependency(%q<redcarpet>.freeze, [">= 0"])
-    s.add_dependency(%q<rspec>.freeze, [">= 0"])
+  spec.required_ruby_version = ">= 3.1"
+
+  spec.metadata = {
+    "homepage_uri"          => spec.homepage,
+    "bug_tracker_uri"       => "#{spec.homepage}/issues",
+    "changelog_uri"         => "#{spec.homepage}/blob/master/CHANGELOG.md",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    tracked = `git ls-files -z`.split("\x0")
+    # Always include these even if not yet committed (helps local builds).
+    extra = %w[CHANGELOG.md lib/url_validation/version.rb]
+    (tracked + extra).uniq.reject do |f|
+      f.match(%r{\A(?:test|spec|features|bin|gemfiles|\.github|\.idea)/}) ||
+        f.match(%r{\A\.(?:rspec|rubocop\.yml|standard\.yml|ruby-version|ruby-gemset|gitignore|document|travis\.yml)\z}) ||
+        f.match(%r{\AGemfile(?:\.lock)?\z}) ||
+        f == "VERSION"
+    end.select { |f| File.exist?(File.join(__dir__, f)) }
   end
-end
+  spec.require_paths = ["lib"]
 
+  spec.add_dependency "activemodel",   ">= 6.1"
+  spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency "addressable",   "~> 2.8"
+  spec.add_dependency "httpi",         "~> 4.0"
+
+  spec.add_development_dependency "rake",     "~> 13.0"
+  spec.add_development_dependency "rspec",    "~> 3.13"
+  spec.add_development_dependency "standard", "~> 1.0"
+  spec.add_development_dependency "webmock",  "~> 3.0"
+end

metadata

@@ -1,153 +1,150 @@
 --- !ruby/object:Gem::Specification
 name: url_validation
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Tim Morgan
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: addressable
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: httpi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: juwelier
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.13'
 - !ruby/object:Gem::Dependency
-  name: redcarpet
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: A simple, localizable EachValidator for URL fields in ActiveRecord 3.0.
-email: git@timothymorgan.info
+        version: '3.0'
+description: A simple, localizable ActiveModel::EachValidator for URL fields. Supports
+  format validation as well as optional network reachability checks via HEAD (or any
+  other HTTP verb) requests.
+email:
+- git@timothymorgan.info
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.md
+extra_rdoc_files: []
 files:
-- ".document"
-- ".rspec"
-- ".ruby-gemset"
-- ".ruby-version"
-- Gemfile
-- Gemfile.lock
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - lib/url_validation.rb
-- spec/spec_helper.rb
-- spec/url_validator_spec.rb
+- lib/url_validation/version.rb
 - url_validation.gemspec
-homepage: http://github.com/riscfuture/url_validation
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/riscfuture/url_validation
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/riscfuture/url_validation
+  bug_tracker_uri: https://github.com/riscfuture/url_validation/issues
+  changelog_uri: https://github.com/riscfuture/url_validation/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -155,16 +152,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 4.0.11
 specification_version: 4
-summary: Simple URL validation in Rails 3+
+summary: Simple URL validation for ActiveModel.
 test_files: []

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/.ruby-gemset

@@ -1 +0,0 @@
-url_validation

data/.ruby-version

@@ -1 +0,0 @@
-2.4.1

data/Gemfile

@@ -1,18 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'addressable', require: 'addressable/uri' # for unicode URIs
-gem 'activesupport'
-gem 'activerecord'
-gem 'httpi'
-
-group :development do
-  # PUBLISHING
-  gem 'juwelier'
-
-  # DOCS
-  gem 'yard', require: nil
-  gem 'redcarpet', require: nil
-
-  # SPECS
-  gem 'rspec'
-end

data/Gemfile.lock

@@ -1,106 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activemodel (5.1.1)
-      activesupport (= 5.1.1)
-    activerecord (5.1.1)
-      activemodel (= 5.1.1)
-      activesupport (= 5.1.1)
-      arel (~> 8.0)
-    activesupport (5.1.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    addressable (2.4.0)
-    arel (8.0.0)
-    builder (3.2.3)
-    concurrent-ruby (1.0.5)
-    descendants_tracker (0.0.4)
-      thread_safe (~> 0.3, >= 0.3.1)
-    diff-lcs (1.3)
-    faraday (0.9.2)
-      multipart-post (>= 1.2, < 3)
-    git (1.3.0)
-    github_api (0.17.0)
-      addressable (~> 2.4.0)
-      descendants_tracker (~> 0.0.4)
-      faraday (~> 0.8, < 0.10)
-      hashie (>= 3.4)
-      mime-types (>= 1.16, < 3.0)
-      oauth2 (~> 1.0)
-    hashie (3.5.5)
-    highline (1.7.8)
-    httpi (2.4.2)
-      rack
-      socksify
-    i18n (0.8.4)
-    juwelier (2.4.5)
-      builder
-      bundler (>= 1.13)
-      git (>= 1.2.5)
-      github_api
-      highline (>= 1.6.15)
-      kamelcase (~> 0)
-      nokogiri (>= 1.5.10)
-      psych (~> 2.2)
-      rake
-      rdoc
-      semver2
-    jwt (1.5.6)
-    kamelcase (0.0.0)
-      semver2 (~> 3)
-    mime-types (2.99.3)
-    mini_portile2 (2.1.0)
-    minitest (5.10.2)
-    multi_json (1.12.1)
-    multi_xml (0.6.0)
-    multipart-post (2.0.0)
-    nokogiri (1.7.2)
-      mini_portile2 (~> 2.1.0)
-    oauth2 (1.3.1)
-      faraday (>= 0.8, < 0.12)
-      jwt (~> 1.0)
-      multi_json (~> 1.3)
-      multi_xml (~> 0.5)
-      rack (>= 1.2, < 3)
-    psych (2.2.4)
-    rack (2.0.3)
-    rake (12.0.0)
-    rdoc (5.1.0)
-    redcarpet (3.4.0)
-    rspec (3.6.0)
-      rspec-core (~> 3.6.0)
-      rspec-expectations (~> 3.6.0)
-      rspec-mocks (~> 3.6.0)
-    rspec-core (3.6.0)
-      rspec-support (~> 3.6.0)
-    rspec-expectations (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-mocks (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-support (3.6.0)
-    semver2 (3.4.2)
-    socksify (1.7.1)
-    thread_safe (0.3.6)
-    tzinfo (1.2.3)
-      thread_safe (~> 0.1)
-    yard (0.9.9)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord
-  activesupport
-  addressable
-  httpi
-  juwelier
-  redcarpet
-  rspec
-  yard
-
-BUNDLED WITH
-   1.15.0

data/VERSION

@@ -1 +0,0 @@
-1.2.0

data/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-require 'bundler'
-Bundler.require :default, :development
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'url_validation'
-require 'active_model'
-require 'active_support/core_ext/kernel/singleton_class'
-
-RSpec.configure do |c|
-  
-end

data/spec/url_validator_spec.rb

@@ -1,235 +0,0 @@
-require 'spec_helper'
-
-class Record
-  extend ActiveModel::Translation
-  include ActiveModel::Validations
-  attr_accessor :field
-end
-
-describe UrlValidator do
-  before :each do
-    @record = Record.new
-  end
-
-  context '[basic]' do
-    it "should allow nil if :allow_nil is set" do
-      @validator = UrlValidator.new(attributes: %i(field), allow_nil: true)
-      @validator.validate_each(@record, :field, nil)
-      expect(@record.errors).to be_empty
-    end
-
-    it "should allow \"\" if :allow_blank is set" do
-      @validator = UrlValidator.new(attributes: %i(field), allow_blank: true)
-      @validator.validate_each(@record, :field, "")
-      expect(@record.errors).to be_empty
-    end
-  end
-
-  context '[format]' do
-    it "should only allow HTTP URLs if :scheme is set to 'http'" do
-      @validator = UrlValidator.new(attributes: %i(field), scheme: 'http')
-      @validator.validate_each(@record, :field, 'http://www.apple.com')
-      expect(@record.errors).to be_empty
-
-      @validator.validate_each(@record, :field, 'https://www.apple.com')
-      expect(@record.errors[:field].first).to include('invalid_url')
-    end
-
-    it "should only allow HTTP and HTTPS URLs if :scheme is set to %w(http https)" do
-      @validator = UrlValidator.new(attributes: %i(field), scheme: %w(http https))
-      @validator.validate_each(@record, :field, 'http://www.apple.com')
-      expect(@record.errors).to be_empty
-      @validator.validate_each(@record, :field, 'https://www.apple.com')
-      expect(@record.errors).to be_empty
-
-      @validator.validate_each(@record, :field, 'ftp://www.apple.com')
-      expect(@record.errors[:field].first).to include('invalid_url')
-    end
-
-    it "should try a default scheme if :default_scheme is set" do
-      @validator = UrlValidator.new(attributes: %i(field), scheme: 'http', default_scheme: 'http')
-      @validator.validate_each(@record, :field, 'www.apple.com')
-      expect(@record.errors).to be_empty
-    end
-
-    context '[HTTP(S)]' do
-      it "should not allow garbage URLs that still somehow pass the ridiculously open-ended RFC" do
-        @validator = UrlValidator.new(attributes: %i(field))
-
-        %w(
-            http:sdg.sdfg/
-            http/sdg.d
-            http:://dsfg.dsfg/
-            http//sdg..g
-            http://://sdfg.f).each do |uri|
-          @record.errors.clear
-          @validator.validate_each(@record, :field, uri)
-          expect(@record.errors[:field].first).to include('invalid_url')
-        end
-      end
-
-      it "should not allow invalid scheme formats" do
-        @validator = UrlValidator.new(attributes: %i(field))
-        @validator.validate_each(@record, :field, ' https://www.apple.com')
-        expect(@record.errors[:field].first).to include('invalid_url')
-      end
-    end
-  end
-
-  context '[accessibility]' do
-    context '[:check_host]' do
-      it "should only validate if the host is accessible when :check_host is set" do
-        @validator = UrlValidator.new(attributes: %i(field))
-        @validator.validate_each(@record, :field, 'http://www.invalid.tld')
-        expect(@record.errors).to be_empty
-
-        @validator = UrlValidator.new(attributes: %i(field), check_host: true)
-        @validator.validate_each(@record, :field, 'http://www.invalid.tld')
-        expect(@record.errors[:field].first).to include('url_not_accessible')
-      end
-
-      it "should not perform the accessibility check if :check_host is set to 'http' and the URL scheme is not HTTP" do
-        @validator = UrlValidator.new(attributes: %i(field), check_host: 'http')
-        @validator.validate_each(@record, :field, 'https://www.invalid.tld')
-        expect(@record.errors).to be_empty
-      end
-
-      it "should only validate if the host is accessible when :check_host is set to 'http' and the URL scheme is HTTP" do
-        @validator = UrlValidator.new(attributes: %i(field), check_host: 'http')
-        @validator.validate_each(@record, :field, 'http://www.invalid.tld')
-        expect(@record.errors[:field].first).to include('url_not_accessible')
-      end
-
-      it "should not perform the accessibility check if :check_host is set to %w(http https) and the URL scheme is not HTTP(S)" do
-        @validator = UrlValidator.new(attributes: %i(field), check_host: %w(http https), scheme: %w(ftp http https))
-        @validator.validate_each(@record, :field, 'ftp://www.invalid.tld')
-        expect(@record.errors).to be_empty
-      end
-
-      it "should only validate if the host is accessible when :check_host is set to %w(http https) and the URL scheme is HTTP(S)" do
-        @validator = UrlValidator.new(attributes: %i(field), check_host: %w(http https))
-        @validator.validate_each(@record, :field, 'http://www.invalid.tld')
-        expect(@record.errors[:field].first).to include('url_not_accessible')
-
-        @validator = UrlValidator.new(attributes: %i(field), check_host: %w(http https))
-        @validator.validate_each(@record, :field, 'https://www.invalid.tld')
-        expect(@record.errors[:field].first).to include('url_not_accessible')
-      end
-
-      it "should only validate the host" do
-        @validator = UrlValidator.new(attributes: %i(field), check_host: true)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors).to be_empty
-      end
-    end
-
-    context '[:check_path]' do
-      it "should not validate if the response code is equal to the Integer value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: 404)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: 405)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate if the response code is equal to the Symbol value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: :not_found)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: :unauthorized)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate if the response code is within the Range value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: 400..499)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: 500..599)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate if the response code is equal to the Integer value contained in the Array value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: [404, 405])
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: [405, 406])
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate if the response code is equal to the Symbol value contained in the Array value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: %i(not_found unauthorized))
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: %i(unauthorized moved_permanently))
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate if the response code is equal to the Range value contained in the Array value of this option" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: [400..499, 500..599])
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-
-        @record.errors.clear
-
-        @validator = UrlValidator.new(attributes: %i(field), check_path: [500..599, 300..399])
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should skip validation by default" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: nil)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field]).to be_empty
-      end
-
-      it "should not validate 4xx and 5xx response codes if the value is true" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: true)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(@record.errors[:field].first).to include('url_invalid_response')
-      end
-
-      it "should skip validation for non-HTTP URLs" do
-        @validator = UrlValidator.new(attributes: %i(field), check_path: true, scheme: %w(ftp http https))
-        @validator.validate_each(@record, :field, 'ftp://ftp.sdgasdgohaodgh.com/sdgjsdg')
-        expect(@record.errors[:field]).to be_empty
-      end
-    end
-
-    context '[:httpi_adapter]' do
-      it "should use the specified HTTPI adapter" do
-        @validator = UrlValidator.new(attributes: %i(field), httpi_adapter: :curl, check_host: true)
-        expect(HTTPI).to receive(:get).once.with(an_instance_of(HTTPI::Request), :curl).and_return(false)
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-      end
-    end
-
-    context '[:request_callback]' do
-      it "should be yielded the HTTPI request" do
-        called     = false
-        @validator = UrlValidator.new(attributes: %i(field), check_host: true, request_callback: ->(request) { called = true; expect(request).to be_kind_of(HTTPI::Request) })
-        @validator.validate_each(@record, :field, 'http://www.google.com/sdgsdgf')
-        expect(called).to eql(true)
-      end
-    end
-  end
-end