public_suffix_service 0.4.0

data/lib/public_suffix_service/rule_list.rb

@@ -0,0 +1,246 @@
+#
+# = Public Suffix Service
+#
+# Domain Name parser based on the Public Suffix List
+#
+#
+# Category::    Net
+# Package::     PublicSuffixService
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+module PublicSuffixService
+
+  # = Rule List
+  #
+  # A PublicSuffixService::RuleList is a collection of one or more PublicSuffixService::Rule.
+  #
+  # Given a RuleList, you can add or remove PublicSuffixService::Rule,
+  # iterate all items in the list or search for the first rule
+  # which matches a specific domain name.
+  #
+  #   # Create a new list
+  #   list =  PublicSuffixService::RuleList.new
+  #
+  #   # Push two rules to the list
+  #   list << PublicSuffixService::Rule.factory("it")
+  #   list << PublicSuffixService::Rule.factory("com")
+  #
+  #   # Get the size of the list
+  #   list.size
+  #   # => 2
+  #
+  #   # Search for the rule matching given domain
+  #   list.find("example.com")
+  #   # => #<PublicSuffixService::Rule::Normal>
+  #   list.find("example.org")
+  #   # => nil
+  #
+  # You can create as many PublicSuffixService::RuleList you want.
+  # The PublicSuffixService::RuleList.default rule list is used by DomainName
+  # to tokenize and validate a domain.
+  #
+  # PublicSuffixService::RuleList implements Enumerable module.
+  #
+  class RuleList
+    include Enumerable
+
+    # Gets the list of rules.
+    # Each rule is expected to be a subclass of PublicSuffixService::Rule::Base.
+    #
+    # Returns an Array of rules.
+    attr_reader :list
+
+
+    # Initializes an empty PublicSuffixService::RuleList.
+    # If block is given, yields on self.
+    def initialize(&block) # :yields: self
+      @list = []
+      yield(self) if block_given?
+    end
+
+    # Checks whether two lists are equal.
+    # RuleList <tt>one</tt> is equal to <tt>two</tt>, if <tt>two</tt> is an instance of 
+    # <tt>PublicSuffixService::RuleList</tt> and each <tt>PublicSuffixService::Rule::Base</tt>
+    # in list <tt>one</tt> is available in list <tt>two</tt>,
+    # in the same order.
+    #
+    # other - The PublicSuffixService::RuleList to compare.
+    #
+    # Returns true if self is equal to other.
+    def ==(other)
+      return false unless other.is_a?(RuleList)
+      self.equal?(other) ||
+      self.list == other.list
+    end
+    alias :eql? :==
+
+    # Iterates each rule in the list.
+    #
+    # Returns nothing.
+    def each(*args, &block)
+      @list.each(*args, &block)
+    end
+
+    # Gets the list as Array.
+    #
+    # Return an Array.
+    def to_a
+      @list
+    end
+
+    # Adds the given object to the list.
+    #
+    # rule - The rule to add to the list. 
+    #        Expected to be a subclass of PublicSuffixService::Rule::Base.
+    #
+    # Returns self.
+    def add(rule)
+      @list << rule
+      self
+    end
+    alias << add
+
+    # Gets the number of elements in the list.
+    #
+    # Returns an Integer.
+    def size
+      @list.size
+    end
+    alias length size
+
+    # Checks whether the list is empty.
+    #
+    # Returns true if the list contains no elements.
+    def empty?
+      @list.empty?
+    end
+
+    # Removes all elements.
+    #
+    # Returns self.
+    def clear
+      @list.clear
+      self
+    end
+
+
+    # Returns the most appropriate rule for domain.
+    #
+    # From the Public Suffix List documentation:
+    #
+    # * If a hostname matches more than one rule in the file,
+    #   the longest matching rule (the one with the most levels) will be used.
+    # * An exclamation mark (!) at the start of a rule marks an exception to a previous wildcard rule.
+    #   An exception rule takes priority over any other matching rule.
+    #
+    # == Algorithm description
+    #
+    # * Match domain against all rules and take note of the matching ones.
+    # * If no rules match, the prevailing rule is "*".
+    # * If more than one rule matches, the prevailing rule is the one which is an exception rule.
+    # * If there is no matching exception rule, the prevailing rule is the one with the most labels.
+    # * If the prevailing rule is a exception rule, modify it by removing the leftmost label.
+    # * The public suffix is the set of labels from the domain
+    #   which directly match the labels of the prevailing rule (joined by dots).
+    # * The registered domain is the public suffix plus one additional label.
+    #
+    # Note: This might not be the most efficient algorithm.
+    #
+    # Returns a PublicSuffixService::Rule::Base instance or nil.
+    def find(domain)
+      rules = select(domain)
+      rules.select { |r|   r.type == :exception }.first ||
+      rules.inject { |t,r| t.length > r.length ? t : r }
+    end
+
+    # Selects all the rules matching given domain.
+    #
+    # Returns an Array of rules.
+    #   Each rule is expected to be a subclass of PublicSuffixService::Rule::Base.
+    def select(domain)
+      @list.select { |rule| rule.match?(domain) }
+    end
+
+
+    @@default = nil
+
+    class << self
+
+      # Gets the default <tt>PublicSuffixService::RuleList</tt>.
+      # Initializes a new <tt>PublicSuffixService::RuleList</tt> 
+      # parsing the content of <tt>PublicSuffixService::RuleList.default_definition</tt> if necessary.
+      #
+      # Returns an instance of PublicSuffixService::RuleList.
+      def default
+        @@default ||= parse(default_definition)
+      end
+
+      # Sets the default <tt>PublicSuffixService::RuleList</tt> to <tt>value</tt>.
+      #
+      # value - The new PublicSuffixService::RuleList.
+      #
+      # Returns the new PublicSuffixService::RuleList.
+      def default=(value)
+        @@default = value
+      end
+
+      # Sets the default <tt>PublicSuffixService::RuleList</tt> to <tt>nil</tt>.
+      #
+      # Returns self.
+      def clear
+        self.default = nil
+        self
+      end
+
+      # Resets the default <tt>PublicSuffixService::RuleList</tt> and reinitialize it
+      # parsing the content of <tt>PublicSuffixService::RuleList.default_definition</tt>.
+      #
+      # Returns an instance of PublicSuffixService::RuleList.
+      def reload
+        self.clear.default
+      end
+
+      # Gets the default definition list.
+      # Can be any <tt>IOStream</tt> including a <tt>File</tt> or a simple <tt>String</tt>.
+      # The object must respond to <tt>#each_line</tt>.
+      #
+      # Returns an object which responds to <tt>#each_line</tt>.
+      def default_definition
+        File.new(File.join(File.dirname(__FILE__), "definitions.dat"))
+      end
+
+
+      # Parse given <tt>input</tt> treating the content as Public Suffic List.
+      # See http://publicsuffix.org/format/ for more details about input format.
+      #
+      # Returns an Array of PublicSuffixService::Rule::Base.
+      def parse(input)
+        new do |list|
+          input.each_line do |line|
+            line.strip!
+
+            # strip blank lines
+            if line.empty?
+              next
+            # strip comments
+            elsif line =~ %r{^//}
+              next
+            # append rule
+            else
+              list << Rule.factory(line)
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/public_suffix_service/version.rb

@@ -0,0 +1,30 @@
+#
+# = Public Suffix Service
+#
+# Domain Name parser based on the Public Suffix List
+#
+#
+# Category::    Net
+# Package::     PublicSuffixService
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+module PublicSuffixService
+
+  module Version
+    MAJOR = 0
+    MINOR = 4
+    PATCH = 0
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join(".")
+  end
+
+  VERSION = Version::STRING
+
+end

data/public_suffix_service.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{public_suffix_service}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Simone Carletti"]
+  s.date = %q{2010-05-31}
+  s.description = %q{    Intelligent Domain Name parser based in the Public Suffic List.     Domain Name can parse and decompose a domain name into top level domain,     domain and subdomains.
+}
+  s.email = %q{weppos@weppos.net}
+  s.extra_rdoc_files = ["CHANGELOG.rdoc", "LICENSE.rdoc", "README.rdoc"]
+  s.files = ["Rakefile", "CHANGELOG.rdoc", "LICENSE.rdoc", "README.rdoc", "public_suffix_service.gemspec", "test/acceptance_test.rb", "test/public_suffix_service/domain_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", "lib/public_suffix_service/definitions.dat", "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", "lib/public_suffix_service.rb"]
+  s.homepage = %q{http://www.simonecarletti.com/code/public-suffix-service}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Domain Name parser based on the Public Suffix List}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+    else
+      s.add_dependency(%q<mocha>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mocha>, [">= 0"])
+  end
+end

data/test/acceptance_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class AcceptanceTest < Test::Unit::TestCase
+
+  CASES = {
+    "google.com" => [nil, "google", "com"],
+    "foo.google.com" => ["foo", "google", "com"],
+
+    "verybritish.co.uk" => [nil, "verybritish", "co.uk"],
+    "foo.verybritish.co.uk" => ["foo", "verybritish", "co.uk"],
+
+    "parliament.uk" => [nil, "parliament", "uk"],
+    "foo.parliament.uk" => ["foo", "parliament", "uk"],
+  }
+
+  def test_all
+    CASES.each do |name, results|
+      domain = PublicSuffixService.parse(name)
+      trd, sld, tld = results
+      assert_equal tld, domain.tld, "Invalid tld for '#{name}'"
+      assert_equal sld, domain.sld, "Invalid sld for '#{name}'"
+      assert_equal trd, domain.trd, "Invalid trd for '#{name}'"
+    end
+  end
+
+end

data/test/public_suffix_service/domain_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class PublicSuffixService::DomainTest < Test::Unit::TestCase
+
+  def setup
+    @klass = PublicSuffixService::Domain
+  end
+
+
+  def test_initialize_with_tld
+    domain = @klass.new("com")
+    assert_equal "com",     domain.tld
+    assert_equal nil,       domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_initialize_with_tld_and_sld
+    domain = @klass.new("com", "google")
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_initialize_with_tld_and_sld_and_trd
+    domain = @klass.new("com", "google", "www")
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "www",     domain.trd
+  end
+
+
+  def test_to_s
+    assert_equal "com",             @klass.new("com").to_s
+    assert_equal "google.com",      @klass.new("com", "google").to_s
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").to_s
+  end
+
+  def test_to_a
+    assert_equal [nil, nil, "com"],         @klass.new("com").to_a
+    assert_equal [nil, "google", "com"],    @klass.new("com", "google").to_a
+    assert_equal ["www", "google", "com"],  @klass.new("com", "google", "www").to_a
+  end
+
+
+  def test_tld
+    assert_equal "com", @klass.new("com", "google", "www").tld
+  end
+
+  def test_sld
+    assert_equal "google", @klass.new("com", "google", "www").sld
+  end
+
+  def test_tld
+    assert_equal "www", @klass.new("com", "google", "www").trd
+  end
+
+
+  def test_name
+    assert_equal "com",             @klass.new("com").name
+    assert_equal "google.com",      @klass.new("com", "google").name
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").name
+  end
+
+  def test_domain
+    assert_equal nil, @klass.new("com").domain
+    assert_equal nil, @klass.new("zip").domain
+    assert_equal "google.com", @klass.new("com", "google").domain
+    assert_equal "google.zip", @klass.new("zip", "google").domain
+    assert_equal "google.com", @klass.new("com", "google", "www").domain
+    assert_equal "google.zip", @klass.new("zip", "google", "www").domain
+  end
+
+  def test_subdomain
+    assert_equal nil, @klass.new("com").subdomain
+    assert_equal nil, @klass.new("zip").subdomain
+    assert_equal nil, @klass.new("com", "google").subdomain
+    assert_equal nil, @klass.new("zip", "google").subdomain
+    assert_equal "www.google.com", @klass.new("com", "google", "www").subdomain
+    assert_equal "www.google.zip", @klass.new("zip", "google", "www").subdomain
+  end
+
+  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
+  end
+
+
+  def test_domain_question
+    assert  @klass.new("com", "google").domain?
+    assert  @klass.new("zip", "google").domain?
+    assert  @klass.new("com", "google", "www").domain?
+    assert !@klass.new("com").domain?
+  end
+
+  def test_subdomain_question
+    assert  @klass.new("com", "google", "www").subdomain?
+    assert  @klass.new("zip", "google", "www").subdomain?
+    assert !@klass.new("com").subdomain?
+    assert !@klass.new("com", "google").subdomain?
+  end
+
+  def test_is_a_domain_question
+    assert  @klass.new("com", "google").is_a_domain?
+    assert  @klass.new("zip", "google").is_a_domain?
+    assert !@klass.new("com", "google", "www").is_a_domain?
+    assert !@klass.new("com").is_a_domain?
+  end
+
+  def test_is_a_subdomain_question
+    assert  @klass.new("com", "google", "www").is_a_subdomain?
+    assert  @klass.new("zip", "google", "www").is_a_subdomain?
+    assert !@klass.new("com").is_a_subdomain?
+    assert !@klass.new("com", "google").is_a_subdomain?
+  end
+
+  def test_valid_question
+    assert  @klass.new("com").valid?
+    assert  @klass.new("com", "google").valid?
+    assert  @klass.new("com", "google", "www").valid?
+    assert !@klass.new("zip").valid?
+    assert !@klass.new("zip", "google").valid?
+    assert !@klass.new("zip", "google", "www").valid?
+  end
+
+  def test_valid_domain_question
+    assert  @klass.new("com", "google").valid_domain?
+    assert !@klass.new("zip", "google").valid_domain?
+    assert  @klass.new("com", "google", "www").valid_domain?
+    assert !@klass.new("com").valid_domain?
+  end
+
+  def test_valid_subdomain_question
+    assert  @klass.new("com", "google", "www").valid_subdomain?
+    assert !@klass.new("zip", "google", "www").valid_subdomain?
+    assert !@klass.new("com").valid_subdomain?
+    assert !@klass.new("com", "google").valid_subdomain?
+  end
+
+end