rich_email_validator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 342b23a6f90fe7e83ee17b5c4d359c9bbc06cb69
+  data.tar.gz: 68036edb2fbff383bd50ee82b238b89ea445044b
+SHA512:
+  metadata.gz: f5a82bca84c3d7b9b5e23cdfd7e486e4089e2da26c318cb55f0684c8ded936d0c44b1b796c74127e2d49ebdce6bb592cbbfef2991f493fc17678158fa96454d4
+  data.tar.gz: 9990e019cc24483513138ca10a6d67733bd8fd1141158c00aa7674d7b580d71ca2da8f4ce0bb30ea75630d564741bc588dc04cb5ef0712e2279f9e45934d29e3

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=doc

data/.travis.yml

@@ -0,0 +1,22 @@
+bundler_args: --without development
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - rbx-2
+  - jruby-19mode
+  - ruby-head
+  - jruby-head
+matrix:
+  include:
+    - rvm: jruby-19mode
+      env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - rvm: jruby-head
+      env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: rbx-2
+    - rvm: ruby-head
+  fast_finish: true

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--markup markdown
+-
+README.md
+LICENSE.md

data/Gemfile

@@ -0,0 +1,30 @@
+source 'https://rubygems.org'
+
+gem 'jruby-openssl', :platforms => :jruby
+gem 'rake'
+gem 'yard'
+
+group :development do
+  gem 'pry'
+  gem 'pry-remote'
+  gem 'pry-nav'
+  platforms :ruby_19, :ruby_20, :ruby_21 do
+    gem 'redcarpet'
+  end
+end
+
+group :test do
+  gem 'coveralls', '~> 0.7', :require => false
+  gem 'rspec', '>= 2.14'
+  gem 'rspec-nc'
+  gem 'rubocop', '>= 0.2', :platforms => [:ruby_19, :ruby_20, :ruby_21]
+  gem 'simplecov', '~> 0.7.1', :require => false
+  if RUBY_VERSION >= "1.9.3"
+    gem 'guard', '~> 2.6'
+    gem 'guard-rspec', '~> 4.2'
+  end
+end
+
+
+# Specify your gem's dependencies in feedlr.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^spec/gateway/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/feedlr/#{m[1]}_spec.rb" }
+  watch(%r{^lib/gateway/(.+)\.rb$})     { |m| "spec/feedlr/gateway/#{m[1]}_spec.rb" }
+  watch('spec/helper.rb')  { "spec" }
+end

data/LICENSE.md

@@ -0,0 +1,16 @@
+Copyright (c) 2014 Khaled alHabache
+
+LGPL-3.0 License
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.

data/README.md

