Каков современный уровень проверки электронной почты для Rails? - PullRequest
95 голосов
/ 21 июля 2009

Что вы используете для проверки адресов электронной почты пользователей и почему?

Я использовал validates_email_veracity_of, который фактически запрашивает серверы MX. Но это полно неудач по разным причинам, в основном связанным с сетевым трафиком и надежностью.

Я оглянулся и не смог найти ничего очевидного, что многие люди используют для проверки работоспособности адреса электронной почты. Для этого есть поддерживаемый, достаточно точный плагин или гем?

P.S .: Пожалуйста, не просите меня отправить электронное письмо со ссылкой, чтобы увидеть, работает ли электронное письмо. Я разрабатываю функцию «отправить другу», так что это не практично.

Ответы [ 13 ]

106 голосов
/ 27 июля 2009

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

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

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

Если адрес прошел проверку, вы отправите электронное письмо. Если электронная почта не удалась, вы получите сообщение об ошибке. В этот момент вы можете сказать пользователю «Извините, ваш друг не получил этого, хотите попробовать еще раз?» или пометить его для просмотра вручную, или просто проигнорировать, или что-то еще.

Это те же опции, с которыми вам придется иметь дело, если адрес прошел проверку. Потому что даже если ваша проверка правильна и вы получаете абсолютное доказательство того, что адрес существует, отправка все равно может быть неудачной.

Стоимость ложного срабатывания при проверке низкая. Преимущество лучшей проверки также мало. Проверяйте щедро и беспокоитесь об ошибках, когда они случаются.

67 голосов
/ 24 августа 2010

С Rails 3.0 вы можете использовать проверку электронной почты без регулярных выражений, используя Mail gem .

Вот моя реализация ( упакована как драгоценный камень ).

12 голосов
/ 10 октября 2010

Я создал гем для проверки электронной почты в Rails 3. Я немного удивлен, что в Rails по умолчанию нет ничего подобного.

http://github.com/balexand/email_validator

10 голосов
/ 26 февраля 2012

Похоже, что на данный момент на github больше всего посетителей (для проверки электронной почты в рельсах):

https://github.com/alexdunae/validates_email_format_of

7 голосов
/ 11 ноября 2013

Из Рельсов 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
5 голосов
/ 15 мая 2014

В 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

† Регулярные выражения похожи на насилие; если они не работают, вы не используете их достаточно.

4 голосов
/ 23 июля 2012

Как подсказывает Аллилуйя , я считаю, что использование Mail gem - хороший подход. Тем не менее, мне не нравятся некоторые обручи там.

Я использую:

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)

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

Еще одно замечание, касающееся гема Mail, хотя класс называется RFC2822, в грамматике есть некоторые элементы RFC5322 , например этот тест .

4 голосов
/ 17 марта 2012

В 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 голосов
/ 27 мая 2013

Отмечая другие ответы, все еще остается вопрос - зачем беспокоиться об этом?

Фактический объем граничных случаев, которые многие регулярные выражения могут отрицать или пропустить, кажется проблематичным.

Я думаю, что вопрос в том, «что я пытаюсь достичь?», Даже если вы «проверяете» адрес электронной почты, вы на самом деле не подтверждаете, что это рабочий адрес электронной почты.

Если вы используете регулярное выражение, просто проверьте наличие @ на стороне клиента.

Что касается неправильного сценария электронной почты, добавьте ветку «сообщение не удалось отправить» в ваш код.

1 голос
/ 01 октября 2014

Для Проверка списков рассылки . (Я использую 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, но это очень простое регулярное выражение и не было получено все нужные мне случаи. Некоторые письма столкнулись.

Я пробовал другие регулярные выражения из Интернета, но этот имеет лучшие результаты до сих пор. Надеюсь, это поможет в вашем случае.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...