gman 1.0.0 → 2.0.0

data/lib/gman.rb

@@ -2,10 +2,48 @@ require 'public_suffix'
 require 'yaml'
 require 'swot'
 require "addressable/uri"
-require "email_veracity"
 
 module Gman
 
+  # Source: http://bit.ly/1n2X9iv
+  EMAIL_REGEX = %r{
+        ^
+        (
+          [\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+
+          \.
+        )
+        *
+        [\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+
+        @
+        (
+          (
+            (
+              (
+                (
+                  [a-z0-9]{1}
+                  [a-z0-9\-]{0,62}
+                  [a-z0-9]{1}
+                )
+                |
+                [a-z]
+              )
+              \.
+            )+
+            [a-z]{2,6}
+          )
+          |
+          (
+            \d{1,3}
+            \.
+          ){3}
+          \d{1,3}
+          (
+            \:\d{1,5}
+          )?
+        )
+        $
+      }xi
+
   class << self
 
     # Normalizes and checks if a given string represents a governemnt domain
@@ -16,20 +54,12 @@ module Gman
     #   "foo.gov.uk"
     #   "http://foo.bar.gov"
     #
-    # check_mx - if an email is passed, check the domain for an mx record
-    #
     # Returns boolean true if a government domain
-    def valid?(text, check_mx=false)
+    def valid?(text)
 
       domain = get_domain text
       return false unless PublicSuffix.valid?(domain)
 
-      # validate mx record
-      if check_mx && email?(text)
-        EmailVeracity::Config[:skip_lookup] = false
-        return false unless EmailVeracity::Address.new(text).valid?
-      end
-
       # Ensure non-edu
       return false if Swot::is_academic?(domain)
 
@@ -44,7 +74,7 @@ module Gman
     # returns an instance of our custom public suffix list
     # list behaves like PublicSuffix::List but is limited to our whitelisted domains
     def list
-      @list ||= PublicSuffix::List::parse( File.new(File.join(File.dirname(__FILE__), "domains.txt"), "r:utf-8"))
+      @list ||= PublicSuffix::List::parse(File.new(list_path, "r:utf-8"))
     end
 
     # Get the FQDN name from a URL or email address.
@@ -60,12 +90,16 @@ module Gman
       if uri.host # valid https?://* URI
         uri.host
       elsif email?(text)
-        EmailVeracity::Address.new(text).domain.to_s
+        text.match(/@([\w\.\-]+)\Z/i)[1]
       else # url sans http://
-        uri = Addressable::URI.parse("http://#{text}")
-        # properly parse http://foo edge cases
-        # see https://github.com/sporkmonger/addressable/issues/145
-        uri.host if uri.host =~ /\./
+        begin
+          uri = Addressable::URI.parse("http://#{text}")
+          # properly parse http://foo edge cases
+          # see https://github.com/sporkmonger/addressable/issues/145
+          uri.host if uri.host =~ /\./
+        rescue Addressable::URI::InvalidURIError
+          nil
+        end
       end
     end
 
@@ -86,8 +120,12 @@ module Gman
     #
     # Returns true if email, otherwise false
     def email?(text)
-      EmailVeracity::Config[:skip_lookup] = true
-      EmailVeracity::Address.new(text).valid?
+      text =~ EMAIL_REGEX
+    end
+
+    # Returns the absolute path to the domain list
+    def list_path
+      @list_path ||= File.join(File.dirname(__FILE__), "domains.txt")
     end
   end
 end

data/test/helper.rb

@@ -1,20 +1,21 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'gman'
-require 'net/dns'
-require 'net/dns/resolver'
-
-class Test::Unit::TestCase
-end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gman'
+require 'net/dns'
+require 'net/dns/resolver'
+require './lib/gman/parser'
+
+class Test::Unit::TestCase
+end

data/test/test_gman.rb

@@ -1,122 +1,83 @@
-require 'helper'
-
-VALID = [  "foo.gov",
-            "http://foo.mil",
-            "foo@bar.gc.ca",
-            "foo.gov.au",
-            "https://www.foo.gouv.fr",
-            "foo@ci.champaign.il.us",
-            "foo.bar.baz.gov.au",
-            "foo@bar.gov.uk",
-            ".gov",
-            "foo.fed.us",
-        ]
-
-INVALID = [ "foo.bar.com",
-            "bar@foo.biz",
-            "http://www.foo.biz",
-            "foo.uk",
-            "gov",
-            "foo@k12.champaign.il.us",
-            "foo@kii.gov.by",
-            "foo",
-            "",
-            nil,
-            " ",
-          ]
-
-class TestGman < Test::Unit::TestCase
-
-  def domain_resolves?(domain)
-    res = Net::DNS::Resolver.new
-    res.nameservers = ["8.8.8.8","8.8.4.4", "208.67.222.222", "208.67.220.220"]
-    packet = res.search(domain, Net::DNS::NS)
-    packet.header.anCount > 0
-  end
-
-  should "recognize government email addresses and domains" do
-    VALID.each do |test|
-      assert_equal true, Gman::valid?(test), "#{test} should be detected as a valid government domain"
-    end
-  end
-
-  should "not recognize non-government email addresses and domains" do
-    INVALID.each do |test|
-      assert_equal false, Gman::valid?(test), "#{test} should be detected as an invalid government domain"
-    end
-  end
-
-  should "not contain any educational domains" do
-    Gman.list.each do |entry|
-      assert_equal false, Swot::is_academic?(entry.name), "#{entry.name} is an academic domain"
-    end
-  end
-
-  should "not contain any invalid domains" do
-    Gman.list.each do |entry|
-      assert_equal true, PublicSuffix.valid?("foo.#{entry.name}"), "#{entry.name} is not a valid domain"
-    end
-  end
-
-  should "not allow educational domains" do
-    assert_equal false, Gman::valid?("foo@gwu.edu")
-  end
-
-  should "properly parse domains from strings" do
-    assert_equal "github.gov", Gman::get_domain("foo@github.gov")
-    assert_equal "foo.github.gov", Gman::get_domain("foo.github.gov")
-    assert_equal "github.gov", Gman::get_domain("http://github.gov")
-    assert_equal "github.gov", Gman::get_domain("https://github.gov")
-    assert_equal ".gov", Gman::get_domain(".gov")
-    assert_equal nil, Gman.get_domain("foo")
-  end
-
-  should "validate mx records when asked" do
-    assert_equal true, Gman.valid?("foo@nasa.gov", true)
-    assert_equal false, Gman.valid?("foo@github.gov", true)
-    assert_equal true, Gman.valid?("foo@github.gov", false)
-  end
-
-  should "pass any url on the list" do
-    Gman.list.each do |entry|
-      assert_equal true, Gman.valid?("http://foo.#{entry.name}/bar"), "http://foo.#{entry.name}/bar is not a valid"
-    end
-  end
-
-  should "pass any email on the list" do
-    Gman.list.each do |entry|
-      assert_equal true, Gman.valid?("foo@bar.#{entry.name}"), "foo@bar.#{entry.name} is not a valid"
-    end
-  end
-
-  should "pass any domain on the list" do
-    Gman.list.each do |entry|
-      assert_equal true, Gman.valid?("foo.#{entry.name}"), "foo.#{entry.name} is not a valid domain"
-    end
-  end
-
-  should "only contain resolvable domains" do
-    Gman.list.each do |entry|
-      assert_equal true, domain_resolves? domain
-    end
-  end
-
-
-  should "not err out on invalid domains" do
-    assert_equal false, Gman.valid?("foo@act.gov.au")
-    assert_equal "act.gov.au", Gman.get_domain("foo@act.gov.au")
-    assert_equal nil, Gman.domain_parts("foo@act.gov.au")
-  end
-
-  should "return public suffix domain" do
-    assert_equal PublicSuffix::Domain, Gman.domain_parts("whitehouse.gov").class
-    assert_equal NilClass, Gman.domain_parts("foo.bar").class
-  end
-
-  should "parse domain parts" do
-    assert_equal "gov", Gman.domain_parts("foo@bar.gov").tld
-    assert_equal "bar", Gman.domain_parts("foo.bar.gov").sld
-    assert_equal "bar", Gman.domain_parts("https://foo.bar.gov").sld
-    assert_equal "bar.gov", Gman.domain_parts("foo@bar.gov").domain
-  end
-end
+require File.join(File.dirname(__FILE__), 'helper')
+
+VALID = [  "foo.gov",
+            "http://foo.mil",
+            "foo@bar.gc.ca",
+            "foo.gov.au",
+            "https://www.foo.gouv.fr",
+            "foo@ci.champaign.il.us",
+            "foo.bar.baz.gov.au",
+            "foo@bar.gov.uk",
+            ".gov",
+            "foo.fed.us",
+        ]
+
+INVALID = [ "foo.bar.com",
+            "bar@foo.biz",
+            "http://www.foo.biz",
+            "foo.uk",
+            "gov",
+            "foo@k12.champaign.il.us",
+            "foo@kii.gov.by",
+            "foo",
+            "",
+            nil,
+            " ",
+          ]
+
+class TestGman < Test::Unit::TestCase
+
+
+  should "recognize government email addresses and domains" do
+    VALID.each do |test|
+      assert_equal true, Gman::valid?(test), "#{test} should be detected as a valid government domain"
+    end
+  end
+
+  should "not recognize non-government email addresses and domains" do
+    INVALID.each do |test|
+      assert_equal false, Gman::valid?(test), "#{test} should be detected as an invalid government domain"
+    end
+  end
+
+  should "not allow educational domains" do
+    assert_equal false, Gman::valid?("foo@gwu.edu")
+  end
+
+  should "properly parse domains from strings" do
+    assert_equal "github.gov", Gman::get_domain("foo@github.gov")
+    assert_equal "foo.github.gov", Gman::get_domain("foo.github.gov")
+    assert_equal "github.gov", Gman::get_domain("http://github.gov")
+    assert_equal "github.gov", Gman::get_domain("https://github.gov")
+    assert_equal ".gov", Gman::get_domain(".gov")
+    assert_equal nil, Gman.get_domain("foo")
+  end
+
+  should "not err out on invalid domains" do
+    assert_equal false, Gman.valid?("foo@act.gov.au")
+    assert_equal "act.gov.au", Gman.get_domain("foo@act.gov.au")
+    assert_equal nil, Gman.domain_parts("foo@act.gov.au")
+  end
+
+  should "return public suffix domain" do
+    assert_equal PublicSuffix::Domain, Gman.domain_parts("whitehouse.gov").class
+    assert_equal NilClass, Gman.domain_parts("foo.bar").class
+  end
+
+  should "parse domain parts" do
+    assert_equal "gov", Gman.domain_parts("foo@bar.gov").tld
+    assert_equal "bar", Gman.domain_parts("foo.bar.gov").sld
+    assert_equal "bar", Gman.domain_parts("https://foo.bar.gov").sld
+    assert_equal "bar.gov", Gman.domain_parts("foo@bar.gov").domain
+  end
+
+  should "not err out on invalid hosts" do
+    assert_nothing_raised do
+      assert_equal nil, Gman.get_domain("</@foo.com")
+    end
+  end
+
+  should "returns the path to domains.txt" do
+    assert_equal true, File.exists?(Gman.list_path)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gman
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-23 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: public_suffix
@@ -43,22 +43,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: email_veracity
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement