Apa yang canggih dalam validasi email untuk Rails?

Apa yang Anda gunakan untuk memvalidasi alamat email pengguna, dan mengapa?

Saya telah menggunakan validates_email_veracity_ofyang sebenarnya menanyakan server MX. Tetapi itu penuh dengan kegagalan karena berbagai alasan, kebanyakan terkait dengan lalu lintas jaringan dan keandalan.

Saya melihat sekeliling dan saya tidak dapat menemukan sesuatu yang jelas bahwa banyak orang menggunakan untuk melakukan pemeriksaan kewarasan pada alamat email. Apakah ada plugin atau gem yang dipelihara dan cukup akurat untuk ini?

NB: Tolong jangan suruh saya mengirim email dengan link untuk melihat apakah email itu berfungsi. Saya sedang mengembangkan fitur "kirim ke teman", jadi ini tidak praktis.

Dengan Rails 3.0 Anda dapat menggunakan validasi email tanpa regexp menggunakan permata Mail .

Berikut adalah implementasi saya ( dikemas sebagai permata ).

Jangan membuat ini lebih sulit dari yang seharusnya. Fitur Anda tidak penting; validasi hanyalah langkah kewarasan dasar untuk menangkap kesalahan ketik. Saya akan melakukannya dengan regex sederhana, dan tidak menyia-nyiakan siklus CPU pada sesuatu yang terlalu rumit:

/\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/

Itu diadaptasi dari http://www.regular-expressions.info/email.html - yang harus Anda baca jika Anda benar-benar ingin mengetahui semua pengorbanan. Jika Anda menginginkan regex yang lebih benar dan jauh lebih rumit yang sepenuhnya sesuai dengan RFC822, itu juga ada di halaman itu. Tapi masalahnya adalah ini: Anda tidak harus melakukannya dengan benar.

Jika alamat tersebut lolos validasi, Anda akan mengirim email. Jika email gagal, Anda akan mendapatkan pesan kesalahan. Pada tahap mana Anda dapat memberi tahu pengguna "Maaf, teman Anda tidak menerimanya, apakah Anda ingin mencoba lagi?" atau tandai untuk peninjauan manual, atau abaikan saja, atau apa pun.

Ini adalah opsi yang sama yang harus Anda tangani jika alamat tersebut lolos validasi. Karena meskipun validasi Anda sempurna dan Anda memperoleh bukti mutlak bahwa alamat tersebut ada, pengiriman masih bisa gagal.

Biaya positif palsu pada validasi rendah. Manfaat validasi yang lebih baik juga rendah. Validasi dengan murah hati, dan khawatirkan kesalahan saat terjadi.

Saya membuat permata untuk validasi email di Rails 3. Saya agak terkejut bahwa Rails tidak menyertakan sesuatu seperti ini secara default.

http://github.com/balexand/email_validator

Proyek ini tampaknya memiliki paling banyak pengamat di github saat ini (untuk validasi email di rel):

https://github.com/alexdunae/validates_email_format_of

Dari dokumen Rails 4 :

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
      record.errors[attribute] << (options[:message] || "is not an email")
    end
  end
end

class Person < ActiveRecord::Base
  validates :email, presence: true, email: true
end

Di Rails 4 cukup tambahkan validates :email, email:true(dengan asumsi field Anda dipanggil email) ke model Anda dan kemudian tulis sederhana (atau kompleks †) EmailValidatoruntuk menyesuaikan dengan kebutuhan Anda.

misalnya: - model Anda:

class TestUser
  include Mongoid::Document
  field :email,     type: String
  validates :email, email: true
end

Validator Anda (masuk app/validators/email_validator.rb)

