ruby_regex 0.0.5 → 0.0.6

data/README.rdoc

@@ -38,6 +38,7 @@ If you want to contribute send me a pull request with new regular expressions (a
 
 - Lleïr Borràs
 - Jaime Iniesta
+- Fernando Guillen
 
 ---
 

data/lib/ruby_regex.rb

@@ -45,29 +45,8 @@ module RubyRegex
   # Del.icio.us username
   DeliciousUsername = /^([a-z0-9\_\-])+$/ix
   
-  # RFC822 Email Address Regex
-  # 
-  # Originally written by Cal Henderson
-  # c.f. http://iamcal.com/publish/articles/php/parsing_email/
-  #
-  # Translated to Ruby by Tim Fletcher, with changes suggested by Dan Kubb.
-  #
-  # Licensed under a Creative Commons Attribution-ShareAlike 2.5 License
-  # http://creativecommons.org/licenses/by-sa/2.5/
-  Email = begin
-    qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
-    dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
-    atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
-      '\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
-    quoted_pair = '\\x5c[\\x00-\\x7f]'
-    domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
-    quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
-    domain_ref = atom
-    sub_domain = "(?:#{domain_ref}|#{domain_literal})"
-    word = "(?:#{atom}|#{quoted_string})"
-    domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
-    local_part = "#{word}(?:\\x2e#{word})*"
-    addr_spec = "#{local_part}\\x40#{domain}"
-    pattern = /\A#{addr_spec}\z/
-  end
+  # Email
+  # From the email regex research: http://fightingforalostcause.net/misc/2006/compare-email-regex.php
+  # Authors: James Watts and Francisco Jose Martin Moreno
+  Email = /^([\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})?)$/i
 end

data/test/fixtures/emails.yml

@@ -0,0 +1,39 @@
+valid:
+  - "l3tt3rsAndNumb3rs@domain.com"
+  - "has-dash@domain.com"
+  - "hasApostrophe.o'leary@domain.org"
+  - "uncommonTLD@domain.museum"
+  - "uncommonTLD@domain.travel"
+  - "uncommonTLD@domain.mobi"
+  - "countryCodeTLD@domain.uk"
+  - "countryCodeTLD@domain.rw"
+  - "lettersInDomain@911.com"
+  - "underscore_inLocal@domain.net"
+  - "subdomain@sub.domain.com"
+  - "local@dash-inDomain.com"
+  - "dot.inLocal@foo.com"
+  - "a@singleLetterLocal.org"
+  - "singleLetterDomain@x.org"
+  - "&*=?^+{}'~@validCharsInLocal.net"
+  - "foor@bar.newTLD"
+
+
+invalid:
+  - "@missingLocal.org"
+  - "someone-else@127.0.0.1.26"
+  - "missingdomain@.com"
+  - "missingatSign.net"
+  - "missingDot@com"
+  - "two@@signs.com"
+  - "colonButNoPort@127.0.0.1:"
+  - ""
+  - ".localStartsWithDot@domain.com"
+  - "localEndsWithDot.@domain.com"
+  - "two..consecutiveDots@domain.com"
+  - "domainStartsWithDash@-domain.com"
+  - "domainEndsWithDash@domain-.com"
+  - "numbersInTLD@domain.c0m"
+  - "missingTLD@domain."
+  - "! #$%(),/;<>[]`|@invalidCharsInLocal.org"
+  - "invalidCharsInDomain@! #$%(),/;<>_[]`|.org"
+  - "local@SecondLevelDomainNamesAreInvalidIfTheyAreLongerThan64Charactersss.org"

data/test/ruby_regex_test.rb

@@ -2,230 +2,143 @@ require 'test/unit'
 require 'rubygems'
 require 'active_support'
 require 'active_support/test_case'
-require 'ruby_regex'
+require File.join( File.dirname(__FILE__), '../lib/ruby_regex' )
 
-class RubyRegexTest < ActiveSupport::TestCase
+class RubyRegexTest < ActiveSupport::TestCase  
+  
   #Username
   def test_valid_usernames
-    usernames = ['test', 'test_test', 'test1', 'test_1']
-    usernames.each do |username|
-      message = build_message(message, '<?> do not pass the test', username)
-      assert(username =~ RubyRegex::Username, username)
-    end
+    check_valid_regex RubyRegex::Username, ['test', 'test_test', 'test1', 'test_1']
   end
   
   def test_invalid_usernames
