🔀 Merge pull request #2 from Komposten/release-1.2.0

Release 1.2.0

Author: Komposten

CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.2.0
+- Added a hash map-based `ruleMap` to `SuffixRules` to speed up the performance when matching rules.
+- Added `subdomain` and `icannSubdomain` to `PublicSuffix`.
+- Added `isSubdomainOf`, `hasKnownSuffix` and `hasValidDomain` to `PublicSuffix`.
+- Added `DomainUtils` with the following static functions:
+    - `isSubdomainOf`
+    - `isSubdomain`
+    - `isKnownSuffix`
+    - `hasValidDomain`
+- Added `PublicSuffix.fromString` as a convenience method for `PublicSuffix(Uri.parse(string))`.
+- Updated docs and parameter names to say URL instead of URI, which is more correct (`PublicSuffix.sourceUri` is unchanged to avoid breaking changes).
+
 ## 1.1.0
 - Added primary library `public_suffix.dart`, which can be used without `dart:io` and `dart:html` (but still requires to be initialised with a suffix list).
 

lib/public_suffix.dart

@@ -10,3 +10,4 @@
 
 export 'src/public_suffix_base.dart';
 export 'src/suffix_rules.dart';
+export 'src/utilities.dart';

lib/src/browser/suffix_rules_helper.dart

@@ -54,7 +54,7 @@ class SuffixRulesHelper {
         object = e.target;
       }
 
