valid_email 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42a2f72cc8d27b8f7bfa7cc975a7b06512f6cbac
-  data.tar.gz: 6e6a23102e9b365aa96da9ce632dc8b890f15753
+  metadata.gz: c545251c17d33f29c1cc777e798aa7a08937af43
+  data.tar.gz: 78da306fab1e3a75633be0cb25c7430d809e0361
 SHA512:
-  metadata.gz: 3918c4f4a86617449a70451e7f914874972dcb7045beead234ddbfac21b69e84e269e21122ba1e2b433bbadc0d362815f6f0e91dbc34eb1c860af7b53164dc10
-  data.tar.gz: 907854ee62fcc7474d225ab1c87b526b1c688c61f58b40c79023bf84e8b61b13a23dd0b692b03df5886affbe7c82e0d18be0241905ef85148bd58d540afdfa97
+  metadata.gz: 48566bddaff58f5d006f3b398a39ca3713902805eec7ef69fcc9fe0b6a7451aaf40fc457627e568a973336559a171c6ad2f98732e1806e9cc88e943334000d68
+  data.tar.gz: 41fd65d81b424fbbbb566f8f94e9be28f435afeca997fe49f4409508b76136a1fab068100181adb0e0998d1a0fd99ee199f76c9a07f9936fdaac95377a1128d9

data/README.md

@@ -32,7 +32,7 @@ In your code :
     p.email = "John Does <john@doe.com>"
     p.valid? # => false
 
-You can check if email domain has MX record :
+You can check if email domain has MX record:
 
     validates :email, :email => {:mx => true, :message => I18n.t('validations.errors.models.user.invalid_email')}
 
@@ -40,6 +40,10 @@ Or
 
     validates :email, :email => {:message => I18n.t('validations.errors.models.user.invalid_email')}, :mx => {:message => I18n.t('validations.errors.models.user.invalid_mx')}
 
+You can check if the email domain looks valid. This uses a regular expression so no external services are required, which improves the performance of this check:
+
+    validates :email, :email => {:domain => true}
+
 Alternatively, you can check if an email domain has a MX or A record by using `:mx_with_fallback` instead of `:mx`.
 
 You can detect disposable accounts

data/config/locales/hu.yml

@@ -0,0 +1,5 @@
+hu:
+  valid_email:
+    validations:
+      email:
+        invalid: "érvénytelen email cím"

data/config/locales/ja.yml

@@ -0,0 +1,5 @@
+ja:
+  valid_email:
+    validations:
+      email:
+        invalid: "不正な値です"

data/config/locales/uk.yml

@@ -0,0 +1,5 @@
+uk:
+  valid_email:
+    validations:
+      email:
+        invalid: "неправильний формат"

data/config/valid_email.yml

@@ -44,6 +44,7 @@ disposable_email_services:
   - a-bc.net
   - afrobacon.com
   - ajaxapp.net
+  - amail4.me
   - amilegit.com
   - amiri.net
   - amiriindustries.com
@@ -254,6 +255,9 @@ disposable_email_services:
   - mailexpire.com
   - mailfa.tk
   - mailfreeonline.com
+  - mailhazard.com
+  - mailhazard.us
+  - mailhz.me
   - mailin8r.com
   - mailinater.com
   - mailinator.com
@@ -512,6 +516,8 @@ disposable_email_services:
   - yopmail.net
   - ypmail.webarnak.fr.eu.org
   - yuurok.com
+  - zebins.com
+  - zebins.eu
   - zehnminutenmail.de
   - zippymail.info
   - zoaxe.com

data/lib/valid_email/all.rb

@@ -3,3 +3,4 @@ require 'valid_email/email_validator'
 require 'valid_email/mx_validator'
 require 'valid_email/mx_with_fallback_validator'
 require 'valid_email/ban_disposable_email_validator'
+require 'valid_email/domain_validator'

data/lib/valid_email/ban_disposable_email_validator.rb

@@ -1,6 +1,5 @@
 require 'active_model'
 require 'active_model/validations'
-require 'mail'
 require 'valid_email/validate_email'
 class BanDisposableEmailValidator < ActiveModel::EachValidator
   # A list of disposable email domains