class EmailValidator < ActiveModel::EachValidator
  EMAIL_ADDRESS_QTEXT           = Regexp.new '[^\\x0d\\x22\\x5c\\x80-\\xff]', nil, 'n'
  EMAIL_ADDRESS_DTEXT           = Regexp.new '[^\\x0d\\x5b-\\x5d\\x80-\\xff]', nil, 'n'
  EMAIL_ADDRESS_ATOM            = Regexp.new '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+', nil, 'n'
  EMAIL_ADDRESS_QUOTED_PAIR     = Regexp.new '\\x5c[\\x00-\\x7f]', nil, 'n'
  EMAIL_ADDRESS_DOMAIN_LITERAL  = Regexp.new "\\x5b(?:#{EMAIL_ADDRESS_DTEXT}|#{EMAIL_ADDRESS_QUOTED_PAIR})*\\x5d", nil, 'n'
  EMAIL_ADDRESS_QUOTED_STRING   = Regexp.new "\\x22(?:#{EMAIL_ADDRESS_QTEXT}|#{EMAIL_ADDRESS_QUOTED_PAIR})*\\x22", nil, 'n'
  EMAIL_ADDRESS_DOMAIN_REF      = EMAIL_ADDRESS_ATOM
  EMAIL_ADDRESS_SUB_DOMAIN      = "(?:#{EMAIL_ADDRESS_DOMAIN_REF}|#{EMAIL_ADDRESS_DOMAIN_LITERAL})"
  EMAIL_ADDRESS_WORD            = "(?:#{EMAIL_ADDRESS_ATOM}|#{EMAIL_ADDRESS_QUOTED_STRING})"
  EMAIL_ADDRESS_DOMAIN          = "#{EMAIL_ADDRESS_SUB_DOMAIN}(?:\\x2e#{EMAIL_ADDRESS_SUB_DOMAIN})*"
  EMAIL_ADDRESS_LOCAL_PART      = "#{EMAIL_ADDRESS_WORD}(?:\\x2e#{EMAIL_ADDRESS_WORD})*"
  EMAIL_ADDRESS_SPEC            = "#{EMAIL_ADDRESS_LOCAL_PART}\\x40#{EMAIL_ADDRESS_DOMAIN}"
  EMAIL_ADDRESS_PATTERN         = Regexp.new "#{EMAIL_ADDRESS_SPEC}", nil, 'n'
  EMAIL_ADDRESS_EXACT_PATTERN   = Regexp.new "\\A#{EMAIL_ADDRESS_SPEC}\\z", nil, 'n'

  def validate_each(record, attribute, value)
    unless value =~ EMAIL_ADDRESS_EXACT_PATTERN
      record.errors[attribute] << (options[:message] || 'is not a valid email')
    end
  end
end

Ini akan mengizinkan semua jenis email yang valid, termasuk email yang diberi tag seperti "test+no_really@test.tes" dan seterusnya.

Untuk mengujinya dengan rspecdispec/validators/email_validator_spec.rb

require 'spec_helper'

describe "EmailValidator" do
  let(:validator) { EmailValidator.new({attributes: [:email]}) }
  let(:model) { double('model') }

  before :each do
    model.stub("errors").and_return([])
    model.errors.stub('[]').and_return({})  
    model.errors[].stub('<<')
  end

  context "given an invalid email address" do
    let(:invalid_email) { 'test test tes' }
    it "is rejected as invalid" do
      model.errors[].should_receive('<<')
      validator.validate_each(model, "email", invalid_email)
    end  
  end

  context "given a simple valid address" do
    let(:valid_simple_email) { 'test@test.tes' }
    it "is accepted as valid" do
      model.errors[].should_not_receive('<<')    
      validator.validate_each(model, "email", valid_simple_email)
    end
  end

  context "given a valid tagged address" do
    let(:valid_tagged_email) { 'test+thingo@test.tes' }
    it "is accepted as valid" do
      model.errors[].should_not_receive('<<')    
      validator.validate_each(model, "email", valid_tagged_email)
    end
  end
end

Begitulah cara saya melakukannya. YMMV

† Ekspresi reguler seperti kekerasan; jika tidak berfungsi, Anda tidak cukup menggunakannya.

Seperti yang disarankan Hallelujah, saya pikir menggunakan permata Mail adalah pendekatan yang baik. Namun, saya tidak menyukai beberapa rintangan di sana.

Saya menggunakan:

def self.is_valid?(email) 

  parser = Mail::RFC2822Parser.new
  parser.root = :addr_spec
  result = parser.parse(email)

  # Don't allow for a TLD by itself list (sam@localhost)
  # The Grammar is: (local_part "@" domain) / local_part ... discard latter
  result && 
     result.respond_to?(:domain) && 
     result.domain.dot_atom_text.elements.size > 1
end

Anda bisa lebih tegas dengan menuntut agar TLD (domain tingkat atas) ada dalam daftar ini , namun Anda akan dipaksa untuk memperbarui daftar itu sebagai TLD baru yang muncul (seperti penambahan tahun 2012 .mobidan .tel)

Keuntungan dari mengaitkan parser langsung adalah bahwa aturan dalam tata bahasa Mail cukup lebar untuk bagian-bagian yang digunakan permata Mail, ia dirancang untuk memungkinkannya mengurai alamat seperti user<user@example.com>yang umum untuk SMTP. Dengan mengonsumsinya dari Mail::AddressAnda dipaksa untuk melakukan banyak pemeriksaan tambahan.

Catatan lain tentang permata Mail, meskipun kelasnya disebut RFC2822, tata bahasanya memiliki beberapa elemen RFC5322 , misalnya tes ini .

Di Rails 3 dimungkinkan untuk menulis validator yang dapat digunakan kembali , karena pos hebat ini menjelaskan:

http://archives.ryandaigle.com/articles/2009/8/11/what-s-new-in-edge-rails-independent-model-validators

class EmailValidator < ActiveRecord::Validator   
  def validate()
    record.errors[:email] << "is not valid" unless
    record.email =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i   
  end
end