-    usernames = ['test-test', 'test.test', 'test/test', 'test@test']
-    usernames.each do |username|
-      message = build_message(message, '<?> do not pass the test', username)
-      assert(username !~ RubyRegex::Username, username)
-    end
+    check_invalid_regex RubyRegex::Username, ['test-test', 'test.test', 'test/test', 'test@test']
   end
   
   # DNI
   def test_valid_dnis
-    dnis = ['40990889J', '99888777h']
-    dnis.each do |dni|
-      message = build_message(message, '<?> do not pass the test', dni)
-      assert(dni =~ RubyRegex::Username, dni)
-    end
+    check_valid_regex RubyRegex::Dni, ['40990889J', '99888777h']
   end
   
   def test_invalid_dnis
-    dnis = ['90.900.900V', '90900900-V']
-    dnis.each do |dni|
-      message = build_message(message, '<?> do not pass the test', dni)
-      assert(dni !~ RubyRegex::Username, dni)
-    end
+    check_invalid_regex RubyRegex::Dni, ['90.900.900V', '90900900-V']
   end
   
   # Email
   def test_valid_emails
-    emails = ['test@test.com', 'test@test.co.uk', 'test@test.es', 'test@test.info']
-    emails.each do |email|
-      message = build_message(message, '<?> do not pass the test', email)
-      assert(email =~ RubyRegex::Email, email)
-    end
+    check_valid_regex RubyRegex::Email, load_fixture('emails')['valid']
   end
 
-  #TODO: 'test@test' is a valid domain, fix!!!
   def test_invalid_emails
-    emails = ['test/test.com', 'test', 'test-test.com', 'test.test.com']
-    emails.each do |email|
-      message = build_message(message, '<?> do not pass the test', email)
-      assert(email !~ RubyRegex::Email, message)
-    end
+    check_invalid_regex RubyRegex::Email, load_fixture('emails')["invalid"]
   end
   
   # Domains
   def test_valid_domains
-    domains = [ 'test.com', 'www.test.com', 'test.es', 'www.test.es', 'test.co.uk', 'www.test.co.uk', 'test.info', 'www.test.info', 'test.com.es', 'www.test.com.es']
-    domains.each do |domain|
-      message = build_message(message, '<?> do not pass the test', domain)
-      assert(domain =~ RubyRegex::Domain, message)
-    end
+    check_valid_regex RubyRegex::Domain, ['test.com', 'www.test.com', 'test.es', 'www.test.es', 'test.co.uk', 'www.test.co.uk', 'test.info', 'www.test.info', 'test.com.es', 'www.test.com.es', 'test-test.com']
   end
   
   def test_invalid_domains
-    domains = [ 'test.', 'www.test.e', 'www.test.', 'test.e', '!test.com', 'test/test.com']
-    domains.each do |domain|
-      message = build_message(message, '<?> do not pass the test', domain)
-      assert(domain !~ RubyRegex::Domain, message)
-    end
+    check_invalid_regex RubyRegex::Domain, ['test.', 'www.test.e', 'www.test.', 'test.e', '!test.com', 'test/test.com', 'test_test.com']
   end
   
   # Url
   def test_valid_url
-    urls = [ 'http://test.com', 'http://www.test.com', 'http://test.es/index', 'http://www.test.es/index.html', 
-      'https://test.co.uk', 'http://www.test.co.uk/index.html?id=34&name=username']
-    urls.each do |url|
-      message = build_message('<?> do not pass the test', url)
-      assert(url =~ RubyRegex::URL, message)
-    end
+    check_valid_regex RubyRegex::URL, ['http://test.com', 'http://www.test.com', 'http://test.es/index', 'http://www.test.es/index.html', 'https://test.co.uk', 'http://www.test.co.uk/index.html?id=34&name=username']
   end
   
   def test_invalid_url
-    urls = [ 'test.com', 'www.test.com', 'http://test.es-index', 'http://www.test.es?index.html']
-    urls.each do |url|
-      message = build_message(message, '<?> do not pass the test', url)
-      assert(url !~ RubyRegex::URL, message)
-    end
+    check_invalid_regex RubyRegex::URL, ['test.com', 'www.test.com', 'http://test.es-index', 'http://www.test.es?index.html']
   end
   
   # CreditCard
   def test_valid_credit_cards
