Rails: ¿Cuál es una buena forma de validar enlaces (URL)?

Me preguntaba cómo validaría mejor las URL en Rails. Estaba pensando en usar una expresión regular, pero no estoy seguro de si esta es la mejor práctica.

Y, si tuviera que usar una expresión regular, ¿alguien podría sugerirme una? Todavía soy nuevo en Regex.

Validar una URL es un trabajo complicado. También es una solicitud muy amplia.

¿Qué quieres hacer exactamente? ¿Quieres validar el formato de la URL, la existencia o qué? Hay varias posibilidades, dependiendo de lo que quieras hacer.

Una expresión regular puede validar el formato de la URL. Pero incluso una expresión regular compleja no puede garantizar que esté tratando con una URL válida.

Por ejemplo, si toma una expresión regular simple, probablemente rechazará el siguiente host

http://invalid##host.com

pero permitirá

http://invalid-host.foo

ese es un host válido, pero no un dominio válido si considera los TLD existentes. De hecho, la solución funcionaría si desea validar el nombre de host, no el dominio porque el siguiente es un nombre de host válido

http://host.foo

así el siguiente

http://localhost

Ahora, déjame darte algunas soluciones.

Si desea validar un dominio, debe olvidarse de las expresiones regulares. La mejor solución disponible en este momento es la Lista de sufijos públicos, una lista mantenida por Mozilla. Creé una biblioteca Ruby para analizar y validar dominios en la lista de sufijos públicos, y se llama PublicSuffix .

Si desea validar el formato de un URI / URL, puede utilizar expresiones regulares. En lugar de buscar uno, use el URI.parsemétodo Ruby incorporado .

require 'uri'

def valid_url?(uri)
  uri = URI.parse(uri) && !uri.host.nil?
rescue URI::InvalidURIError
  false
end

Incluso puedes decidir hacerlo más restrictivo. Por ejemplo, si desea que la URL sea una URL HTTP / HTTPS, puede hacer que la validación sea más precisa.

require 'uri'

def valid_url?(url)
  uri = URI.parse(url)
  uri.is_a?(URI::HTTP) && !uri.host.nil?
rescue URI::InvalidURIError
  false
end

Por supuesto, hay toneladas de mejoras que puede aplicar a este método, incluida la comprobación de una ruta o un esquema.

Por último, pero no menos importante, también puede empaquetar este código en un validador:

class HttpUrlValidator < ActiveModel::EachValidator

  def self.compliant?(value)
    uri = URI.parse(value)
    uri.is_a?(URI::HTTP) && !uri.host.nil?
  rescue URI::InvalidURIError
    false
  end

  def validate_each(record, attribute, value)
    unless value.present? && self.class.compliant?(value)
      record.errors.add(attribute, "is not a valid HTTP URL")
    end
  end

end

# in the model
validates :example_attribute, http_url: true

Yo uso un forro dentro de mis modelos:

validates :url, format: URI::regexp(%w[http https])

Creo que es lo suficientemente bueno y fácil de usar. Además, debería ser teóricamente equivalente al método de Simone, ya que utiliza la misma expresión regular internamente.

Siguiendo la idea de Simone, puede crear fácilmente su propio validador.

class UrlValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    return if value.blank?
    begin
      uri = URI.parse(value)
      resp = uri.kind_of?(URI::HTTP)
    rescue URI::InvalidURIError
      resp = false
    end
    unless resp == true
      record.errors[attribute] << (options[:message] || "is not an url")
    end
  end
end

y luego usar

validates :url, :presence => true, :url => true

en tu modelo

También hay validate_url gem (que es solo un buen contenedor para la Addressable::URI.parsesolución).

Solo agrega

gem 'validate_url'

a tu Gemfile, y luego en modelos puedes

validates :click_through_url, url: true

Esta pregunta ya está respondida, pero qué diablos, propongo la solución que estoy usando.

