valid_email 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 066fc2f842dfd3d3afc0df730f7e44951a6692aa035b378036e2587731073dd1
-  data.tar.gz: a21522fd9b8453ff36fc960fdbcd916843fe3232a4a87f2528611f1d8f9f693c
+  metadata.gz: 7e0da2f8d6e1b69a777c0d9a6bb14632fa577ecfa55acb7128d436e1543a6842
+  data.tar.gz: c8a125e2971de31cd1e43a49827af99cb1a44130082c555b448083aa1fc6bbaf
 SHA512:
-  metadata.gz: f6dbf19e9942dacf1d749d3027d1d20e130a64c1418c7cae5e43165d0ddf304d46f02a530658760626af4cbe6cb686fcb30964bfd8512967e74c7599712c06cf
-  data.tar.gz: cd549c34b78c76ef33ed9e60b3d683706a6fde6bcf2e5dcf7223dbf26f46a7556bbcb3325e8a862f1708b80072fce0f5c4b2e8bef479178d9633ffabd8224ddd
+  metadata.gz: 736072b973d66828d1f2cd78b6248599a5ecc3d054d0cbbd1354a4735447a97024575649c7bbe110edb576f18cedd647d378ceb12a9d8344639179c3c8d8ade0
+  data.tar.gz: 52fa87c50d4bf5570779706a39dea8c803b894256d7a92563b0b02009f92b262b6439565d4efd5345b65974f41dbd899085c6349f7c1cb4a5e9c82abcf21efe1

data/.github/workflows/ci.yaml

@@ -0,0 +1,44 @@
+name: CI
+on:
+  workflow_dispatch:
+  push:
+
+permissions:
+  checks: write
+  contents: read
+  pull-requests: write
+
+jobs:
+  rspec:
+    name: RSpec (ruby ${{ matrix.ruby-version }})
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version:
+          - '1.9.3'
+          - '2.0'
+          - '2.1'
+          - '2.2'
+          - '2.3'
+          - '2.4'
+          - '2.5'
+          - '2.6'
+          - '2.7'
+          - '3.0'
+          - '3.1'
+          - '3.2'
+          - 'jruby-head'
+          - 'truffleruby-head'
+    env:
+      CI: true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rake

data/README.md

@@ -1,98 +1,141 @@
-# Purpose
+# Valid Email
 
-It validates email for application use (registering a new account for example)
+## Purpose
 
-# Usage
+It validates email for application use (registering a new account for example).
 
-In your Gemfile :
-
-    gem 'valid_email'
+## Usage
 
+In your `Gemfile`:
+```ruby
+gem 'valid_email'
+```
 
-In your code :
+In your code:
+```ruby
+require 'valid_email'
 
-    require 'valid_email'
-    class Person
-      include ActiveModel::Validations
-      attr_accessor :name, :email
+class Person
+  include ActiveModel::Validations
+  attr_accessor :name, :email
 
-      validates :name, :presence => true, :length => { :maximum => 100 }
-      validates :email, :presence => true, :email => true
-    end
+  validates :name, presence: true, length: { maximum: 100 }
+  validates :email, presence: true, email: true
+end
 
 
-    p = Person.new
-    p.name = "hallelujah"
-    p.email = "john@doe.com"
-    p.valid? # => true
+person = Person.new
+person.name = 'hallelujah'
+person.email = 'john@doe.com'
+person.valid? # => true
 
-    p.email = "john@doe"
-    p.valid? # => false
+person.email = 'john@doe'
+person.valid? # => false
 
-    p.email = "John Does <john@doe.com>"
-    p.valid? # => false
+person.email = 'John Does <john@doe.com>'
+person.valid? # => false
+```
 
 You can check if email domain has MX record:
-
-    validates :email, :email => {:mx => true, :message => I18n.t('validations.errors.models.user.invalid_email')}
+```ruby
+validates :email,
+          email: {
+            mx: true,
+            message: I18n.t('validations.errors.models.user.invalid_email')
+          }
+```
 
 Or
 
-    validates :email, :email => {:message => I18n.t('validations.errors.models.user.invalid_email')}, :mx => {:message => I18n.t('validations.errors.models.user.invalid_mx')}
+```ruby
+validates :email,
+          email: {
+            message: I18n.t('validations.errors.models.user.invalid_email')
+          },
+          mx: {
+            message: I18n.t('validations.errors.models.user.invalid_mx')
+          }
+```
 
 By default, the email domain is validated using a regular expression, which does not require an external service and improves performance.
 Alternatively, you can check if an email domain has a MX or A record by using `:mx_with_fallback` instead of `:mx`.
 
-    validates :email, :email => {:mx_with_fallback => true}
+```ruby
+validates :email, email: { mx_with_fallback: true }
+```
 
 You can detect disposable accounts
 
-    validates :email, :email => {:ban_disposable_email => true, :message => I18n.t('validations.errors.models.user.invalid_email')}
+```ruby
+validates :email,
+          email: {
+            ban_disposable_email: true,
+            message: I18n.t('validations.errors.models.user.invalid_email')
+          }
+```
 
-If you don't want the MX validator stuff, just require the right file
+You can also detect a partial match on disposable accounts, good for services that use subdomains.
 
-    require 'valid_email/email_validator'
+```ruby
+validates :email,
+          email: {
+            message: I18n.t('validations.errors.models.user.invalid_email')
+            ban_disposable_email: true,
+            partial: true
+          }
+```
+
+If you don't want the MX validator stuff, just require the right file
 
-Or in your Gemfile
+```ruby
+require 'valid_email/email_validator'
+```
 
-    gem 'valid_email', :require => 'valid_email/email_validator'
+Or in your `Gemfile`
 
+```ruby
+gem 'valid_email', require: 'valid_email/email_validator'
+```
 
 ### Usage outside of model validation
-There is a chance that you want to use e-mail validator outside of model validation.  
+
+There is a chance that you want to use e-mail validator outside of model validation.
 If that's the case, you can use the following methods:
 
 ```ruby
-ValidateEmail.valid?('email@randommail.com') # You can optionally pass a hash of options, same as validator
+options = {} # You can optionally pass a hash of options, same as validator
+ValidateEmail.valid?('email@randommail.com', options)
 ValidateEmail.mx_valid?('email@randommail.com')
 ValidateEmail.mx_valid_with_fallback?('email@randommail.com')
 ValidateEmail.valid?('email@randommail.com')
 ```
 
-Load it (and not the rails extensions) with 
-
-    gem 'valid_email', require: 'valid_email/validate_email'
+Load it (and not the Rails extensions) with
 
+```ruby
+gem 'valid_email', require: 'valid_email/validate_email'
+```
 
 ### String and Nil object extensions
 
-There is also a String and Nil class extension, if you require the gem in this way in Gemfile:
+There is also a String and Nil class extension, if you require the gem in this way in `Gemfile`:
 
 ```ruby
-gem 'valid_email', require: ['valid_email/all_with_extensions']
+gem 'valid_email', require: 'valid_email/all_with_extensions'
 ```
 
 You will be able to use the following methods:
 ```ruby
 nil.email? # => false
-"john@gmail.com".email? # => May return true if it exists. It accepts a hash of options like ValidateEmail.valid?
+'john@gmail.com'.email? # => May return true if it exists.
+# It accepts a hash of options like ValidateEmail.valid?
 ```
 
 ## Code Status
 