-    credit_cards = [ '1234123412341234', '1234 1234 1234 1234', '1234-1234-1234-1234']
-    credit_cards.each do |credit_card|
-      message = build_message(message, '<?> do not pass the test', credit_card)
-      assert(credit_card =~ RubyRegex::CreditCard, message)
-    end
+    check_valid_regex RubyRegex::CreditCard, [ '1234123412341234', '1234 1234 1234 1234', '1234-1234-1234-1234']
   end
   
   def test_invalid_credit_cards
-    credit_cards = [ '1234_1234_1234_1234', '1234', '12341234', '123412341234', 
-      '1234  1234 1234 1234', '1234-1234 12341234', '123a-1234-1234-1234']
-    credit_cards.each do |credit_card|
-      message = build_message(message, '<?> do not pass the test', credit_card)
-      assert(credit_card !~ RubyRegex::Domain, message)
-    end
+    check_invalid_regex RubyRegex::CreditCard, ['1234_1234_1234_1234', '1234', '12341234', '123412341234', '1234  1234 1234 1234', '1234-1234 12341234', '123a-1234-1234-1234']
   end
   
   # US Social Security
   def test_valid_usss_numbers
-    usss_numbers = [ '123-12-1234']
-    usss_numbers.each do |usss_number|
-      message = build_message(message, '<?> do not pass the test', usss_number)
-      assert(usss_number =~ RubyRegex::USSocialSecurity, message)
-    end
+    check_valid_regex RubyRegex::USSocialSecurity, ['123-12-1234']
   end
   
   def test_invalid_usss_numbers
-    usss_numbers = [ '1234_1234_1234_1234', '1234', '123121234', '123_12_1234', '123 12 1234']
-    usss_numbers.each do |usss_number|
-      message = build_message(message, '<?> do not pass the test', usss_number)
-      assert(usss_number !~ RubyRegex::USSocialSecurity, message)
-    end
+    check_invalid_regex RubyRegex::USSocialSecurity, [ '1234_1234_1234_1234', '1234', '123121234', '123_12_1234', '123 12 1234']
   end
   
   # General Postal Code
   def test_valid_postal_codes
-    postal_codes = [ '12345']
-    postal_codes.each do |postal_code|
-      message = build_message(message, '<?> do not pass the test', postal_code)
-      assert(postal_code =~ RubyRegex::GeneralPostalCode, message)
-    end
+    check_valid_regex RubyRegex::GeneralPostalCode, ['12345']
   end
   
   def test_invalid_postal_codes
-    postal_codes = [ '1', '12', '123', '1234', '123456']
-    postal_codes.each do |postal_code|
-      message = build_message(message, '<?> do not pass the test', postal_code)
-      assert(postal_code !~ RubyRegex::GeneralPostalCode, message)
-    end
+    check_invalid_regex RubyRegex::GeneralPostalCode, [ '1', '12', '123', '1234', '123456']
   end
   
   # ZIP Code
   def test_valid_zip_codes
-    zip_codes = [ '12345', '12345-1234']
-    zip_codes.each do |zip_code|
-      message = build_message(message, '<?> do not pass the test', zip_code)
-      assert(zip_code =~ RubyRegex::ZIPCode, message)
-    end
+    check_valid_regex RubyRegex::ZIPCode, [ '12345', '12345-1234']
   end
   
   def test_invalid_zip_codes
-    zip_codes = [ '1', '12', '123', '1234', '123456', '12345_1234', '12345 1234', '1234-1234']
-    zip_codes.each do |zip_code|
-      message = build_message(message, '<?> do not pass the test', zip_code)
-      assert(zip_code !~ RubyRegex::ZIPCode, message)
-    end
+    check_invalid_regex RubyRegex::ZIPCode, [ '1', '12', '123', '1234', '123456', '12345_1234', '12345 1234', '1234-1234']
   end
   
   # Twitter usernames
   def test_valid_twitter_usernames
-    twitter_usernames = ['ji', 'nickel84', 'sepa_rate']
-    twitter_usernames.each do |twitter_username|
-      message = build_message(message, '<?> does not pass the test', twitter_username)
-      assert(twitter_username =~ RubyRegex::TwitterUsername, message)
-    end
+    check_valid_regex RubyRegex::TwitterUsername, ['ji', 'nickel84', 'sepa_rate']
   end
   
   def test_invalid_twitter_usernames