@@ -0,0 +1,103 @@
+# RichEmailValidator
+
+A set of helpers to validate emails:
+
+- [x] Validate an email
+- [x] Filter a list of emails
+- [x] Filter a list of emails from file
+- [x] Filter a list of emails from file and output to file
+
+It works as follows:
+
+- Checks the availability of the mx records of the email's domain. This is done via a DNS lookup.
+- Checks the format of the email via a regular expression that can be configured. **This is done for performance only**.
+- Use a configurable number of threads to check thousands of emails in minutes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rich_email_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rich_email_validator
+
+## Usage
+
+### Validate an email
+
+```ruby
+require 'rich_email_validator'
+RichEmailValidator.valid_email?('khellls@gmail.com') # => true
+RichEmailValidator.valid_email?('khellls@g.com') # => false because DNS lookup check
+```
+### Set a predfined Regexp
+
+It's only used for **performace reasons** to filter the format of an email before doing a DNS lookup check.
+
+The current value is:
+
+```ruby
+/\A[\w!#$%&'*+\/=?`{|}~^-]+(?:\.[\w!#$%&'*+\/=?`{|}~^-]+)*@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}\Z/i
+
+```
+
+You can change it:
+```ruby
+# Customized email regular expression
+RichEmailValidator.email_regexp = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i 
+
+```
+
+### Filter a list of emails
+
+```ruby
+list = ['khellls@g.com', 'khellls@gmail.com']
+RichEmailValidator.filter_list(list) #=> ["khellls@gmail.com"]
+
+# You have a fine grained control, so you can control threads count
+# Default is 20
+RichEmailValidator.filter_list(list, threads_count: 15)
+
+```
+
+### Filter a list of emails from file
+
+```ruby
+file_path = '/path/to/emails_list'
+File.readlines(file_path).size #=> 15 
+RichEmailValidator.filter_file(file_path).size #=> 10 
+
+# You have a fine grained control, so you can control threads count
+# Default is 20
+RichEmailValidator.filter_file(file_path, threads_count: 15)
+
+```
+
+### Filter a list of emails from file and output to file
+
+```ruby
+file_path = '/path/to/emails_list'
+output_path = '/path/to/output'
+File.readlines(file_path).size # => 15 
+RichEmailValidator.export_valid_list(file_path, output_path)
+File.readlines('output.txt').size #=> 10 
+
+# You have a fine grained control, so you can control threads count
+# Default is 20
+RichEmailValidator.export_valid_list(file_path, output_path, threads_count: 15)
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rich_email_validator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'doc']
+end
+
+task :default => :spec

data/collection.rb

@@ -0,0 +1,20 @@
+require 'delegate'
+module Feedlr
+  # When the response is of Array type,
+  #  it creates an array of Feedlr::Base or plain types values
+  class Collection < SimpleDelegator
+    # Initializer
+    # @param [Array] data
+    # @return [Feedlr::Collection]
+    def initialize(data = [])
+      super([])
+      data.each { |value| self << build_object(value) }
+    end
+
+    private
+
+    def build_object(value)
+      value.is_a?(Hash) ? Feedlr::Base.new(value) : value
+    end
+  end
+end

data/lib/rich_email_validator/email_validator.rb

@@ -0,0 +1,67 @@
+require 'resolv'
+
+module RichEmailValidator
+  # Validate email address
+  class EmailValidator
+    class << self
+      attr_writer :email_regexp
+
+      def valid?(email)
+        new(email).valid?
+      end
+
+      def email_regexp
+        @email_regexp || default_email_regexp
+      end
+
+      private
+
+      def default_email_regexp
+        @default_email_regexp ||=
+          /\A[\w!#$%&'*+\/=?`{|}~^-]+(?:\.[\w!#$%&'*+\/=?`{|}~^-]+)*@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}\Z/i
+      end
+    end
+
+    attr_reader :email
+
+    # Validates an email
+    # @param email [String]
+    def initialize(email)
+      @email = email
+    end
+
+    # Validates an email
+    # @return [Boolean]
+    def valid?
+      @valid ||= valid_form? && valid_mx_record?
+    end
+
+    # Validates an email
+    # @return [Boolean]
+    def valid_form?
+      @valid_form ||= check_form
+    end
+
+    # Validates an email
+    # @return [Boolean]
+    def valid_mx_record?
+      @validate_mx_record ||= check_mx_record
+    end
+
+    private
+
+    def check_form
+      (email =~ (self.class.email_regexp)) == 0
+    end
+
+    def check_mx_record
+      domain = email.match(/\@(.+)/)[1]
+      mx = 0
+      Resolv::DNS.open do |dns|
+        mx = dns.getresources(domain, Resolv::DNS::Resource::IN::MX) +
+          dns.getresources(domain, Resolv::DNS::Resource::IN::A)
+      end
+      mx.size > 0 ? true : false
+    end
+  end
+end

data/lib/rich_email_validator/file_validator.rb

@@ -0,0 +1,58 @@
+module RichEmailValidator
+  # Validate input file emails and save valid ones to another output file
+  class FileValidator
+    attr_reader :input_file_path
+
+    class << self
+      # Validates input from file
+      # @param input_file_path [File]
+      # @param [Hash] options
+      # @option options [#to_int] :threads_count number of threads that will
+      #  be fired simultaneously to calculate the result
+      # @return [Array]
+      def filter(input_file_path, options = {})
+        new(input_file_path, options).filter
+      end
+
+      # Validates input from file and write to file
+      # @param input_file_path [File]
+      # @param output_file_path [File]
+      # @param [Hash] options
+      # @option options [#to_int] :threads_count number of threads that will
+      #  be fired simultaneously to calculate the result
+      def export_valid_list(input_file_path, output_file_path, options = {})
+        new(input_file_path, options).export_valid_list(output_file_path)
+      end
+    end
+
+    # Validates input from file
+    # @param input_file_path [File]
+    # @param [Hash] options
+    # @option options [#to_int] :threads_count number of threads that will
+    #  be fired simultaneously to calculate the result
+    def initialize(input_file_path, options = {})
+      @input_file_path = input_file_path
+      @options = options
+    end
+
+    # Validates input from file
+    # @return [Array]
+    def filter
+      @filtered ||= run_filter
+    end
+
+    # Validates input from file and writes to file
+    def export_valid_list(output_file_path)
+      File.open(output_file_path, 'w') do |file|
+        filter.each { |email| file.puts(email) }
+      end
+    end
+
+    private
+
+    def run_filter
+      list = File.readlines(@input_file_path).map(&:chomp)
+      ListValidator.filter(list, @options)
+    end
+  end
+end

data/lib/rich_email_validator/list_validator.rb

@@ -0,0 +1,60 @@
+require 'resolv'
+require 'forwardable'
+
+module RichEmailValidator
+  # Validates list of emails and return the valid ones
+  class ListValidator
+    class << self
+      # Validates list of emails
+      # @param list [Enumerator]
+      # @param [Hash] options
+      # @option options [#to_int] :threads_count number of threads that will
+      #  be fired simultaneously to calculate the result
+      # @return [Array]
+      def filter(list, options = {})
+        new(list, options).filter
+      end
+    end
+
+    attr_reader :list, :threads_count
+
+    # Validates list of emails
+    # @param list [Enumerator]
+    # @param [Hash] options
+    # @option options [#to_int] :threads_count number of threads that will
+    #  be fired simultaneously to calculate the result
+    def initialize(list, options = {})
+      @list = list
+      @threads_count = options.fetch(:threads_count) { 20 }
+      @result = []
+      @total_slices = (@list.size / @threads_count.to_f).ceil
+    end
+
+    # Validates list of emails
+    # @return [Array]
+    def filter
+      @filtered ||= run_filter
+    end
+
+    private
+
+    attr_reader :result, :total_slices
+
+    def run_filter
+      threads = (0...total_slices).map do |slice_index|
+        Thread.new { filter_slice(slice_index) }
+      end
+      threads.each { |thread| thread.join }
+      result.select { |email| email }
+    end
+
+    def filter_slice(slice_index)
+      start_index = (threads_count * slice_index)
+      end_index = [start_index + threads_count, list.size].min
+      (start_index...end_index).each do |list_index|
+        email = list[list_index]
+        result[list_index] = email if EmailValidator.valid?(email)
+      end
+    end
+  end
+end

data/lib/rich_email_validator/version.rb

@@ -0,0 +1,15 @@
+module RichEmailValidator
+  # Gem's version
+  class Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+
+    class << self
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH].compact.join('.')
+      end
+    end
+  end
+end

data/lib/rich_email_validator.rb

@@ -0,0 +1,48 @@
+require_relative 'rich_email_validator/version'
+require_relative 'rich_email_validator/email_validator'
+require_relative 'rich_email_validator/list_validator'
+require_relative 'rich_email_validator/file_validator'
+
+# RichEmailValidator top level module
+module RichEmailValidator
+  class << self
+    # Validates an email
+    # @param email [String]
+    # @return [Boolean]
+    def valid_email?(email)
+      EmailValidator.valid?(email)
+    end
+
+    # Validates list of emails
+    # @param list [Enumerator]
+    # @param [Hash] options
+    # @option options [#to_int] :threads_count number of threads that will
+    #  be fired simultaneously to calculate the result
+    # @return [Array]
+    def filter_list(list, options = {})
+      ListValidator.filter(list, options)
+    end
+
+    # Validates input from file
+    # @param input_file_path [File]
+    # @param [Hash] options
+    # @option options [#to_int] :threads_count number of threads that will
+    #  be fired simultaneously to calculate the result
+    # @return [Array]
+    def filter_file(input_file_path, options = {})
+      FileValidator.filter(input_file_path, options)
+    end
+
+    # Validates input from file and writes to file
+    # @param input_file_path [File]
+    # @param output_file_path [File]
+    # @param [Hash] options
+    # @option options [#to_int] :threads_count number of threads that will
+    #  be fired simultaneously to calculate the result
+    def export_valid_list(input_file_path, output_file_path, options = {})
+      FileValidator.export_valid_list(input_file_path,
+                                      output_file_path,
+                                      options)
+    end
+  end
+end

data/rich_email_validator.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rich_email_validator/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rich_email_validator"
+  gem.version       = RichEmailValidator::Version
+  gem.authors       = ["Khaled alHabache"]
+  gem.email         = ["khellls@gmail.com"]
+  gem.summary       = %q{Set of helpers to validate emails}
+  gem.description   = %q{Set of helpers to validate emails}
+  gem.homepage      = "https://github.com/Startappz/rich_email_validator"
+  gem.license       = 'LGPL-3'
+  gem.required_ruby_version = '>= 1.9.2'
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files = Dir.glob('spec/**/*')
+  gem.require_paths = ['lib']
+end

data/spec/fixtures/list_fixture.txt

@@ -0,0 +1,15 @@
+fatmazohra27688@hotmail.com
+rawnd2013@gmail.com
+al7.zena@hotmail.com
+saron@a121@gmail.com
+batoolsali@hotmail.com
+faroha20032@hotmail.com
+khellls@gmail.com
+um.rashoodi@live.com
+www kowtheralhabsi@yahoo.com
+lolatop42@yahoo.com
+hessa41185@hotmail.com
+nevony_2005[@yahoo.com
+@dghc.com
+moooon_880@hotmail.com
+hassan@@adnan.com.sa

data/spec/fixtures/valid_fixture.txt

@@ -0,0 +1,10 @@
+fatmazohra27688@hotmail.com
+rawnd2013@gmail.com
+al7.zena@hotmail.com
+batoolsali@hotmail.com
+faroha20032@hotmail.com
+khellls@gmail.com
+um.rashoodi@live.com
+lolatop42@yahoo.com
+hessa41185@hotmail.com
+moooon_880@hotmail.com

data/spec/helper.rb

@@ -0,0 +1,103 @@
+require_relative '../lib/rich_email_validator'
+
+#  This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+
+RSpec.configure do |config|
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end
+
+def fixture_path(path)
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', path))
+end
+
+def get_list(file_name)
+  File.readlines(fixture_path(file_name)).map(&:chomp)
+end

data/spec/rich_email_validator/email_validator_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+EmailValidator = RichEmailValidator::EmailValidator
+
+describe EmailValidator do
+
+  describe '#validate_email' do
+
+    context 'valid email' do
+      it 'returns true for valid email' do
+        email = 'khellls@gmail.com'
+        validator = EmailValidator.new(email)
+        expect(validator.valid?).to eq(true)
+      end
+    end
+
+    context 'non valid email' do
+      it 'returns false for invalid email format' do
+        email = '@gmail.com'
+        validator = EmailValidator.new(email)
+        expect(validator.valid?).to eq(false)
+      end
+
+      it 'returns false for invalid DNS' do
+        email = 'koko@gsfsfsf.com'
+        validator = EmailValidator.new(email)
+        expect(validator.valid?).to eq(false)
+      end
+    end
+  end
+
+  describe '::regexp' do
+    after(:each) { EmailValidator.email_regexp = nil }
+    it 'returns default regexp if not set' do
+      EmailValidator.email_regexp = nil
+      expect(EmailValidator).to receive(:default_email_regexp)
+      EmailValidator.email_regexp
+    end
+
+    it 'returns regexp if set' do
+      EmailValidator.email_regexp = /\d/
+      expect(EmailValidator).not_to receive(:default_email_regexp)
+      EmailValidator.email_regexp
+    end
+  end
+
+end

data/spec/rich_email_validator/file_validator_spec.rb

@@ -0,0 +1,28 @@
+require 'helper'
+require 'fileutils'
+
+FileValidator = RichEmailValidator::FileValidator
+
+describe FileValidator do
+  let(:invalid_fixture_path) { fixture_path('list_fixture.txt') }
+  let(:valid_fixture_path) { fixture_path('valid_fixture.txt') }
+
+  describe '#filter' do
+    let(:valid_list) { get_list('valid_fixture.txt') }
+    it 'returns a list of valid emails' do
+      output = FileValidator.new(invalid_fixture_path).filter
+      expect(output).to eq(valid_list)
+    end
+  end
+
+  describe '#export_valid_list' do
+    let(:output_path) { fixture_path('output.tmp') }
+    after(:each) { FileUtils.rm_rf(output_path) }
+    it 'creates new file with with valid emails' do
+      FileValidator.new(invalid_fixture_path).export_valid_list(output_path)
+      output_data = File.read(output_path)
+      valid_fixture_data = File.read(valid_fixture_path)
+      expect(output_data).to eq(valid_fixture_data)
+    end
+  end
+end

data/spec/rich_email_validator/list_validator_spec.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+ListValidator = RichEmailValidator::ListValidator
+
+describe ListValidator do
+
+  describe '#filter' do
+    let(:list) { get_list('list_fixture.txt') }
+    let(:valid_list) { get_list('valid_fixture.txt') }
+    it 'returns a list of valid emails' do
+      output = ListValidator.new(list).filter
+      expect(output).to eq(valid_list)
+    end
+  end
+end

data/spec/rich_email_validator/rich_email_validator_spec.rb

@@ -0,0 +1,86 @@
+require 'helper'
+
+describe RichEmailValidator do
+  describe '::valid_email' do
+    let(:email) { 'somehting' }
+    let(:result) { [true, false].sample }
+
+    before(:each) do
+      allow(RichEmailValidator::EmailValidator)
+      .to receive(:valid?).with(email).and_return(result)
+    end
+
+    it 'delegates to EmailValidator' do
+      expect(RichEmailValidator::EmailValidator)
+      .to receive(:valid?).with(email).and_return(result)
+      RichEmailValidator.valid_email?(email)
+    end
+
+    it 'returns the same delegated call result' do
+      expect(RichEmailValidator.valid_email?(email)).to eq(result)
+    end
+  end
+
+  describe '::filter_list' do
+    let(:list) { %w(one, two) }
+    let(:options) { { o: 1, t: 2 } }
+    let(:result) { [true, false].sample }
+
+    before(:each) do
+      allow(RichEmailValidator::ListValidator)
+      .to receive(:filter).with(list, options).and_return(result)
+    end
+
+    it 'delegates to EmailValidator' do
+      expect(RichEmailValidator::ListValidator)
+      .to receive(:filter).with(list, options).and_return(result)
+      RichEmailValidator.filter_list(list, options)
+    end
+
+    it 'returns the same delegated call result' do
+      expect(RichEmailValidator.filter_list(list, options)).to eq(result)
+    end
+  end
+
+  describe '::filter_file' do
+    let(:file_path) { 'somewhere' }
+    let(:options) { { o: 1, t: 2 } }
+    let(:result) { [true, false].sample }
+
+    before(:each) do
+      allow(RichEmailValidator::FileValidator)
+      .to receive(:filter).with(file_path, options).and_return(result)
+    end
+
+    it 'delegates to EmailValidator' do
+      expect(RichEmailValidator::FileValidator)
+      .to receive(:filter).with(file_path, options).and_return(result)
+      RichEmailValidator.filter_file(file_path, options)
+    end
+
+    it 'returns the same delegated call result' do
+      expect(RichEmailValidator.filter_file(file_path, options)).to eq(result)
+    end
+  end
+
+  describe '::export_valid_list' do
+    let(:file_path) { 'somewhere' }
+    let(:output_file_path) { 'somewhere' }
+    let(:options) { { o: 1, t: 2 } }
+    let(:result) { [true, false].sample }
+
+    before(:each) do
+      allow(RichEmailValidator::FileValidator)
+      .to receive(:export_valid_list)
+      .with(file_path, options)
+    end
+
+    it 'delegates to EmailValidator' do
+      expect(RichEmailValidator::FileValidator)
+      .to receive(:export_valid_list)
+      .with(file_path, output_file_path, options)
+      RichEmailValidator.export_valid_list(file_path, output_file_path, options)
+    end
+  end
+
+end

data/spec/rich_email_validator/version_spec.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+describe RichEmailValidator do
+
+  it 'must be defined' do
+    expect(RichEmailValidator::Version).to be
+  end
+
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: rich_email_validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Khaled alHabache
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-16 00:00:00.000000000 Z
+dependencies: []
+description: Set of helpers to validate emails
+email:
+- khellls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Guardfile
+- LICENSE.md
+- README.md
+- Rakefile
+- collection.rb
+- lib/rich_email_validator.rb
+- lib/rich_email_validator/email_validator.rb
+- lib/rich_email_validator/file_validator.rb
+- lib/rich_email_validator/list_validator.rb
+- lib/rich_email_validator/version.rb
+- rich_email_validator.gemspec
+- spec/fixtures/list_fixture.txt
+- spec/fixtures/valid_fixture.txt
+- spec/helper.rb
+- spec/rich_email_validator/email_validator_spec.rb
+- spec/rich_email_validator/file_validator_spec.rb
+- spec/rich_email_validator/list_validator_spec.rb
+- spec/rich_email_validator/rich_email_validator_spec.rb
+- spec/rich_email_validator/version_spec.rb
+homepage: https://github.com/Startappz/rich_email_validator
+licenses:
+- LGPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Set of helpers to validate emails
+test_files:
+- spec/fixtures/list_fixture.txt
+- spec/fixtures/valid_fixture.txt
+- spec/helper.rb
+- spec/rich_email_validator/email_validator_spec.rb
+- spec/rich_email_validator/file_validator_spec.rb
+- spec/rich_email_validator/list_validator_spec.rb
+- spec/rich_email_validator/rich_email_validator_spec.rb
+- spec/rich_email_validator/version_spec.rb
+has_rdoc: