Convalida per URL / Dominio usando Regex? (Rails)

Sto cercando di creare una convalida che controlli per assicurarsi che un dominio / url sia valido ad esempio “test.com”

def valid_domain_name? domain_name = domain.split(".") name = /(?:[A-Z0-9\-])+/.match(domain_name[0]).nil? tld = /(?:[AZ]{2}|aero|ag|asia|at|be|biz|ca|cc|cn|com|de|edu|eu|fm|gov|gs|jobs|jp|in|info|me|mil|mobi|museum|ms|name|net|nu|nz|org|tc|tw|tv|uk|us|vg|ws)/.match(domain_name[1]).nil? if name == false or tld == false errors.add(:domain_name, 'Invalid domain name. Please only use names with letters (AZ) and numbers (0-9).') end end 

Questo è quello che ho finora ma non funziona. Fa passare male gli URL senza fallire.

Non conosco regex molto bene.

Inciampato su questo:

 validates_format_of :domain_name, :with => /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[az]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix 

A proposito: Rubular è una risorsa fantastica per testare le tue espressioni regolari Ruby

@ La risposta di Tate è valida per un URL completo, ma se si desidera convalidare una colonna di domain , non si desidera consentire i bit URL aggiuntivi consentiti dalla regex (ad esempio, non si desidera consentire a un URL con un percorso di un file).

Così ho rimosso il protocollo, la porta, il percorso del file e le parti di stringa della regex, risultando in questo:

^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[az]{2,5}$


Controlla gli stessi casi di test per entrambe le versioni.

 ^(http|https):\/\/|[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[az]{2,6}(:[0-9]{1,5})?(\/.*)?$/ix 
  • example.com
  • sub.example.com
  • sub.domain.my-example.com
  • example.com/?stuff=true
  • example.com:5000/?stuff=true
  • sub.domain.my-example.com/path/to/file/hello.html
  • hello.museum
  • http://railsgirls.com

http://rubular.com/r/cdkLxAkTbk

Aggiunto http: // facoltativo o https: //

Il TLD più lungo è .museum , che ha 6 caratteri …

Lo è un altro modo per eseguire la convalida dell’URL in Rails

 validates :web_address, :format => { :with => URI::regexp(%w(http https)), :message => "Valid URL required"} 

Risposta migliore da quando Ruby 1.8.6

 require 'uri' def valid_domain_name?(domain_name) domain_name =~ URI::regexp(%w(http https)) end 

Quello che funziona per me è

 def validate_url(text) uri = URI.parse(text) raise URI::InvalidURIError unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS) rescue URI::InvalidURIError errors.add(:url, 'is invalid') end end 

Ho preso ciò che avevi e lo ho modificato in modo da poter rendere http:// o https:// opzionale:

 /^((http|https):\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[az]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix 

Secondo Google , questo funziona bene:

 /^([a-z0-9]([-a-z0-9]*[a-z0-9])?\\.)+((a[cdefgilmnoqrstuwxz]|aero|arpa)|(b[abdefghijmnorstvwyz]|biz)|(c[acdfghiklmnorsuvxyz]|cat|com|coop)|d[ejkmoz]|(e[ceghrstu]|edu)|f[ijkmor]|(g[abdefghilmnpqrstuwy]|gov)|h[kmnrtu]|(i[delmnoqrst]|info|int)|(j[emop]|jobs)|k[eghimnprwyz]|l[abcikrstuvy]|(m[acdghklmnopqrstuvwxyz]|mil|mobi|museum)|(n[acefgilopruz]|name|net)|(om|org)|(p[aefghklmnrstwy]|pro)|qa|r[eouw]|s[abcdeghijklmnortvyz]|(t[cdfghjklmnoprtvwz]|travel)|u[agkmsyz]|v[aceginu]|w[fs]|y[etu]|z[amw])$/i 

Un po ‘lungo …

Non fa distinzione tra maiuscole e minuscole … non assomiglia alle espressioni regex, ma non conosco Ruby. O forse li hai capitalizzati prima.

Mi piace questo plugin per la convalida degli URL: https://github.com/henrik/validates_url_format_of/tree

Usando la risposta di Brian Ray al di sopra della quale penso risponda alla domanda (dominio non url) e aggiornandola per Rails 4.

 /\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[az]{2,5}\z/ix 

Prova a regolare lo schema in modo che inizi con ^ (il carattere “inizia con”) e finisca con $ (“termina con”), in modo che l’intero modello legga “una stringa che inizia con questo e poi finisce”, altrimenti il la corrispondenza per il nome, ad esempio, sarà una corrispondenza positiva se il modello è stato trovato (cioè ha un solo carattere corretto).

 ^(([a-zA-Z]{1})|([a-zA-Z]{1}[a-zA-Z]{1})|([a-zA-Z]{1}[0-9]{1})|([0-9]{1}[a-zA-Z]{1})|([a-zA-Z0-9][a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]))\.([a-zA-Z]{2,6}|[a-zA-Z0-9-]{2,30}\.[a-zA-Z]{2,3})$ 

Convalida del nome di dominio con RegEx

Questo è il mio validatore di URL, usando il parser integrato di Ruby

 class UrlValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) p = URI::Parser.new valid = begin p.parse(value) true rescue false end unless valid record.errors[attribute] << (options[:message] || "is an invalid URL") end end end