email_address 0.0.3 → 0.1.0

data/lib/email_address/matcher.rb

@@ -1,119 +0,0 @@
-module EmailAddress
-  ##############################################################################
-  # Matcher - Allows matching of an email address against a list of matching
-  #           tokens.
-  #
-  # Match Patterns
-  #   * Top-Level-Domain:         .org
-  #   * Domain Name:              example.com
-  #   * Registration Name:        hotmail.   (matches any TLD)
-  #   * Domain Glob:              *.exampl?.com
-  #   * Provider Name:            google
-  #   * Mailbox Name or Glob:     user00*@
-  #   * Address or Glob:          postmaster@domain*.com
-  #   * Provider or Registration: msn (?? Possible combo for either match?)
-  #
-  # Usage:
-  #   m = EmailAddress::Matcher.new(".org example.com hotmail. google user*@ root@*.com")
-  #   m.include?("pat@example.com")
-  ##############################################################################
-
-  class Matcher
-    attr_reader :rules, :email
-
-    def self.matches?(rule, email)
-      EmailAddress::Matcher.new(rule).matches?(email)
-    end
-
-    def initialize(rules=[], empty_rules_return=false)
-      self.rules = rules
-      @empty_rules_return = empty_rules_return
-    end
-
-    def rules=(r)
-      @rules = r.is_a?(Array) ? r : r.split(/\s+/)
-      @rules = @rules.map(&:downcase)
-    end
-
-    def email=(e)
-      e = EmailAddress.new(e) if e.is_a?(String)
-      if e.is_a?(EmailAddress::Address)
-        @email_address    = e
-        @email            = e.normalize
-        @mailbox          = e.mailbox
-        @domain           = e.host.name
-        @domain_parts     = e.host.parts
-        @provider         = e.provider
-      elsif e.is_a?(Hash)
-        @email            = e[:email]
-        @mailbox          = e[:mailbox]
-        @domain           = e[:domain]
-        @domain_parts     = EmailAddress::DomainParser.new(@domain).parts
-        @provider         = e[:provider]
-      end
-    end
-
-    # Takes a email address string, returns true if it matches a rule
-    def include?(email_address)
-      self.email = email_address
-      return @empty_rules_return if @rules.empty?
-      @rules.each do |rule|
-        return true if registration_name_matches?(rule)
-        return true if tld_matches?(rule)
-        return true if provider_matches?(rule)
-        return true if domain_matches?(rule)
-        return true if email_matches?(rule)
-        return true if @email_address && ip_cidr_matches?(rule)
-      end
-      false
-    end
-
-    # Does "example." match any tld?
-    def registration_name_matches?(rule)
-      @domain_parts[:registration_name]+'.' == rule ? true : false
-    end
-
-    # Does "sub.example.com" match ".com" and ".example.com" top level names?
-    def tld_matches?(rule)
-      rule.match(/\A\..+\z/) &&
-        ( @domain[-rule.size, rule.size] == rule || ".#{@domain}" == rule) \
-        ? true : false
-    end
-
-    def provider_matches?(rule)
-      rule =~ /\A[\w\-]*\z/ && self.provider == rule.to_sym
-    end
-
-    def provider
-      @provider ||= EmailAddress::Config.providers.each do |prov, defn|
-        if defn.has_key?(:domains) && !defn[:domains].empty?
-          defn[:domains].each do |d|
-            if domain_matches?(d) || registration_name_matches?(d)
-              return @provider = prov
-            end
-          end
-        end
-      end
-      @provider ||= :unknown
-    end
-
-    # Does domain == rule or glob matches?
-    def domain_matches?(rule, domain=@domain)
-      return false if rule.include?("@")
-      domain == rule || File.fnmatch?(rule, domain)
-    end
-
-    # Does "root@*.com" match "root@example.com" domain name
-    def email_matches?(rule)
-      return false unless rule.include?("@")
-      @email == rule || File.fnmatch?(rule, @email)
-    end
-
-    # Does an IP of mail exchanger for "sub.example.com" match "xxx.xx.xx.xx/xx"?
-    def ip_cidr_matches?(rule)
-      return false unless rule.match(/\A\d.+\/\d+\z/) && @email_address.host.exchanger
-      @email_address.host.exchanger.in_cidr?(rule) ? true : false
-    end
-
-  end
-end

data/lib/email_address/validator.rb

@@ -1,141 +0,0 @@
-module EmailAddress
-  class Validator
-    LEGIBLE_LOCAL_REGEX = /\A[a-z0-9]+(([\.\-\_\'\+][a-z0-9]+)+)?\z/
-    DOT_ATOM_REGEX = /[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]/
-    ERRORS = %i(bad_syntax bad_email bad_mailbox bad_domain bad_exchanger bad_recipient)
-    attr_reader :error
-
-    def self.validate(address, options={})
-      EmailAddress::Validator.new(address, options).valid?
-    end
-
-    def initialize(address, options={})
-      @address = address
-      @local   = address.local
-      @host    = address.host
-      @options = options
-      @rules   = EmailAddress::Config.provider(@host.provider)
-      @error   = nil
-    end
-
-    # Returns true if email address seems valid, false otherwise.
-    # For error, call #error method to get error code (symbol).
-    def valid?
-      return false unless valid_sizes?
-      if @rules[:valid_mailbox] && ! @rules[:valid_mailbox].call(@local.to_s)
-        #p ["VALIDATOR", @local.to_s, @rules[:valid_mailbox]]
-        return invalid(:bad_mailbox)
-      else
-        return false unless valid_local?
-      end
-      if EmailAddress::Config.options[:check_dns]
-        return invalid(:bad_exchanger) unless valid_mx? || (valid_dns? && @options[:allow_dns_a])
-      end
-      true
-    end
-
-    def mailbox_validator(v)
-      return true unless v
-      if v.is_a?(Proc)
-        return invalid(:bad_mailbox) unless @rules[:valid_mailbox].call(@local)
-      elsif v == :legible
-        return legible?
-      elsif v == :rfc
-        return rfc_compliant?
-      end
-    end
-
-    # True if the DNS A record or MX records are defined
-    # Why A record? Some domains are misconfigured with only the A record.
-    def valid_dns?
-      @host.exchanger.has_dns_a_record?
-    end
-
-    # True if the DNS MX records have been defined. More strict than #valid?
-    def valid_mx?
-      @host.exchanger.mxers.size > 0
-    end
-
-    # Allows single, simple punctua3Nz=Xj/7c9 tion character between words
-    def legible?
-      @local.to_s =~ LEGIBLE_LOCAL_REGEX
-    end
-
-    def valid_sizes?
-      return invalid(:bad_email) unless @rules[:address_size].include?(@address.to_s.size)
-      return invalid(:bad_mailbox) unless @rules[:local_size  ].include?(@local.to_s.size)
-      return invalid(:bad_mailbox) unless @rules[:mailbox_size].include?(@local.mailbox.size)
-      return invalid(:bad_domain ) unless @rules[:domain_size ].include?(@host.to_s.size)
-      true
-    end
-
-    def valid_local?
-      return invalid(:bad_mailbox) unless valid_local_part?(@local.mailbox)
-      return invalid(:bad_mailbox) unless @local.comment.empty? || valid_local_part?(@local.comment)
-      if @local.tag
-        @local.tag.split(@rules[:tag_separator]).each do |t|
-          return invalid(:bad_mailbox, t) unless valid_local_part?(t)
-        end
-      end
-      true
-    end
-
-    # Valid within a mailbox, tag, comment
-    def valid_local_part?(p)
-      p =~ LEGIBLE_LOCAL_REGEX
-    end
-
-
-    def invalid(reason, *info)
-      @error = reason
-      #p "INVALID ----> #{reason} for #{@local.to_s}@#{@host.to_s} #{info.inspect}"
-      false
-    end
-
-    def valid_google_local?
-      true
-    end
-
-    ############################################################################
-    # RFC5322 Rules (Oct 2008):
-    #---------------------------------------------------------------------------
-    # addr-spec       =   local-part "@" domain
-    # local-part      =   dot-atom / quoted-string / obs-local-part
-    # domain          =   dot-atom / domain-literal / obs-domain
-    # domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
-    # dtext           =   %d33-90 /          ; Printable US-ASCII
-    #                     %d94-126 /         ;  characters not including
-    #                     obs-dtext          ;  "[", "]", or "\"
-    # atext           =   ALPHA / DIGIT /    ; Printable US-ASCII
-    #                        "!" / "#" /        ;  characters not including
-    #                        "$" / "%" /        ;  specials.  Used for atoms.
-    #                        "&" / "'" /
-    #                        "*" / "+" /
-    #                        "-" / "/" /
-    #                        "=" / "?" /
-    #                        "^" / "_" /
-    #                        "`" / "{" /
-    #                        "|" / "}" /
-    #                        "~"
-    # atom            =   [CFWS] 1*atext [CFWS]
-    # dot-atom-text   =   1*atext *("." 1*atext)
-    # dot-atom        =   [CFWS] dot-atom-text [CFWS]
-    # specials        =   "(" / ")" /        ; Special characters that do
-    #                        "<" / ">" /        ;  not appear in atext
-    #                        "[" / "]" /
-    #                        ":" / ";" /
-    #                        "@" / "\" /
-    #                        "," / "." /
-    #                        DQUOTE
-    # qtext           =   %d33 /             ; Printable US-ASCII
-    #                        %d35-91 /          ;  characters not including
-    #                        %d93-126 /         ;  "\" or the quote character
-    #                        obs-qtext
-    # qcontent        =   qtext / quoted-pair
-    # quoted-string   =   [CFWS]
-    #                        DQUOTE *([FWS] qcontent) [FWS] DQUOTE
-    #                        [CFWS]
-    ############################################################################
-
-  end
-end

data/test/email_address/test_domain_matcher.rb

@@ -1,21 +0,0 @@
-require_relative '../test_helper'
-
-class TestDomainMatcher < MiniTest::Test
-  MATCHER = EmailAddress::DomainMatcher
-
-  def test_hostname
-    assert_equal true, MATCHER.matches?("example.com", "example.com")
-    assert_equal true, MATCHER.matches?("example.com", "example")
-    assert_equal true, MATCHER.matches?("example.com", ".com")
-    assert_equal true, MATCHER.matches?("example.com", ".example.com")
-  end
-
-  def test_list
-    assert_equal true, MATCHER.matches?("example.com", %w(ex .tld example))
-  end
-
-  def test_glob_matches
-    assert_equal true, MATCHER.matches?("example.com", %w(ex*.com))
-  end
-
-end

data/test/email_address/test_domain_parser.rb

@@ -1,29 +0,0 @@
-require_relative '../test_helper'
-
-class TestDomainParser < MiniTest::Test
-  def test_hostname
-    parts = EmailAddress::DomainParser.parse("Example.com")
-    assert_equal 'example.com', parts[:domain_name]
-    assert_equal 'example', parts[:registration_name]
-    assert_equal 'com', parts[:tld]
-    assert_equal '', parts[:subdomains]
-  end
-
-  def test_sld
-    parts = EmailAddress::DomainParser.parse("sub.Example.co.uk")
-    assert_equal 'example.co.uk', parts[:domain_name]
-    assert_equal 'co.uk', parts[:tld]
-    assert_equal 'sub', parts[:subdomains]
-  end
-
-  def test_provider
-    parser = EmailAddress::DomainParser.new("gmail.com")
-    assert_equal :google, parser.provider
-  end
-
-  def test_yahoo
-    parser = EmailAddress::DomainParser.new("yahoo.co.uk")
-    assert_equal :yahoo, parser.provider
-  end
-  
-end

data/test/email_address/test_matcher.rb

@@ -1,44 +0,0 @@
-require_relative '../test_helper'
-
-class TestDomainMatcher < MiniTest::Test
-
-  def setup
-    @matcher = EmailAddress::Matcher.new(
-      ".org example.com domain*.com hotmail. google user*@ root@*.com 207.99.0.0/16")
-  end
-
-  def test_tld
-    assert_equal true, @matcher.include?("pat@example.org")
-  end
-
-  def test_domain
-    assert_equal true, @matcher.include?("pat@example.com")
-    assert_equal false, @matcher.include?("pat@nomatch.com")
-  end
-
-  def test_registration
-    assert_equal true, @matcher.include?("pat@hotmail.ca")
-  end
-
-  def test_domain_glob
-    assert_equal true, @matcher.include?("pat@domain123.com")
-  end
-
-  def test_provider
-    assert_equal true, @matcher.include?("pat@gmail.com")
-  end
-
-  def test_mailbox
-    assert_equal true, @matcher.include?("user123@example.com")
-  end
-
-  def test_address
-    assert_equal true, @matcher.include?("root@example.com")
-  end
-
-  def test_cidr
-    # If this breaks, check its MX IP addresses against "207.99.0.0/30"
-    assert_equal true, @matcher.include?("test@biglist.com")
-  end
-
-end

data/test/email_address/test_validator.rb

@@ -1,16 +0,0 @@
-require_relative '../test_helper'
-
-class EmailAddress::TestValidator < MiniTest::Test
-
-  def test_basic
-    assert_equal true, EmailAddress.new('user.name@gmail.com').valid?
-    assert_equal true, EmailAddress.new('user.name+tagme@gmail.com').valid?
-  end
-
-  def test_bad_local
-    assert_equal false, EmailAddress.new('user!name@gmail.com').valid?
-    assert_equal false, EmailAddress.new('***@yahoo.com').valid?
-    assert_equal false, EmailAddress.new('***@unknowndom41n.com').valid?
-  end
-
-end