Який рівень техніки перевіряє електронну пошту для Rails?

Що ви використовуєте для перевірки електронних адрес користувачів і чому?

Я використовував, validates_email_veracity_ofякі насправді запитують сервери MX. Але це повне збоїв з різних причин, здебільшого пов'язаних з мережевим трафіком та надійністю.

Я озирнувся і не зміг знайти нічого очевидного, що багато людей використовують для перевірки стану здоров'я на адресу електронної пошти. Чи існує для цього підтримуваний, досить точний плагін чи самоцвіт?

PS: Будь ласка, не кажіть мені відправляти електронне повідомлення з посиланням, щоб перевірити, чи працює електронне повідомлення. Я розробляю функцію "надіслати другові", тому це не практично.

У Rails 3.0 ви можете використовувати перевірку електронної пошти без регулярних виразів, використовуючи поштовий камінь Mail .

Ось моя реалізація ( упакована як самоцвіт ).

Не ускладнюйте це, ніж потрібно. Ваша функція некритична; перевірка - це лише основний розумний крок, щоб вловити помилки. Я б зробив це за допомогою простого регулярного виразу, і не витрачав би цикли процесора на щось занадто складне:

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

Це було адаптовано з http://www.regular-expressions.info/email.html - яке вам слід прочитати, якщо ви дійсно хочете знати всі компроміси. Якщо ви хочете отримати більш правильний і набагато складніший, повністю сумісний з RFC822 регулярний вираз, це теж на цій сторінці. Але справа в наступному: вам не потрібно все правильно розуміти.

Якщо адреса пройде перевірку, ви надішлете електронне повідомлення. Якщо повідомлення електронної пошти не вдається, ви отримаєте повідомлення про помилку. На цьому етапі ви можете сказати користувачеві "Вибачте, ваш друг цього не отримав, чи хочете ви спробувати ще раз?" або позначте його для ручного перегляду, або просто ігноруйте, або що завгодно.

Це ті ж самі опції , які ви хочете мати справу з тим, якщо адреса дійсно проходить перевірку. Тому що навіть якщо ваша перевірка досконала і ви отримаєте абсолютний доказ існування адреси, надсилання все одно може не вдатися.

Вартість помилково позитивного результату перевірки низька. Перевага від кращої перевірки також низька. Щедро перевіряйте і турбуйтеся про помилки, коли вони трапляються.

Я створив дорогоцінний камінь для перевірки електронної пошти в Rails 3. Я напевно здивований, що Rails за замовчуванням не включає щось подібне.

http://github.com/balexand/email_validator

На даний момент у цьому проекті найбільше спостерігачів на github (для перевірки електронної пошти на рейках):

https://github.com/alexdunae/validates_email_format_of

З Rails 4 docs :

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

У Rails 4 просто додайте validates :email, email:true(припускаючи, що ваше поле викликається email) до вашої моделі, а потім напишіть простий (або складний †)EmailValidator відповідно до ваших потреб.

наприклад: - Ваша модель:

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

Ваш валідатор (заходить 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

Це дозволить отримувати всі види дійсних електронних листів, включаючи електронні листи з тегами, такі як "test+no_really@test.tes" тощо.

Щоб перевірити це за допомогою rspecвашогоspec/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

Ось як я це зробив у будь-якому випадку. YMMV

† Регулярні висловлювання подібні до насильства; якщо вони не працюють, ви використовуєте недостатньо їх.

Як припускає Алілуя, я вважаю, що використання дорогоцінного каменя Mail - хороший підхід. Однак мені не подобаються деякі обручі там.

Я використовую:

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

Ви можете бути жорсткішими, вимагаючи, щоб TLD (домени верхнього рівня) були в цьому списку , однак ви були б змушені оновити цей список у міру появи нових TLD (наприклад, доповнення 2012 .mobiта .tel)

Перевага прямого підключення синтаксичного аналізатора полягає в тому, що правила в граматиці пошти досить широкі для частин, які використовує самоцвіт Mail, він призначений для аналізу адреси, подібної user<user@example.com>до загальної для SMTP. Споживаючи його від Mail::Addressвас, ви змушені робити купу додаткових перевірок.

Ще одна примітка щодо самоцвіту Mail, хоча клас називається RFC2822, граматика містить деякі елементи RFC5322 , наприклад цей тест .

У Rails 3 можна написати багаторазовий валідатор, як пояснюється в цій чудовій публікації:

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

і використовувати його з validates_with:

class User < ActiveRecord::Base   
  validates_with EmailValidator
end

Відзначаючи інші відповіді, все ще залишається питання - навіщо турбуватися про це розумно?

Фактичний обсяг крайових випадків, який багато регулярних виразів може заперечити або пропустити, здається проблематичним.

Я думаю, що питання полягає в тому, "що я намагаюся отримати?", Навіть якщо ви "перевіряєте" електронну адресу, ви насправді не підтверджуєте, що це робоча електронна адреса.

Якщо ви використовуєте регулярний вираз, просто перевірте наявність @ на стороні клієнта.

Що стосується неправильного сценарію електронної пошти, у вашому коді є гілка "повідомлення не вдалося надіслати".

В основному є 3 найпоширеніші варіанти:

1. Regexp (регулярний вираз для електронної пошти, що працює для всіх, не існує, тому прокрутіть свій власний)
2. Запит MX (саме цим ви користуєтесь)
3. Створення маркера активації та відправлення його поштою (спосіб restful_authentication)

Якщо ви не хочете використовувати як validates_email_veracity_of, так і генерацію токенів, я б скористався перевіркою регулярних виразів старої школи.

У самоцвіті Mail вбудований синтаксичний аналізатор адрес.

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

Це рішення базується на відповідях @SFEley та @Alessandro DS, з рефактором та роз'ясненнями щодо використання.

Ви можете використовувати цей клас валідатора у своїй моделі так:

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

З огляду на те, що у вашій app/validatorsпапці є (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

Для перевірки списків розсилки . (Я використовую Rails 4.1.6)

Я отримав свій регулярний вираз звідси . Здається, він дуже повний, і його перевіряли на великій кількості комбінацій. Результати ви можете побачити на цій сторінці.

Я трохи змінив його на регулярний вираз Ruby і помістив у свій lib/validators/email_list_validator.rb

Ось код:

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

І я використовую це так у моделі:

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

Він перевірить списки розсилки, як цей, з різними роздільниками та синтаксисом:

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

До того, як використовувати цей регулярний вираз, я використовував Devise.email_regexp, але це дуже простий регулярний вираз, і я не отримав усіх необхідних випадків. Деякі електронні листи зіткнулись.

Я спробував інші регулярні вирази з Інтернету, але цей отримав найкращі результати дотепер. Сподіваюся, це допоможе у вашому випадку.