-      if (e is HttpRequest) {
+      if (object is HttpRequest) {
         throw Exception(
             "Request for public suffix list failed: [${object.status}] ${object.statusText}");
       } else {

lib/src/io/suffix_rules_helper.dart

@@ -46,14 +46,17 @@ class SuffixRulesHelper {
   }
 
   static Future<void> _initFromUrl(Uri uri) async {
-    try {
-      var request = await HttpClient().getUrl(uri);
-      var response = await request.close();
-      var data = await response.transform(Utf8Decoder()).join();
+    var request = await HttpClient().getUrl(uri);
+    var response = await request.close();
 
-      SuffixRules.initFromString(data);
-    } catch (e) {
-      rethrow;
+    switch (response.statusCode) {
+      case 200:
+        var data = await response.transform(Utf8Decoder()).join();
+        SuffixRules.initFromString(data);
+        break;
+      default:
+        throw Exception(
+            "Request for public suffix list failed: [${response.statusCode}]");
     }
   }
 }

lib/src/public_suffix_base.dart

@@ -12,52 +12,69 @@ import 'package:punycode/punycode.dart';
 
 import 'suffix_rules.dart';
 
-/// A description of the public suffix, root domain and registrable domain for a URI.
+/// A description of the public suffix, root domain and registrable domain for a URL.
 class PublicSuffix {
   final Uri sourceUri;
 
   bool _sourcePunycoded = false;
+  bool _hasKnownSuffix;
   String _root;
   String _suffix;
   String _domain;
+  String _subdomain;
   String _icannRoot;
   String _icannSuffix;
   String _icannDomain;
+  String _icannSubdomain;
 
   PublicSuffix _punyDecoded;
 
-  /// Returns the registrable domain part of the URI, based on both ICANN/IANA and private rules.
+  /// Returns the registrable domain part of the URL, based on both ICANN/IANA and private rules.
   ///
   /// The registrable domain is the public suffix and one preceding label.
   /// For example, `images.google.co.uk` has the registrable domain `google.co.uk`.
   String get domain => _domain;
 
-  /// Returns the root domain part of the URI, based on both ICANN/IANA and private rules.
+  /// Returns the subdomain part of the URL, based on both ICANN/IANA and private rules.
+  ///
+  /// The subdomain is the part of the host that precedes the registrable domain
+  /// (see [domain]).
+  /// For example, `images.google.co.uk` has the subdomain `images`.
+  String get subdomain => _subdomain;
+
+  /// Returns the root domain part of the URL, based on both ICANN/IANA and private rules.
   ///
   /// The root domain is the label that precedes the public suffix.
   /// For example, `images.google.co.uk` has the root domain `google`.
   String get root => _root;
 
-  /// Returns the public suffix part of the URI, based on both ICANN/IANA and private rules.
+  /// Returns the public suffix part of the URL, based on both ICANN/IANA and private rules.
   ///
   /// The public suffix is the labels at the end of the URL which are not controlled
   /// by the registrant of the domain.
   /// For example, `images.google.co.uk` has the public suffix `co.uk`.
   String get suffix => _suffix;
 
-  /// Returns the registrable domain part of the URI, based on ICANN/IANA rules.
+  /// Returns the registrable domain part of the URL, based on ICANN/IANA rules.
   ///
   /// The registrable domain is the public suffix and one preceding label.
   /// For example, `images.google.co.uk` has the registrable domain `google.co.uk`.
   String get icannDomain => _icannDomain;
 
-  /// Returns the root domain part of the URI, based on ICANN/IANA rules.
+  /// Returns the subdomain part of the URL, based on ICANN/IANA rules.
+  ///
+  /// The subdomain is the part of the host that precedes the registrable domain
+  /// (see [domain]).
+  /// For example, `images.google.co.uk` has the subdomain `images`.
+  String get icannSubdomain => _icannSubdomain;
+
+  /// Returns the root domain part of the URL, based on ICANN/IANA rules.
   ///
   /// The root domain is the label that precedes the public suffix.
   /// For example, `images.google.co.uk` has the root domain `google`.
   String get icannRoot => _icannRoot;
 
-  /// Returns the public suffix part of the URI, based on ICANN/IANA rules.
+  /// Returns the public suffix part of the URL, based on ICANN/IANA rules.
   ///
   /// The public suffix is the labels at the end of the URL which are not controlled
   /// by the registrant of the domain.
@@ -67,16 +84,62 @@ class PublicSuffix {
   /// Returns a punycode decoded version of this object.
   PublicSuffix get punyDecoded => _punyDecoded;
 
-  /// Checks if the URI was matched with a private rule rather than an ICANN/IANA rule.
+  /// Checks if the URL was matched with a private rule rather than an ICANN/IANA rule.
   ///
   /// If [true], then [root], [suffix] and [domain] will be different from the
   /// `icann`-prefixed getters.
   bool isPrivateSuffix() => icannSuffix != _suffix;
 
-  PublicSuffix._(this.sourceUri, this._root, this._suffix, this._icannRoot,
-      this._icannSuffix) {
+  /// Whether the [suffix] is a known suffix or not.
+  ///
+  /// A known suffix is one which has a rule in the suffix rule list.
+  bool hasKnownSuffix() => _hasKnownSuffix;
+
+  /// Checks if the registrable domain is valid.
+  ///
+  /// If [icann] is [true] the check will be based on [icannDomain], otherwise
+  /// [domain] is used.
+  /// If [acceptDefaultRule] is [false] URLs with suffixes only matching the
+  /// default rule (`*`) will be seen as invalid.
+  bool hasValidDomain({bool icann = false, bool acceptDefaultRule = true}) {
+    var _domain = (icann ? icannDomain : domain);
+
+    if (acceptDefaultRule || hasKnownSuffix()) {
+      return _domain != null;
+    } else {
+      return false;
+    }
+  }
+
+  /// Checks if this object represents a subdomain of another.
+  ///
+  /// The domain and subdomain properties are compared to determine if
+  /// this object represents a subdomain of [other]. If [icann] is [true],
+  /// comparison will be based on only the ICANN/IANA rules.
+  ///
+  /// For example, `http://images.google.co.uk` is a subdomain of `http://google.co.uk`.
+  ///
+  /// If [other] has a subdomain and this object represents a subdomain of that,
+  /// [true] is still returned.
+  bool isSubdomainOf(PublicSuffix other, {bool icann = false}) {
+    if (icann) {
+      return icannDomain == other.icannDomain &&
+          icannSubdomain != null &&
+          (other.icannSubdomain == null ||
+              icannSubdomain.endsWith(other.icannSubdomain));
+    } else {
+      return domain == other.domain &&
+          subdomain != null &&
+          (other.subdomain == null || subdomain.endsWith(other.subdomain));
+    }
+  }
+
+  PublicSuffix._(this.sourceUri, String host, this._root, this._suffix,
+      this._icannRoot, this._icannSuffix) {
     _domain = _buildRegistrableDomain(_root, _suffix);
     _icannDomain = _buildRegistrableDomain(_icannRoot, _icannSuffix);
+    _subdomain = _getSubdomain(host, _domain);
+    _icannSubdomain = _getSubdomain(host, _icannDomain);
   }
 
   /// Creates a new instance based on the specified [sourceUri].
@@ -91,15 +154,21 @@ class PublicSuffix {
     }
     if (!sourceUri.hasAuthority) {
       throw ArgumentError(
-          "The URI is missing the authority component: $sourceUri");
+          "The URL is missing the authority component: $sourceUri");
     }
 
-    _parseUri(sourceUri, SuffixRules.rules);
+    _parseUrl(sourceUri, SuffixRules.ruleMap);
   }
 
-  void _parseUri(Uri uri, List<Rule> suffixList) {
-    var host = _decodeHost(uri);
-    var matchingRules = _findMatchingRules(host, suffixList);
+  /// Creates a new instance from a URL in a string.
+  ///
+  /// This is a convenience method that simply converts [url] into a URI object
+  /// and creates an instance from it.
+  PublicSuffix.fromString(String url) : this(Uri.parse(url));
+
+  void _parseUrl(Uri url, Map<String, Iterable<Rule>> suffixMap) {
+    var host = _decodeHost(url);
+    var matchingRules = _findMatchingRules(host, suffixMap);
     var prevailingIcannRule = _getPrevailingRule(matchingRules['icann']);
     var prevailingAllRule = _getPrevailingRule(matchingRules['all']);
 
@@ -117,19 +186,22 @@ class PublicSuffix {
     _suffix = allData['suffix'];
     _root = allData['root'];
     _domain = allData['registrable'];
+    _subdomain = allData['sub'];
     _icannSuffix = icannData['suffix'];
     _icannRoot = icannData['root'];
     _icannDomain = icannData['registrable'];
+    _icannSubdomain = icannData['sub'];
+    _hasKnownSuffix = (prevailingAllRule.labels != "*");
 
     var puny = allData['puny'];
     var icannPuny = icannData['puny'];
 
-    _punyDecoded = PublicSuffix._(sourceUri, puny['root'], puny['suffix'],
+    _punyDecoded = PublicSuffix._(sourceUri, host, puny['root'], puny['suffix'],
         icannPuny['root'], icannPuny['suffix']);
   }
 
-  String _decodeHost(Uri uri) {
-    var host = uri.host.replaceAll(RegExp(r'\.+$'), '').toLowerCase();
+  String _decodeHost(Uri url) {
+    var host = url.host.replaceAll(RegExp(r'\.+$'), '').toLowerCase();
     host = Uri.decodeComponent(host);
 
     var punycodes = RegExp(r'xn--[a-z0-9-]+').allMatches(host);
@@ -149,52 +221,26 @@ class PublicSuffix {
   }
 
   Map<String, List<Rule>> _findMatchingRules(
-      String host, List<Rule> suffixList) {
+      String host, Map<String, Iterable<Rule>> suffixMap) {
     var icannMatches = <Rule>[];
     var allMatches = <Rule>[];
 
-    for (var rule in suffixList) {
-      if (_ruleMatches(rule, host)) {
-        allMatches.add(rule);
+    var lastLabel = host.substring(host.lastIndexOf(('.')) + 1);
+    var suffixList = suffixMap[lastLabel];
 
-        if (rule.isIcann) {
-          icannMatches.add(rule);
-        }
-      }
-    }
-
-    return {'icann': icannMatches, 'all': allMatches};
-  }
-
-  bool _ruleMatches(Rule rule, String host) {
-    var hostParts = host.split('.');
-    var ruleParts = rule.labels.split('.');
-
-    hostParts.removeWhere((e) => e.isEmpty);
-
-    var matches = true;
-
-    if (ruleParts.length <= hostParts.length) {
-      int r = ruleParts.length - 1;
-      int h = hostParts.length - 1;
-
-      while (r >= 0) {
-        var rulePart = ruleParts[r];
-        var hostPart = hostParts[h];
+    if (suffixList != null) {
+      for (var rule in suffixList) {
+        if (rule.matches(host)) {
+          allMatches.add(rule);
 
-        if (rulePart != '*' && rulePart != hostPart) {
-          matches = false;
-          break;
+          if (rule.isIcann) {
+            icannMatches.add(rule);
+          }
         }
-
-        r--;
-        h--;
       }
-    } else {
-      matches = false;
     }
 
-    return matches;
+    return {'icann': icannMatches, 'all': allMatches};
   }
 
   Rule _getPrevailingRule(List<Rule> matchingRules) {
@@ -230,17 +276,20 @@ class PublicSuffix {
     var puny = {'root': root, 'suffix': suffix};
 
     if (_sourcePunycoded) {
+      host = _punyEncode(host);
       suffix = _punyEncode(suffix);
       root = _punyEncode(root);
     }
 
     var registrable = _buildRegistrableDomain(root, suffix);
+    var sub = _getSubdomain(host, registrable);
 
     return {
       'suffix': suffix,
       'root': root,
       'puny': puny,
-      'registrable': registrable
+      'registrable': registrable,
+      'sub': sub
     };
   }
 
@@ -288,4 +337,18 @@ class PublicSuffix {
   String _buildRegistrableDomain(String root, String suffix) {
     return (root.isNotEmpty ? "$root.$suffix" : null);
   }
+
+  String _getSubdomain(String host, String registrableDomain) {
+    var sub;
+
+    if (registrableDomain != null) {
+      var index = host.lastIndexOf(registrableDomain);
+
+      if (index > 0) {
+        sub = host.substring(0, index - 1);
+      }
+    }
+
+    return sub;
+  }
 }