La expresión regular funciona bien con todas las URL que he conocido. El método de establecimiento es tener cuidado si no se menciona ningún protocolo (supongamos que http: //).

Y finalmente, intentamos recuperar la página. Tal vez debería aceptar redireccionamientos y no solo HTTP 200 OK.

# app/models/my_model.rb
validates :website, :allow_blank => true, :uri => { :format => /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix }

def website= url_str
  unless url_str.blank?
    unless url_str.split(':')[0] == 'http' || url_str.split(':')[0] == 'https'
        url_str = "http://" + url_str
    end
  end  
  write_attribute :website, url_str
end

y...

# app/validators/uri_vaidator.rb
require 'net/http'

# Thanks Ilya! http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/
# Original credits: http://blog.inquirylabs.com/2006/04/13/simple-uri-validation/
# HTTP Codes: http://www.ruby-doc.org/stdlib/libdoc/net/http/rdoc/classes/Net/HTTPResponse.html

class UriValidator < ActiveModel::EachValidator
  def validate_each(object, attribute, value)
    raise(ArgumentError, "A regular expression must be supplied as the :format option of the options hash") unless options[:format].nil? or options[:format].is_a?(Regexp)
    configuration = { :message => I18n.t('errors.events.invalid_url'), :format => URI::regexp(%w(http https)) }
    configuration.update(options)

    if value =~ configuration[:format]
      begin # check header response
        case Net::HTTP.get_response(URI.parse(value))
          when Net::HTTPSuccess then true
          else object.errors.add(attribute, configuration[:message]) and false
        end
      rescue # Recover on DNS failures..
        object.errors.add(attribute, configuration[:message]) and false
      end
    else
      object.errors.add(attribute, configuration[:message]) and false
    end
  end
end

También puede probar valid_url gem que permite URL sin el esquema, verifica la zona de dominio y los nombres de host de IP.

Agréguelo a su Gemfile:

gem 'valid_url'

Y luego en modelo:

class WebSite < ActiveRecord::Base
  validates :url, :url => true
end

Solo mis 2 centavos:

before_validation :format_website
validate :website_validator

private

def format_website
  self.website = "http://#{self.website}" unless self.website[/^https?/]
end

def website_validator
  errors[:website] << I18n.t("activerecord.errors.messages.invalid") unless website_valid?
end

def website_valid?
  !!website.match(/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-=\?]*)*\/?$/)
end

EDITAR: expresión regular modificada para que coincida con las URL de los parámetros.

La solución que funcionó para mí fue:

validates_format_of :url, :with => /\A(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w\.-]*)*\/?\Z/i

Intenté usar algunos de los ejemplos que adjuntaste, pero estoy apoyando la URL de esta manera:

Observe el uso de A y Z porque si usa ^ y $ verá esta advertencia de seguridad de los validadores de Rails.

 Valid ones:
 'www.crowdint.com'
 'crowdint.com'
 'http://crowdint.com'
 'http://www.crowdint.com'

 Invalid ones:
  'http://www.crowdint. com'
  'http://fake'
  'http:fake'