-    twitter_usernames = ['nickel 83', 'h.ppywebcoder']
-    twitter_usernames.each do |twitter_username|
-      message = build_message(message, '<?> does not pass the test', twitter_username)
-      assert(twitter_username !~ RubyRegex::TwitterUsername, message)
-    end
+    check_invalid_regex RubyRegex::TwitterUsername, ['nickel 83', 'h.ppywebcoder']
   end  
   
   # Github usernames
   def test_valid_github_usernames
-    github_usernames = ['ji', 'nickel84', 'sepa_rate', 'ernesto-jimenez']
-    github_usernames.each do |github_username|
-      message = build_message(message, '<?> does not pass the test', github_username)
-      assert(github_username =~ RubyRegex::GithubUsername, message)
-    end
+    check_valid_regex RubyRegex::GithubUsername, ['ji', 'nickel84', 'sepa_rate', 'ernesto-jimenez']
   end
   
   def test_invalid_github_usernames
-    github_usernames = ['nickel 84', 'h.ppywebcoder']
-    github_usernames.each do |github_username|
-      message = build_message(message, '<?> does not pass the test', github_username)
-      assert(github_username !~ RubyRegex::GithubUsername, message)
-    end
+    check_invalid_regex RubyRegex::GithubUsername, ['nickel 84', 'h.ppywebcoder']
   end
   
   # Slideshare usernames
   def test_valid_slideshare_usernames
-    slideshare_usernames = ['ji', 'nickel84']
-    slideshare_usernames.each do |slideshare_username|
-      message = build_message(message, '<?> does not pass the test', slideshare_username)
-      assert(slideshare_username =~ RubyRegex::SlideshareUsername, message)
-    end
+    check_valid_regex RubyRegex::SlideshareUsername, ['ji', 'nickel84']
   end
   
   def test_invalid_slideshare_usernames
-    slideshare_usernames = ['nickel 84', 'h.ppywebcoder', 'sepa_rate', 'ernesto-jimenez']
-    slideshare_usernames.each do |slideshare_username|
-      message = build_message(message, '<?> does not pass the test', slideshare_username)
-      assert(slideshare_username !~ RubyRegex::SlideshareUsername, message)
-    end
+    check_invalid_regex RubyRegex::SlideshareUsername, ['nickel 84', 'h.ppywebcoder', 'sepa_rate', 'ernesto-jimenez']
   end  
   
   # Del.icio.us usernames
   def test_valid_delicious_usernames
-    delicious_usernames = ['ji', 'nickel84', 'sepa_rate', 'ernesto-jimenez']
-    delicious_usernames.each do |delicious_username|
-      message = build_message(message, '<?> does not pass the test', delicious_username)
-      assert(delicious_username =~ RubyRegex::DeliciousUsername, message)
-    end
+    check_valid_regex RubyRegex::DeliciousUsername, ['ji', 'nickel84', 'sepa_rate', 'ernesto-jimenez']
   end
   
   def test_invalid_delicious_usernames
-    delicious_usernames = ['nickel 84', 'h.ppywebcoder']
-    delicious_usernames.each do |delicious_username|
-      message = build_message(message, '<?> does not pass the test', delicious_username)
-      assert(delicious_username !~ RubyRegex::DeliciousUsername, message)
-    end
+    check_invalid_regex RubyRegex::DeliciousUsername, ['nickel 84', 'h.ppywebcoder']
   end
+  
+  private
+    def load_fixture( name )
+      YAML.load( File.read( File.join( File.dirname(__FILE__), 'fixtures', "#{name}.yml" ) ) )
+    end
+  
+    def check_valid_regex(regexp, strings)
+      strings.each do |str|
+        message = build_message(message, '<?> does not pass the test', str)
+        assert(str =~ regexp, message)
+      end
+    end
+  
+    def check_invalid_regex(regexp, strings)
+      strings.each do |str|
+        message = build_message(message, '<?> does not pass the test', str)
+        assert(str !~ regexp, message)
+      end
+    end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby_regex
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Emili Parreno
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-18 00:00:00 +02:00
+date: 2010-08-26 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +32,8 @@ files:
 - README.rdoc
 - LICENSE
 - lib/ruby_regex.rb
+- test/ruby_regex_test.rb
+- test/fixtures/emails.yml
 has_rdoc: true
 homepage: http://github.com/eparreno/ruby_regex
 licenses: []
@@ -42,25 +45,30 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: none
 test_files: 
 - test/ruby_regex_test.rb
+- test/fixtures/emails.yml