PSL auto-update

.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 
 rvm:
-  - 2.0
   - 2.1
   - 2.2
   - 2.3.3

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 #### master
 
+- CHANGED: Dropped support for Ruby < 2.1
 - CHANGED: `PublicSuffix::List#rules` is now protected. You should not rely on it as the internal rule representation is subject to change to optimize performances.
 - CHANGED: Removed `PublicSuffix::List.clear`, it was an unnecessary accessor method. Use `PublicSuffix::List.default = nil` if you **really** need to reset the default list. You shouldn't.
 - CHANGED: `PublicSuffix::List#select` is now private. You should not use it, instead use ``PublicSuffix::List#find`. 

Gemfile

@@ -7,4 +7,4 @@ gem "minitest"
 gem "minitest-reporters"
 gem "rubocop", require: false
 
-gem "memory_profiler", require: false if !RUBY_VERSION.start_with?("2.0")
+gem "memory_profiler", require: false

lib/public_suffix/list.rb

@@ -90,7 +90,7 @@ def self.parse(input, private_domains: true)
             next
 
           else
-            list.add(Rule.factory(line, private: section == 2), reindex: false)
+            list.add(Rule.factory(line, private: section == 2))
 
           end
         end
@@ -103,32 +103,8 @@ def self.parse(input, private_domains: true)
     # @yield [self] Yields on self.
     # @yieldparam [PublicSuffix::List] self The newly created instance.
     def initialize
-      @rules = []
+      @rules = {}
       yield(self) if block_given?
-      reindex!
-    end
-
-
-    # Creates a naive index for +@rules+. Just a hash that will tell
-    # us where the elements of +@rules+ are relative to its first
-    # {PublicSuffix::Rule::Base#labels} element.
-    #
-    # For instance if @rules[5] and @rules[4] are the only elements of the list
-    # where Rule#labels.first is 'us' @indexes['us'] #=> [5,4], that way in
-    # select we can avoid mapping every single rule against the candidate domain.
-    def reindex!
-      @indexes = {}
-      @rules.each_with_index do |rule, index|
-        tld = Domain.name_to_labels(rule.value).last
-        @indexes[tld] ||= []
-        @indexes[tld] << index
-      end
-    end
-
-    # Gets the naive index, a hash that with the keys being the first label of
-    # every rule pointing to an array of integers (indexes of the rules in @rules).
-    def indexes
-      @indexes.dup
     end
 
 
@@ -138,7 +114,7 @@ def indexes
     # {PublicSuffix::List} and each +PublicSuffix::Rule::*+
     # in list <tt>one</tt> is available in list <tt>two</tt>, in the same order.
     #
-    # @param other [PublicSuffix::List] the List to compare
+    # @param  other [PublicSuffix::List] the List to compare
     # @return [Boolean]
     def ==(other)
       return false unless other.is_a?(List)
@@ -147,27 +123,26 @@ def ==(other)
     alias eql? ==
 
     # Iterates each rule in the list.
-    def each(*args, &block)
-      @rules.each(*args, &block)
+    def each(&block)
+      Enumerator.new do |y|
+        @rules.each do |key, node|
+          y << entry_to_rule(node, key)
+        end
+      end.each(&block)
     end
 
 
     # Adds the given object to the list and optionally refreshes the rule index.
     #
-    # @see #reindex!
-    #
     # @param  rule [PublicSuffix::Rule::*] the rule to add to the list
-    # @param reindex [Boolean] Set to true to recreate the rule index
-    #   after the rule has been added to the list.
     # @return [self]
-    def add(rule, reindex: true)
-      @rules << rule
-      reindex! if reindex
+    def add(rule)
+      @rules[rule.value] = rule_to_entry(rule)
       self
     end
     alias << add
 
-    # Gets the number of elements in the list.
+    # Gets the number of rules in the list.
     #
     # @return [Integer]
     def size
@@ -181,34 +156,15 @@ def empty?
       @rules.empty?
     end
 
-    # Removes all elements.
+    # Removes all rules.
     #
     # @return [self]
     def clear
       @rules.clear
-      reindex!
       self
     end
 
-    # Finds and returns the most appropriate rule for the domain name.
-    #
-    # 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
-    #
-    # 1. Match domain against all rules and take note of the matching ones.
-    # 2. If no rules match, the prevailing rule is "*".
-    # 3. If more than one rule matches, the prevailing rule is the one which is an exception rule.
-    # 4. If there is no matching exception rule, the prevailing rule is the one with the most labels.
-    # 5. If the prevailing rule is a exception rule, modify it by removing the leftmost label.
-    # 6. The public suffix is the set of labels from the domain
-    #    which directly match the labels of the prevailing rule (joined by dots).
-    # 7. The registered domain is the public suffix plus one additional label.
+    # Finds and returns the rule corresponding to the longest public suffix for the hostname.
     #
     # @param  name [#to_s] the hostname
     # @param  default [PublicSuffix::Rule::*] the default rule to return in case no rule matches