data/lib/valid_email/domain_validator.rb

@@ -0,0 +1,13 @@
+require 'active_model'
+require 'active_model/validations'
+require 'valid_email/validate_email'
+
+class DomainValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    r = ValidateEmail.domain_valid?(value)
+    record.errors.add attribute, (options[:message] || I18n.t(:invalid, :scope => "valid_email.validations.email")) unless r
+
+    r
+  end
+end
+

data/lib/valid_email/email_validator.rb

@@ -1,6 +1,5 @@
 require 'active_model'
 require 'active_model/validations'
-require 'mail'
 require 'valid_email/validate_email'
 class EmailValidator < ActiveModel::EachValidator
   def validate_each(record,attribute,value)
@@ -21,6 +20,9 @@ class EmailValidator < ActiveModel::EachValidator
       require 'valid_email/ban_disposable_email_validator'
       r = BanDisposableEmailValidator.new(:attributes => attributes).validate(record)
     end
-    record.errors.add attribute, (options[:message] || I18n.t(:invalid, :scope => "valid_email.validations.email")) unless r
+    unless r
+      msg = (options[:message] || I18n.t(:invalid, :scope => "valid_email.validations.email"))
+      record.errors.add attribute, (msg % {value: value})
+    end  
   end
 end

data/lib/valid_email/mx_validator.rb

@@ -1,6 +1,5 @@
 require 'active_model'
 require 'active_model/validations'
-require 'mail'
 require 'resolv'
 require 'valid_email/validate_email'
 class MxValidator < ActiveModel::EachValidator

data/lib/valid_email/validate_email.rb

