रेलें: लिंक (URL) को मान्य करने का एक अच्छा तरीका क्या है?

125

मैं सोच रहा था कि मैं रेल में URL को कैसे मान्य करूंगा। मैं एक नियमित अभिव्यक्ति का उपयोग करने के बारे में सोच रहा था, लेकिन मुझे यकीन नहीं है कि यह सबसे अच्छा अभ्यास है।

और, अगर मैं एक रेगीक्स का उपयोग कर रहा था, तो क्या कोई मुझे एक सुझाव दे सकता है? मैं अभी भी रेगेक्स के लिए नया हूं।

ruby-on-rails  ruby  regex  validation  url 
— नीलकंठ
स्रोत
— जॉन श्नाइडर

जवाबों:

151

URL मान्य करना एक मुश्किल काम है। यह एक बहुत व्यापक अनुरोध भी है।

तुम क्या करना चाहते हो, बिल्कुल? क्या आप URL के स्वरूप, अस्तित्व या क्या को मान्य करना चाहते हैं? कई संभावनाएं हैं, जो आप करना चाहते हैं उसके आधार पर।

एक नियमित अभिव्यक्ति URL के प्रारूप को मान्य कर सकती है। लेकिन यहां तक ​​कि एक जटिल नियमित अभिव्यक्ति यह सुनिश्चित नहीं कर सकती है कि आप एक वैध URL के साथ काम कर रहे हैं।

उदाहरण के लिए, यदि आप एक सरल नियमित अभिव्यक्ति लेते हैं, तो यह संभवतः निम्नलिखित होस्ट को अस्वीकार कर देगा

http://invalid##host.com

लेकिन यह अनुमति देगा

http://invalid-host.foo

यदि आप मौजूदा TLD पर विचार करते हैं तो यह एक मान्य होस्ट है, लेकिन एक मान्य डोमेन नहीं है। वास्तव में, समाधान तब काम करेगा जब आप होस्टनाम को मान्य करना चाहते हैं, न कि डोमेन क्योंकि निम्नलिखित एक मान्य होस्टनाम है

http://host.foo

निम्नलिखित के रूप में अच्छी तरह से

http://localhost

अब, मैं आपको कुछ समाधान देता हूं।

यदि आप एक डोमेन को मान्य करना चाहते हैं, तो आपको नियमित अभिव्यक्ति के बारे में भूलने की आवश्यकता है। फिलहाल उपलब्ध सबसे अच्छा समाधान सार्वजनिक प्रत्यय सूची, मोज़िला द्वारा रखी गई सूची है। मैंने सार्वजनिक प्रत्यय सूची के खिलाफ डोमेन को पार्स और मान्य करने के लिए एक रूबी लाइब्रेरी बनाई, और इसे पब्लिकसफिक्स कहा जाता है ।

यदि आप URI / URL के प्रारूप को मान्य करना चाहते हैं, तो आप नियमित अभिव्यक्तियों का उपयोग करना चाह सकते हैं। एक की खोज करने के बजाय, अंतर्निहित रूबी URI.parseविधि का उपयोग करें।

require 'uri'

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

आप इसे और अधिक प्रतिबंधक बनाने का निर्णय भी ले सकते हैं। उदाहरण के लिए, यदि आप चाहते हैं कि URL HTTP / HTTPS URL हो, तो आप सत्यापन को अधिक सटीक बना सकते हैं।

require 'uri'

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

बेशक, इस पद्धति पर कई सुधार हो सकते हैं, जिसमें पथ या योजना की जाँच करना शामिल है।