@@ -221,7 +177,7 @@ def find(name, default: default_rule, **options)
       rule || default
     end
 
-    # Selects all the rules matching given domain.
+    # Selects all the rules matching given hostame.
     #
     # If `ignore_private` is set to true, the algorithm will skip the rules that are flagged as
     # private domain. Note that the rules will still be part of the loop.
@@ -239,12 +195,24 @@ def find(name, default: default_rule, **options)
     # @return [Array<PublicSuffix::Rule::*>]
     def select(name, ignore_private: false)
       name = name.to_s
-      indices = (@indexes[Domain.name_to_labels(name).last] || [])
 
-      finder = @rules.values_at(*indices).lazy
-      finder = finder.select { |rule| rule.match?(name) }
-      finder = finder.select { |rule| !rule.private } if ignore_private
-      finder.to_a
+      parts = name.split(DOT).reverse!
+      index = 0
+      query = parts[index]
+      rules = []
+
+      loop do
+        match = @rules[query]
+        if !match.nil? && (ignore_private == false || match.private == false)
+          rules << entry_to_rule(match, query)
+        end
+
+        index += 1
+        break if index >= parts.size
+        query = parts[index] + DOT + query
+      end
+
+      rules
     end
     private :select
 
@@ -262,5 +230,16 @@ def default_rule
 
     attr_reader :rules
 
+
+    private
+
+    def entry_to_rule(entry, value)
+      entry.type.new(value: value, length: entry.length, private: entry.private)
+    end
+
+    def rule_to_entry(rule)
+      Rule::Entry.new(rule.class, rule.length, rule.private)
+    end
+
   end
 end

lib/public_suffix/rule.rb

@@ -19,6 +19,9 @@ module PublicSuffix
   #
   module Rule
 
+    # @api internal
+    Entry = Struct.new(:type, :length, :private)
+
     # = Abstract rule class
     #
     # This represent the base class for a Rule definition
@@ -106,13 +109,21 @@ class Base
       attr_reader :private
 
 
-      # Initializes a new rule with name and value.
-      # If value is +nil+, name also becomes the value for this rule.
+      # Initializes a new rule from the content.
+      #
+      # @param  content [String] the content of the rule
+      # @param  private [Boolean]
+      def self.build(content, private: false)
+        new(value: content, private: private)
+      end
+
+      # Initializes a new rule.
       #
-      # @param value [String] the value of the rule
-      def initialize(value, private: false)
+      # @param  value [String]
+      # @param  private [Boolean]
+      def initialize(value:, length: nil, private: false)
         @value    = value.to_s
-        @length   = @value.count(DOT) + 1
+        @length   = length || @value.count(DOT) + 1
         @private  = private
       end
 
@@ -204,15 +215,21 @@ def parts
     # Wildcard represents a wildcard rule (e.g. *.co.uk).
     class Wildcard < Base
 
-      # Initializes a new rule from +definition+.
+      # Initializes a new rule from the content.
       #
-      # The wildcard "*" is removed from the value,
-      # as it's common for each wildcard rule.
+      # @param  content [String] the content of the rule
+      # @param  private [Boolean]
+      def self.build(content, private: false)
+        new(value: content.to_s[2..-1], private: private)
+      end
+
+      # Initializes a new rule.
       #
-      # @param definition [String] the rule as defined in the PSL
-      def initialize(definition, private: false)
-        super(definition.to_s[2..-1], private: private)
-        @length += 1 # * counts as 1
+      # @param  value [String]
+      # @param  private [Boolean]
+      def initialize(value:, length: nil, private: false)
+        super(value: value, length: length, private: private)
+        length or @length += 1 # * counts as 1
       end
 
       # Gets the original rule definition.
@@ -245,14 +262,12 @@ def parts
     # Exception represents an exception rule (e.g. !parliament.uk).
     class Exception < Base
 
-      # Initializes a new rule from +definition+.
-      #
-      # The bang ! is removed from the value,
-      # as it's common for each exception rule.
+      # Initializes a new rule from the content.
       #
-      # @param definition [String] the rule as defined in the PSL
-      def initialize(definition, private: false)
-        super(definition.to_s[1..-1], private: private)
+      # @param  content [String] the content of the rule
+      # @param  private [Boolean]
+      def self.build(content, private: false)
+        new(value: content.to_s[1..-1], private: private)
       end
 
       # Gets the original rule definition.
@@ -314,7 +329,7 @@ def self.factory(content, private: false)
         Exception
       else
         Normal
-      end.new(content, private: private)
+      end.build(content, private: private)
     end
 
     # The default rule to use if no rule match.

public_suffix.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.description = "PublicSuffix can parse and decompose a domain name into top level domain, domain and subdomains."
   s.licenses    = ["MIT"]
 
-  s.required_ruby_version = ">= 2.0"
+  s.required_ruby_version = ">= 2.1"
 
   s.require_paths    = ["lib"]
   s.files            = `git ls-files`.split("\n")

test/.empty

@@ -0,0 +1,2 @@
+# This is an empty file I use to force a non-empty commit when I only need to store notes
+..