public_suffix_service 0.9.0 → 0.9.1

data/test/unit/public_suffix_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class PublicSuffixTest < Test::Unit::TestCase
+
+  def test_self_parse_a_domain_with_tld_and_sld
+    domain = PublicSuffix.parse("example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal nil,       domain.trd
+
+    domain = PublicSuffix.parse("example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_trd
+    domain = PublicSuffix.parse("alpha.example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "alpha",   domain.trd
+
+    domain = PublicSuffix.parse("alpha.example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "alpha",   domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_4rd
+    domain = PublicSuffix.parse("one.two.example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "one.two", domain.trd
+
+    domain = PublicSuffix.parse("one.two.example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "one.two", domain.trd
+  end
+
+  def test_self_parse_a_fully_qualified_domain_name
+    domain = PublicSuffix.parse("www.example.com.")
+    assert_instance_of PublicSuffix::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(PublicSuffix::DomainInvalid) { PublicSuffix.parse("example.zip") }
+    assert_match %r{example\.zip}, error.message
+  end
+
+  def test_self_parse_should_raise_with_unallowed_domain
+    error = assert_raise(PublicSuffix::DomainNotAllowed) { PublicSuffix.parse("example.ke") }
+    assert_match %r{example\.ke}, error.message
+  end
+
+
+  def test_self_valid
+    assert  PublicSuffix.valid?("google.com")
+    assert  PublicSuffix.valid?("www.google.com")
+    assert  PublicSuffix.valid?("google.co.uk")
+    assert  PublicSuffix.valid?("www.google.co.uk")
+  end
+
+  # Returns false when domain has an invalid TLD
+  def test_self_valid_with_invalid_tld
+    assert !PublicSuffix.valid?("google.zip")
+    assert !PublicSuffix.valid?("www.google.zip")
+  end
+
+  def test_self_valid_with_fully_qualified_domain_name
+    assert  PublicSuffix.valid?("google.com.")
+    assert  PublicSuffix.valid?("google.co.uk.")
+    assert !PublicSuffix.valid?("google.zip.")
+  end
+
+end

data/test/{public_suffix_service → unit}/rule_test.rb

@@ -1,38 +1,38 @@
 require 'test_helper'
 
-class PublicSuffixService::RuleTest < Test::Unit::TestCase
+class PublicSuffix::RuleTest < Test::Unit::TestCase
 
   def test_factory_should_return_rule_normal
-    rule = PublicSuffixService::Rule.factory("com")
-    assert_instance_of PublicSuffixService::Rule::Normal, rule
+    rule = PublicSuffix::Rule.factory("com")
+    assert_instance_of PublicSuffix::Rule::Normal, rule
 
-    rule = PublicSuffixService::Rule.factory("verona.it")
-    assert_instance_of PublicSuffixService::Rule::Normal, rule
+    rule = PublicSuffix::Rule.factory("verona.it")
+    assert_instance_of PublicSuffix::Rule::Normal, rule
   end
 
   def test_factory_should_return_rule_exception
-    rule = PublicSuffixService::Rule.factory("!british-library.uk")
-    assert_instance_of PublicSuffixService::Rule::Exception, rule
+    rule = PublicSuffix::Rule.factory("!british-library.uk")
+    assert_instance_of PublicSuffix::Rule::Exception, rule
   end
 
   def test_factory_should_return_rule_wildcard
-    rule = PublicSuffixService::Rule.factory("*.do")
-    assert_instance_of PublicSuffixService::Rule::Wildcard, rule
+    rule = PublicSuffix::Rule.factory("*.do")
+    assert_instance_of PublicSuffix::Rule::Wildcard, rule
 
-    rule = PublicSuffixService::Rule.factory("*.sch.uk")
-    assert_instance_of PublicSuffixService::Rule::Wildcard, rule
+    rule = PublicSuffix::Rule.factory("*.sch.uk")
+    assert_instance_of PublicSuffix::Rule::Wildcard, rule
   end
 
 end
 
 
-class PublicSuffixService::RuleBaseTest < Test::Unit::TestCase
+class PublicSuffix::RuleBaseTest < Test::Unit::TestCase
 
-  class ::PublicSuffixService::Rule::Test < ::PublicSuffixService::Rule::Base
+  class ::PublicSuffix::Rule::Test < ::PublicSuffix::Rule::Base
   end
 
   def setup
-    @klass = PublicSuffixService::Rule::Base
+    @klass = PublicSuffix::Rule::Base
   end
 
 
@@ -47,14 +47,14 @@ class PublicSuffixService::RuleBaseTest < Test::Unit::TestCase
   end
 
   def test_equality_with_self
-    rule = PublicSuffixService::Rule::Base.new("foo")
+    rule = PublicSuffix::Rule::Base.new("foo")
     assert_equal rule, rule
   end
 
   def test_equality_with_internals
     assert_equal      @klass.new("foo"), @klass.new("foo")
     assert_not_equal  @klass.new("foo"), @klass.new("bar")
-    assert_not_equal  @klass.new("foo"), PublicSuffixService::Rule::Test.new("bar")
+    assert_not_equal  @klass.new("foo"), PublicSuffix::Rule::Test.new("bar")
     assert_not_equal  @klass.new("foo"), Class.new { def name; foo; end }.new
   end
 
@@ -88,10 +88,10 @@ class PublicSuffixService::RuleBaseTest < Test::Unit::TestCase
 end
 
 
-class PublicSuffixService::RuleNormalTest < Test::Unit::TestCase
+class PublicSuffix::RuleNormalTest < Test::Unit::TestCase
 
   def setup
-    @klass = PublicSuffixService::Rule::Normal
+    @klass = PublicSuffix::Rule::Normal
   end
 
 
@@ -165,10 +165,10 @@ class PublicSuffixService::RuleNormalTest < Test::Unit::TestCase
 end
 
 
-class PublicSuffixService::RuleExceptionTest < Test::Unit::TestCase
+class PublicSuffix::RuleExceptionTest < Test::Unit::TestCase
 
   def setup
-    @klass = PublicSuffixService::Rule::Exception
+    @klass = PublicSuffix::Rule::Exception
   end
 
 
@@ -236,10 +236,10 @@ class PublicSuffixService::RuleExceptionTest < Test::Unit::TestCase
 end
 
 
-class PublicSuffixService::RuleWildcardTest < Test::Unit::TestCase
+class PublicSuffix::RuleWildcardTest < Test::Unit::TestCase
 
   def setup
-    @klass = PublicSuffixService::Rule::Wildcard
+    @klass = PublicSuffix::Rule::Wildcard
   end
 
 

metadata

@@ -1,50 +1,58 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: public_suffix_service
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.9.1
   prerelease: 
-  version: 0.9.0
 platform: ruby
-authors: 
+authors:
 - Simone Carletti
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-17 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rr
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2011-12-24 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70168588273080 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *70168588273080
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70168588268020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70168588268020
+- !ruby/object:Gem::Dependency
   name: yard
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &70168588259580 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id002
-description: PublicSuffixService can parse and decompose a domain name into top level domain, domain and subdomains.
+  version_requirements: *70168588259580
+description: PublicSuffixService gem is now known as PublicSuffix.
 email: weppos@weppos.net
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gemtest
 - .gitignore
+- .travis.yml
 - .yardopts
 - CHANGELOG.md
 - Gemfile
@@ -52,53 +60,52 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/public_suffix.rb
+- lib/public_suffix/definitions.txt
+- lib/public_suffix/domain.rb
+- lib/public_suffix/errors.rb
+- lib/public_suffix/list.rb
+- lib/public_suffix/rule.rb
+- lib/public_suffix/rule_list.rb
+- lib/public_suffix/version.rb
 - lib/public_suffix_service.rb
-- lib/public_suffix_service/definitions.txt
-- lib/public_suffix_service/domain.rb
-- lib/public_suffix_service/errors.rb
-- lib/public_suffix_service/rule.rb
-- lib/public_suffix_service/rule_list.rb
-- lib/public_suffix_service/version.rb
 - 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
 - test/test_helper.rb
-homepage: http://www.simonecarletti.com/code/public_suffix_service
+- test/unit/domain_test.rb
+- test/unit/errors_test.rb
+- test/unit/list_test.rb
+- test/unit/public_suffix_test.rb
+- test/unit/rule_test.rb
+homepage: http://www.simonecarletti.com/code/public_suffix
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.3
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Domain name parser based in the Public Suffix List.
-test_files: 
+test_files:
 - 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
 - test/test_helper.rb
+- test/unit/domain_test.rb
+- test/unit/errors_test.rb
+- test/unit/list_test.rb
+- test/unit/public_suffix_test.rb
+- test/unit/rule_test.rb

data/test/public_suffix_service/errors_test.rb

@@ -1,23 +0,0 @@
-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_list_test.rb

@@ -1,193 +0,0 @@
-require 'test_helper'
-
-class PublicSuffixService::RuleListTest < Test::Unit::TestCase
-
-  def setup
-    @list = PublicSuffixService::RuleList.new
-  end
-
-  def teardown
-    PublicSuffixService::RuleList.clear
-  end
-
-
-  def test_initialize
-    assert_instance_of PublicSuffixService::RuleList, @list
-    assert_equal 0, @list.length
-  end
-
-  def test_initialize_create_index_when_empty
-    assert_equal({}, @list.indexes)
-  end
-
-  def test_indexes
-    @list = PublicSuffixService::RuleList.parse(<<EOS)
-// com : http://en.wikipedia.org/wiki/.com
-com
-
-// uk : http://en.wikipedia.org/wiki/.uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-EOS
-
-    assert !@list.indexes.empty?
-    assert_equal [1,2,3,4], @list.indexes.delete('uk')
-    assert_equal [0], @list.indexes.delete('com')
-    assert @list.indexes.empty?
-  end
-
-
-  def test_equality_with_self
-    list = PublicSuffixService::RuleList.new
-    assert_equal list, list
-  end
-
-  def test_equality_with_internals
-    rule = PublicSuffixService::Rule.factory("com")
-    assert_equal PublicSuffixService::RuleList.new.add(rule), PublicSuffixService::RuleList.new.add(rule)
-  end
-
-
-  def test_add
-    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
-    assert_equal @list, @list <<  PublicSuffixService::Rule.factory("")
-    assert_equal 2, @list.length
-  end
-
-  def test_add_should_recreate_index
-    @list = PublicSuffixService::RuleList.parse("com")
-    assert_equal PublicSuffixService::Rule.factory("com"), @list.find("google.com")
-    assert_equal nil, @list.find("google.net")
-
-    @list << PublicSuffixService::Rule.factory("net")
-    assert_equal PublicSuffixService::Rule.factory("com"), @list.find("google.com")
-    assert_equal PublicSuffixService::Rule.factory("net"), @list.find("google.net")
-  end
-
-  def test_empty?
-    assert  @list.empty?
-    @list.add(PublicSuffixService::Rule.factory(""))
-    assert !@list.empty?
-  end
-
-  def test_size
-    assert_equal 0, @list.length
-    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
-    assert_equal 1, @list.length
-  end
-
-  def test_clear
-    assert_equal 0, @list.length
-    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
-    assert_equal 1, @list.length
-    assert_equal @list, @list.clear
-    assert_equal 0, @list.length
-  end
-
-
-  def test_find
-    @list = PublicSuffixService::RuleList.parse(<<EOS)
-// com : http://en.wikipedia.org/wiki/.com
-com
-
-// uk : http://en.wikipedia.org/wiki/.uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-EOS
-    assert_equal PublicSuffixService::Rule.factory("com"),  @list.find("google.com")
-    assert_equal PublicSuffixService::Rule.factory("com"),  @list.find("foo.google.com")
-    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("google.uk")
-    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("google.co.uk")
-    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("foo.google.co.uk")
-    assert_equal PublicSuffixService::Rule.factory("!british-library.uk"), @list.find("british-library.uk")
-    assert_equal PublicSuffixService::Rule.factory("!british-library.uk"), @list.find("foo.british-library.uk")
-  end
-
-  def test_select
-    @list = PublicSuffixService::RuleList.parse(<<EOS)
-// com : http://en.wikipedia.org/wiki/.com
-com
-
-// uk : http://en.wikipedia.org/wiki/.uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-EOS
-    assert_equal 2, @list.select("british-library.uk").size
-  end
-
-
-  def test_self_default_getter
-    assert_equal     nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-    PublicSuffixService::RuleList.default
-    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-  end
-
-  def test_self_default_setter
-    PublicSuffixService::RuleList.default
-    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-    PublicSuffixService::RuleList.default = nil
-    assert_equal     nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-  end
-
-  def test_self_clear
-    PublicSuffixService::RuleList.default
-    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-    PublicSuffixService::RuleList.clear
-    assert_equal     nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
-  end
-
-  def test_self_reload
-    PublicSuffixService::RuleList.default
-    mock(PublicSuffixService::RuleList).default_definition { "" }
-
-    PublicSuffixService::RuleList.reload
-    assert_equal PublicSuffixService::RuleList.new, PublicSuffixService::RuleList.default
-  end
-
-
-  def test_self_parse
-    list = PublicSuffixService::RuleList.parse(<<EOS)
-// ***** BEGIN LICENSE BLOCK *****
-// Version: MPL 1.1/GPL 2.0/LGPL 2.1
-//
-// ***** END LICENSE BLOCK *****
-
-// ac : http://en.wikipedia.org/wiki/.ac
-ac
-com.ac
-
-// ad : http://en.wikipedia.org/wiki/.ad
-ad
-
-// ar : http://en.wikipedia.org/wiki/.ar
-*.ar
-!congresodelalengua3.ar
-EOS
-
-    assert_instance_of PublicSuffixService::RuleList, list
-    assert_equal 5, list.length
-    assert_equal %w(ac com.ac ad *.ar !congresodelalengua3.ar).map { |name| PublicSuffixService::Rule.factory(name) }, list.to_a
-  end
-
-  def test_self_parse_should_create_cache
-    list = PublicSuffixService::RuleList.parse(<<EOS)
-// com : http://en.wikipedia.org/wiki/.com
-com
-
-// uk : http://en.wikipedia.org/wiki/.uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-EOS
-
-    assert_equal PublicSuffixService::Rule.factory("com"), list.find("google.com")
-  end
-
-end