-* [![Build Status](https://travis-ci.org/hallelujah/valid_email.svg?branch=master)](https://travis-ci.org/hallelujah/valid_email)
+[![Build Status](https://github.com/hallelujah/valid_email/actions/workflows/ci.yaml/badge.svg)](https://github.com/hallelujah/valid_email/actions/workflows/ci.yaml)
 
-# Credits
+## Credits
 
 * Ramihajamalala Hery hery[at]rails-royce.org
 * Fire-Dragon-DoL francesco.belladonna[at]gmail.com
@@ -109,18 +152,14 @@ nil.email? # => false
 * Jean Boussier jean.boussier[at]gmail.com
 * Masaki Hara - @qnighy
 
-# Note on Patches/Pull Requests
-
-* Fork the project.
-
-* Make your feature addition or bug fix.
-
-* Add tests for it. This is important so I don’t break it in a future version unintentionally.
-
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+## Pull Requests
 
-* Send me a pull request. Bonus points for topic branches.
+1. Fork the project.
+2. Make your feature addition or bug fix.
+3. Add tests for it. This is important so I don’t break it in a future version unintentionally.
+4. Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+5. Send me a pull request. Bonus points for topic branches.
 
-# Copyright
+## Copyright
 
 Copyright &copy; 2011 Ramihajamalala Hery. See LICENSE for details

data/config/locales/cs.yml

@@ -0,0 +1,5 @@
+cs:
+  valid_email:
+    validations:
+      email:
+        invalid: je neplatný

data/config/locales/es.yml

@@ -0,0 +1,5 @@
+es:
+  valid_email:
+    validations:
+      email:
+        invalid: "no es válido"

data/config/valid_email.yml

@@ -347,7 +347,6 @@ disposable_email_services:
   - prtnx.com
   - punkass.com
   - putthisinyourspamdatabase.com
-  - qq.com
   - quickinbox.com
   - rcpt.at
   - recode.me

data/lib/valid_email/ban_disposable_email_validator.rb

@@ -15,9 +15,19 @@ class BanDisposableEmailValidator < ActiveModel::EachValidator
   end
 
   def validate_each(record, attribute, value)
-    r = ValidateEmail.ban_disposable_email?(value)
-    record.errors.add attribute, (options[:message] || I18n.t(:invalid, :scope => "valid_email.validations.email")) unless r
+    # Check if part of domain is in disposable_email_services yml list
+    if options[:partial]
+      r = ValidateEmail.ban_partial_disposable_email?(value)
+      record.errors.add attribute, (options[:message] ||
+        I18n.t(:invalid, :scope => "valid_email.validations.email")) unless r
 
-    r
+      r
+    else
+      r = ValidateEmail.ban_disposable_email?(value)
+      record.errors.add attribute, (options[:message] ||
+        I18n.t(:invalid, :scope => "valid_email.validations.email")) unless r
+
+      r
+    end
   end
 end

data/lib/valid_email/email_validator.rb

@@ -18,11 +18,11 @@ class EmailValidator < ActiveModel::EachValidator
     # Check if domain is disposable
     if r && options[:ban_disposable_email]
       require 'valid_email/ban_disposable_email_validator'
-      r = BanDisposableEmailValidator.new(:attributes => attributes, message: options[:message]).validate(record)
+      r = BanDisposableEmailValidator.new(:attributes => attributes, message: options[:message], partial: options[:partial]).validate(record)
     end
     unless r
       msg = (options[:message] || I18n.t(:invalid, :scope => "valid_email.validations.email"))
-      record.errors.add attribute, (msg % {value: value})
+      record.errors.add attribute, message: I18n.interpolate(msg, value: value)
     end
   end
 end

data/lib/valid_email/validate_email.rb

@@ -1,4 +1,5 @@
 require 'mail'
+require 'simpleidn'
 
 class ValidateEmail
   class << self
@@ -27,7 +28,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.any?(&:empty?)
+      return false unless domain_dot_elements.size > 1 && domain_dot_elements.none?(&:empty?)
 
       # Ensure that the local segment adheres to adheres to RFC-5322
       return false unless valid_local?(m.local)
@@ -90,11 +91,17 @@ class ValidateEmail
       m = Mail::Address.new(value)
       return false unless m.domain
 
+      if m.domain.ascii_only?
+        ascii_domain = m.domain
+      else
+        ascii_domain = SimpleIDN.to_ascii(m.domain)
+      end
+
       Resolv::DNS.open do |dns|
         dns.timeouts = MxValidator.config[:timeouts] unless MxValidator.config[:timeouts].empty?
 
-        return dns.getresources(m.domain, Resolv::DNS::Resource::IN::MX).size > 0 || (
-          fallback && dns.getresources(m.domain, Resolv::DNS::Resource::IN::A).size > 0
+        return dns.getresources(ascii_domain, Resolv::DNS::Resource::IN::MX).size > 0 || (
+          fallback && dns.getresources(ascii_domain, Resolv::DNS::Resource::IN::A).size > 0
         )
       end
     rescue Mail::Field::ParseError
@@ -121,5 +128,15 @@ class ValidateEmail
     rescue Mail::Field::ParseError
       false
     end
+
+    def ban_partial_disposable_email?(value)
+      m = Mail::Address.new(value)
+      m.domain && !BanDisposableEmailValidator.config.any? do |bde|
+        next if bde == nil
+        m.domain.end_with?(bde)
+      end
+    rescue Mail::Field::ParseError
+      false
+    end
   end
 end

data/lib/valid_email/version.rb

@@ -1 +1 @@
-ValidEmailVersion = "0.1.3"
+ValidEmailVersion = "0.2.1"

data/spec/email_validator_spec.rb

@@ -1,63 +1,73 @@
 require 'spec_helper'
 
+RSpec::Matchers.define :have_error_messages do |field, expected|
+  match do |model|
+    errors = model.errors[field]
+
+    messages = errors.map do |error|
+      case error
+      when String then error
+      when Hash then error[:message]
+      else fail ArgumentError, "Unknown model error type #{error.class}"
+      end
+    end
+
+    expect(messages).to eq expected
+  end
+end
+
 describe EmailValidator do
-  person_class = Class.new do
+  email_class = Class.new do
     include ActiveModel::Validations
+
     attr_accessor :email
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "TestModel")
+    end
+  end
+
+  person_class = Class.new(email_class) do
     validates :email, :email => true
   end
 
-  person_class_mx = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_mx = Class.new(email_class) do
     validates :email, :email => {:mx => true}
   end
 
-  person_class_mx_with_fallback = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_mx_with_fallback = Class.new(email_class) do
     validates :email, :email => {:mx_with_fallback => true}
   end
 
-  person_class_disposable_email = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_disposable_email = Class.new(email_class) do
     validates :email, :email => {:ban_disposable_email => true}
   end
 
-  person_class_nil_allowed = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_partial_disposable_email = Class.new(email_class) do
+    validates :email, :email => {:ban_disposable_email => true, :partial => true}
+  end
+
+  person_class_nil_allowed = Class.new(email_class) do
     validates :email, :email => {:allow_nil => true}
   end
 
-  person_class_blank_allowed = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_blank_allowed = Class.new(email_class) do
     validates :email, :email => {:allow_blank => true}
   end
 
-  person_class_mx_separated = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_mx_separated = Class.new(email_class) do
     validates :email, :mx => true
   end
 
-  person_class_mx_with_fallback_separated = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_mx_with_fallback_separated = Class.new(email_class) do
     validates :email, :mx_with_fallback => true
   end
 
-  person_class_domain = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_class_domain = Class.new(email_class) do
     validates :email, :domain => true
   end
 
-  person_message_specified = Class.new do
-    include ActiveModel::Validations
-    attr_accessor :email
+  person_message_specified = Class.new(email_class) do
     validates :email, :email => { :message => 'custom message', :ban_disposable_email => true }
   end
 
@@ -79,43 +89,43 @@ describe EmailValidator do
 
       it "fails when email empty" do
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email is not valid" do
         subject.email = 'joh@doe'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email domain is prefixed with dot" do
         subject.email = 'john@.doe'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email domain contains two consecutive dots" do
         subject.email = 'john@doe-two..com'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email ends with a period" do
         subject.email = 'john@doe.com.'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email ends with special characters" do
         subject.email = 'john@doe.com&'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when email is valid with information" do
         subject.email = '"John Doe" <john@doe.com>'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "passes when email is simple email address" do
@@ -127,42 +137,51 @@ describe EmailValidator do
       it "fails when email is simple email address not stripped" do
         subject.email = 'john@doe.com            '
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when domain contains a space" do
         subject.email = 'john@doe .com'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when passing multiple simple email addresses" do
         subject.email = 'john@doe.com, maria@doe.com'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
-
     end
 
     describe "validating email with MX and fallback to A" do
+      let(:dns) { instance_double('Resolv::DNS', :dns) }
+
       subject { person_class_mx_with_fallback.new }
 
+      before do
+        allow(Resolv::DNS).to receive(:open).and_yield(dns)
+      end
+
       it "passes when email domain has MX record" do
-        subject.email = 'john@gmail.com'
+        allow(dns).to receive(:getresources).with('has-mx-record.org', Resolv::DNS::Resource::IN::MX).and_return(['1.2.3.4'])
+        subject.email = 'john@has-mx-record.org'
         expect(subject.valid?).to be_truthy
         expect(subject.errors[:email]).to be_empty
       end
 
       it "passes when email domain has no MX record but has an A record" do
-        subject.email = 'john@subdomain.rubyonrails.org'
+        allow(dns).to receive(:getresources).with('has-a-record.org', Resolv::DNS::Resource::IN::MX).and_return([])
+        allow(dns).to receive(:getresources).with('has-a-record.org', Resolv::DNS::Resource::IN::A).and_return(['1.2.3.4'])
+        subject.email = 'john@has-a-record.org'
         expect(subject.valid?).to be_truthy
         expect(subject.errors[:email]).to be_empty
       end
 
       it "fails when domain does not exists" do
-        subject.email = 'john@nonexistentdomain.abc'
+        allow(dns).to receive(:getresources).with('does-not-exist.org', anything).and_return([])
+        subject.email = 'john@does-not-exist.org'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
     end
 
@@ -178,13 +197,13 @@ describe EmailValidator do
       it "fails when email domain has no MX record" do
         subject.email = 'john@subdomain.rubyonrails.org'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "fails when domain does not exists" do
         subject.email = 'john@nonexistentdomain.abc'
         expect(subject.valid?).to be_falsey
-        expect(subject.errors[:email]).to eq errors
+        expect(subject).to have_error_messages(:email, errors)
       end
     end
 
@@ -228,6 +247,22 @@ describe EmailValidator do
       it "fails when email from disposable email services" do
         subject.email = 'john@grr.la'
         expect(subject.valid?).to be_falsey
+        expect(subject).to have_error_messages(:email, errors)
+      end
+    end
+
+    describe "validating email against partial disposable service match" do
+      subject { person_class_partial_disposable_email.new }
+
+      it "passes when email from trusted email services" do
+        subject.email = 'john@test.mail.ru'
+        expect(subject.valid?).to be_truthy
+        expect(subject.errors[:email]).to be_empty
+      end
+
+      it "fails when disposable email services partially matches email domain" do
+        subject.email = 'john@sub.grr.la'
+        expect(subject.valid?).to be_falsey
         expect(subject.errors[:email]).to eq errors
       end
     end
@@ -238,7 +273,7 @@ describe EmailValidator do
       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
+        expect(subject).to have_error_messages(:email, errors)
       end
 
       it "passes with valid domain" do
@@ -290,4 +325,19 @@ describe EmailValidator do
     let!(:errors) { [ "est invalide" ] }
     it_behaves_like "Validating emails"
   end
+
+  describe 'Translating in czech' do
+    let!(:locale){ :cs }
+    let!(:errors) do
+      [
+        I18n.t(
+          :invalid,
+          locale: locale,
+          scope: [:valid_email, :validations, :email]
+        )
+      ]
+    end
+
+    it_behaves_like 'Validating emails'
+  end
 end

data/spec/spec_helper.rb

@@ -2,5 +2,11 @@ $:.unshift File.expand_path('../../lib',__FILE__)
 require 'valid_email'
 
 RSpec.configure do |config|
+  config.order = :random
   config.raise_errors_for_deprecations!
+  Kernel.srand config.seed
+
+  if ENV['CI']
+    config.warnings = true
+  end
 end

data/spec/validate_email_spec.rb

@@ -15,13 +15,27 @@ describe ValidateEmail do
     end
 
     context 'when mx: true option passed' do
+      let(:dns) { Resolv::DNS.new }
+
+      def mock_dns_mx
+        allow(dns).to receive(:getresources).and_return([])
+        allow(Resolv::DNS).to receive(:new).and_return(dns)
+      end
+
       it 'returns true when mx record exist' do
         expect(ValidateEmail.valid?('user@gmail.com', mx: true)).to be_truthy
       end
 
       it "returns false when mx record doesn't exist" do
+        mock_dns_mx
         expect(ValidateEmail.valid?('user@example.com', mx: true)).to be_falsey
       end
+
+      it "IDN-encodes the domain name if it contains multibyte characters" do
+        mock_dns_mx
+        ValidateEmail.valid?("user@\u{1F600}.com", mx: true)
+        expect(dns).to have_received(:getresources).with('xn--e28h.com', anything)
+      end
     end
 
     context 'when domain: true option passed' do

data/valid_email.gemspec

@@ -12,21 +12,20 @@ Gem::Specification.new do |s|
   s.description = %q{ActiveModel Validation for email}
   s.license     = 'MIT'
 
-  s.rubyforge_project = "valid_email"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_development_dependency "rspec", "~> 2.99"
-  s.add_development_dependency "rake", '< 11.0'
+  s.add_development_dependency "rspec", "~> 3.10"
+  s.add_development_dependency "rake"
   s.add_runtime_dependency "mail", ">= 2.6.1"
-  if Gem::Version.new(RUBY_VERSION) <= Gem::Version.new('2.0')
+  s.add_runtime_dependency "simpleidn"
+  if Gem::Version.new(RUBY_VERSION.dup) <= Gem::Version.new('2.0')
     s.add_runtime_dependency 'mime-types', '<= 2.6.2'
   end
-  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.2')
+  if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.2.2')
     s.add_runtime_dependency "activemodel", '< 5.0.0'
   else
     s.add_runtime_dependency "activemodel"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valid_email
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - Ramihajamalala Hery
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2024-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mail
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.6.1
+- !ruby/object:Gem::Dependency
+  name: simpleidn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -73,15 +87,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yaml"
 - ".gitignore"
-- ".travis.yml"
+- ".rspec"
 - Gemfile
 - History.md
 - LICENSE
 - README.md
 - Rakefile
+- config/locales/cs.yml
 - config/locales/de.yml
 - config/locales/en.yml
+- config/locales/es.yml
 - config/locales/fi.yml
 - config/locales/fr.yml
 - config/locales/hu.yml
@@ -113,7 +130,7 @@ homepage: https://github.com/hallelujah/valid_email
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,9 +145,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: valid_email
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.5.6
+signing_key:
 specification_version: 4
 summary: ActiveModel Validation for email
 test_files:

data/.travis.yml

@@ -1,15 +0,0 @@
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2.1
-  - 2.2.2
-  - 2.3.3
-  - 2.4.0
-  - jruby-19mode
-  - jruby-20mode
-before_install:
-  - gem install bundler:1.17.3