dnsaur 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f66e48837e8ecf6f1054428ec24ded5bb6dac963
+  data.tar.gz: 60c6ead262c3ec8520a55c178fb4113978a1482a
+SHA512:
+  metadata.gz: aff9730e949bc99f3ce852f46a5b2183bb7cccc41def6e738da726734f3d9103fdcdf66e8c54a059d315cd3043bd5ef4ca60ade445710e87a13b590319aed295
+  data.tar.gz: 067d14eb95347c9eff2bae485b7cf3e8beddca05964cf614a493b2b613706067b51fd136aca82ca670082010885ea6367d0f44c3af03f5c6ad9ca632947be072

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: 8NC95fsJvtAh0zfZgqPvvDAjJqs4ZGXs9

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# OSX Operating files
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.1.3

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem "codeclimate-test-reporter", group: :test, require: nil
+  gem 'coveralls', require: false
+  gem 'guard-rspec', require: false
+  gem 'pry'
+  gem 'rake'
+  gem 'rspec', '~> 3.1.0'
+  gem 'terminal-notifier-guard'
+end

data/Gemfile.lock

@@ -0,0 +1,85 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    codeclimate-test-reporter (0.4.1)
+      simplecov (>= 0.7.1, < 1.0.0)
+    coderay (1.1.0)
+    coveralls (0.7.1)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    ffi (1.9.6)
+    formatador (0.2.5)
+    guard (2.7.0)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.3.1)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    hitimes (1.2.2)
+    listen (2.7.11)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    mime-types (2.4.3)
+    multi_json (1.10.1)
+    netrc (0.8.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    terminal-notifier-guard (1.6.1)
+    thor (0.19.1)
+    timers (4.0.1)
+      hitimes
+    tins (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  codeclimate-test-reporter
+  coveralls
+  guard-rspec
+  pry
+  rake
+  rspec (~> 3.1.0)
+  terminal-notifier-guard

data/Guardfile

@@ -0,0 +1,7 @@
+guard :rspec, cmd: "bundle exec rspec"  do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  notification :terminal_notifier
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Patrick Vice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,140 @@
+#Dnsaur
+[![Code Climate](https://codeclimate.com/github/patvice/dnsaur/badges/gpa.svg)](https://codeclimate.com/github/patvice/dnsaur) [![Coverage Status](https://coveralls.io/repos/patvice/dnsaur/badge.png?branch=master)](https://coveralls.io/r/patvice/dnsaur?branch=master) [![Circle CI](https://circleci.com/gh/patvice/dnsaur.png?style=badge)](https://circleci.com/gh/patvice/dnsaur)
+
+
+Dnsaur is a simple DNS checker / email corrector for ruby. This gem does three things; when a user misspells a domain, it suggests the right spelling, it provide simple reverse DNS helper methods to help verifiy these emails, and splits emails into three parts(top level domain, domain, address).
+
+The email suggestion part of the gem is based off a small javascript library called
+[mailcheck.js](https://github.com/mailcheck/mailcheck). If you are looking for a more front end
+solution for correcting email input, I suggest checking this out.
+
+## How the suggest works
+
+When your user types in "user@hotnail.con", Dnsaur will suggest "user@hotmail.com". It can also
+suggest top level domains, where a user types "user@hotmail.cmo" and would suggest ".com"
+
+It does this by comparing a list of popular default domains and defualt top level domains suplied to
+the gem.
+
+## Usage
+Dnsaur can be used ether as an instance or as class methods. When creating an instance you need to
+supply it with email,
+```ruby
+email = "test@example.com"
+dns = Dnsaur.new email
+=> #<Dnsaur:0x007fb8ea17d590 @original_email="test@example.com", ...
+```
+custom domains and/or custom top level domains are optional.
+For more information on custom domain, see the `Domains`section below.
+
+### Email Suggestion/Correction
+
+In the suggest method, you can pass an email and it will return a suggested email in a hash
+example:
+```ruby
+# Class Methods
+email = "test@hotnail.con"
+Dnsaur.suggest email
+=>
+{
+  address:          'test',             // the address; part before the @ sign
+  domain:           'hotmail.com',      // the suggested domain
+  top_level_domain: 'com',              // the suggested top level domain
+  full:             'test@hotmail.com'  // the full suggested email
+}
+```
+If there is no match, or it is an exact match to a defualt domain, it will return false.
+
+### Reverse DNS lookup Helpers
+The DNS lookup for this gem uses `Resolv` from the ruby stdlib, but I supplied class/instanced helper methods
+for ease of use. If you have an instances of the class, it
+
+```ruby
+#Class Methods
+email = "test@example.com"
+Dnsaur.valid_dns? email
+=> true || false
+
+#Instant Methods
+email = "test@hotnail.com"
+dns = Dnsaur.new email
+dns.valid_original_dns?
+=> true || false
+
+dns.valid_suggested_email?
+=> true || false
+```
+
+### Spliting and Vaildating Emails
+
+The split_email method is used to split the email into three parts
+```ruby
+email = "test@exmaple.com"
+Dnsaur.split_email email
+{
+  top_level_domain: 'com',         // the top level domain
+  domain:           'example.com', // the domain
+  address:          'test'         // the address; part before the @ sign
+}
+```
+
+## Domains
+Just like [mailcheck.js](https://github.com/mailcheck/mailcheck), you can and should give Dnsaur
+a custom list of domains/top level domains that your user will most likely use to sign up.
+
+This can be done in two different way, ether by giving a completly new list and passing it
+into and instance:
+```ruby
+email = "test@example.com"
+domains = ['customdomain.com', 'anotherdomain.net']
+top_level_domains = ['com.au', 'ru']
+
+Dnsaur.default_domains = domains
+Dnsaur.default_top_level_domains = top_level_domains
+
+Dnsaur.default_domains
+=> ["customdomain.com", "anotherdomain.net"]
+Dnsaur.default_top_level_domains
+=> ["com.au", "ru"]
+```
+
+Or if you want to just add values to the default domains provided,
+you can pushing new values into the class constants:
+```ruby
+Dnsaur.default_domains.push('customdomain.com', 'anotherdomain.net')
+Dnsaur.default_top_level_domains.push('com.au', 'ru')
+```
+
+`default_domains` and `default_top_level_domains` are class members, with one change, all other instances of your class will have your custom list of domains
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dnsaur'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dnsaur
+
+## Still left Todo
+
+There is still alot of polish that I would like to do to the code in this gem, and I would
+also like to add some more functionality for validating emails:
+
+- More test, and better test for all specs
+- RFC822 regexp-based to be able to validate emails. [link](http://ex-parrot.com/~pdw/Mail-RFC822-Address.html)
+- Using STMP VRFY command as well as RCTP TO: for better DNS validation
+- Improve suggest methods readlity, and usablity
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/dnsaur/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 @@
+Dir.glob('tasks/**/*.rake').each(&method(:import))

data/dnsaur.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'dnsaur'
+
+Gem::Specification.new do |s|
+  s.name          = 'dnsaur'
+  s.version       = Dnsaur::VERSION
+  s.date          = '2014-10-25'
+  s.authors       = ['Patrick Vice']
+  s.email         = ['patrickgvice@gmail.com']
+  s.summary       = 'A simple dns checker/ mistyped email suggester'
+  s.description   = <<-EOF
+   Dnsaur is a simple DNS checker / email corrector for ruby. This gem does three
+   things; when a user misspells a domain, it suggests the right spelling, it
+   provide simple reverse DNS helper methods to help verifiy these emails, and
+   splits emails into three parts(top level domain, domain, address).
+  EOF
+  s.homepage      = 'https://github.com/pavice/dnsaur'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

data/lib/dnsaur/dnsaur.rb

@@ -0,0 +1,61 @@
+require "dnsaur/version"
+require "dnsaur/sift_3_distance"
+require "dnsaur/email_manipulation"
+
+class Dnsaur
+  include EmailManipulation
+
+  ARG_ERROR = "An email can not be empty or invalid"
+  attr_reader :original_email
+
+  def initialize email
+    if Dnsaur.valid_email? email
+      @original_email = email
+    else
+      raise ArgumentError, ARG_ERROR
+    end
+    @suggested_email = suggest @original_email
+  end
+
+  def self.open(*args)
+    dnsaur = new(*args)
+    return dnsaur unless block_given?
+    begin
+      yield dnsaur
+    end
+  end
+
+  def original_email
+    @original_email
+  end
+
+  def original_email= email
+    raise ArgumentError, ARG_ERROR unless Dnsaur.valid_email? email
+    @original_email = email
+    @suggested_email = suggest email
+  end
+
+  def suggested_email
+    return false unless @suggested_email
+    @suggested_email[:full] if @suggested_email
+  end
+
+  def valid_original_dns?
+    Dnsaur.valid_dns? @original_email
+  end
+
+  def valid_suggested_dns?
+    return false unless @suggested_email
+    Dnsaur.valid_dns? @suggested_email[:full]
+  end
+
+  def self.valid_dns? email
+    email_parts = Dnsaur.split_email email
+    mx = Resolv::DNS.open.getresources(email_parts[:domain], Resolv::DNS::Resource::IN::MX)
+    mx.size > 0 ? true : false
+  end
+
+  def self.valid_email? email
+    !!(Dnsaur.split_email email)
+  end
+end

data/lib/dnsaur/email_manipulation.rb

@@ -0,0 +1,97 @@
+require 'pry'
+
+module EmailManipulation
+  include Sift3Distance
+
+  DOMAIN_THRESHOLD = 4
+  TOP_LEVEL_THRESHOLD = 3
+  DEFAULT_ERROR = "default domains list can't be nil or empty"
+  TOP_LEVEL_ERROR = "default top level domains can't be nil or empty"
+
+
+  @@default_domains = ["yahoo.com", "google.com", "hotmail.com", "gmail.com", "me.com", "aol.com", "mac.com",
+                       "live.com", "comcast.net", "googlemail.com", "msn.com", "hotmail.co.uk", "yahoo.co.uk",
+                       "facebook.com", "verizon.net", "sbcglobal.net", "att.net", "gmx.com", "mail.com",
+                       "outlook.com", "icloud.com"]
+
+  @@default_top_level_domains = ["co.jp", "co.uk", "com", "net", "org", "info", "edu", "gov", "mil", "ca"]
+
+  def default_domains
+    @@default_domains
+  end
+
+  def default_domains= domains
+    raise ArgumentError, DEFAULT_ERROR if domains.nil? || domains.empty?
+    @@default_domains = domains
+  end
+
+  def default_top_level_domains
+    @@default_top_level_domains
+  end
+
+  def default_top_level_domains= top_level_domains
+    raise ArgumentError, TOP_LEVEL_ERROR if top_level_domains.nil? || top_level_domains.empty?
+    @@default_top_level_domains = top_level_domains
+  end
+
+  def suggest email
+    email_parts = self.split_email(email)
+    closest_domain = self.find_closest_domain(email_parts[:domain], @@default_domains, DOMAIN_THRESHOLD)
+
+    if closest_domain
+      if closest_domain != email_parts[:domain]
+        return { address: email_parts[:address], domain: closest_domain, full: email_parts[:address] + "@" + closest_domain }
+      end
+    else
+      closest_top_level_domain = self.find_closest_domain(email_parts[:top_level_domain], @@default_top_level_domains, TOP_LEVEL_THRESHOLD)
+
+      if closest_top_level_domain && closest_top_level_domain != email_parts[:top_level_domain]
+        closest_domain = email_parts[:domain].split('.', 2).first + '.' + closest_top_level_domain
+
+        return { address: email_parts[:address], domain: closest_domain, full: email_parts[:address] + "@" + closest_domain }
+      end
+    end
+
+    return false
+  end
+
+  def split_email email
+    parts = email.downcase.split('@')
+
+    return false if parts.length < 2 || parts.include?('')
+
+    address = parts.first
+    domain = parts.last
+    top_level_domain = domain.split('.', 2).last
+
+    return {top_level_domain: top_level_domain, domain: domain, address: address}
+  end
+
+  def find_closest_domain domain, domains, threshold
+    min_distance = 99
+    closest_domain = nil
+
+    return false if !domain || !domains
+
+    domains.each do |d|
+      if domain == d
+        return
+      end
+      dist = self.sift_3_distance(domain, d)
+      if (dist < min_distance)
+        min_distance = dist
+        closest_domain = d
+      end
+    end
+
+    if min_distance <= threshold && !closest_domain.nil?
+      return closest_domain
+    else
+      return false
+    end
+  end
+
+  def self.included(base)
+    base.extend(EmailManipulation)
+  end
+end

data/lib/dnsaur/sift_3_distance.rb

@@ -0,0 +1,48 @@
+module Sift3Distance
+
+  def sift_3_distance s1, s2
+    #My version of the the sift3 algorithm re-written in ruby
+    # sift3: http://siderite.blogspot.com/2007/04/super-fast-and-accurate-string-distance.html
+    if s1.nil? || s1.length == 0
+      if s2.nil? || s2.length == 0
+        return 0;
+      else
+        return s2.length
+      end
+    end
+
+    return s1.length if s2.nil? || s2.length == 0
+
+    c = 0
+    offset1 = 0
+    offset2 = 0
+    lcs = 0
+    max_offset = 5
+
+    begin
+      if s1[c + offset1] == s2[c + offset2]
+        lcs+= 1
+      else
+        offset1 = 0
+        offset2 = 0
+        max_offset.times do |i|
+          if (c+i < s1.length) && (s1[c+i] == s2[c])
+            offset1 = i
+            break
+          end
+          if (c+i < s2.length) && (s1[c] == s2[c+i])
+            offset2 = i
+            break
+          end
+        end
+      end
+      c+= 1
+    end while c+offset1 < s1.length && c+offset2 < s2.length
+
+    (s1.length + s2.length)/2 - lcs
+  end
+
+  def self.included(base)
+    base.extend(Sift3Distance)
+  end
+end

data/lib/dnsaur/version.rb

@@ -0,0 +1,3 @@
+class Dnsaur
+  VERSION = '0.1.0'
+end

data/lib/dnsaur.rb

@@ -0,0 +1 @@
+require "dnsaur/dnsaur"

data/spec/lib/dnsaur/dnsaur_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Dnsaur do
+
+  describe "::initialize" do
+    it "when the email is invalid it raises an error" do
+      email = ""
+      expect{ Dnsaur.new email }.to raise_error(ArgumentError)
+    end
+    it "suggests an email when it being initialized" do
+      email = "test@hotnail.con"
+      dns = Dnsaur.new email
+      expect(dns.suggested_email).to be_truthy
+    end
+  end
+
+  context "class methods" do
+
+    describe "::valid_dns?" do
+      it "returns true when there reverse DNS lookup returns MX" do
+        email = "test@example.com"
+        Resolv::DNS.stub_chain(:open, :getresources).and_return ['true', 'true']
+        expect(Dnsaur.valid_dns? email).to be true
+      end
+      it "returns false when there is no MX for that domain" do
+        email = "test@example.com"
+        Resolv::DNS.stub_chain(:open, :getresources).and_return []
+        expect(Dnsaur.valid_dns? email).to be false
+      end
+    end
+
+    describe "::valid_email?" do
+      it "returns true when the email format is valid" do
+        email = "test@example.com"
+        expect(Dnsaur.valid_email? email).to be true
+      end
+      it "returns false when the email format is not valid" do
+        email = "test@"
+        expect(Dnsaur.valid_email? email).to be false
+      end
+    end
+  end
+
+  context 'instance methods' do
+    before do
+      @dnsaur = Dnsaur.new "test@hotnail.com"
+    end
+
+    describe "#original_email" do
+     it "returns an email given when a new instance is created" do
+        expect(@dnsaur.original_email).to eq("test@hotnail.com")
+      end
+    end
+
+    describe "#original_email=" do
+      it "sets a new email for that object" do
+        email = "test@example.com"
+        @dnsaur.original_email = email
+        expect(@dnsaur.original_email).to eq(email)
+      end
+      it "sets a new suggestion when an email is changed" do
+        email = "test@example.com"
+        @dnsaur.original_email = email
+        expect(@dnsaur.suggested_email).to be_falsey
+      end
+      it "raises an error when trying to change to an invalid email" do
+        email = "test@"
+        expect{@dnsaur.original_email= email}.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "#suggested_email" do
+      it "returns a suggested email" do
+        expect(@dnsaur.suggested_email).to eq('test@hotmail.com')
+      end
+      it "it returns false if there is not suggest" do
+        email = "test@example.com"
+        @dnsaur.original_email = email
+        expect(@dnsaur.suggested_email).to be_falsey
+      end
+    end
+
+    describe "#valid_original_dns?" do
+      it "returns true when reverse DNS lookup returns MX" do
+        Resolv::DNS.stub_chain(:open, :getresources).and_return ['true', 'true']
+        expect(@dnsaur.valid_original_dns?).to be true
+      end
+      it "returns fail when there is no MX for that domain" do
+        Resolv::DNS.stub_chain(:open, :getresources).and_return []
+        expect(@dnsaur.valid_original_dns?).to be false
+      end
+    end
+
+    describe "#valid_suggested_dns?" do
+      it "returns true when there reverse DNS lookup returns MX" do
+        Resolv::DNS.stub_chain(:open, :getresources).and_return ['true', 'true']
+        expect(@dnsaur.valid_suggested_dns?).to be true
+      end
+      it "returns false when there is no MX for that domain" do
+        Resolv::DNS.stub_chain(:open, :getresources).and_return []
+        expect(@dnsaur.valid_suggested_dns?).to be false
+      end
+    end
+  end
+end

data/spec/lib/dnsaur/email_manipulation_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe EmailManipulation do
+  let(:domains) {["yahoo.com", "google.com", "hotmail.com", "gmail.com", "me.com", "aol.com", "mac.com",
+                  "live.com", "comcast.net", "googlemail.com", "msn.com", "hotmail.co.uk", "yahoo.co.uk",
+                  "facebook.com", "verizon.net", "sbcglobal.net", "att.net", "gmx.com", "mail.com",
+                  "outlook.com", "icloud.com"] }
+
+  let(:top_level_domains){ ["co.jp", "co.uk", "com", "net", "org", "info", "edu", "gov", "mil", "ca"] }
+
+  class DummyEmailManipulation
+  end
+
+  before(:each) do
+    @email_manipulation = DummyEmailManipulation.new
+    @email_manipulation.extend(EmailManipulation)
+  end
+  after(:each) do
+    @email_manipulation.default_domains = domains
+    @email_manipulation.default_top_level_domains = top_level_domains
+  end
+
+  describe "#default_domains" do
+    it "returns a list of domains" do
+      expect(@email_manipulation.default_domains).to be_truthy
+    end
+  end
+
+  describe "#default_domains=" do
+    it "assigns a new set of domains" do
+      domain_list = ['example.com', 'fake.org']
+      @email_manipulation.default_domains= domain_list
+      expect(@email_manipulation.default_domains).to eq(domain_list)
+    end
+    it "raise an error when passed an empty array" do
+      domain_list = []
+      expect{@email_manipulation.default_domains= domain_list}.to raise_error
+    end
+    it "raises an error when passed nil" do
+      domain_list = nil
+      expect{@email_manipulation.default_domains= domain_list}.to raise_error
+    end
+  end
+
+  describe "#default_top_level_domains" do
+    it "returns a list of top_level_domains" do
+      expect(@email_manipulation.default_top_level_domains).to be_truthy
+    end
+  end
+
+  describe "#default_top_level_domains=" do
+    it "assigns a new set of domains" do
+      tldomain_list = ['example.com', 'fake.org']
+      @email_manipulation.default_top_level_domains= tldomain_list
+      expect(@email_manipulation.default_top_level_domains).to eq(tldomain_list)
+    end
+    it "raise an error when passed an empty array" do
+      tldomain_list = []
+      expect{@email_manipulation.default_top_level_domains= tldomain_list}.to raise_error
+    end
+    it "raises an error when passed nil" do
+      tldomain_list = nil
+      expect{@email_manipulation.default_top_level_domains= tldomain_list}.to raise_error
+    end
+  end
+
+  describe "#suggest" do
+    it "returns a corrected top level domain" do
+      email = "test@example.con"
+      suggest_return = {address: "test", domain: "example.com", full: "test@example.com"}
+      expect(@email_manipulation.suggest email).to eq(suggest_return)
+    end
+    it "returns a corrected domain" do
+      email = "test@hotnail.con"
+      suggest_return = {address: "test", domain: "hotmail.com", full: "test@hotmail.com"}
+      expect(@email_manipulation.suggest email).to eq(suggest_return)
+    end
+    it "returns false when a email doesn't match default domains" do
+      email = "test@example.com"
+      expect(@email_manipulation.suggest email).to be false
+    end
+  end
+
+  describe "#split_email" do
+    it "splits an email into three parts" do
+      email = 'test@example.com'
+      split_return = {top_level_domain: 'com',domain: 'example.com', address: 'test'}
+      expect(@email_manipulation.split_email email).to eq(split_return)
+    end
+    it "returns the same top level domain/domain when givin an domain without a top level domain" do
+      #this is actually a valid email, according
+      email = 'test@example'
+      split_return = {:top_level_domain=>"example", :domain=>"example", :address=>"test"}
+      expect(@email_manipulation.split_email email).to eq(split_return)
+    end
+    it "returns false if the email doesn't have a domain" do
+      email = 'test@'
+      expect(@email_manipulation.split_email email).to be false
+    end
+    it "returns false if there is no @ symbol in the string" do
+      email = 'test'
+      expect(@email_manipulation.split_email email).to be false
+    end
+  end
+
+  describe "#find_closest_domain" do
+    it "returns false when passed nil attributes" do
+      expect(@email_manipulation.find_closest_domain nil, nil, 4).to be false
+    end
+    it "returns false when there is no match" do
+      domain = "example.com"
+      expect(@email_manipulation.find_closest_domain domain, domains, 4).to be false
+    end
+    it "returns nil when there is an exact match" do
+      domain = "hotmail.com"
+      expect(@email_manipulation.find_closest_domain domain, domains, 4).to be nil
+    end
+    it "passes a suggestion when there is a differece less then the threshold" do
+      domain = "hotmail.c"
+      expect(@email_manipulation.find_closest_domain domain, domains, 4).to eq('hotmail.com')
+    end
+  end
+end

data/spec/lib/dnsaur/sift_3_distance_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Sift3Distance do
+  class DummySift3Distance
+  end
+
+  before(:each) do
+    @sift_3_distance = DummySift3Distance.new
+    @sift_3_distance.extend(Sift3Distance)
+  end
+
+  describe "#sift_3_distance" do
+    it "returns the different of two strings" do
+      s1 = "example"
+      s2 = "eample"
+      expect(@sift_3_distance.sift_3_distance s1, s2).to eq 1
+    end
+    it "returns zero when both arguments is nil or empty" do
+      s1 = nil
+      s2 = ""
+      expect(@sift_3_distance.sift_3_distance s1, s2).to eq 0
+    end
+    it "returns the length of the first string if the second sring is nil or empty" do
+      s1 = "example"
+      s2 = nil
+      expect(@sift_3_distance.sift_3_distance s1, s2).to eq s1.length
+    end
+    it "returns the length of the second string if the first string is nil or empty" do
+      s1 = nil
+      s2 = "example"
+      expect(@sift_3_distance.sift_3_distance s1, s2).to eq s2.length
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'dnsaur'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

data/tasks/debug.rake

@@ -0,0 +1,4 @@
+desc 'Open an irb session preloaded with this library'
+task :console do
+  sh 'irb -rubygems -I lib -r dnsaur.rb'
+end

data/tasks/rspec.rake

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: dnsaur
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick Vice
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-25 00:00:00.000000000 Z
+dependencies: []
+description: |2
+     Dnsaur is a simple DNS checker / email corrector for ruby. This gem does three
+     things; when a user misspells a domain, it suggests the right spelling, it
+     provide simple reverse DNS helper methods to help verifiy these emails, and
+     splits emails into three parts(top level domain, domain, address).
+email:
+- patrickgvice@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- dnsaur.gemspec
+- lib/dnsaur.rb
+- lib/dnsaur/dnsaur.rb
+- lib/dnsaur/email_manipulation.rb
+- lib/dnsaur/sift_3_distance.rb
+- lib/dnsaur/version.rb
+- spec/lib/dnsaur/dnsaur_spec.rb
+- spec/lib/dnsaur/email_manipulation_spec.rb
+- spec/lib/dnsaur/sift_3_distance_spec.rb
+- spec/spec_helper.rb
+- tasks/debug.rake
+- tasks/rspec.rake
+homepage: https://github.com/pavice/dnsaur
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple dns checker/ mistyped email suggester
+test_files: []