@@ -1,11 +1,18 @@
+require 'mail'
+
 class ValidateEmail
   class << self
     SPECIAL_CHARS = %w(( ) , : ; < > @ [ ])
     SPECIAL_ESCAPED_CHARS = %w(\  \\ ")
     LOCAL_MAX_LEN = 64
+    DOMAIN_REGEX = /\A^([[:alpha:]]{1}|([[:alnum:]][a-zA-Z0-9-]{0,61}[[:alnum:]]))(\.([[:alnum:]][a-zA-Z0-9-]{0,61}[[:alnum:]]))+\z/
 
     def valid?(value, user_options={})
-      options = { :mx => false, :message => nil }.merge(user_options)
+      options = {
+        :mx => false,
+        :domain => false,
+        :message => nil
+      }.merge(user_options)
 
       m = Mail::Address.new(value)
       # We must check that value contains a domain and that value is an email address
@@ -20,7 +27,7 @@ class ValidateEmail
       return false unless m.domain.match(/^\S+$/)
 
       domain_dot_elements = m.domain.split(/\./)
-      return false unless domain_dot_elements.size > 1 && domain_dot_elements.all?(&:present?)
+      return false unless domain_dot_elements.size > 1 && !domain_dot_elements.any?(&:empty?)
 
       # Ensure that the local segment adheres to adheres to RFC-5322
       return false unless valid_local?(m.local)
@@ -31,9 +38,20 @@ class ValidateEmail
         return mx_valid?(value)
       end
 
+      if options[:domain]
+        require 'valid_email/domain_validator'
+        return domain_valid?(value)
+      end
+
       true
     rescue Mail::Field::ParseError
       false
+    rescue ArgumentError => error
+      if error.message == 'bad value for range'
+        false
+      else
+        raise error
+      end
     end
 
     def valid_local?(local)
@@ -65,7 +83,7 @@ class ValidateEmail
         # If we're not in a quoted dot atom then no special characters are allowed.
         return false unless ((SPECIAL_CHARS | SPECIAL_ESCAPED_CHARS) & dot_atom.split('')).empty?
       end
-      return true 
+      return true
     end
 
     def mx_valid?(value, fallback=false)
@@ -87,6 +105,13 @@ class ValidateEmail
       mx_valid?(value, true)
     end
 
+    def domain_valid?(value)
+      m = Mail::Address.new(value)
+      return false unless m.domain
+
+      !(m.domain =~ DOMAIN_REGEX).nil?
+    end
+
     def ban_disposable_email?(value)
       m = Mail::Address.new(value)
       m.domain && !BanDisposableEmailValidator.config.include?(m.domain)

data/lib/valid_email/version.rb

@@ -1 +1 @@
-ValidEmailVersion = "0.0.11"
+ValidEmailVersion = "0.0.12"

data/spec/email_validator_spec.rb

@@ -49,11 +49,17 @@ describe EmailValidator do
     validates :email, :mx_with_fallback => true
   end
 
+  person_class_domain = Class.new do
+    include ActiveModel::Validations
+    attr_accessor :email
+    validates :email, :domain => true
+  end
+
   shared_examples_for "Invalid model" do
     before { subject.valid? }
 
-    it { should_not be_valid }
-    specify { subject.errors[:email].should =~ errors }
+    it { is_expected.not_to be_valid }
+    specify { expect(subject.errors[:email]).to match_array errors }
   end
 
   shared_examples_for "Validating emails" do
@@ -65,57 +71,57 @@ describe EmailValidator do
     describe "validating email" do
       subject { person_class.new }
 
-      it "should fail when email empty" do
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+      it "fails when email empty" do
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when email is not valid" do
+      it "fails when email is not valid" do
         subject.email = 'joh@doe'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when email domain is prefixed with dot" do
+      it "fails when email domain is prefixed with dot" do
         subject.email = 'john@.doe'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when email domain contains two consecutive dots" do
+      it "fails when email domain contains two consecutive dots" do
         subject.email = 'john@doe-two..com'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when email is valid with information" do
+      it "fails when email is valid with information" do
         subject.email = '"John Doe" <john@doe.com>'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should pass when email is simple email address" do
+      it "passes when email is simple email address" do
         subject.email = 'john@doe.com'
-        subject.valid?.should be_truthy
-        subject.errors[:email].should be_empty
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
       end
 
-      it "should fail when email is simple email address not stripped" do
+      it "fails when email is simple email address not stripped" do
         subject.email = 'john@doe.com            '
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when domain contains a space" do
+      it "fails when domain contains a space" do
         subject.email = 'john@doe .com'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when passing multiple simple email addresses" do
+      it "fails when passing multiple simple email addresses" do
         subject.email = 'john@doe.com, maria@doe.com'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
     end
@@ -123,44 +129,44 @@ describe EmailValidator do
     describe "validating email with MX and fallback to A" do
       subject { person_class_mx_with_fallback.new }
 
-      it "should pass when email domain has MX record" do
+      it "passes when email domain has MX record" do
         subject.email = 'john@gmail.com'
-        subject.valid?.should be_truthy
-        subject.errors[:email].should be_empty
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
       end
 
-      it "should pass when email domain has no MX record but has an A record" do
+      it "passes when email domain has no MX record but has an A record" do
         subject.email = 'john@subdomain.rubyonrails.org'
-        subject.valid?.should be_truthy
-        subject.errors[:email].should be_empty
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
       end
 
-      it "should fail when domain does not exists" do
+      it "fails when domain does not exists" do
         subject.email = 'john@nonexistentdomain.abc'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
     end
 
     describe "validating email with MX" do
       subject { person_class_mx.new }
 
-      it "should pass when email domain has MX record" do
+      it "passes when email domain has MX record" do
         subject.email = 'john@gmail.com'
-        subject.valid?.should be_truthy
-        subject.errors[:email].should be_empty
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
       end
 
-      it "should fail when email domain has no MX record" do
+      it "fails when email domain has no MX record" do
         subject.email = 'john@subdomain.rubyonrails.org'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
 
-      it "should fail when domain does not exists" do
+      it "fails when domain does not exists" do
         subject.email = 'john@nonexistentdomain.abc'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
     end
 
@@ -169,12 +175,12 @@ describe EmailValidator do
 
       context "when domain is not specified" do
         before { subject.email = 'john' }
-        it_should_behave_like "Invalid model"
+        it_behaves_like "Invalid model"
       end
 
       context "when domain is not specified but @ is" do
         before { subject.email = 'john@' }
-        it_should_behave_like "Invalid model"
+        it_behaves_like "Invalid model"
       end
     end
 
@@ -183,40 +189,55 @@ describe EmailValidator do
 
       context "when domain is not specified" do
         before { subject.email = 'john' }
-        it_should_behave_like "Invalid model"
+        it_behaves_like "Invalid model"
       end
 
       context "when domain is not specified but @ is" do
         before { subject.email = 'john@' }
-        it_should_behave_like "Invalid model"
+        it_behaves_like "Invalid model"
       end
     end
 
     describe "validating email from disposable service" do
       subject { person_class_disposable_email.new }
 
-      it "should pass when email from trusted email services" do
+      it "passes when email from trusted email services" do
         subject.email = 'john@mail.ru'
-        subject.valid?.should be_truthy
-        subject.errors[:email].should be_empty
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
       end
 
-      it "should fail when email from disposable email services" do
+      it "fails when email from disposable email services" do
         subject.email = 'john@grr.la'
-        subject.valid?.should be_falsey
-        subject.errors[:email].should == errors
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
       end
     end
 
+    describe "validating domain" do
+      subject { person_class_domain.new }
+
+      it "does not pass with an invalid domain" do
+        subject.email = "test@example.org$\'"
+        expect(subject.valid?).to be_falsey
+        expect(subject.errors[:email]).to eq errors
+      end
+
+      it "passes with valid domain" do
+        subject.email = 'john@example.org'
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
+      end
+    end
   end
 
   describe "Can allow nil" do
     subject { person_class_nil_allowed.new }
 
-    it "should pass even if mail isn't set" do
+    it "passes even if mail isn't set" do
       subject.email = nil
-      subject.should be_valid
-      subject.errors[:email].should be_empty
+      expect(subject).to be_valid
+      expect(subject.errors[:email]).to be_empty
     end
 
   end
@@ -224,10 +245,10 @@ describe EmailValidator do
   describe "Can allow blank" do
     subject { person_class_blank_allowed.new }
 
-    it "should pass even if mail is a blank string set" do
+    it "passes even if mail is a blank string set" do
       subject.email = ''
-      subject.should be_valid
-      subject.errors[:email].should be_empty
+      expect(subject).to be_valid
+      expect(subject.errors[:email]).to be_empty
     end
 
   end
@@ -235,13 +256,13 @@ describe EmailValidator do
   describe "Translating in english" do
     let!(:locale){ :en }
     let!(:errors) { [ "is invalid" ] }
-    it_should_behave_like "Validating emails"
+    it_behaves_like "Validating emails"
   end
 
   describe "Translating in french" do
     let!(:locale){ :fr }
 
     let!(:errors) { [ "est invalide" ] }
-    it_should_behave_like "Validating emails"
+    it_behaves_like "Validating emails"
   end
 end

data/spec/extensions_validator_spec.rb

@@ -3,20 +3,20 @@ require 'valid_email/all_with_extensions'
 
 describe String do
 
-  it { "mymail@gmail".should respond_to(:email?) }
+  it { expect("mymail@gmail").to respond_to(:email?) }
 
   it "is a valid e-mail" do
-    "mymail@gmail.com".email?.should be_truthy
+    expect("mymail@gmail.com".email?).to be_truthy
   end
 
   it "is not valid when text is not a real e-mail" do
-    "invalidMail".email?.should be_falsey
+    expect("invalidMail".email?).to be_falsey
   end
 
   context "when nil" do
 
     it "is invalid e-mail" do
-      nil.email?.should be_falsey
+      expect(nil.email?).to be_falsey
     end
 
   end

data/spec/validate_email_spec.rb

@@ -1,65 +1,120 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe ValidateEmail do
   describe '.valid?' do
-    it 'should return true when passed email has valid format' do
-      ValidateEmail.valid?('user@gmail.com').should be_truthy
-      ValidateEmail.valid?('valid.user@gmail.com').should be_truthy
+    it 'returns true when passed email has valid format' do
+      expect(ValidateEmail.valid?('user@gmail.com')).to be_truthy
+      expect(ValidateEmail.valid?('valid.user@gmail.com')).to be_truthy
     end
 
-    it 'should return false when passed email has invalid format' do
-      ValidateEmail.valid?('user@gmail.com.').should be_falsey
-      ValidateEmail.valid?('user.@gmail.com').should be_falsey
+    it 'returns false when passed email has invalid format' do
+      expect(ValidateEmail.valid?('user@gmail.com.')).to be_falsey
+      expect(ValidateEmail.valid?('user.@gmail.com')).to be_falsey
+      expect(ValidateEmail.valid?('Hgft@(()).com')).to be_falsey
     end
 
     context 'when mx: true option passed' do
-      it 'should return true when mx record exist' do
-        ValidateEmail.valid?('user@gmail.com', mx: true).should be_truthy
+      it 'returns true when mx record exist' do
+        expect(ValidateEmail.valid?('user@gmail.com', mx: true)).to be_truthy
       end
 
-      it "should return false when mx record doesn't exist" do
-        ValidateEmail.valid?('user@example.com', mx: true).should be_falsey
+      it "returns false when mx record doesn't exist" do
+        expect(ValidateEmail.valid?('user@example.com', mx: true)).to be_falsey
+      end
+    end
+
+    context 'when domain: true option passed' do
+      context 'with valid domains' do
+        valid_domains = [
+          'example.org',
+          '0-mail.com',
+          '0815.ru',
+          '0clickemail.com',
+          'test.co.uk',
+          'fux0ringduh.com',
+          'girlsundertheinfluence.com',
+          'h.mintemail.com',
+          'mail-temporaire.fr',
+          'mt2009.com',
+          'mega.zik.dj',
+          'e.test.com',
+          'a.aa',
+          'test.xn--clchc0ea0b2g2a9gcd',
+          'my-domain.com',
+        ]
+
+        valid_domains.each do |valid_domain|
+          it "returns true for #{valid_domain}" do
+            email = "john@#{valid_domain}"
+            expect(ValidateEmail.valid?(email, domain: true)).to be_truthy
+          end
+        end
+      end
+
+      context 'with invalid domain' do
+        invalid_domains = [
+          '-eouae.test',
+          'oue-.test',
+          'oeuoue.-oeuoue',
+          'oueaaoeu.oeue-',
+          'ouoeu.eou_ueoe',
+          'тест.рф',
+          '.test.com',
+          'test..com',
+          'test@test.com',
+          "example.org$\'",
+        ]
+
+        invalid_domains.each do |invalid_domain|
+          it "returns false for #{invalid_domain}" do
+            email = "john@#{invalid_domain}"
+            expect(ValidateEmail.valid?(email, domain: true)).to be_falsey
+          end
+        end
       end
     end
   end
 
   describe '.valid_local?' do
-    it 'should return false if the local segment is too long' do
-      ValidateEmail.valid_local?(
-        'abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde'
-      ).should be_falsey
+    it 'returns false if the local segment is too long' do
+      expect(
+        ValidateEmail.valid_local?(
+          'abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde'
+        )
+      ).to be_falsey
     end
 
-    it 'should return false if the local segment has an empty dot atom' do
-      ValidateEmail.valid_local?('.user').should be_falsey
-      ValidateEmail.valid_local?('.user.').should be_falsey
-      ValidateEmail.valid_local?('user.').should be_falsey
-      ValidateEmail.valid_local?('us..er').should be_falsey
+    it 'returns false if the local segment has an empty dot atom' do
+      expect(ValidateEmail.valid_local?('.user')).to be_falsey
+      expect(ValidateEmail.valid_local?('.user.')).to be_falsey
+      expect(ValidateEmail.valid_local?('user.')).to be_falsey
+      expect(ValidateEmail.valid_local?('us..er')).to be_falsey
     end
 
-    it 'should return false if the local segment has a special character in an unquoted dot atom' do
-      ValidateEmail.valid_local?('us@er').should be_falsey
-      ValidateEmail.valid_local?('user.\\.name').should be_falsey
-      ValidateEmail.valid_local?('user."name').should be_falsey
+    it 'returns false if the local segment has a special character in an unquoted dot atom' do
+      expect(ValidateEmail.valid_local?('us@er')).to be_falsey
+      expect(ValidateEmail.valid_local?('user.\\.name')).to be_falsey
+      expect(ValidateEmail.valid_local?('user."name')).to be_falsey
     end
 
-    it 'should return false if the local segment has an unescaped special character in a quoted dot atom' do
-      ValidateEmail.valid_local?('test." test".test').should be_falsey
-      ValidateEmail.valid_local?('test."test\".test').should be_falsey
-      ValidateEmail.valid_local?('test."te"st".test').should be_falsey
-      ValidateEmail.valid_local?('test."\".test').should be_falsey
+    it 'returns false if the local segment has an unescaped special character in a quoted dot atom' do
+      expect(ValidateEmail.valid_local?('test." test".test')).to be_falsey
+      expect(ValidateEmail.valid_local?('test."test\".test')).to be_falsey
+      expect(ValidateEmail.valid_local?('test."te"st".test')).to be_falsey
+      expect(ValidateEmail.valid_local?('test."\".test')).to be_falsey
     end
 
-    it 'should return true if special characters exist but are properly quoted and escaped' do
-      ValidateEmail.valid_local?('"\ test"').should be_truthy
-      ValidateEmail.valid_local?('"\\\\"').should be_truthy
-      ValidateEmail.valid_local?('test."te@st".test').should be_truthy
-      ValidateEmail.valid_local?('test."\\\\\"".test').should be_truthy
-      ValidateEmail.valid_local?('test."blah\"\ \\\\"').should be_truthy
+    it 'returns true if special characters exist but are properly quoted and escaped' do
+      expect(ValidateEmail.valid_local?('"\ test"')).to be_truthy
+      expect(ValidateEmail.valid_local?('"\\\\"')).to be_truthy
+      expect(ValidateEmail.valid_local?('test."te@st".test')).to be_truthy
+      expect(ValidateEmail.valid_local?('test."\\\\\"".test')).to be_truthy
+      expect(ValidateEmail.valid_local?('test."blah\"\ \\\\"')).to be_truthy
     end
 
-    it 'should return true if all characters are within the set of allowed characters' do
-      ValidateEmail.valid_local?('!#$%&\'*+-/=?^_`{|}~."\\\\\ \"(),:;<>@[]"').should be_truthy
+    it 'returns true if all characters are within the set of allowed characters' do
+      expect(ValidateEmail.valid_local?('!#$%&\'*+-/=?^_`{|}~."\\\\\ \"(),:;<>@[]"')).to be_truthy
     end
   end
-end
+end

data/valid_email.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://my.rails-royce.org/2010/07/21/email-validation-in-ruby-on-rails-without-regexp"
   s.summary     = %q{ActiveModel Validation for email}
   s.description = %q{ActiveModel Validation for email}
+  s.license     = 'MIT'
 
   s.rubyforge_project = "valid_email"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valid_email
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Ramihajamalala Hery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2016-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -83,14 +83,18 @@ files:
 - config/locales/en.yml
 - config/locales/fi.yml
 - config/locales/fr.yml
+- config/locales/hu.yml
+- config/locales/ja.yml
 - config/locales/pl.yml
 - config/locales/ru.yml
 - config/locales/sv.yml
+- config/locales/uk.yml
 - config/valid_email.yml
 - lib/valid_email.rb
 - lib/valid_email/all.rb
 - lib/valid_email/all_with_extensions.rb
 - lib/valid_email/ban_disposable_email_validator.rb
+- lib/valid_email/domain_validator.rb
 - lib/valid_email/email_validator.rb
 - lib/valid_email/mx_validator.rb
 - lib/valid_email/mx_with_fallback_validator.rb
@@ -102,7 +106,8 @@ files:
 - spec/validate_email_spec.rb
 - valid_email.gemspec
 homepage: http://my.rails-royce.org/2010/07/21/email-validation-in-ruby-on-rails-without-regexp
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -120,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: valid_email
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: ActiveModel Validation for email
@@ -129,4 +134,3 @@ test_files:
 - spec/extensions_validator_spec.rb
 - spec/spec_helper.rb
 - spec/validate_email_spec.rb
-has_rdoc: