public_suffix_service 0.7.0 → 0.8.0

data/CHANGELOG.rdoc

@@ -1,5 +1,13 @@
 = Changelog
 
+
+== Release 0.8.0
+
+* CHANGED: Update public suffix list to d1a5599b49fa 2010-10-25 15:10 +0100 (#9)
+
+* NEW: Add support for Fully Qualified Domain Names (#7)
+
+
 == Release 0.7.0
 
 * CHANGED: Using YARD to document the code instead of RDoc.

data/README.rdoc

@@ -50,7 +50,7 @@ The best way to install Public Suffix Service< is via {RubyGems}[http://www.ruby
 You might need administrator privileges on your system to install the Gem.
 
 
-== Usage
+== Basic Usage
 
 Example domain without subdomains.
 
@@ -93,6 +93,22 @@ Simple validation example.
   PublicSuffixService.valid?("x.yz")
   # => false
 
+== Fully Qualified Domain Names
+
+This library automatically recognizes Fully Qualified Domain Names. A FQDN is a domain name that end with a trailing dot.
+
+  # Parse a standard domain name
+  domain = PublicSuffixService.parse("www.google.com")
+  # => #<PublicSuffixService::Domain>
+  domain.tld
+  # => "com"
+
+  # Parse a fully qualified domain name
+  domain = PublicSuffixService.parse("www.google.com.")
+  # => #<PublicSuffixService::Domain>
+  domain.tld
+  # => "com"
+
 
 == Credits
 

data/Rakefile

@@ -55,11 +55,11 @@ spec = Gem::Specification.new do |s|
   # You should probably have a README of some kind. Change the filename
   # as appropriate
   s.extra_rdoc_files  = Dir.glob("*.rdoc")
-  s.rdoc_options      = %w(--main README.rdoc)
+  s.rdoc_options      = %w( --main README.rdoc )
 
   # Add any extra files to include in the gem (like your README)
-  s.files             = %w(Rakefile) + Dir.glob("*.{rdoc,gemspec}") + Dir.glob("{test,lib}/**/*")
-  s.require_paths     = ["lib"]
+  s.files             = %w( Rakefile ) + Dir.glob("*.{rdoc,gemspec}") + Dir.glob("{test,lib}/**/*")
+  s.require_paths     = %w( lib )
 
   # If you want to depend on other gems, add them here, along with any
   # relevant versions
@@ -95,27 +95,13 @@ desc "Package the library and generates the gemspec"
 task :package => [:gemspec]
 
 
-desc "Generate RDoc documentation"
-Rake::RDocTask.new do |r|
-  r.main = "README.rdoc"
-  r.rdoc_files.include("*.rdoc", "lib/**/*.rb")
-  r.rdoc_dir = "rdoc"
-end
-
-namespace :rdoc do
-  desc "Publish RDoc documentation to the site"
-  task :publish => [:clobber_rdoc, :rdoc] do
-    ENV["username"] || raise(ArgumentError, "Missing ssh username")
-    sh "rsync -avz --delete rdoc/ #{ENV["username"]}@code:/var/www/apps/code/#{PKG_NAME}/rdoc"
-  end
-end
-
-
 begin
   require "yard"
   require "yard/rake/yardoc_task"
 
-  YARD::Rake::YardocTask.new(:yardoc)
+  YARD::Rake::YardocTask.new(:yardoc) do |y|
+    y.options = ["--output-dir", "yardoc"]
+  end
 
   namespace :yardoc do
     desc "Publish YARD documentation to the site"
@@ -155,17 +141,6 @@ task :console do
   sh "irb -rubygems -I lib -r public_suffix_service.rb"
 end
 
-begin
-  require "code_statistics"
-  desc "Show library's code statistics"
-  task :stats do
-    CodeStatistics.new(["Public Suffix Service", "lib"],
-                       ["Tests", "test"]).to_s
-  end
-rescue LoadError
-  puts "CodeStatistics (Rails) is not available"
-end
-
 
 desc <<-DESC
   Downloads the Public Suffix List file from the repository \

data/lib/public_suffix_service/definitions.dat

@@ -711,7 +711,6 @@ operaunite.com
 
 // Requested by Eduardo Vela <evn@google.com> 2010-09-06
 appspot.com
-blogspot.com
 
 // coop : http://en.wikipedia.org/wiki/.coop
 coop
@@ -4240,6 +4239,7 @@ mil.to
 // tr : http://en.wikipedia.org/wiki/.tr
 *.tr
 !nic.tr
+!tsk.tr
 // Used by government in the TRNC
 // http://en.wikipedia.org/wiki/.nc.tr
 gov.nc.tr
@@ -4290,11 +4290,14 @@ club.tw
 
 // tz : http://en.wikipedia.org/wiki/.tz
 // Submitted by registry <randy@psg.com> 2008-06-17
+// Updated from http://www.tznic.or.tz/index.php/domains.html 2010-10-25
 ac.tz
 co.tz
 go.tz
+mil.tz
 ne.tz
 or.tz
+sc.tz
 
 // ua : http://www.nic.net.ua/
 ua

data/lib/public_suffix_service/rule.rb

@@ -197,7 +197,7 @@ module PublicSuffixService
       #
       # @example
       #   rule = Rule.factory("*.do")
-      #   # #<PublicSuffixService::Rule::Wildcard>
+      #   # => #<PublicSuffixService::Rule::Wildcard>
       #   rule.allow?("example.do")
       #   # => false
       #   rule.allow?("www.example.do")
@@ -278,7 +278,7 @@ module PublicSuffixService
       #   The array with [trd + sld, tld].
       #
       def decompose(domain)
-        domain.to_s =~ /^(.*)\.(#{parts.join('\.')})$/
+        domain.to_s.chomp(".") =~ /^(.*)\.(#{parts.join('\.')})$/
         [$1, $2]
       end
 
@@ -320,7 +320,7 @@ module PublicSuffixService
       #   The array with [trd + sld, tld].
       #
       def decompose(domain)
-        domain.to_s =~ /^(.*)\.(.*?\.#{parts.join('\.')})$/
+        domain.to_s.chomp(".") =~ /^(.*)\.(.*?\.#{parts.join('\.')})$/
         [$1, $2]
       end
 
@@ -358,7 +358,7 @@ module PublicSuffixService
       #   The array with [trd + sld, tld].
       #
       def decompose(domain)
-        domain.to_s =~ /^(.*)\.(#{parts.join('\.')})$/
+        domain.to_s.chomp(".") =~ /^(.*)\.(#{parts.join('\.')})$/
         [$1, $2]
       end
 

data/lib/public_suffix_service/rule_list.rb

@@ -185,6 +185,8 @@ module PublicSuffixService
     #   which directly match the labels of the prevailing rule (joined by dots).
     # * The registered domain is the public suffix plus one additional label.
     #
+    # @param  [String, #to_s] domain The domain name.
+    #
     # @return [PublicSuffixService::Rule::*, nil]
     def find(domain)
       rules = select(domain)

data/lib/public_suffix_service/version.rb

@@ -18,7 +18,7 @@ module PublicSuffixService
 
   module Version
     MAJOR = 0
-    MINOR = 7
+    MINOR = 8
     PATCH = 0
     BUILD = nil
 

data/lib/public_suffix_service.rb

@@ -34,17 +34,25 @@ module PublicSuffixService
   # Parsing uses the default {PublicSuffixService::RuleList}.
   #
   # @param  [String, #to_s] domain
-  #   The domain name to parse.
+  #   The domain name or fully qualified domain name to parse.
   #
   # @return [PublicSuffixService::Domain]
   #
   # @example Parse a valid domain
   #   PublicSuffixService.parse("google.com")
   #   # => #<PubliSuffixService::Domain ...>
-  #   
+  # 
   # @example Parse a valid subdomain
   #   PublicSuffixService.parse("www.google.com")
   #   # => #<PubliSuffixService::Domain ...>
+  # 
+  # @example Parse a fully qualified domain
+  #   PublicSuffixService.parse("google.com.")
+  #   # => #<PubliSuffixService::Domain ...>
+  # 
+  # @example Parse a fully qualified domain (subdomain)
+  #   PublicSuffixService.parse("www.google.com.")
+  #   # => #<PubliSuffixService::Domain ...>
   #
   # @example Parse an invalid domain
   #   PublicSuffixService.parse("x.yz")
@@ -63,7 +71,7 @@ module PublicSuffixService
   def self.parse(domain)
     rule = RuleList.default.find(domain)
     if rule.nil?
-      raise(DomainInvalid, "`#{domain}' is not a valid domain")
+      raise DomainInvalid, "`#{domain}' is not a valid domain"
     end
     if !rule.allow?(domain)
       raise DomainNotAllowed, "`#{domain}' is not allowed according to Registry policy"
@@ -86,30 +94,36 @@ module PublicSuffixService
   # without actually parsing it.
   #
   # This method doesn't care whether domain is a domain or subdomain.
-  # The check is performed using the default {PublicSuffixService::RuleList}.
+  # The validation is performed using the default {PublicSuffixService::RuleList}.
   #
   # @param  [String, #to_s] domain
-  #   The domain name to check.
+  #   The domain name or fully qualified domain name to validate.
   #
   # @return [Boolean]
   #
-  # @example Check a valid domain
+  # @example Validate a valid domain
   #   PublicSuffixService.valid?("example.com")
   #   # => true
   #
-  # @example Check a valid subdomain
+  # @example Validate a valid subdomain
   #   PublicSuffixService.valid?("www.example.com")
   #   # => true
   #
-  # @example Check a not-assigned domain
+  # @example Validate a not-assigned domain
   #   PublicSuffixService.valid?("example.zip")
   #   # => false
   #
-  # @example Check a not-allowed domain
+  # @example Validate a not-allowed domain
   #   PublicSuffixService.valid?("example.do")
   #   # => false
   #   PublicSuffixService.valid?("www.example.do")
   #   # => true
+  # 
+  # @example Validate a fully qualified domain
+  #   PublicSuffixService.valid?("google.com.")
+  #   # => true
+  #   PublicSuffixService.valid?("www.google.com.")
+  #   # => true
   #
   # @example Check an URL (which is not a valid domain)
   #   PublicSuffixService.valid?("http://www.example.com")

data/public_suffix_service.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{public_suffix_service}
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Simone Carletti"]
-  s.date = %q{2010-09-18}
+  s.date = %q{2010-10-09}
   s.description = %q{    Intelligent domain name parser based in the Public Suffic List.     PublicSuffixService can parse and decompose a domain name into top level domain,     domain and subdomains.
 }
   s.email = %q{weppos@weppos.net}
@@ -23,11 +23,11 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<rr>, [">= 0"])
     else
-      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<rr>, [">= 0"])
     end
   else
-    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<rr>, [">= 0"])
   end
 end

data/test/public_suffix_service/domain_test.rb

@@ -6,9 +6,26 @@ class PublicSuffixService::DomainTest < Test::Unit::TestCase
     @klass = PublicSuffixService::Domain
   end
 
-  def test_domain_to_lables
-    assert_equal %w{com live spaces someone},       PublicSuffixService::Domain.domain_to_labels('someone.spaces.live.com')
-    assert_equal %w{com zoho wiki leontina23samiko}, PublicSuffixService::Domain.domain_to_labels('leontina23samiko.wiki.zoho.com')
+  # Tokenizes given input into labels.
+  def test_self_domain_to_labels
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffixService::Domain.domain_to_labels("someone.spaces.live.com")
+    assert_equal  %w( com zoho wiki leontina23samiko ),
+                  PublicSuffixService::Domain.domain_to_labels("leontina23samiko.wiki.zoho.com")
+  end
+
+  # Converts input into String.
+  def test_self_domain_to_labels_converts_input_to_string
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffixService::Domain.domain_to_labels(:"someone.spaces.live.com")
+  end
+
+  # Ignores trailing .
+  def test_self_domain_to_labels_ignores_trailing_dot
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffixService::Domain.domain_to_labels("someone.spaces.live.com")
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffixService::Domain.domain_to_labels(:"someone.spaces.live.com")
   end
 
 

data/test/public_suffix_service/errors_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class ErrorsTest < Test::Unit::TestCase
+
+  # Inherits from StandardError
+  def test_error_inheritance
+    assert_kind_of  StandardError,
+                    PublicSuffixService::Error.new
+  end
+
+  # Inherits from PublicSuffixService::Error
+  def test_domain_invalid_inheritance
+    assert_kind_of  PublicSuffixService::Error,
+                    PublicSuffixService::DomainInvalid.new
+  end
+
+  # Inherits from PublicSuffixService::DomainInvalid
+  def test_domain_not_allowed_inheritance
+    assert_kind_of  PublicSuffixService::DomainInvalid,
+                    PublicSuffixService::DomainNotAllowed.new
+  end
+
+end

data/test/public_suffix_service/rule_test.rb

@@ -63,9 +63,11 @@ class PublicSuffixService::RuleBaseTest < Test::Unit::TestCase
     assert  @klass.new("uk").match?("example.uk")
     assert !@klass.new("gk").match?("example.uk")
     assert !@klass.new("example").match?("example.uk")
+
     assert  @klass.new("uk").match?("example.co.uk")
     assert !@klass.new("gk").match?("example.co.uk")
     assert !@klass.new("co").match?("example.co.uk")
+
     assert  @klass.new("co.uk").match?("example.co.uk")
     assert !@klass.new("uk.co").match?("example.co.uk")
     assert !@klass.new("go.uk").match?("example.co.uk")
@@ -107,20 +109,34 @@ class PublicSuffixService::RuleNormalTest < Test::Unit::TestCase
     assert  @klass.new("uk").match?("example.uk")
     assert !@klass.new("gk").match?("example.uk")
     assert !@klass.new("example").match?("example.uk")
+
     assert  @klass.new("uk").match?("example.co.uk")
     assert !@klass.new("gk").match?("example.co.uk")
     assert !@klass.new("co").match?("example.co.uk")
+
     assert  @klass.new("co.uk").match?("example.co.uk")
     assert !@klass.new("uk.co").match?("example.co.uk")
     assert !@klass.new("go.uk").match?("example.co.uk")
   end
 
+  def test_match_with_fully_qualified_domain_name
+    assert  @klass.new("com").match?("com.")
+    assert  @klass.new("com").match?("example.com.")
+    assert  @klass.new("com").match?("www.example.com.")
+  end
+
   def test_allow
     assert !@klass.new("com").allow?("com")
     assert  @klass.new("com").allow?("example.com")
     assert  @klass.new("com").allow?("www.example.com")
   end
 
+  def test_allow_with_fully_qualified_domain_name
+    assert !@klass.new("com").allow?("com.")
+    assert  @klass.new("com").allow?("example.com.")
+    assert  @klass.new("com").allow?("www.example.com.")
+  end
+
 
   def test_length
     assert_equal 1, @klass.new("com").length
@@ -135,8 +151,15 @@ class PublicSuffixService::RuleNormalTest < Test::Unit::TestCase
   end
 
   def test_decompose
-    assert_equal %w(example com), @klass.new("com").decompose("example.com")
-    assert_equal %w(foo.example com), @klass.new("com").decompose("foo.example.com")
+    assert_equal [nil, nil], @klass.new("com").decompose("com")
+    assert_equal %w( example com ), @klass.new("com").decompose("example.com")
+    assert_equal %w( foo.example com ), @klass.new("com").decompose("foo.example.com")
+  end
+
+  def test_decompose_with_fully_qualified_domain_name
+    assert_equal [nil, nil], @klass.new("com").decompose("com.")
+    assert_equal %w( example com ), @klass.new("com").decompose("example.com.")
+    assert_equal %w( foo.example com ), @klass.new("com").decompose("foo.example.com.")
   end
 
 end
@@ -168,6 +191,25 @@ class PublicSuffixService::RuleExceptionTest < Test::Unit::TestCase
     assert !@klass.new("!british-library.uk").match?("example.co.uk")
   end
 
+  def test_match_with_fully_qualified_domain_name
+    assert  @klass.new("!uk").match?("uk.")
+    assert  @klass.new("!uk").match?("co.uk.")
+    assert  @klass.new("!uk").match?("example.co.uk.")
+    assert  @klass.new("!uk").match?("www.example.co.uk.")
+  end
+
+  def test_allow
+    assert !@klass.new("!british-library.uk").allow?("uk")
+    assert  @klass.new("!british-library.uk").allow?("british-library.uk")
+    assert  @klass.new("!british-library.uk").allow?("www.british-library.uk")
+  end
+
+  def test_allow_with_fully_qualified_domain_name
+    assert !@klass.new("!british-library.uk").allow?("uk.")
+    assert  @klass.new("!british-library.uk").allow?("british-library.uk.")
+    assert  @klass.new("!british-library.uk").allow?("www.british-library.uk.")
+  end
+
 
   def test_length
     assert_equal 1, @klass.new("!british-library.uk").length
@@ -175,13 +217,20 @@ class PublicSuffixService::RuleExceptionTest < Test::Unit::TestCase
   end
 
   def test_parts
-    assert_equal %w(uk), @klass.new("!british-library.uk").parts
-    assert_equal %w(tokyo jp), @klass.new("!metro.tokyo.jp").parts
+    assert_equal %w( uk ), @klass.new("!british-library.uk").parts
+    assert_equal %w( tokyo jp ), @klass.new("!metro.tokyo.jp").parts
   end
 
   def test_decompose
-    assert_equal %w(british-library uk), @klass.new("!british-library.uk").decompose("british-library.uk")
-    assert_equal %w(foo.british-library uk), @klass.new("!british-library.uk").decompose("foo.british-library.uk")
+    assert_equal [nil, nil], @klass.new("!british-library.uk").decompose("uk")
+    assert_equal %w( british-library uk ), @klass.new("!british-library.uk").decompose("british-library.uk")
+    assert_equal %w( foo.british-library uk ), @klass.new("!british-library.uk").decompose("foo.british-library.uk")
+  end
+
+  def test_decompose_with_fully_qualified_domain_name
+    assert_equal [nil, nil], @klass.new("!british-library.uk").decompose("uk.")
+    assert_equal %w( british-library uk ), @klass.new("!british-library.uk").decompose("british-library.uk.")
+    assert_equal %w( foo.british-library uk ), @klass.new("!british-library.uk").decompose("foo.british-library.uk.")
   end
 
 end
@@ -211,10 +260,25 @@ class PublicSuffixService::RuleWildcardTest < Test::Unit::TestCase
     assert !@klass.new("*.go.uk").match?("example.co.uk")
   end
 
+  def test_match_with_fully_qualified_domain_name
+    assert  @klass.new("*.uk").match?("uk.")
+    assert  @klass.new("*.uk").match?("co.uk.")
+    assert  @klass.new("*.uk").match?("example.co.uk.")
+    assert  @klass.new("*.uk").match?("www.example.co.uk.")
+  end
+
   def test_allow
-    assert !@klass.new("*.com").allow?("com")
-    assert !@klass.new("*.com").allow?("example.com")
-    assert  @klass.new("*.com").allow?("www.example.com")
+    assert !@klass.new("*.uk").allow?("uk")
+    assert !@klass.new("*.uk").allow?("co.uk")
+    assert  @klass.new("*.uk").allow?("example.co.uk")
+    assert  @klass.new("*.uk").allow?("www.example.co.uk")
+  end
+
+  def test_allow_with_fully_qualified_domain_name
+    assert !@klass.new("*.uk").allow?("uk.")
+    assert !@klass.new("*.uk").allow?("co.uk.")
+    assert  @klass.new("*.uk").allow?("example.co.uk.")
+    assert  @klass.new("*.uk").allow?("www.example.co.uk.")
   end
 
 
@@ -224,14 +288,20 @@ class PublicSuffixService::RuleWildcardTest < Test::Unit::TestCase
   end
 
   def test_parts
-    assert_equal %w(uk), @klass.new("*.uk").parts
-    assert_equal %w(co uk), @klass.new("*.co.uk").parts
+    assert_equal %w( uk ), @klass.new("*.uk").parts
+    assert_equal %w( co uk ), @klass.new("*.co.uk").parts
   end
 
   def test_decompose
     assert_equal [nil, nil], @klass.new("*.do").decompose("nic.do")
-    assert_equal %w(google co.uk), @klass.new("*.uk").decompose("google.co.uk")
-    assert_equal %w(foo.google co.uk), @klass.new("*.uk").decompose("foo.google.co.uk")
+    assert_equal %w( google co.uk ), @klass.new("*.uk").decompose("google.co.uk")
+    assert_equal %w( foo.google co.uk ), @klass.new("*.uk").decompose("foo.google.co.uk")
+  end
+
+  def test_decompose_with_fully_qualified_domain_name
+    assert_equal [nil, nil], @klass.new("*.do").decompose("nic.do.")
+    assert_equal %w( google co.uk ), @klass.new("*.uk").decompose("google.co.uk.")
+    assert_equal %w( foo.google co.uk ), @klass.new("*.uk").decompose("foo.google.co.uk.")
   end
 
 end

data/test/public_suffix_service_test.rb

@@ -44,6 +44,14 @@ class PublicSuffixServiceTest < Test::Unit::TestCase
     assert_equal "one.two", domain.trd
   end
 
+  def test_self_parse_a_fully_qualified_domain_name
+    domain = PublicSuffixService.parse("www.example.com.")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "www",     domain.trd
+  end
+
   def test_self_parse_should_raise_with_invalid_domain
     error = assert_raise(PublicSuffixService::DomainInvalid) { PublicSuffixService.parse("example.zip") }
     assert_match %r{example\.zip}, error.message
@@ -55,13 +63,23 @@ class PublicSuffixServiceTest < Test::Unit::TestCase
   end
 
 
-  def test_self_valid_question
+  def test_self_valid
     assert  PublicSuffixService.valid?("google.com")
     assert  PublicSuffixService.valid?("www.google.com")
     assert  PublicSuffixService.valid?("google.co.uk")
     assert  PublicSuffixService.valid?("www.google.co.uk")
+  end
+
+  # Returns false when domain has an invalid TLD
+  def test_self_valid_with_invalid_tld
     assert !PublicSuffixService.valid?("google.zip")
     assert !PublicSuffixService.valid?("www.google.zip")
   end
 
+  def test_self_valid_with_fully_qualified_domain_name
+    assert  PublicSuffixService.valid?("google.com.")
+    assert  PublicSuffixService.valid?("google.co.uk.")
+    assert !PublicSuffixService.valid?("google.zip.")
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: public_suffix_service
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 63
   prerelease: false
   segments: 
   - 0
-  - 7
+  - 8
   - 0
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Simone Carletti
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-09 00:00:00 +02:00
+date: 2010-12-05 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - public_suffix_service.gemspec
 - test/acceptance_test.rb
 - test/public_suffix_service/domain_test.rb
+- test/public_suffix_service/errors_test.rb
 - test/public_suffix_service/rule_list_test.rb
 - test/public_suffix_service/rule_test.rb
 - test/public_suffix_service_test.rb