Me encontré con el mismo problema últimamente (necesitaba validar las URL en una aplicación Rails) pero tuve que hacer frente al requisito adicional de las URL unicode (p. Ej. http://кц.рф ) ...

Investigué un par de soluciones y encontré lo siguiente:

• Lo primero y más sugerido es usar URI.parse . Verifique la respuesta de Simone Carletti para más detalles. Esto funciona bien, pero no para las URL unicode.
• El segundo método que vi fue el de Ilya Grigorik: http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/ Básicamente, intenta hacer una solicitud al url si funciona, es válido ...
• El tercer método que encontré (y el que prefiero) es un enfoque similar URI.parsepero que usa la addressablegema en lugar del URIstdlib. Este enfoque se detalla aquí: http://rawsyntax.com/blog/url-validation-in-rails-3-and-ruby-in-general/

Aquí hay una versión actualizada del validador publicado por David James . Ha sido publicado por Benjamin Fleischer . Mientras tanto, presioné un tenedor actualizado que se puede encontrar aquí .

require 'addressable/uri'

# Source: http://gist.github.com/bf4/5320847
# Accepts options[:message] and options[:allowed_protocols]
# spec/validators/uri_validator_spec.rb
class UriValidator < ActiveModel::EachValidator

  def validate_each(record, attribute, value)
    uri = parse_uri(value)
    if !uri
      record.errors[attribute] << generic_failure_message
    elsif !allowed_protocols.include?(uri.scheme)
      record.errors[attribute] << "must begin with #{allowed_protocols_humanized}"
    end
  end

private

  def generic_failure_message
    options[:message] || "is an invalid URL"
  end

  def allowed_protocols_humanized
    allowed_protocols.to_sentence(:two_words_connector => ' or ')
  end

  def allowed_protocols
    @allowed_protocols ||= [(options[:allowed_protocols] || ['http', 'https'])].flatten
  end

  def parse_uri(value)
    uri = Addressable::URI.parse(value)
    uri.scheme && uri.host && uri
  rescue URI::InvalidURIError, Addressable::URI::InvalidURIError, TypeError
  end

end

...

require 'spec_helper'

# Source: http://gist.github.com/bf4/5320847
# spec/validators/uri_validator_spec.rb
describe UriValidator do
  subject do
    Class.new do
      include ActiveModel::Validations
      attr_accessor :url
      validates :url, uri: true
    end.new
  end

  it "should be valid for a valid http url" do
    subject.url = 'http://www.google.com'
    subject.valid?
    subject.errors.full_messages.should == []
  end

  ['http://google', 'http://.com', 'http://ftp://ftp.google.com', 'http://ssh://google.com'].each do |invalid_url|
    it "#{invalid_url.inspect} is a invalid http url" do
      subject.url = invalid_url
      subject.valid?
      subject.errors.full_messages.should == []
    end
  end

  ['http:/www.google.com','<>hi'].each do |invalid_url|
    it "#{invalid_url.inspect} is an invalid url" do
      subject.url = invalid_url
      subject.valid?
      subject.errors.should have_key(:url)
      subject.errors[:url].should include("is an invalid URL")
    end
  end

  ['www.google.com','google.com'].each do |invalid_url|
    it "#{invalid_url.inspect} is an invalid url" do
      subject.url = invalid_url
      subject.valid?
      subject.errors.should have_key(:url)
      subject.errors[:url].should include("is an invalid URL")
    end
  end

  ['ftp://ftp.google.com','ssh://google.com'].each do |invalid_url|
    it "#{invalid_url.inspect} is an invalid url" do
      subject.url = invalid_url
      subject.valid?
      subject.errors.should have_key(:url)
      subject.errors[:url].should include("must begin with http or https")
    end
  end
end

Tenga en cuenta que todavía hay URI HTTP extraños que se analizan como direcciones válidas.

http://google  
http://.com  
http://ftp://ftp.google.com  
http://ssh://google.com

Aquí hay un problema para la addressablegema que cubre los ejemplos.

Utilizo una ligera variación en la solución lafeber anterior . No permite puntos consecutivos en el nombre de host (como por ejemplo en www.many...dots.com):

%r"\A(https?://)?[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]{2,6}(/.*)?\Z"i

URI.parseparece exigir el prefijo de esquema, que en algunos casos no es lo que puede desear (por ejemplo, si desea permitir que sus usuarios deletreen rápidamente URL en formas como twitter.com/username)

He estado usando la gema 'activevalidators' y funciona bastante bien (no solo para la validación de URL)

puedes encontrarlo aquí

Todo está documentado, pero básicamente una vez que se agregó la gema, querrá agregar las siguientes líneas en un inicializador, por ejemplo: /config/environments/initializers/active_validators_activation.rb

# Activate all the validators
ActiveValidators.activate(:all)

(Nota: puede reemplazar: todo por: url o: lo que sea si solo desea validar tipos específicos de valores)

Y luego en tu modelo algo como esto

class Url < ActiveRecord::Base
   validates :url, :presence => true, :url => true
end

Ahora reinicie el servidor y eso debería ser

Si desea una validación simple y un mensaje de error personalizado:

  validates :some_field_expecting_url_value,
            format: {
              with: URI.regexp(%w[http https]),
              message: 'is not a valid URL'
            }

Puede validar varias URL utilizando algo como:

validates_format_of [:field1, :field2], with: URI.regexp(['http', 'https']), allow_nil: true

https://github.com/perfectline/validates_url es una joya agradable y simple que hará casi todo por ti

Recientemente tuve este mismo problema y encontré una solución para las URL válidas.

validates_format_of :url, :with => URI::regexp(%w(http https))
validate :validate_url
def validate_url

  unless self.url.blank?

    begin

      source = URI.parse(self.url)

      resp = Net::HTTP.get_response(source)

    rescue URI::InvalidURIError

      errors.add(:url,'is Invalid')

    rescue SocketError 

      errors.add(:url,'is Invalid')

    end



  end

La primera parte del método validate_url es suficiente para validar el formato url. La segunda parte se asegurará de que la URL exista enviando una solicitud.

Me gustó monopatch el módulo URI para agregar el válido? método

dentro config/initializers/uri.rb

module URI
  def self.valid?(url)
    uri = URI.parse(url)
    uri.is_a?(URI::HTTP) && !uri.host.nil?
  rescue URI::InvalidURIError
    false
  end
end

Y como un modulo

module UrlValidator
  extend ActiveSupport::Concern
  included do
    validates :url, presence: true, uniqueness: true
    validate :url_format
  end

  def url_format
    begin
      errors.add(:url, "Invalid url") unless URI(self.url).is_a?(URI::HTTP)
    rescue URI::InvalidURIError
      errors.add(:url, "Invalid url")
    end
  end
end

Y luego, include UrlValidatoren cualquier modelo para el que desee validar las URL. Solo incluye opciones.

La validación de URL no se puede manejar simplemente mediante el uso de una expresión regular, ya que el número de sitios web sigue creciendo y siguen apareciendo nuevos esquemas de nombres de dominio.

En mi caso, simplemente escribo un validador personalizado que busca una respuesta exitosa.

class UrlValidator < ActiveModel::Validator
  def validate(record)
    begin
      url = URI.parse(record.path)
      response = Net::HTTP.get(url)
      true if response.is_a?(Net::HTTPSuccess)   
    rescue StandardError => error
      record.errors[:path] << 'Web address is invalid'
      false
    end  
  end
end

Estoy validando el pathatributo de mi modelo usando record.path. También estoy enviando el error al nombre del atributo respectivo usando record.errors[:path].

Simplemente puede reemplazar esto con cualquier nombre de atributo.

Luego, simplemente llamo al validador personalizado en mi modelo.

class Url < ApplicationRecord

  # validations
  validates_presence_of :path
  validates_with UrlValidator

end

Podrías usar regex para esto, para mí funciona bien este:

(^|[\s.:;?\-\]<\(])(ftp|https?:\/\/[-\w;\/?:@&=+$\|\_.!~*\|'()\[\]%#,]+[\w\/#](\(\))?)(?=$|[\s',\|\(\).:;?\-\[\]>\)])