public_suffix_service 0.9.0 → 0.9.1

data/lib/public_suffix/rule_list.rb

@@ -0,0 +1,14 @@
+#--
+# Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2011 Simone Carletti <weppos@weppos.net>
+#++
+
+
+warn("DEPRECATION WARNING: The PublicSuffix::RuleList object has been deprecated and will be removed in PublicSuffix 1.0. Please use PublicSuffix::List instead.")
+
+module PublicSuffix
+  RuleList = List
+end

data/lib/{public_suffix_service → public_suffix}/version.rb

@@ -1,18 +1,18 @@
 #--
-# Public Suffix Service
+# Public Suffix
 #
-# Domain Name parser based on the Public Suffix List.
+# Domain name parser based on the Public Suffix List.
 #
 # Copyright (c) 2009-2011 Simone Carletti <weppos@weppos.net>
 #++
 
 
-module PublicSuffixService
+module PublicSuffix
 
   module Version
     MAJOR = 0
     MINOR = 9
-    PATCH = 0
+    PATCH = 1
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join(".")

data/lib/public_suffix_service.rb

@@ -1,130 +1,14 @@
 #--
-# Public Suffix Service
+# Public Suffix
 #
-# Domain Name parser based on the Public Suffix List.
+# Domain name parser based on the Public Suffix List.
 #
 # Copyright (c) 2009-2011 Simone Carletti <weppos@weppos.net>
 #++
 
 
-require 'public_suffix_service/domain'
-require 'public_suffix_service/version'
-require 'public_suffix_service/errors'
-require 'public_suffix_service/rule'
-require 'public_suffix_service/rule_list'
+warn("DEPRECATION WARNING: The PublicSuffixService gem is now known as PublicSuffix. Please install `public_suffix` instead of `public_suffix_service`.")
 
+require 'public_suffix'
 
-module PublicSuffixService
-
-  NAME            = "Public Suffix Service"
-  GEM             = "public_suffix_service"
-  AUTHORS         = ["Simone Carletti <weppos@weppos.net>"]
-
-
-  # Parses +domain+ and returns the
-  # {PublicSuffixService::Domain} instance.
-  #
-  # Parsing uses the default {PublicSuffixService::RuleList}.
-  #
-  # @param  [String, #to_s] domain
-  #   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")
-  #   # => PublicSuffixService::DomainInvalid
-  #
-  # @example Parse an URL (not supported, only domains)
-  #   PublicSuffixService.parse("http://www.google.com")
-  #   # => PublicSuffixService::DomainInvalid
-  #
-  # @raise [PublicSuffixService::Error]
-  #   If domain is not a valid domain.
-  # @raise [PublicSuffixService::DomainNotAllowed]
-  #   If a rule for +domain+ is found, but the rule
-  #   doesn't allow +domain+.
-  #
-  def self.parse(domain)
-    rule = RuleList.default.find(domain)
-    if rule.nil?
-      raise DomainInvalid, "`#{domain}' is not a valid domain"
-    end
-    if !rule.allow?(domain)
-      raise DomainNotAllowed, "`#{domain}' is not allowed according to Registry policy"
-    end
-
-    left, right = rule.decompose(domain)
-
-    parts = left.split(".")
-    # If we have 0 parts left, there is just a tld and no domain or subdomain
-    # If we have 1 part  left, there is just a tld, domain and not subdomain
-    # If we have 2 parts left, the last part is the domain, the other parts (combined) are the subdomain
-    tld = right
-    sld = parts.empty? ? nil : parts.pop
-    trd = parts.empty? ? nil : parts.join(".")
-
-    Domain.new(tld, sld, trd)
-  end
-
-  # Checks whether +domain+ is assigned and allowed,
-  # without actually parsing it.
-  #
-  # This method doesn't care whether domain is a domain or subdomain.
-  # The validation is performed using the default {PublicSuffixService::RuleList}.
-  #
-  # @param  [String, #to_s] domain
-  #   The domain name or fully qualified domain name to validate.
-  #
-  # @return [Boolean]
-  #
-  # @example Validate a valid domain
-  #   PublicSuffixService.valid?("example.com")
-  #   # => true
-  #
-  # @example Validate a valid subdomain
-  #   PublicSuffixService.valid?("www.example.com")
-  #   # => true
-  #
-  # @example Validate a not-assigned domain
-  #   PublicSuffixService.valid?("example.zip")
-  #   # => false
-  #
-  # @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")
-  #   # => false
-  #
-  def self.valid?(domain)
-    rule = RuleList.default.find(domain)
-    !rule.nil? && rule.allow?(domain)
-  end
-
-end
+PublicSuffixService = PublicSuffix

data/public_suffix_service.gemspec

@@ -1,34 +1,37 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{public_suffix_service}
-  s.version = "0.8.3"
+  s.name = "public_suffix_service"
+  s.version = "0.9.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{Simone Carletti}]
-  s.date = %q{2011-06-17}
-  s.description = %q{PublicSuffixService can parse and decompose a domain name into top level domain, domain and subdomains.}
-  s.email = %q{weppos@weppos.net}
-  s.files = [%q{.gemtest}, %q{.gitignore}, %q{.yardopts}, %q{CHANGELOG.md}, %q{Gemfile}, %q{Gemfile.lock}, %q{LICENSE}, %q{README.md}, %q{Rakefile}, %q{lib/public_suffix_service.rb}, %q{lib/public_suffix_service/definitions.txt}, %q{lib/public_suffix_service/domain.rb}, %q{lib/public_suffix_service/errors.rb}, %q{lib/public_suffix_service/rule.rb}, %q{lib/public_suffix_service/rule_list.rb}, %q{lib/public_suffix_service/version.rb}, %q{public_suffix_service.gemspec}, %q{test/acceptance_test.rb}, %q{test/public_suffix_service/domain_test.rb}, %q{test/public_suffix_service/errors_test.rb}, %q{test/public_suffix_service/rule_list_test.rb}, %q{test/public_suffix_service/rule_test.rb}, %q{test/public_suffix_service_test.rb}, %q{test/test_helper.rb}]
-  s.homepage = %q{http://www.simonecarletti.com/code/public_suffix_service}
-  s.require_paths = [%q{lib}]
+  s.authors = ["Simone Carletti"]
+  s.date = "2011-12-24"
+  s.description = "PublicSuffixService gem is now known as PublicSuffix."
+  s.email = "weppos@weppos.net"
+  s.files = [".gemtest", ".gitignore", ".travis.yml", ".yardopts", "CHANGELOG.md", "Gemfile", "Gemfile.lock", "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", "public_suffix_service.gemspec", "test/acceptance_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"]
+  s.homepage = "http://www.simonecarletti.com/code/public_suffix"
+  s.require_paths = ["lib"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
-  s.rubygems_version = %q{1.8.3}
-  s.summary = %q{Domain name parser based in the Public Suffix List.}
-  s.test_files = [%q{test/acceptance_test.rb}, %q{test/public_suffix_service/domain_test.rb}, %q{test/public_suffix_service/errors_test.rb}, %q{test/public_suffix_service/rule_list_test.rb}, %q{test/public_suffix_service/rule_test.rb}, %q{test/public_suffix_service_test.rb}, %q{test/test_helper.rb}]
+  s.rubygems_version = "1.8.11"
+  s.summary = "Domain name parser based in the Public Suffix List."
+  s.test_files = ["test/acceptance_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"]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rr>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
       s.add_development_dependency(%q<yard>, [">= 0"])
     else
-      s.add_dependency(%q<rr>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
       s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rr>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
     s.add_dependency(%q<yard>, [">= 0"])
   end
 end

data/test/acceptance_test.rb

@@ -15,7 +15,7 @@ class AcceptanceTest < Test::Unit::TestCase
 
   def test_valid
     ValidCases.each do |name, results|
-      domain = PublicSuffixService.parse(name)
+      domain = PublicSuffix.parse(name)
       trd, sld, tld = results
       assert_equal tld, domain.tld, "Invalid tld for '#{name}'"
       assert_equal sld, domain.sld, "Invalid sld for '#{name}'"
@@ -24,12 +24,12 @@ class AcceptanceTest < Test::Unit::TestCase
   end
 
   InvalidCases = {
-    "nic.ke" => PublicSuffixService::DomainNotAllowed,
+    "nic.ke" => PublicSuffix::DomainNotAllowed,
   }
 
   def test_invalid
     InvalidCases.each do |name, error|
-      assert_raise(error) { PublicSuffixService.parse(name) }
+      assert_raise(error) { PublicSuffix.parse(name) }
     end
   end
 

data/test/test_helper.rb

@@ -1,10 +1,6 @@
 require 'rubygems'
 require 'test/unit'
-require 'rr'
+require 'mocha'
 
 $:.unshift File.expand_path('../../lib', __FILE__)
-require 'public_suffix_service'
-
-class Test::Unit::TestCase
-  include RR::Adapters::TestUnit
-end
+require 'public_suffix'

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

@@ -1,31 +1,31 @@
 require 'test_helper'
 
-class PublicSuffixService::DomainTest < Test::Unit::TestCase
+class PublicSuffix::DomainTest < Test::Unit::TestCase
 
   def setup
-    @klass = PublicSuffixService::Domain
+    @klass = PublicSuffix::Domain
   end
 
   # 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")
+                  PublicSuffix::Domain.domain_to_labels("someone.spaces.live.com")
     assert_equal  %w( com zoho wiki leontina23samiko ),
-                  PublicSuffixService::Domain.domain_to_labels("leontina23samiko.wiki.zoho.com")
+                  PublicSuffix::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")
+                  PublicSuffix::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")
+                  PublicSuffix::Domain.domain_to_labels("someone.spaces.live.com")
     assert_equal  %w( com live spaces someone ),
-                  PublicSuffixService::Domain.domain_to_labels(:"someone.spaces.live.com")
+                  PublicSuffix::Domain.domain_to_labels(:"someone.spaces.live.com")
   end
 
 
@@ -72,7 +72,7 @@ class PublicSuffixService::DomainTest < Test::Unit::TestCase
     assert_equal "google", @klass.new("com", "google", "www").sld
   end
 
-  def test_tld
+  def test_trd
     assert_equal "www", @klass.new("com", "google", "www").trd
   end
 
@@ -103,9 +103,9 @@ class PublicSuffixService::DomainTest < Test::Unit::TestCase
 
   def test_rule
     assert_equal nil,                                      @klass.new("zip").rule
-    assert_equal PublicSuffixService::Rule.factory("com"), @klass.new("com").rule
-    assert_equal PublicSuffixService::Rule.factory("com"), @klass.new("com", "google").rule
-    assert_equal PublicSuffixService::Rule.factory("com"), @klass.new("com", "google", "www").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com", "google").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com", "google", "www").rule
   end
 
 

data/test/unit/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,
+                    PublicSuffix::Error.new
+  end
+
+  # Inherits from PublicSuffix::Error
+  def test_domain_invalid_inheritance
+    assert_kind_of  PublicSuffix::Error,
+                    PublicSuffix::DomainInvalid.new
+  end
+
+  # Inherits from PublicSuffix::DomainInvalid
+  def test_domain_not_allowed_inheritance
+    assert_kind_of  PublicSuffix::DomainInvalid,
+                    PublicSuffix::DomainNotAllowed.new
+  end
+
+end

data/test/unit/list_test.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+
+class PublicSuffix::ListTest < Test::Unit::TestCase
+
+  def setup
+    @list = PublicSuffix::List.new
+  end
+
+  def teardown
+    PublicSuffix::List.clear
+  end
+
+
+  def test_initialize
+    assert_instance_of PublicSuffix::List, @list
+    assert_equal 0, @list.length
+  end
+
+  def test_initialize_create_index_when_empty
+    assert_equal({}, @list.indexes)
+  end
+
+  def test_indexes
+    @list = PublicSuffix::List.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 = PublicSuffix::List.new
+    assert_equal list, list
+  end
+
+  def test_equality_with_internals
+    rule = PublicSuffix::Rule.factory("com")
+    assert_equal PublicSuffix::List.new.add(rule), PublicSuffix::List.new.add(rule)
+  end
+
+
+  def test_add
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal @list, @list <<  PublicSuffix::Rule.factory("")
+    assert_equal 2, @list.length
+  end
+
+  def test_add_should_recreate_index
+    @list = PublicSuffix::List.parse("com")
+    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
+    assert_equal nil, @list.find("google.net")
+
+    @list << PublicSuffix::Rule.factory("net")
+    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
+    assert_equal PublicSuffix::Rule.factory("net"), @list.find("google.net")
+  end
+
+  def test_empty?
+    assert  @list.empty?
+    @list.add(PublicSuffix::Rule.factory(""))
+    assert !@list.empty?
+  end
+
+  def test_size
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.length
+  end
+
+  def test_clear
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.length
+    assert_equal @list, @list.clear
+    assert_equal 0, @list.length
+  end
+
+
+  def test_find
+    @list = PublicSuffix::List.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 PublicSuffix::Rule.factory("com"),  @list.find("google.com")
+    assert_equal PublicSuffix::Rule.factory("com"),  @list.find("foo.google.com")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("google.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("google.co.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("foo.google.co.uk")
+    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), @list.find("british-library.uk")
+    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), @list.find("foo.british-library.uk")
+  end
+
+  def test_select
+    @list = PublicSuffix::List.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, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_default_setter
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.default = nil
+    assert_equal     nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_clear
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.clear
+    assert_equal     nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_reload
+    PublicSuffix::List.default
+    PublicSuffix::List.expects(:default_definition).returns("")
+
+    PublicSuffix::List.reload
+    assert_equal PublicSuffix::List.new, PublicSuffix::List.default
+  end
+
+
+  def test_self_parse
+    list = PublicSuffix::List.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 PublicSuffix::List, list
+    assert_equal 5, list.length
+    assert_equal %w(ac com.ac ad *.ar !congresodelalengua3.ar).map { |name| PublicSuffix::Rule.factory(name) }, list.to_a
+  end
+
+  def test_self_parse_should_create_cache
+    list = PublicSuffix::List.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 PublicSuffix::Rule.factory("com"), list.find("google.com")
+  end
+
+end