dan gunakan dengan validates_with:

class User < ActiveRecord::Base   
  validates_with EmailValidator
end

Memperhatikan jawaban lainnya, pertanyaannya masih tersisa - mengapa repot-repot menjadi pintar tentang itu?

Volume kasus edge sebenarnya yang mungkin ditolak atau dilewatkan oleh banyak regex tampaknya bermasalah.

Saya rasa pertanyaannya adalah 'apa yang saya coba capai?', Meskipun Anda 'memvalidasi' alamat email tersebut, Anda sebenarnya tidak memvalidasi bahwa itu adalah alamat email yang berfungsi.

Jika Anda menggunakan regexp, cukup periksa keberadaan @ di sisi klien.

Adapun skenario email yang salah, memiliki cabang 'pesan gagal mengirim' ke kode Anda.

Pada dasarnya ada 3 opsi paling umum:

1. Regexp (tidak ada regexp alamat email yang berfungsi untuk semua, jadi buat alamat email Anda sendiri)
2. Kueri MX (itulah yang Anda gunakan)
3. Menghasilkan token aktivasi dan mengirimkannya (cara restful_authentication)

Jika Anda tidak ingin menggunakan validates_email_veracity_of dan pembuatan token, saya akan menggunakan pemeriksaan regexp sekolah lama.

Permata Mail memiliki pengurai alamat bawaan.

begin
  Mail::Address.new(email)
  #valid
rescue Mail::Field::ParseError => e
  #invalid
end

Solusi ini didasarkan pada jawaban oleh @SFEley dan @Alessandro DS, dengan refactor, dan klarifikasi penggunaan.

Anda dapat menggunakan kelas validator ini dalam model Anda seperti:

class MyModel < ActiveRecord::Base
  # ...
  validates :colum, :email => { :allow_nil => true, :message => 'O hai Mark!' }
  # ...
end

Mengingat Anda memiliki yang berikut di app/validatorsfolder Anda (Rails 3):

class EmailValidator < ActiveModel::EachValidator

  def validate_each(record, attribute, value)
    return options[:allow_nil] == true if value.nil?

    unless matches?(value)
      record.errors[attribute] << (options[:message] || 'must be a valid email address')
    end
  end

  def matches?(value)
    return false unless value

    if /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/.match(value).nil?
      false
    else
      true
    end

  end
end

Untuk Validasi Milis . (Saya menggunakan Rails 4.1.6)

Saya mendapatkan regexp saya dari sini . Tampaknya ini sangat lengkap, dan telah diuji terhadap banyak kombinasi. Anda dapat melihat hasilnya di halaman itu.

Saya sedikit mengubahnya menjadi Ruby regexp, dan memasukkannya ke file lib/validators/email_list_validator.rb

Berikut kodenya:

require 'mail'

class EmailListValidator < ActiveModel::EachValidator

  # Regexp source: https://fightingforalostcause.net/content/misc/2006/compare-email-regex.php
  EMAIL_VALIDATION_REGEXP   = Regexp.new('\A(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){255,})(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){65,}@)(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22))(?:\.(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-[a-z0-9]+)*)|(?:\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\]))\z', true)

  def validate_each(record, attribute, value)
    begin
      invalid_emails = Mail::AddressList.new(value).addresses.map do |mail_address|
        # check if domain is present and if it passes validation through the regex
        (mail_address.domain.present? && mail_address.address =~ EMAIL_VALIDATION_REGEXP) ? nil : mail_address.address
      end

      invalid_emails.uniq!
      invalid_emails.compact!
      record.errors.add(attribute, :invalid_emails, :emails => invalid_emails.to_sentence) if invalid_emails.present?
    rescue Mail::Field::ParseError => e

      # Parse error on email field.
      # exception attributes are:
      #   e.element : Kind of element that was wrong (in case of invalid addres it is Mail::AddressListParser)
      #   e.value: mail adresses passed to parser (string)
      #   e.reason: Description of the problem. A message that is not very user friendly
      if e.reason.include?('Expected one of')
        record.errors.add(attribute, :invalid_email_list_characters)
      else
        record.errors.add(attribute, :invalid_emails_generic)
      end
    end
  end

end

Dan saya menggunakannya seperti ini dalam model:

validates :emails, :presence => true, :email_list => true

Ini akan memvalidasi milis seperti ini, dengan pemisah dan sintaks yang berbeda:

mail_list = 'John Doe <john@doe.com>, chuck@schuld.dea.th; David G. <david@pink.floyd.division.bell>'

Sebelum menggunakan regexp ini, saya menggunakan Devise.email_regexp, tapi itu regexp yang sangat sederhana dan tidak mendapatkan semua kasus yang saya butuhkan. Beberapa email terbentur.

Saya mencoba regex lain dari web, tapi yang ini mendapatkan hasil terbaik sampai sekarang. Semoga membantu dalam kasus Anda.