अंतिम लेकिन कम से कम, आप इस कोड को एक सत्यापनकर्ता में भी पैकेज कर सकते हैं:

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
— सिमोन कारलेटी
स्रोत
1
ध्यान दें कि वर्ग URI::HTTPShttps uris (उदा:URI.parse("https://yo.com").class => URI::HTTPS
— te
12
URI::HTTPSइनहेरिट करता है URI:HTTP, यही कारण है कि मैं इसका उपयोग करता हूं kind_of?।
— सिमोन कारलेटी
1
किसी URL को सुरक्षित रूप से मान्य करने के लिए अब तक का सबसे पूर्ण समाधान।
— फबरीज़ो रागिनी
4
URI.parse('http://invalid-host.foo')सही है क्योंकि URI एक मान्य URL है। यह भी ध्यान दें कि .fooअब एक वैध TLD है। iana.org/domains/root/db/foo.html
— सिमोन कारलेटी
1
@jmccartie कृपया पूरी पोस्ट पढ़ें। यदि आप योजना के बारे में परवाह करते हैं, तो आपको अंतिम कोड का उपयोग करना चाहिए, जिसमें एक प्रकार की जांच भी शामिल है, न कि केवल उस रेखा पर। आपने पोस्ट के अंत से पहले पढ़ना बंद कर दिया।
— सिमोन कारलेटी
101

मैं अपने मॉडल के अंदर एक लाइनर का उपयोग करता हूं:

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

मुझे लगता है कि उपयोग करने के लिए काफी अच्छा और सरल है। इसके अलावा यह सैद्धांतिक रूप से सिमोन की विधि के समतुल्य होना चाहिए, क्योंकि यह आंतरिक रूप से बहुत ही रीजैक्स का उपयोग करता है।

— मत्तेओ कोलिना
स्रोत
17
दुर्भाग्य 'http://'से उपरोक्त पैटर्न से मेल खाता है। देखें:URI::regexp(%w(http https)) =~ 'http://'
— डेविड जे।
15
साथ ही एक url http:fakeभी मान्य होगा।
— नथ्नवाड़ा ११'१२ को
54

सिमोन के विचार के बाद, आप आसानी से अपना सत्यापनकर्ता बना सकते हैं।

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

और फिर उपयोग करें 

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

अपने मॉडल में।

— jlfenaux
स्रोत
1
मुझे यह वर्ग कहां रखना चाहिए? इनिशियलाइज़र में?
— deb
3
मैं @gbc से उद्धृत करता हूं: "यदि आप अपने कस्टम सत्यापनकर्ताओं को ऐप / सत्यापनकर्ताओं में रखते हैं तो वे आपकी config / application.rb फ़ाइल को बदलने की आवश्यकता के बिना स्वचालित रूप से लोड हो जाएंगे।" ( stackoverflow.com/a/6610270/839847 )। ध्यान दें कि स्टीफन पेटर्सन के नीचे दिए गए जवाब से पता चलता है कि उन्होंने "ऐप / वैलिडेटर्स" में भी इसी तरह की फाइल सेव की थी।
— bergie3000
4
यह तभी जाँचता है जब url http: // या https: // से शुरू होता है, यह एक उचित URL सत्यापन नहीं है
— maggix
1
यदि आप URL को वैकल्पिक होने के लिए खर्च कर सकते हैं तो समाप्त करें: क्लास OptionalUrlValidator <UrlValidator मान validate_each (रिकॉर्ड, विशेषता, मान) सही है यदि value.blank? सुपर एंड एंड लौटें
— डर्टी हेनरी
1
यह एक अच्छा मान्यता नहीं है:URI("http:").kind_of?(URI::HTTP) #=> true
— smathy
29

वहाँ भी है validate_url रत्न (जो सिर्फ एक अच्छा आवरण हैAddressable::URI.parse समाधान के )।

बस जोड़ दो 

gem 'validate_url'

अपने Gemfile, और फिर मॉडल में आप कर सकते हैं

validates :click_through_url, url: true
— dolzenko
स्रोत
@ ЕнвгенийМасленков जो सिर्फ इसलिए हो सकता है क्योंकि इसकी कल्पना युक्ति के अनुसार मान्य है, लेकिन आप github.com/sporkmonger/addressable/issues की जाँच करना चाहते हैं । सामान्य मामले में भी हमने पाया है कि कोई भी मानक का पालन नहीं करता है और इसके बजाय सरल प्रारूप सत्यापन का उपयोग कर रहा है।
— dolzenko
13

यह सवाल पहले से ही उत्तर है, लेकिन क्या बिल्ली, मैं उस समाधान का प्रस्ताव करता हूं जिसका मैं उपयोग कर रहा हूं।

Regexp मेरे द्वारा मिले सभी url के साथ ठीक काम करता है। यदि प्रोटोकॉल का उल्लेख नहीं किया जाता है (तो मान लें कि http: //)।

और अंत में, हम पेज लाने की कोशिश करते हैं। शायद मुझे रीडायरेक्ट स्वीकार करना चाहिए न कि केवल HTTP 200 ओके।

# 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

तथा...

# 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
— स्टीफन पेटर्सन
स्रोत
वास्तव में साफ! आपके इनपुट के लिए धन्यवाद, अक्सर एक समस्या के कई दृष्टिकोण होते हैं; यह बहुत अच्छा है जब लोग अपने शेयर करते हैं।
— जय
6
बस यह इंगित करना चाहता था कि रेल सुरक्षा गाइड के अनुसार आपको उस regexp में $ ^ के बजाय \ A और \ z का उपयोग करना चाहिए
— Jared
1
मुझें यह पसंद है। क्विज़ को सत्यापनकर्ता में ले जाकर कोड को थोड़ा सूखने का त्वरित सुझाव, क्योंकि मुझे लगता है कि आप चाहते हैं कि यह पूरे मॉडल के अनुरूप हो। बोनस: यह आपको validate_each के तहत पहली पंक्ति छोड़ने की अनुमति देगा।
— पॉल पेटेंगेंग
क्या होगा अगर url लंबा और समयबाह्य ले रहा है? टाइमआउट त्रुटि संदेश दिखाने के लिए सबसे अच्छा विकल्प क्या होगा या यदि पेज नहीं खोला जा सकता है?
— user588324
यह कभी भी सुरक्षा ऑडिट को पारित नहीं करेगा, आप अपने सर्वरों को एक मनमाने ढंग से url
— मौरिसियो
12

आप valid_url भी आज़मा सकते हैं मणि जो बिना स्कीम के URL की अनुमति देता है, डोमेन ज़ोन और आईपी-होस्टनाम की जाँच करता है।

इसे अपने जेमफाइल में जोड़ें:

gem 'valid_url'

और फिर मॉडल में:

class WebSite < ActiveRecord::Base
  validates :url, :url => true
end
— रोमन राल्टोव्स
स्रोत
यह बहुत अच्छा है, विशेष रूप से बिना योजना के URL, जो URI वर्ग के साथ आश्चर्यजनक रूप से शामिल है।
— पॉल पेटेंगेंग
आईपी ​​आधारित यूआरएल के माध्यम से खुदाई करने और फर्जी लोगों का पता लगाने की इस मणि की क्षमता से मैं हैरान था। धन्यवाद!
— द ओज
10

बस मेरे 2 सेंट:

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

संपादित करें: पैरामीटर url से मिलान करने के लिए बदला हुआ रेक्स।

— lafeber
स्रोत
1
अपने इनपुट, हमेशा अच्छे के लिए धन्यवाद विभिन्न समाधान को देखने के लिए
— जय
Btw, आपका regexp मान्य स्ट्रिंग को क्वेरी स्ट्रिंग के साथ अस्वीकार कर देगा जैसेhttp://test.com/fdsfsdf?a=b
— MikDiet
2
हमने इस कोड को उत्पादन में डाल दिया और .match regex लाइन पर अनंत छोरों पर टाइमआउट प्राप्त करते रहे। निश्चित नहीं है कि, सिर्फ कुछ कॉर्नसेकस के लिए सावधानी बरतें और ऐसा क्यों होता है, इस पर अन्य विचारों को सुनना पसंद करेंगे।
— टोबुलकेह
10

मेरे लिए काम करने वाला समाधान था:

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

मैंने आपके द्वारा संलग्न किए गए कुछ उदाहरणों का उपयोग करने की कोशिश की, लेकिन मैं url का समर्थन कर रहा हूं:

A और Z के उपयोग पर ध्यान दें क्योंकि यदि आप ^ और $ का उपयोग करते हैं, तो आप रेल सत्यापनकर्ताओं से यह चेतावनी सुरक्षा देखेंगे।

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

 Invalid ones:
  'http://www.crowdint. com'
  'http://fake'
  'http:fake'
— हर्बेरेटो पेरेज़
स्रोत
1
इसके साथ प्रयास करें "https://portal.example.com/portal/#"। रूबी 2.1.6 में मूल्यांकन लटका हुआ है।
— पुराना प्रो
आप सही कह रहे हैं कि कुछ मामलों में इस नियमित अभिव्यक्ति को हल करने में हमेशा के लिए लग जाता है :(
— हेइब्रेटो पेरेज़
1
जाहिर है, ऐसा कोई रेगेक्स नहीं है जो हर परिदृश्य को कवर करता है, इसीलिए मैं केवल एक साधारण सत्यापन का उपयोग करके समाप्त कर रहा हूं: मान्य: url, प्रारूप: {with: URI.regexp}, अगर: Proc.new {| a | a.url.present? }
— हर्बेरेटो पेरेज़
5

मैं हाल ही में एक ही समस्या में भाग गया था (मुझे एक रेल एप्लिकेशन में यूआरएल को मान्य करने की आवश्यकता थी) लेकिन मुझे यूनिकोड यूआरएल (जैसे http://кц.рф) की अतिरिक्त आवश्यकता का सामना करना पड़ा ...

मैंने कुछ समाधानों पर शोध किया और निम्नलिखित में आया:

  • पहली और सबसे सुझाई गई चीज का उपयोग कर रहा है URI.parse। विवरण के लिए सिमोन कारलेटी द्वारा उत्तर की जाँच करें। यह ठीक काम करता है, लेकिन यूनिकोड यूआरएल के लिए नहीं।
  • दूसरी विधि जो मैंने देखी , वह थी इलिया ग्रिगोरिक: http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/ मूल रूप से, वह एक अनुरोध करने की कोशिश करता है। यूआरएल; यदि यह काम करता है, तो यह वैध है ...
  • तीसरी विधि मैंने पाया (और एक मैं पसंद करते हैं) के लिए इसी तरह एक दृष्टिकोण है URI.parse, लेकिन का उपयोग कर addressableके बजाय मणि URIstdlib। यह दृष्टिकोण यहाँ विस्तृत है: http://rawsyntax.com/blog/url-validation-in-rails-3-and-ruby-in-general/
— severin
स्रोत
हाँ, लेकिन Addressable::URI.parse('http:///').scheme # => "http"Addressable::URI.parse('Съешь [же] ещё этих мягких французских булок да выпей чаю')
— पते
4

यहां डेविड जेम्स द्वारा पोस्ट किए गए सत्यापनकर्ता का एक अद्यतन संस्करण है । इसे बेंजामिन फ्लीशर द्वारा प्रकाशित किया गया है । इस बीच, मैंने एक अद्यतन कांटा धक्का दिया जो यहां पाया जा सकता है ।

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

कृपया ध्यान दें कि अभी भी अजीब HTTP URI हैं जिन्हें मान्य पते के रूप में पार्स किया गया है।

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

यहां मणि के लिएaddressable एक मुद्दा है जो उदाहरणों को कवर करता है।

— JJD
स्रोत
3

मैं ऊपर दिए गए लम्बर समाधान पर थोड़ी भिन्नता का उपयोग करता हूं । यह होस्टनाम में लगातार डॉट्स को बंद करता है (जैसे कि उदाहरण के लिए www.many...dots.com):

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

URI.parseऐसा लगता है कि स्कीम प्रीफ़िक्सिंग कर रही है, जो कुछ मामलों में नहीं है जो आप चाहते हैं (उदाहरण के लिए, यदि आप अपने उपयोगकर्ताओं को URL को जल्दी से फ़ॉर्म में रखने की अनुमति देना चाहते हैं जैसे twitter.com/username)

— फ्रेंको
स्रोत
2

मैं 'activevalidators' मणि का उपयोग कर रहा हूं और यह बहुत अच्छी तरह से काम करता है (न कि केवल urls सत्यापन के लिए)

आप इसे यहाँ पा सकते हैं

यह सब प्रलेखित है, लेकिन मूल रूप से एक बार मणि जोड़ने के बाद आप एक इनिशियलाइज़र में निम्नलिखित कुछ पंक्तियों को जोड़ना चाहते हैं:

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

(नोट: आप प्रतिस्थापित कर सकते हैं: सभी द्वारा: url या: जो भी यदि आप केवल विशिष्ट प्रकार के मूल्यों को मान्य करना चाहते हैं)

और फिर वापस अपने मॉडल में कुछ इस तरह से

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

अब सर्वर को पुनरारंभ करें और यह होना चाहिए

— अरनौद बुचोट
स्रोत
2

यदि आप साधारण सत्यापन और एक कस्टम त्रुटि संदेश चाहते हैं:

  validates :some_field_expecting_url_value,
            format: {
              with: URI.regexp(%w[http https]),
              message: 'is not a valid URL'
            }
— कालेब
स्रोत
1

आप कुछ का उपयोग करके कई यूआरएल को मान्य कर सकते हैं:

validates_format_of [:field1, :field2], with: URI.regexp(['http', 'https']), allow_nil: true
— डेमियन रोशे
स्रोत
1
आप इस योजना के बिना URL को कैसे संभालेंगे (जैसे www.bar.com/foo)?
— क्रेग
1

हाल ही में मेरे पास यही मुद्दा था और मुझे वैध यूआरएल के लिए एक काम मिला। 

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

Validate_url विधि का पहला भाग url प्रारूप को मान्य करने के लिए पर्याप्त है। दूसरा भाग एक अनुरोध भेजकर सुनिश्चित करेगा कि url मौजूद है।

— Dilnavaz
स्रोत
क्या होगा अगर यूआरएल एक संसाधन की ओर इशारा करता है जो बहुत बड़ा है (कहते हैं, कई गीगाबाइट्स)?
— जॉन श्नाइडर
@JonSchneider प्राप्त करने के बजाय http हेड अनुरोध (जैसे यहां ) का उपयोग कर सकता है।
— वेवगेन
1

मुझे वैध जोड़ने के लिए URI मॉड्यूल को बंद करना पसंद है? तरीका

के भीतर 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
— ब्लेयर एंडरसन
स्रोत
0

और एक मॉड्यूल के रूप में

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

और फिर बस include UrlValidatorकिसी भी मॉडल में जिसे आप url के लिए मान्य करना चाहते हैं। सिर्फ विकल्पों के लिए शामिल हैं।

— एमसीबी
स्रोत
0

नियमित रूप से अभिव्यक्ति का उपयोग करके URL सत्यापन को नियंत्रित नहीं किया जा सकता है क्योंकि वेबसाइटों की संख्या बढ़ती रहती है और नई डोमेन नामकरण योजनाएं आती रहती हैं।

मेरे मामले में, मैं बस एक कस्टम सत्यापनकर्ता लिखता हूं जो एक सफल प्रतिक्रिया के लिए जांच करता है।

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

मैं pathउपयोग करके अपने मॉडल की विशेषता को मान्य कर रहा हूं record.path। मैं त्रुटि का उपयोग करके संबंधित विशेषता नाम पर भी जोर दे रहा हूं record.errors[:path]।

आप इसे किसी भी विशेषता नाम के साथ बदल सकते हैं।

फिर, मैं बस अपने मॉडल में कस्टम सत्यापनकर्ता कहता हूं।

class Url < ApplicationRecord

  # validations
  validates_presence_of :path
  validates_with UrlValidator

end
— नोमान उर रहमान
स्रोत
क्या होगा अगर यूआरएल एक संसाधन की ओर इशारा करता है जो बहुत बड़ा है (कहते हैं, कई गीगाबाइट्स)?
— जॉन श्नाइडर
0

आप इसके लिए regex का उपयोग कर सकते हैं, मेरे लिए यह अच्छा काम करता है:

(^|[\s.:;?\-\]<\(])(ftp|https?:\/\/[-\w;\/?:@&=+$\|\_.!~*\|'()\[\]%#,]+[\w\/#](\(\))?)(?=$|[\s',\|\(\).:;?\-\[\]>\)])
— spirito_libero
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.