Noissue - Rename lib/domain.js to lib/url.js

lib/url.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 46 matching lines @@
  * <code>www.example.com</code>, this function yields
  * <code>www.example.com</code>, <code>example.com</code>, and
  * <code>com</code>, in that order.
  *
  * @param {string} domain The domain.
  * @param {boolean} [includeBlank] Whether to include the blank suffix at the
  *   end.
  *
  * @yields {string} The next suffix for the domain.
  */
-function* suffixes(domain, includeBlank = false)
+function* domainSuffixes(domain, includeBlank = false)
 {
   while (domain != "")
   {
     yield domain;
 
     let dotIndex = domain.indexOf(".");
     domain = dotIndex == -1 ? "" : domain.substr(dotIndex + 1);
   }
 
   if (includeBlank)
     yield "";
 }
 
-exports.suffixes = suffixes;
+exports.domainSuffixes = domainSuffixes;
 
 /**
  * Checks whether the given hostname is a domain.
  *
  * @param {string} hostname
  * @returns {boolean}
  */
 function isDomain(hostname)
 {
   // No hostname or IPv4 address, also considering hexadecimal octets.
   if (/^((0x[\da-f]+|\d+)(\.|$))*$/i.test(hostname))
     return false;
 
   // IPv6 address. Since there can't be colons in domains, we can
   // just check whether there are any colons to exclude IPv6 addresses.
   return hostname.indexOf(":") == -1;
 }
 
 /**
  * Gets the base domain for the given hostname.
  *
  * @param {string} hostname
  * @returns {string}
  */
-function getDomain(hostname)
+function getBaseDomain(hostname)
 {
   let slices = [];
   let cutoff = NaN;
 
-  for (let suffix of suffixes(hostname))
+  for (let suffix of domainSuffixes(hostname))
   {
     slices.push(suffix);
 
     let offset = publicSuffixMap.get(suffix);
 
     if (typeof offset != "undefined")
     {
       cutoff = slices.length - 1 - offset;
       break;
     }
   }
 
   if (isNaN(cutoff))
     return slices.length > 2 ? slices[slices.length - 2] : hostname;
 
   if (cutoff <= 0)
     return hostname;
 
   return slices[cutoff];
 }
 
-exports.getDomain = getDomain;
+exports.getBaseDomain = getBaseDomain;
 
 /**
  * Checks whether a request's origin is different from its document's origin.
  *
  * @param {URL} url The request URL.
  * @param {string} documentHostname The IDNA-encoded hostname of the document.
  *
  * @returns {boolean}
  */
 function isThirdParty(url, documentHostname)
 {
   let requestHostname = url.hostname;
 
   if (requestHostname[requestHostname.length - 1] == ".")
     requestHostname = requestHostname.replace(/\.+$/, "");
 
   if (documentHostname[documentHostname.length - 1] == ".")
     documentHostname = documentHostname.replace(/\.+$/, "");
 
   if (requestHostname == documentHostname)
     return false;
 
   if (!isDomain(requestHostname) || !isDomain(documentHostname))
     return true;
 
-  return getDomain(requestHostname) != getDomain(documentHostname);
+  return getBaseDomain(requestHostname) != getBaseDomain(documentHostname);
 }
 
 exports.isThirdParty = isThirdParty;