pax_global_header 0000666 0000000 0000000 00000000064 12707711122 0014512 g ustar 00root root 0000000 0000000 52 comment=0f979e7077bc1ba27778db0f2bb7bba059b1659c
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/ 0000775 0000000 0000000 00000000000 12707711122 0021756 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/.gitignore 0000664 0000000 0000000 00000000017 12707711122 0023744 0 ustar 00root root 0000000 0000000 /node_modules/
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/.hgignore 0000664 0000000 0000000 00000000017 12707711122 0023557 0 ustar 00root root 0000000 0000000 ^node_modules$
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/README.md 0000664 0000000 0000000 00000001503 12707711122 0023234 0 ustar 00root root 0000000 0000000 Adblock Plus core
=================
This repository contains the generic Adblock Plus code that's shared between
platforms. This repository is not designed to be used directly, but instead to
serve as a dependency for `adblockplus`, `adblockpluschrome` and
`libadblockplus`.
Running the unit tests
----------------------
*Note*: The unit test suite isn't complete yet, it is in the process of being
migrated from the
[adblockplustests repository](https://hg.adblockplus.org/adblockplustests/).
In order to run the unit test suite you need a reasonably recent
[Node.js version](https://nodejs.org/). Once Node.js is installed please run
`npm install` in the repository directory in order to install the required
dependencies. After that you can run `npm test` which will execute all tests
in the `test` directory of the repository.
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/chrome/ 0000775 0000000 0000000 00000000000 12707711122 0023233 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/chrome/content/ 0000775 0000000 0000000 00000000000 12707711122 0024705 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/chrome/content/cssProperties.js 0000664 0000000 0000000 00000006721 12707711122 0030116 0 ustar 00root root 0000000 0000000 function splitSelector(selector)
{
if (selector.indexOf(",") == -1)
return [selector];
var selectors = [];
var start = 0;
var level = 0;
var sep = "";
for (var i = 0; i < selector.length; i++)
{
var chr = selector[i];
if (chr == "\\") // ignore escaped characters
i++;
else if (chr == sep) // don't split within quoted text
sep = ""; // e.g. [attr=","]
else if (sep == "")
{
if (chr == '"' || chr == "'")
sep = chr;
else if (chr == "(") // don't split between parentheses
level++; // e.g. :matches(div,span)
else if (chr == ")")
level = Math.max(0, level - 1);
else if (chr == "," && level == 0)
{
selectors.push(selector.substring(start, i));
start = i + 1;
}
}
}
selectors.push(selector.substring(start));
return selectors;
}
function CSSPropertyFilters(window, addSelectorsFunc) {
this.window = window;
this.addSelectorsFunc = addSelectorsFunc;
}
CSSPropertyFilters.prototype = {
stringifyStyle: function(style)
{
var styles = [];
for (var i = 0; i < style.length; i++)
{
var property = style.item(i);
var value = style.getPropertyValue(property);
var priority = style.getPropertyPriority(property);
styles.push(property + ": " + value + (priority ? " !" + priority : "") + ";");
}
styles.sort();
return styles.join(" ");
},
isSameOrigin: function(stylesheet)
{
try
{
return new URL(stylesheet.href).origin == this.window.location.origin;
}
catch (e)
{
// Invalid URL, assume that it is first-party.
return true;
}
},
findSelectors: function(stylesheet, selectors)
{
// Explicitly ignore third-party stylesheets to ensure consistent behavior
// between Firefox and Chrome.
if (!this.isSameOrigin(stylesheet))
return;
var rules = stylesheet.cssRules;
if (!rules)
return;
for (var i = 0; i < rules.length; i++)
{
var rule = rules[i];
if (rule.type != rule.STYLE_RULE)
continue;
var style = this.stringifyStyle(rule.style);
for (var j = 0; j < this.patterns.length; j++)
{
var pattern = this.patterns[j];
var regexp = pattern.regexp;
if (typeof regexp == "string")
regexp = pattern.regexp = new RegExp(regexp);
if (regexp.test(style))
{
var subSelectors = splitSelector(rule.selectorText);
for (var k = 0; k < subSelectors.length; k++)
selectors.push(pattern.prefix + subSelectors[k] + pattern.suffix);
}
}
}
},
addSelectors: function(stylesheets)
{
var selectors = [];
for (var i = 0; i < stylesheets.length; i++)
this.findSelectors(stylesheets[i], selectors);
this.addSelectorsFunc(selectors);
},
onLoad: function(event)
{
var stylesheet = event.target.sheet;
if (stylesheet)
this.addSelectors([stylesheet]);
},
load: function(callback)
{
ext.backgroundPage.sendMessage(
{
type: "filters.get",
what: "cssproperties"
},
function(patterns)
{
this.patterns = patterns;
callback();
}.bind(this)
);
},
apply: function()
{
if (this.patterns.length > 0)
{
var document = this.window.document;
this.addSelectors(document.styleSheets);
document.addEventListener("load", this.onLoad.bind(this), true);
}
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/chrome/content/ui/ 0000775 0000000 0000000 00000000000 12707711122 0025322 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/chrome/content/ui/subscriptions.xml 0000664 0000000 0000000 00000013412 12707711122 0030754 0 ustar 00root root 0000000 0000000
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/dependencies 0000664 0000000 0000000 00000000251 12707711122 0024325 0 ustar 00root root 0000000 0000000 _root = hg:https://hg.adblockplus.org/ git:https://github.com/adblockplus/
_self = buildtools/ensure_dependencies.py
buildtools = buildtools hg:3816c08c0f98 git:93e54d4
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/ensure_dependencies.py 0000775 0000000 0000000 00000033317 12707711122 0026351 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import sys
import os
import posixpath
import re
import io
import errno
import logging
import subprocess
import urlparse
import argparse
from collections import OrderedDict
from ConfigParser import RawConfigParser
USAGE = """
A dependencies file should look like this:
# VCS-specific root URLs for the repositories
_root = hg:https://hg.adblockplus.org/ git:https://github.com/adblockplus/
# File to update this script from (optional)
_self = buildtools/ensure_dependencies.py
# Clone elemhidehelper repository into extensions/elemhidehelper directory at
# tag "1.2".
extensions/elemhidehelper = elemhidehelper 1.2
# Clone buildtools repository into buildtools directory at VCS-specific
# revision IDs.
buildtools = buildtools hg:016d16f7137b git:f3f8692f82e5
# Clone the adblockplus repository into adblockplus directory, overwriting the
# usual source URL for Git repository and specifying VCS specific revision IDs.
adblockplus = adblockplus hg:893426c6a6ab git:git@github.com:user/adblockplus.git@b2ffd52b
# Clone the adblockpluschrome repository into the adblockpluschrome directory,
# from a specific Git repository, specifying the revision ID.
adblockpluschrome = git:git@github.com:user/adblockpluschrome.git@1fad3a7
"""
SKIP_DEPENDENCY_UPDATES = os.environ.get(
"SKIP_DEPENDENCY_UPDATES", ""
).lower() not in ("", "0", "false")
class Mercurial():
def istype(self, repodir):
return os.path.exists(os.path.join(repodir, ".hg"))
def clone(self, source, target):
if not source.endswith("/"):
source += "/"
subprocess.check_call(["hg", "clone", "--quiet", "--noupdate", source, target])
def get_revision_id(self, repo, rev=None):
command = ["hg", "id", "--repository", repo, "--id"]
if rev:
command.extend(["--rev", rev])
# Ignore stderr output and return code here: if revision lookup failed we
# should simply return an empty string.
result = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
return result.strip()
def pull(self, repo):
subprocess.check_call(["hg", "pull", "--repository", repo, "--quiet"])
def update(self, repo, rev, revname):
subprocess.check_call(["hg", "update", "--repository", repo, "--quiet", "--check", "--rev", rev])
def ignore(self, target, repo):
if not self.istype(target):
config_path = os.path.join(repo, ".hg", "hgrc")
ignore_path = os.path.abspath(os.path.join(repo, ".hg", "dependencies"))
config = RawConfigParser()
config.read(config_path)
if not config.has_section("ui"):
config.add_section("ui")
config.set("ui", "ignore.dependencies", ignore_path)
with open(config_path, "w") as stream:
config.write(stream)
module = os.path.relpath(target, repo)
_ensure_line_exists(ignore_path, module)
def postprocess_url(self, url):
return url
class Git():
def istype(self, repodir):
return os.path.exists(os.path.join(repodir, ".git"))
def clone(self, source, target):
source = source.rstrip("/")
if not source.endswith(".git"):
source += ".git"
subprocess.check_call(["git", "clone", "--quiet", source, target])
def get_revision_id(self, repo, rev="HEAD"):
command = ["git", "rev-parse", "--revs-only", rev + '^{commit}']
return subprocess.check_output(command, cwd=repo).strip()
def pull(self, repo):
# Fetch tracked branches, new tags and the list of available remote branches
subprocess.check_call(["git", "fetch", "--quiet", "--all", "--tags"], cwd=repo)
# Next we need to ensure all remote branches are tracked
newly_tracked = False
remotes = subprocess.check_output(["git", "branch", "--remotes"], cwd=repo)
for match in re.finditer(r"^\s*(origin/(\S+))$", remotes, re.M):
remote, local = match.groups()
with open(os.devnull, "wb") as devnull:
if subprocess.call(["git", "branch", "--track", local, remote],
cwd=repo, stdout=devnull, stderr=devnull) == 0:
newly_tracked = True
# Finally fetch any newly tracked remote branches
if newly_tracked:
subprocess.check_call(["git", "fetch", "--quiet", "origin"], cwd=repo)
def update(self, repo, rev, revname):
subprocess.check_call(["git", "checkout", "--quiet", revname], cwd=repo)
def ignore(self, target, repo):
module = os.path.sep + os.path.relpath(target, repo)
exclude_file = os.path.join(repo, ".git", "info", "exclude")
_ensure_line_exists(exclude_file, module)
def postprocess_url(self, url):
# Handle alternative syntax of SSH URLS
if "@" in url and ":" in url and not urlparse.urlsplit(url).scheme:
return "ssh://" + url.replace(":", "/", 1)
return url
repo_types = OrderedDict((
("hg", Mercurial()),
("git", Git()),
))
# [vcs:]value
item_regexp = re.compile(
"^(?:(" + "|".join(map(re.escape, repo_types.keys())) + "):)?"
"(.+)$"
)
# [url@]rev
source_regexp = re.compile(
"^(?:(.*)@)?"
"(.+)$"
)
def merge_seqs(seq1, seq2):
"""Return a list of any truthy values from the suplied sequences
(None, 2), (1,) => [1, 2]
None, (1, 2) => [1, 2]
(1, 2), (3, 4) => [3, 4]
"""
return map(lambda item1, item2: item2 or item1, seq1 or (), seq2 or ())
def parse_spec(path, line):
if "=" not in line:
logging.warning("Invalid line in file %s: %s" % (path, line))
return None, None
key, value = line.split("=", 1)
key = key.strip()
items = value.split()
if not len(items):
logging.warning("No value specified for key %s in file %s" % (key, path))
return key, None
result = OrderedDict()
is_dependency_field = not key.startswith("_")
for i, item in enumerate(items):
try:
vcs, value = re.search(item_regexp, item).groups()
vcs = vcs or "*"
if is_dependency_field:
if i == 0 and vcs == "*":
# In order to be backwards compatible we have to assume that the first
# source contains only a URL/path for the repo if it does not contain
# the VCS part
url_rev = (value, None)
else:
url_rev = re.search(source_regexp, value).groups()
result[vcs] = merge_seqs(result.get(vcs), url_rev)
else:
if vcs in result:
logging.warning("Ignoring duplicate value for type %r "
"(key %r in file %r)" % (vcs, key, path))
result[vcs] = value
except AttributeError:
logging.warning("Ignoring invalid item %r for type %r "
"(key %r in file %r)" % (item, vcs, key, path))
continue
return key, result
def read_deps(repodir):
result = {}
deps_path = os.path.join(repodir, "dependencies")
try:
with io.open(deps_path, "rt", encoding="utf-8") as handle:
for line in handle:
# Remove comments and whitespace
line = re.sub(r"#.*", "", line).strip()
if not line:
continue
key, spec = parse_spec(deps_path, line)
if spec:
result[key] = spec
return result
except IOError, e:
if e.errno != errno.ENOENT:
raise
return None
def safe_join(path, subpath):
# This has been inspired by Flask's safe_join() function
forbidden = {os.sep, os.altsep} - {posixpath.sep, None}
if any(sep in subpath for sep in forbidden):
raise Exception("Illegal directory separator in dependency path %s" % subpath)
normpath = posixpath.normpath(subpath)
if posixpath.isabs(normpath):
raise Exception("Dependency path %s cannot be absolute" % subpath)
if normpath == posixpath.pardir or normpath.startswith(posixpath.pardir + posixpath.sep):
raise Exception("Dependency path %s has to be inside the repository" % subpath)
return os.path.join(path, *normpath.split(posixpath.sep))
def get_repo_type(repo):
for name, repotype in repo_types.iteritems():
if repotype.istype(repo):
return name
return "hg"
def ensure_repo(parentrepo, parenttype, target, type, root, sourcename):
if os.path.exists(target):
return
if SKIP_DEPENDENCY_UPDATES:
logging.warning("SKIP_DEPENDENCY_UPDATES environment variable set, "
"%s not cloned", target)
return
postprocess_url = repo_types[type].postprocess_url
root = postprocess_url(root)
sourcename = postprocess_url(sourcename)
if os.path.exists(root):
url = os.path.join(root, sourcename)
else:
url = urlparse.urljoin(root, sourcename)
logging.info("Cloning repository %s into %s" % (url, target))
repo_types[type].clone(url, target)
repo_types[parenttype].ignore(target, parentrepo)
def update_repo(target, type, revision):
resolved_revision = repo_types[type].get_revision_id(target, revision)
current_revision = repo_types[type].get_revision_id(target)
if resolved_revision != current_revision:
if SKIP_DEPENDENCY_UPDATES:
logging.warning("SKIP_DEPENDENCY_UPDATES environment variable set, "
"%s not checked out to %s", target, revision)
return
if not resolved_revision:
logging.info("Revision %s is unknown, downloading remote changes" % revision)
repo_types[type].pull(target)
resolved_revision = repo_types[type].get_revision_id(target, revision)
if not resolved_revision:
raise Exception("Failed to resolve revision %s" % revision)
logging.info("Updating repository %s to revision %s" % (target, resolved_revision))
repo_types[type].update(target, resolved_revision, revision)
def resolve_deps(repodir, level=0, self_update=True, overrideroots=None, skipdependencies=set()):
config = read_deps(repodir)
if config is None:
if level == 0:
logging.warning("No dependencies file in directory %s, nothing to do...\n%s" % (repodir, USAGE))
return
if level >= 10:
logging.warning("Too much subrepository nesting, ignoring %s" % repo)
return
if overrideroots is not None:
config["_root"] = overrideroots
for dir, sources in config.iteritems():
if (dir.startswith("_") or
skipdependencies.intersection([s[0] for s in sources if s[0]])):
continue
target = safe_join(repodir, dir)
parenttype = get_repo_type(repodir)
_root = config.get("_root", {})
for key in sources.keys() + _root.keys():
if key == parenttype or key is None and vcs != "*":
vcs = key
source, rev = merge_seqs(sources.get("*"), sources.get(vcs))
if not (vcs and source and rev):
logging.warning("No valid source / revision found to create %s" % target)
continue
ensure_repo(repodir, parenttype, target, vcs, _root.get(vcs, ""), source)
update_repo(target, vcs, rev)
resolve_deps(target, level + 1, self_update=False,
overrideroots=overrideroots, skipdependencies=skipdependencies)
if self_update and "_self" in config and "*" in config["_self"]:
source = safe_join(repodir, config["_self"]["*"])
try:
with io.open(source, "rb") as handle:
sourcedata = handle.read()
except IOError, e:
if e.errno != errno.ENOENT:
raise
logging.warning("File %s doesn't exist, skipping self-update" % source)
return
target = __file__
with io.open(target, "rb") as handle:
targetdata = handle.read()
if sourcedata != targetdata:
logging.info("Updating %s from %s, don't forget to commit" % (target, source))
with io.open(target, "wb") as handle:
handle.write(sourcedata)
if __name__ == "__main__":
logging.info("Restarting %s" % target)
os.execv(sys.executable, [sys.executable, target] + sys.argv[1:])
else:
logging.warning("Cannot restart %s automatically, please rerun" % target)
def _ensure_line_exists(path, pattern):
with open(path, 'a+') as f:
file_content = [l.strip() for l in f.readlines()]
if not pattern in file_content:
file_content.append(pattern)
f.seek(0, os.SEEK_SET)
f.truncate()
for l in file_content:
print >>f, l
if __name__ == "__main__":
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
parser = argparse.ArgumentParser(description="Verify dependencies for a set of repositories, by default the repository of this script.")
parser.add_argument("repos", metavar="repository", type=str, nargs="*", help="Repository path")
parser.add_argument("-q", "--quiet", action="store_true", help="Suppress informational output")
args = parser.parse_args()
if args.quiet:
logging.disable(logging.INFO)
repos = args.repos
if not len(repos):
repos = [os.path.dirname(__file__)]
for repo in repos:
resolve_deps(repo)
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/generate_docs.py 0000775 0000000 0000000 00000001500 12707711122 0025131 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# coding: utf-8
import os
import subprocess
import sys
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DEPENDENCY_SCRIPT = os.path.join(BASE_DIR, "ensure_dependencies.py")
if __name__ == "__main__":
try:
subprocess.check_call([sys.executable, DEPENDENCY_SCRIPT, BASE_DIR])
except subprocess.CalledProcessError as e:
print >>sys.stderr, e
print >>sys.stderr, "Failed to ensure dependencies being up-to-date!"
# We're faking an invocation of build.py here, because we would have to
# duplicate command line parsing otherwise. It would be nicer if buildtools
# would make it possible to invoke the docs command directly.
args = sys.argv
args[1:1] = ["-t", "gecko", "docs"]
import buildtools.build
buildtools.build.processArgs(BASE_DIR, args)
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/ 0000775 0000000 0000000 00000000000 12707711122 0022524 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/antiadblockInit.js 0000664 0000000 0000000 00000006032 12707711122 0026162 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
Cu.import("resource://gre/modules/Services.jsm");
let {Utils} = require("utils");
let {Prefs} = require("prefs");
let {ActiveFilter} = require("filterClasses");
let {FilterStorage} = require("filterStorage");
let {FilterNotifier} = require("filterNotifier");
let {Subscription} = require("subscriptionClasses");
let {Notification} = require("notification");
exports.initAntiAdblockNotification = function initAntiAdblockNotification()
{
let notification = {
id: "antiadblock",
type: "question",
title: Utils.getString("notification_antiadblock_title"),
message: Utils.getString("notification_antiadblock_message"),
urlFilters: []
};
function notificationListener(approved)
{
let subscription = Subscription.fromURL(Prefs.subscriptions_antiadblockurl);
if (subscription.url in FilterStorage.knownSubscriptions)
subscription.disabled = !approved;
}
function addAntiAdblockNotification(subscription)
{
let urlFilters = [];
for (let filter of subscription.filters)
{
if (filter instanceof ActiveFilter)
{
for (let domain in filter.domains)
{
let urlFilter = "||" + domain + "^$document";
if (domain && filter.domains[domain] && urlFilters.indexOf(urlFilter) == -1)
urlFilters.push(urlFilter);
}
}
}
notification.urlFilters = urlFilters;
Notification.addNotification(notification);
Notification.addQuestionListener(notification.id, notificationListener);
}
function removeAntiAdblockNotification()
{
Notification.removeNotification(notification);
Notification.removeQuestionListener(notification.id, notificationListener);
}
let subscription = Subscription.fromURL(Prefs.subscriptions_antiadblockurl);
if (subscription.lastDownload && subscription.disabled)
addAntiAdblockNotification(subscription);
function onSubscriptionChange(subscription)
{
let url = Prefs.subscriptions_antiadblockurl;
if (url != subscription.url)
return;
if (url in FilterStorage.knownSubscriptions && !subscription.disabled)
addAntiAdblockNotification(subscription);
else
removeAntiAdblockNotification();
}
FilterNotifier.on("subscription.updated", onSubscriptionChange);
FilterNotifier.on("subscription.removed", onSubscriptionChange);
FilterNotifier.on("subscription.disabled", onSubscriptionChange);
}
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/cssRules.js 0000664 0000000 0000000 00000003462 12707711122 0024672 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview CSS property filtering implementation.
*/
let {ElemHide} = require("elemHide");
let {Filter} = require("filterClasses");
var filters = Object.create(null);
/**
* CSS rules component
* @class
*/
let CSSRules = exports.CSSRules =
{
/**
* Removes all known filters
*/
clear: function()
{
filters = Object.create(null);
},
/**
* Add a new CSS property filter
* @param {CSSPropertyFilter} filter
*/
add: function(filter)
{
filters[filter.text] = true;
},
/**
* Removes a CSS property filter
* @param {CSSPropertyFilter} filter
*/
remove: function(filter)
{
delete filters[filter.text];
},
/**
* Returns a list of all rules active on a particular domain
* @param {String} domain
* @return {CSSPropertyFilter[]}
*/
getRulesForDomain: function(domain)
{
let result = [];
let keys = Object.getOwnPropertyNames(filters);
for (let key of keys)
{
let filter = Filter.fromText(key);
if (filter.isActiveOnDomain(domain) && !ElemHide.getException(filter, domain))
result.push(filter);
}
return result;
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/downloader.js 0000664 0000000 0000000 00000026111 12707711122 0025221 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Downloads a set of URLs in regular time intervals.
*/
let {Utils} = require("utils");
let MILLIS_IN_SECOND = exports.MILLIS_IN_SECOND = 1000;
let MILLIS_IN_MINUTE = exports.MILLIS_IN_MINUTE = 60 * MILLIS_IN_SECOND;
let MILLIS_IN_HOUR = exports.MILLIS_IN_HOUR = 60 * MILLIS_IN_MINUTE;
let MILLIS_IN_DAY = exports.MILLIS_IN_DAY = 24 * MILLIS_IN_HOUR;
/**
* Creates a new downloader instance.
* @param {Function} dataSource Function that will yield downloadable objects on each check
* @param {Integer} initialDelay Number of milliseconds to wait before the first check
* @param {Integer} checkInterval Interval between the checks
* @constructor
*/
let Downloader = exports.Downloader = function Downloader(dataSource, initialDelay, checkInterval)
{
this.dataSource = dataSource;
this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
this._timer.initWithCallback(function()
{
this._timer.delay = checkInterval;
this._doCheck();
}.bind(this), initialDelay, Ci.nsITimer.TYPE_REPEATING_SLACK);
this._downloading = Object.create(null);
}
Downloader.prototype =
{
/**
* Timer triggering the downloads.
* @type nsITimer
*/
_timer: null,
/**
* Map containing the URLs of objects currently being downloaded as its keys.
*/
_downloading: null,
/**
* Function that will yield downloadable objects on each check.
* @type Function
*/
dataSource: null,
/**
* Maximal time interval that the checks can be left out until the soft
* expiration interval increases.
* @type Integer
*/
maxAbsenceInterval: 1 * MILLIS_IN_DAY,
/**
* Minimal time interval before retrying a download after an error.
* @type Integer
*/
minRetryInterval: 1 * MILLIS_IN_DAY,
/**
* Maximal allowed expiration interval, larger expiration intervals will be
* corrected.
* @type Integer
*/
maxExpirationInterval: 14 * MILLIS_IN_DAY,
/**
* Maximal number of redirects before the download is considered as failed.
* @type Integer
*/
maxRedirects: 5,
/**
* Called whenever expiration intervals for an object need to be adapted.
* @type Function
*/
onExpirationChange: null,
/**
* Callback to be triggered whenever a download starts.
* @type Function
*/
onDownloadStarted: null,
/**
* Callback to be triggered whenever a download finishes successfully. The
* callback can return an error code to indicate that the data is wrong.
* @type Function
*/
onDownloadSuccess: null,
/**
* Callback to be triggered whenever a download fails.
* @type Function
*/
onDownloadError: null,
/**
* Checks whether anything needs downloading.
*/
_doCheck: function()
{
let now = Date.now();
for (let downloadable of this.dataSource())
{
if (downloadable.lastCheck && now - downloadable.lastCheck > this.maxAbsenceInterval)
{
// No checks for a long time interval - user must have been offline, e.g.
// during a weekend. Increase soft expiration to prevent load peaks on the
// server.
downloadable.softExpiration += now - downloadable.lastCheck;
}
downloadable.lastCheck = now;
// Sanity check: do expiration times make sense? Make sure people changing
// system clock don't get stuck with outdated subscriptions.
if (downloadable.hardExpiration - now > this.maxExpirationInterval)
downloadable.hardExpiration = now + this.maxExpirationInterval;
if (downloadable.softExpiration - now > this.maxExpirationInterval)
downloadable.softExpiration = now + this.maxExpirationInterval;
// Notify the caller about changes to expiration parameters
if (this.onExpirationChange)
this.onExpirationChange(downloadable);
// Does that object need downloading?
if (downloadable.softExpiration > now && downloadable.hardExpiration > now)
continue;
// Do not retry downloads too often
if (downloadable.lastError && now - downloadable.lastError < this.minRetryInterval)
continue;
this._download(downloadable, 0);
}
},
/**
* Stops the periodic checks.
*/
cancel: function()
{
this._timer.cancel();
},
/**
* Checks whether an address is currently being downloaded.
*/
isDownloading: function(/**String*/ url) /**Boolean*/
{
return url in this._downloading;
},
/**
* Starts downloading for an object.
*/
download: function(/**Downloadable*/ downloadable)
{
// Make sure to detach download from the current execution context
Utils.runAsync(this._download.bind(this, downloadable, 0));
},
/**
* Generates the real download URL for an object by appending various
* parameters.
*/
getDownloadUrl: function(/**Downloadable*/ downloadable) /** String*/
{
let {addonName, addonVersion, application, applicationVersion, platform, platformVersion} = require("info");
let url = downloadable.redirectURL || downloadable.url;
if (url.indexOf("?") >= 0)
url += "&";
else
url += "?";
// We limit the download count to 4+ to keep the request anonymized
let downloadCount = downloadable.downloadCount;
if (downloadCount > 4)
downloadCount = "4+";
url += "addonName=" + encodeURIComponent(addonName) +
"&addonVersion=" + encodeURIComponent(addonVersion) +
"&application=" + encodeURIComponent(application) +
"&applicationVersion=" + encodeURIComponent(applicationVersion) +
"&platform=" + encodeURIComponent(platform) +
"&platformVersion=" + encodeURIComponent(platformVersion) +
"&lastVersion=" + encodeURIComponent(downloadable.lastVersion) +
"&downloadCount=" + encodeURIComponent(downloadCount);
return url;
},
_download: function(downloadable, redirects)
{
if (this.isDownloading(downloadable.url))
return;
let downloadUrl = this.getDownloadUrl(downloadable);
let request = null;
let errorCallback = function errorCallback(error)
{
let channelStatus = -1;
try
{
channelStatus = request.channel.status;
} catch (e) {}
let responseStatus = request.status;
Cu.reportError("Adblock Plus: Downloading URL " + downloadable.url + " failed (" + error + ")\n" +
"Download address: " + downloadUrl + "\n" +
"Channel status: " + channelStatus + "\n" +
"Server response: " + responseStatus);
if (this.onDownloadError)
{
// Allow one extra redirect if the error handler gives us a redirect URL
let redirectCallback = null;
if (redirects <= this.maxRedirects)
{
redirectCallback = function redirectCallback(url)
{
downloadable.redirectURL = url;
this._download(downloadable, redirects + 1);
}.bind(this);
}
this.onDownloadError(downloadable, downloadUrl, error, channelStatus, responseStatus, redirectCallback);
}
}.bind(this);
try
{
request = new XMLHttpRequest();
request.mozBackgroundRequest = true;
request.open("GET", downloadUrl);
}
catch (e)
{
errorCallback("synchronize_invalid_url");
return;
}
try {
request.overrideMimeType("text/plain");
request.channel.loadFlags = request.channel.loadFlags |
request.channel.INHIBIT_CACHING |
request.channel.VALIDATE_ALWAYS;
// Override redirect limit from preferences, user might have set it to 1
if (request.channel instanceof Ci.nsIHttpChannel)
request.channel.redirectionLimit = this.maxRedirects;
}
catch (e)
{
Cu.reportError(e)
}
request.addEventListener("error", function(event)
{
if (onShutdown.done)
return;
delete this._downloading[downloadable.url];
errorCallback("synchronize_connection_error");
}.bind(this), false);
request.addEventListener("load", function(event)
{
if (onShutdown.done)
return;
delete this._downloading[downloadable.url];
// Status will be 0 for non-HTTP requests
if (request.status && request.status != 200)
{
errorCallback("synchronize_connection_error");
return;
}
downloadable.downloadCount++;
this.onDownloadSuccess(downloadable, request.responseText, errorCallback, function redirectCallback(url)
{
if (redirects >= this.maxRedirects)
errorCallback("synchronize_connection_error");
else
{
downloadable.redirectURL = url;
this._download(downloadable, redirects + 1);
}
}.bind(this));
}.bind(this), false);
request.send(null);
this._downloading[downloadable.url] = true;
if (this.onDownloadStarted)
this.onDownloadStarted(downloadable);
},
/**
* Produces a soft and a hard expiration interval for a given supplied
* expiration interval.
* @return {Array} soft and hard expiration interval
*/
processExpirationInterval: function(/**Integer*/ interval)
{
interval = Math.min(Math.max(interval, 0), this.maxExpirationInterval);
let soft = Math.round(interval * (Math.random() * 0.4 + 0.8));
let hard = interval * 2;
let now = Date.now();
return [now + soft, now + hard];
}
};
/**
* An object that can be downloaded by the downloadable
* @param {String} url URL that has to be requested for the object
* @constructor
*/
let Downloadable = exports.Downloadable = function Downloadable(url)
{
this.url = url;
}
Downloadable.prototype =
{
/**
* URL that has to be requested for the object.
* @type String
*/
url: null,
/**
* URL that the download was redirected to if any.
* @type String
*/
redirectURL: null,
/**
* Time of last download error or 0 if the last download was successful.
* @type Integer
*/
lastError: 0,
/**
* Time of last check whether the object needs downloading.
* @type Integer
*/
lastCheck: 0,
/**
* Object version corresponding to the last successful download.
* @type Integer
*/
lastVersion: 0,
/**
* Soft expiration interval, will increase if no checks are performed for a
* while.
* @type Integer
*/
softExpiration: 0,
/**
* Hard expiration interval, this is fixed.
* @type Integer
*/
hardExpiration: 0,
/**
* Number indicating how often the object was downloaded.
* @type Integer
*/
downloadCount: 0,
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/elemHide.js 0000664 0000000 0000000 00000022344 12707711122 0024603 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Element hiding implementation.
*/
Cu.import("resource://gre/modules/Services.jsm");
var {Utils} = require("utils");
var {IO} = require("io");
var {Prefs} = require("prefs");
var {ElemHideException} = require("filterClasses");
var {FilterNotifier} = require("filterNotifier");
/**
* Lookup table, filters by their associated key
* @type Object
*/
var filterByKey = Object.create(null);
/**
* Lookup table, keys of the filters by filter text
* @type Object
*/
var keyByFilter = Object.create(null);
/**
* Lookup table, keys are known element hiding exceptions
* @type Object
*/
var knownExceptions = Object.create(null);
/**
* Lookup table, lists of element hiding exceptions by selector
* @type Object
*/
var exceptions = Object.create(null);
/**
* Currently applied stylesheet URL
* @type nsIURI
*/
var styleURL = null;
/**
* Element hiding component
* @class
*/
var ElemHide = exports.ElemHide =
{
/**
* Indicates whether filters have been added or removed since the last apply() call.
* @type Boolean
*/
isDirty: false,
/**
* Inidicates whether the element hiding stylesheet is currently applied.
* @type Boolean
*/
applied: false,
/**
* Called on module startup.
*/
init: function()
{
Prefs.addListener(function(name)
{
if (name == "enabled")
ElemHide.apply();
});
onShutdown.add(() => ElemHide.unapply());
let styleFile = IO.resolveFilePath(Prefs.data_directory);
styleFile.append("elemhide.css");
styleURL = Services.io.newFileURI(styleFile).QueryInterface(Ci.nsIFileURL);
},
/**
* Removes all known filters
*/
clear: function()
{
filterByKey = Object.create(null);
keyByFilter = Object.create(null);
knownExceptions = Object.create(null);
exceptions = Object.create(null);
ElemHide.isDirty = false;
ElemHide.unapply();
},
/**
* Add a new element hiding filter
* @param {ElemHideFilter} filter
*/
add: function(filter)
{
if (filter instanceof ElemHideException)
{
if (filter.text in knownExceptions)
return;
let selector = filter.selector;
if (!(selector in exceptions))
exceptions[selector] = [];
exceptions[selector].push(filter);
knownExceptions[filter.text] = true;
}
else
{
if (filter.text in keyByFilter)
return;
let key;
do {
key = Math.random().toFixed(15).substr(5);
} while (key in filterByKey);
filterByKey[key] = filter;
keyByFilter[filter.text] = key;
ElemHide.isDirty = true;
}
},
/**
* Removes an element hiding filter
* @param {ElemHideFilter} filter
*/
remove: function(filter)
{
if (filter instanceof ElemHideException)
{
if (!(filter.text in knownExceptions))
return;
let list = exceptions[filter.selector];
let index = list.indexOf(filter);
if (index >= 0)
list.splice(index, 1);
delete knownExceptions[filter.text];
}
else
{
if (!(filter.text in keyByFilter))
return;
let key = keyByFilter[filter.text];
delete filterByKey[key];
delete keyByFilter[filter.text];
ElemHide.isDirty = true;
}
},
/**
* Checks whether an exception rule is registered for a filter on a particular
* domain.
*/
getException: function(/**Filter*/ filter, /**String*/ docDomain) /**ElemHideException*/
{
if (!(filter.selector in exceptions))
return null;
let list = exceptions[filter.selector];
for (let i = list.length - 1; i >= 0; i--)
if (list[i].isActiveOnDomain(docDomain))
return list[i];
return null;
},
/**
* Will be set to true if apply() is running (reentrance protection).
* @type Boolean
*/
_applying: false,
/**
* Will be set to true if an apply() call arrives while apply() is already
* running (delayed execution).
* @type Boolean
*/
_needsApply: false,
/**
* Generates stylesheet URL and applies it globally
*/
apply: function()
{
if (this._applying)
{
this._needsApply = true;
return;
}
if (!ElemHide.isDirty || !Prefs.enabled)
{
// Nothing changed, looks like we merely got enabled/disabled
if (Prefs.enabled && !ElemHide.applied)
{
try
{
Utils.styleService.loadAndRegisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
ElemHide.applied = true;
}
catch (e)
{
Cu.reportError(e);
}
}
else if (!Prefs.enabled && ElemHide.applied)
{
ElemHide.unapply();
}
return;
}
IO.writeToFile(styleURL.file, this._generateCSSContent(), function(e)
{
this._applying = false;
// _generateCSSContent is throwing NS_ERROR_NOT_AVAILABLE to indicate that
// there are no filters. If that exception is passed through XPCOM we will
// see a proper exception here, otherwise a number.
let noFilters = (e == Cr.NS_ERROR_NOT_AVAILABLE || (e && e.result == Cr.NS_ERROR_NOT_AVAILABLE));
if (noFilters)
{
e = null;
IO.removeFile(styleURL.file, function(e) {});
}
else if (e)
Cu.reportError(e);
if (this._needsApply)
{
this._needsApply = false;
this.apply();
}
else if (!e)
{
ElemHide.isDirty = false;
ElemHide.unapply();
if (!noFilters)
{
try
{
Utils.styleService.loadAndRegisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
ElemHide.applied = true;
}
catch (e)
{
Cu.reportError(e);
}
}
FilterNotifier.triggerListeners("elemhideupdate");
}
}.bind(this));
this._applying = true;
},
_generateCSSContent: function*()
{
// Grouping selectors by domains
let domains = Object.create(null);
let hasFilters = false;
for (let key in filterByKey)
{
let filter = filterByKey[key];
let domain = filter.selectorDomain || "";
let list;
if (domain in domains)
list = domains[domain];
else
{
list = Object.create(null);
domains[domain] = list;
}
list[filter.selector] = key;
hasFilters = true;
}
if (!hasFilters)
throw Cr.NS_ERROR_NOT_AVAILABLE;
function escapeChar(match)
{
return "\\" + match.charCodeAt(0).toString(16) + " ";
}
// Return CSS data
let cssTemplate = "-moz-binding: url(about:abp-elemhidehit?%ID%#dummy) !important;";
for (let domain in domains)
{
let rules = [];
let list = domains[domain];
if (domain)
yield ('@-moz-document domain("' + domain.split(",").join('"),domain("') + '"){').replace(/[^\x01-\x7F]/g, escapeChar);
else
{
// Only allow unqualified rules on a few protocols to prevent them from blocking chrome
yield '@-moz-document url-prefix("http://"),url-prefix("https://"),'
+ 'url-prefix("mailbox://"),url-prefix("imap://"),'
+ 'url-prefix("news://"),url-prefix("snews://"){';
}
for (let selector in list)
yield selector.replace(/[^\x01-\x7F]/g, escapeChar) + "{" + cssTemplate.replace("%ID%", list[selector]) + "}";
yield '}';
}
},
/**
* Unapplies current stylesheet URL
*/
unapply: function()
{
if (ElemHide.applied)
{
try
{
Utils.styleService.unregisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
}
catch (e)
{
Cu.reportError(e);
}
ElemHide.applied = false;
}
},
/**
* Retrieves the currently applied stylesheet URL
* @type String
*/
get styleURL()
{
return ElemHide.applied ? styleURL.spec : null;
},
/**
* Retrieves an element hiding filter by the corresponding protocol key
*/
getFilterByKey: function(/**String*/ key) /**Filter*/
{
return (key in filterByKey ? filterByKey[key] : null);
},
/**
* Returns a list of all selectors active on a particular domain (currently
* used only in Chrome, Opera and Safari).
*/
getSelectorsForDomain: function(/**String*/ domain, /**Boolean*/ specificOnly)
{
let result = [];
let keys = Object.getOwnPropertyNames(filterByKey);
for (let key of keys)
{
let filter = filterByKey[key];
if (specificOnly && (!filter.domains || filter.domains[""]))
continue;
if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
result.push(filter.selector);
}
return result;
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/events.js 0000664 0000000 0000000 00000004771 12707711122 0024377 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
"use strict";
/**
* Registers and emits named events.
*
* @constructor
*/
exports.EventEmitter = function()
{
this._listeners = Object.create(null);
};
exports.EventEmitter.prototype = {
/**
* Adds a listener for the specified event name.
*
* @param {string} name
* @param {function} listener
*/
on: function(name, listener)
{
if (name in this._listeners)
this._listeners[name].push(listener);
else
this._listeners[name] = [listener];
},
/**
* Removes a listener for the specified event name.
*
* @param {string} name
* @param {function} listener
*/
off: function(name, listener)
{
let listeners = this._listeners[name];
if (listeners)
{
let idx = listeners.indexOf(listener);
if (idx != -1)
listeners.splice(idx, 1);
}
},
/**
* Adds a one time listener and returns a promise that
* is resolved the next time the specified event is emitted.
*
* @return {Promise}
*/
once: function(name)
{
return new Promise(resolve =>
{
let listener = () =>
{
this.off(name, listener);
resolve();
};
this.on(name, listener);
});
},
/**
* Returns a copy of the array of listeners for the specified event.
*
* @param {string} name
* @return {function[]}
*/
listeners: function(name)
{
let listeners = this._listeners[name];
return listeners ? listeners.slice() : [];
},
/**
* Calls all previously added listeners for the given event name.
*
* @param {string} name
* @param {...*} [arg]
*/
emit: function(name)
{
let args = [];
for (let i = 1; i < arguments.length; i++)
args.push(arguments[i]);
let listeners = this.listeners(name);
for (let listener of listeners)
listener.apply(null, args);
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/filterClasses.js 0000664 0000000 0000000 00000071432 12707711122 0025674 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Definition of Filter class and its subclasses.
*/
let {FilterNotifier} = require("filterNotifier");
/**
* Abstract base class for filters
*
* @param {String} text string representation of the filter
* @constructor
*/
function Filter(text)
{
this.text = text;
this.subscriptions = [];
}
exports.Filter = Filter;
Filter.prototype =
{
/**
* String representation of the filter
* @type String
*/
text: null,
/**
* Filter subscriptions the filter belongs to
* @type Subscription[]
*/
subscriptions: null,
/**
* Filter type as a string, e.g. "blocking".
* @type String
*/
get type()
{
throw new Error("Please define filter type in the subclass");
},
/**
* Serializes the filter to an array of strings for writing out on the disk.
* @param {string[]} buffer buffer to push the serialization results into
*/
serialize: function(buffer)
{
buffer.push("[Filter]");
buffer.push("text=" + this.text);
},
toString: function()
{
return this.text;
}
};
/**
* Cache for known filters, maps string representation to filter objects.
* @type Object
*/
Filter.knownFilters = Object.create(null);
/**
* Regular expression that element hiding filters should match
* @type RegExp
*/
Filter.elemhideRegExp = /^([^\/\*\|\@"!]*?)#(\@)?(?:([\w\-]+|\*)((?:\([\w\-]+(?:[$^*]?=[^\(\)"]*)?\))*)|#([^{}]+))$/;
/**
* Regular expression that RegExp filters specified as RegExps should match
* @type RegExp
*/
Filter.regexpRegExp = /^(@@)?\/.*\/(?:\$~?[\w\-]+(?:=[^,\s]+)?(?:,~?[\w\-]+(?:=[^,\s]+)?)*)?$/;
/**
* Regular expression that options on a RegExp filter should match
* @type RegExp
*/
Filter.optionsRegExp = /\$(~?[\w\-]+(?:=[^,\s]+)?(?:,~?[\w\-]+(?:=[^,\s]+)?)*)$/;
/**
* Regular expression that CSS property filters should match
* Properties must not contain " or '
* @type RegExp
*/
Filter.csspropertyRegExp = /\[\-abp\-properties=(["'])([^"']+)\1\]/;
/**
* Creates a filter of correct type from its text representation - does the basic parsing and
* calls the right constructor then.
*
* @param {String} text as in Filter()
* @return {Filter}
*/
Filter.fromText = function(text)
{
if (text in Filter.knownFilters)
return Filter.knownFilters[text];
let ret;
let match = (text.indexOf("#") >= 0 ? Filter.elemhideRegExp.exec(text) : null);
if (match)
ret = ElemHideBase.fromText(text, match[1], !!match[2], match[3], match[4], match[5]);
else if (text[0] == "!")
ret = new CommentFilter(text);
else
ret = RegExpFilter.fromText(text);
Filter.knownFilters[ret.text] = ret;
return ret;
};
/**
* Deserializes a filter
*
* @param {Object} obj map of serialized properties and their values
* @return {Filter} filter or null if the filter couldn't be created
*/
Filter.fromObject = function(obj)
{
let ret = Filter.fromText(obj.text);
if (ret instanceof ActiveFilter)
{
if ("disabled" in obj)
ret._disabled = (obj.disabled == "true");
if ("hitCount" in obj)
ret._hitCount = parseInt(obj.hitCount) || 0;
if ("lastHit" in obj)
ret._lastHit = parseInt(obj.lastHit) || 0;
}
return ret;
};
/**
* Removes unnecessary whitespaces from filter text, will only return null if
* the input parameter is null.
*/
Filter.normalize = function(/**String*/ text) /**String*/
{
if (!text)
return text;
// Remove line breaks and such
text = text.replace(/[^\S ]/g, "");
if (/^\s*!/.test(text))
{
// Don't remove spaces inside comments
return text.trim();
}
else if (Filter.elemhideRegExp.test(text))
{
// Special treatment for element hiding filters, right side is allowed to contain spaces
let [, domain, separator, selector] = /^(.*?)(#\@?#?)(.*)$/.exec(text);
return domain.replace(/\s/g, "") + separator + selector.trim();
}
else
return text.replace(/\s/g, "");
};
/**
* Converts filter text into regular expression string
* @param {String} text as in Filter()
* @return {String} regular expression representation of filter text
*/
Filter.toRegExp = function(text)
{
return text
.replace(/\*+/g, "*") // remove multiple wildcards
.replace(/\^\|$/, "^") // remove anchors following separator placeholder
.replace(/\W/g, "\\$&") // escape special symbols
.replace(/\\\*/g, ".*") // replace wildcards by .*
// process separator placeholders (all ANSI characters but alphanumeric characters and _%.-)
.replace(/\\\^/g, "(?:[\\x00-\\x24\\x26-\\x2C\\x2F\\x3A-\\x40\\x5B-\\x5E\\x60\\x7B-\\x7F]|$)")
.replace(/^\\\|\\\|/, "^[\\w\\-]+:\\/+(?!\\/)(?:[^\\/]+\\.)?") // process extended anchor at expression start
.replace(/^\\\|/, "^") // process anchor at expression start
.replace(/\\\|$/, "$") // process anchor at expression end
.replace(/^(\.\*)/, "") // remove leading wildcards
.replace(/(\.\*)$/, ""); // remove trailing wildcards
}
/**
* Class for invalid filters
* @param {String} text see Filter()
* @param {String} reason Reason why this filter is invalid
* @constructor
* @augments Filter
*/
function InvalidFilter(text, reason)
{
Filter.call(this, text);
this.reason = reason;
}
exports.InvalidFilter = InvalidFilter;
InvalidFilter.prototype =
{
__proto__: Filter.prototype,
type: "invalid",
/**
* Reason why this filter is invalid
* @type String
*/
reason: null,
/**
* See Filter.serialize()
*/
serialize: function(buffer) {}
};
/**
* Class for comments
* @param {String} text see Filter()
* @constructor
* @augments Filter
*/
function CommentFilter(text)
{
Filter.call(this, text);
}
exports.CommentFilter = CommentFilter;
CommentFilter.prototype =
{
__proto__: Filter.prototype,
type: "comment",
/**
* See Filter.serialize()
*/
serialize: function(buffer) {}
};
/**
* Abstract base class for filters that can get hits
* @param {String} text see Filter()
* @param {String} [domains] Domains that the filter is restricted to separated by domainSeparator e.g. "foo.com|bar.com|~baz.com"
* @constructor
* @augments Filter
*/
function ActiveFilter(text, domains)
{
Filter.call(this, text);
this.domainSource = domains;
}
exports.ActiveFilter = ActiveFilter;
ActiveFilter.prototype =
{
__proto__: Filter.prototype,
_disabled: false,
_hitCount: 0,
_lastHit: 0,
/**
* Defines whether the filter is disabled
* @type Boolean
*/
get disabled()
{
return this._disabled;
},
set disabled(value)
{
if (value != this._disabled)
{
let oldValue = this._disabled;
this._disabled = value;
FilterNotifier.triggerListeners("filter.disabled", this, value, oldValue);
}
return this._disabled;
},
/**
* Number of hits on the filter since the last reset
* @type Number
*/
get hitCount()
{
return this._hitCount;
},
set hitCount(value)
{
if (value != this._hitCount)
{
let oldValue = this._hitCount;
this._hitCount = value;
FilterNotifier.triggerListeners("filter.hitCount", this, value, oldValue);
}
return this._hitCount;
},
/**
* Last time the filter had a hit (in milliseconds since the beginning of the epoch)
* @type Number
*/
get lastHit()
{
return this._lastHit;
},
set lastHit(value)
{
if (value != this._lastHit)
{
let oldValue = this._lastHit;
this._lastHit = value;
FilterNotifier.triggerListeners("filter.lastHit", this, value, oldValue);
}
return this._lastHit;
},
/**
* String that the domains property should be generated from
* @type String
*/
domainSource: null,
/**
* Separator character used in domainSource property, must be overridden by subclasses
* @type String
*/
domainSeparator: null,
/**
* Determines whether the trailing dot in domain names isn't important and
* should be ignored, must be overridden by subclasses.
* @type Boolean
*/
ignoreTrailingDot: true,
/**
* Determines whether domainSource is already upper-case,
* can be overridden by subclasses.
* @type Boolean
*/
domainSourceIsUpperCase: false,
/**
* Map containing domains that this filter should match on/not match on or null if the filter should match on all domains
* @type Object
*/
get domains()
{
// Despite this property being cached, the getter is called
// several times on Safari, due to WebKit bug 132872
let prop = Object.getOwnPropertyDescriptor(this, "domains");
if (prop)
return prop.value;
let domains = null;
if (this.domainSource)
{
let source = this.domainSource;
if (!this.domainSourceIsUpperCase) {
// RegExpFilter already have uppercase domains
source = source.toUpperCase();
}
let list = source.split(this.domainSeparator);
if (list.length == 1 && list[0][0] != "~")
{
// Fast track for the common one-domain scenario
domains = Object.create(null);
domains[""] = false;
if (this.ignoreTrailingDot)
list[0] = list[0].replace(/\.+$/, "");
domains[list[0]] = true;
}
else
{
let hasIncludes = false;
for (let i = 0; i < list.length; i++)
{
let domain = list[i];
if (this.ignoreTrailingDot)
domain = domain.replace(/\.+$/, "");
if (domain == "")
continue;
let include;
if (domain[0] == "~")
{
include = false;
domain = domain.substr(1);
}
else
{
include = true;
hasIncludes = true;
}
if (!domains)
domains = Object.create(null);
domains[domain] = include;
}
domains[""] = !hasIncludes;
}
this.domainSource = null;
}
Object.defineProperty(this, "domains", {value: domains, enumerable: true});
return this.domains;
},
/**
* Array containing public keys of websites that this filter should apply to
* @type string[]
*/
sitekeys: null,
/**
* Checks whether this filter is active on a domain.
* @param {String} docDomain domain name of the document that loads the URL
* @param {String} [sitekey] public key provided by the document
* @return {Boolean} true in case of the filter being active
*/
isActiveOnDomain: function(docDomain, sitekey)
{
// Sitekeys are case-sensitive so we shouldn't convert them to upper-case to avoid false
// positives here. Instead we need to change the way filter options are parsed.
if (this.sitekeys && (!sitekey || this.sitekeys.indexOf(sitekey.toUpperCase()) < 0))
return false;
// If no domains are set the rule matches everywhere
if (!this.domains)
return true;
// If the document has no host name, match only if the filter isn't restricted to specific domains
if (!docDomain)
return this.domains[""];
if (this.ignoreTrailingDot)
docDomain = docDomain.replace(/\.+$/, "");
docDomain = docDomain.toUpperCase();
while (true)
{
if (docDomain in this.domains)
return this.domains[docDomain];
let nextDot = docDomain.indexOf(".");
if (nextDot < 0)
break;
docDomain = docDomain.substr(nextDot + 1);
}
return this.domains[""];
},
/**
* Checks whether this filter is active only on a domain and its subdomains.
*/
isActiveOnlyOnDomain: function(/**String*/ docDomain) /**Boolean*/
{
if (!docDomain || !this.domains || this.domains[""])
return false;
if (this.ignoreTrailingDot)
docDomain = docDomain.replace(/\.+$/, "");
docDomain = docDomain.toUpperCase();
for (let domain in this.domains)
if (this.domains[domain] && domain != docDomain && (domain.length <= docDomain.length || domain.indexOf("." + docDomain) != domain.length - docDomain.length - 1))
return false;
return true;
},
/**
* Checks whether this filter is generic or specific
*/
isGeneric: function() /**Boolean*/
{
return !(this.sitekeys && this.sitekeys.length) &&
(!this.domains || this.domains[""]);
},
/**
* See Filter.serialize()
*/
serialize: function(buffer)
{
if (this._disabled || this._hitCount || this._lastHit)
{
Filter.prototype.serialize.call(this, buffer);
if (this._disabled)
buffer.push("disabled=true");
if (this._hitCount)
buffer.push("hitCount=" + this._hitCount);
if (this._lastHit)
buffer.push("lastHit=" + this._lastHit);
}
}
};
/**
* Abstract base class for RegExp-based filters
* @param {String} text see Filter()
* @param {String} regexpSource filter part that the regular expression should be build from
* @param {Number} [contentType] Content types the filter applies to, combination of values from RegExpFilter.typeMap
* @param {Boolean} [matchCase] Defines whether the filter should distinguish between lower and upper case letters
* @param {String} [domains] Domains that the filter is restricted to, e.g. "foo.com|bar.com|~baz.com"
* @param {Boolean} [thirdParty] Defines whether the filter should apply to third-party or first-party content only
* @param {String} [sitekeys] Public keys of websites that this filter should apply to
* @constructor
* @augments ActiveFilter
*/
function RegExpFilter(text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys)
{
ActiveFilter.call(this, text, domains, sitekeys);
if (contentType != null)
this.contentType = contentType;
if (matchCase)
this.matchCase = matchCase;
if (thirdParty != null)
this.thirdParty = thirdParty;
if (sitekeys != null)
this.sitekeySource = sitekeys;
if (regexpSource.length >= 2 && regexpSource[0] == "/" && regexpSource[regexpSource.length - 1] == "/")
{
// The filter is a regular expression - convert it immediately to catch syntax errors
let regexp = new RegExp(regexpSource.substr(1, regexpSource.length - 2), this.matchCase ? "" : "i");
Object.defineProperty(this, "regexp", {value: regexp});
}
else
{
// No need to convert this filter to regular expression yet, do it on demand
this.regexpSource = regexpSource;
}
}
exports.RegExpFilter = RegExpFilter;
RegExpFilter.prototype =
{
__proto__: ActiveFilter.prototype,
/**
* @see ActiveFilter.domainSourceIsUpperCase
*/
domainSourceIsUpperCase: true,
/**
* Number of filters contained, will always be 1 (required to optimize Matcher).
* @type Integer
*/
length: 1,
/**
* @see ActiveFilter.domainSeparator
*/
domainSeparator: "|",
/**
* Expression from which a regular expression should be generated - for delayed creation of the regexp property
* @type String
*/
regexpSource: null,
/**
* Regular expression to be used when testing against this filter
* @type RegExp
*/
get regexp()
{
// Despite this property being cached, the getter is called
// several times on Safari, due to WebKit bug 132872
let prop = Object.getOwnPropertyDescriptor(this, "regexp");
if (prop)
return prop.value;
let source = Filter.toRegExp(this.regexpSource);
let regexp = new RegExp(source, this.matchCase ? "" : "i");
Object.defineProperty(this, "regexp", {value: regexp});
return regexp;
},
/**
* Content types the filter applies to, combination of values from RegExpFilter.typeMap
* @type Number
*/
contentType: 0x7FFFFFFF,
/**
* Defines whether the filter should distinguish between lower and upper case letters
* @type Boolean
*/
matchCase: false,
/**
* Defines whether the filter should apply to third-party or first-party content only. Can be null (apply to all content).
* @type Boolean
*/
thirdParty: null,
/**
* String that the sitekey property should be generated from
* @type String
*/
sitekeySource: null,
/**
* Array containing public keys of websites that this filter should apply to
* @type string[]
*/
get sitekeys()
{
// Despite this property being cached, the getter is called
// several times on Safari, due to WebKit bug 132872
let prop = Object.getOwnPropertyDescriptor(this, "sitekeys");
if (prop)
return prop.value;
let sitekeys = null;
if (this.sitekeySource)
{
sitekeys = this.sitekeySource.split("|");
this.sitekeySource = null;
}
Object.defineProperty(this, "sitekeys", {value: sitekeys, enumerable: true});
return this.sitekeys;
},
/**
* Tests whether the URL matches this filter
* @param {String} location URL to be tested
* @param {number} typeMask bitmask of content / request types to match
* @param {String} docDomain domain name of the document that loads the URL
* @param {Boolean} thirdParty should be true if the URL is a third-party request
* @param {String} sitekey public key provided by the document
* @return {Boolean} true in case of a match
*/
matches: function(location, typeMask, docDomain, thirdParty, sitekey)
{
if (this.contentType & typeMask &&
(this.thirdParty == null || this.thirdParty == thirdParty) &&
this.isActiveOnDomain(docDomain, sitekey) && this.regexp.test(location))
{
return true;
}
return false;
}
};
// Required to optimize Matcher, see also RegExpFilter.prototype.length
Object.defineProperty(RegExpFilter.prototype, "0",
{
get: function() { return this; }
});
/**
* Creates a RegExp filter from its text representation
* @param {String} text same as in Filter()
*/
RegExpFilter.fromText = function(text)
{
let blocking = true;
let origText = text;
if (text.indexOf("@@") == 0)
{
blocking = false;
text = text.substr(2);
}
let contentType = null;
let matchCase = null;
let domains = null;
let sitekeys = null;
let thirdParty = null;
let collapse = null;
let options;
let match = (text.indexOf("$") >= 0 ? Filter.optionsRegExp.exec(text) : null);
if (match)
{
options = match[1].toUpperCase().split(",");
text = match.input.substr(0, match.index);
for (let option of options)
{
let value = null;
let separatorIndex = option.indexOf("=");
if (separatorIndex >= 0)
{
value = option.substr(separatorIndex + 1);
option = option.substr(0, separatorIndex);
}
option = option.replace(/-/, "_");
if (option in RegExpFilter.typeMap)
{
if (contentType == null)
contentType = 0;
contentType |= RegExpFilter.typeMap[option];
}
else if (option[0] == "~" && option.substr(1) in RegExpFilter.typeMap)
{
if (contentType == null)
contentType = RegExpFilter.prototype.contentType;
contentType &= ~RegExpFilter.typeMap[option.substr(1)];
}
else if (option == "MATCH_CASE")
matchCase = true;
else if (option == "~MATCH_CASE")
matchCase = false;
else if (option == "DOMAIN" && typeof value != "undefined")
domains = value;
else if (option == "THIRD_PARTY")
thirdParty = true;
else if (option == "~THIRD_PARTY")
thirdParty = false;
else if (option == "COLLAPSE")
collapse = true;
else if (option == "~COLLAPSE")
collapse = false;
else if (option == "SITEKEY" && typeof value != "undefined")
sitekeys = value;
else
return new InvalidFilter(origText, "filter_unknown_option");
}
}
try
{
if (blocking)
return new BlockingFilter(origText, text, contentType, matchCase, domains, thirdParty, sitekeys, collapse);
else
return new WhitelistFilter(origText, text, contentType, matchCase, domains, thirdParty, sitekeys);
}
catch (e)
{
return new InvalidFilter(origText, "filter_invalid_regexp");
}
};
/**
* Maps type strings like "SCRIPT" or "OBJECT" to bit masks
*/
RegExpFilter.typeMap = {
OTHER: 1,
SCRIPT: 2,
IMAGE: 4,
STYLESHEET: 8,
OBJECT: 16,
SUBDOCUMENT: 32,
DOCUMENT: 64,
XBL: 1,
PING: 1024,
XMLHTTPREQUEST: 2048,
OBJECT_SUBREQUEST: 4096,
DTD: 1,
MEDIA: 16384,
FONT: 32768,
BACKGROUND: 4, // Backwards compat, same as IMAGE
POPUP: 0x10000000,
GENERICBLOCK: 0x20000000,
ELEMHIDE: 0x40000000,
GENERICHIDE: 0x80000000
};
// DOCUMENT, ELEMHIDE, POPUP, GENERICHIDE and GENERICBLOCK options shouldn't
// be there by default
RegExpFilter.prototype.contentType &= ~(RegExpFilter.typeMap.DOCUMENT |
RegExpFilter.typeMap.ELEMHIDE |
RegExpFilter.typeMap.POPUP |
RegExpFilter.typeMap.GENERICHIDE |
RegExpFilter.typeMap.GENERICBLOCK);
/**
* Class for blocking filters
* @param {String} text see Filter()
* @param {String} regexpSource see RegExpFilter()
* @param {Number} contentType see RegExpFilter()
* @param {Boolean} matchCase see RegExpFilter()
* @param {String} domains see RegExpFilter()
* @param {Boolean} thirdParty see RegExpFilter()
* @param {String} sitekeys see RegExpFilter()
* @param {Boolean} collapse defines whether the filter should collapse blocked content, can be null
* @constructor
* @augments RegExpFilter
*/
function BlockingFilter(text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys, collapse)
{
RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys);
this.collapse = collapse;
}
exports.BlockingFilter = BlockingFilter;
BlockingFilter.prototype =
{
__proto__: RegExpFilter.prototype,
type: "blocking",
/**
* Defines whether the filter should collapse blocked content. Can be null (use the global preference).
* @type Boolean
*/
collapse: null
};
/**
* Class for whitelist filters
* @param {String} text see Filter()
* @param {String} regexpSource see RegExpFilter()
* @param {Number} contentType see RegExpFilter()
* @param {Boolean} matchCase see RegExpFilter()
* @param {String} domains see RegExpFilter()
* @param {Boolean} thirdParty see RegExpFilter()
* @param {String} sitekeys see RegExpFilter()
* @constructor
* @augments RegExpFilter
*/
function WhitelistFilter(text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys)
{
RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys);
}
exports.WhitelistFilter = WhitelistFilter;
WhitelistFilter.prototype =
{
__proto__: RegExpFilter.prototype,
type: "whitelist"
};
/**
* Base class for element hiding filters
* @param {String} text see Filter()
* @param {String} [domains] Host names or domains the filter should be restricted to
* @param {String} selector CSS selector for the HTML elements that should be hidden
* @constructor
* @augments ActiveFilter
*/
function ElemHideBase(text, domains, selector)
{
ActiveFilter.call(this, text, domains || null);
if (domains)
this.selectorDomain = domains.replace(/,~[^,]+/g, "").replace(/^~[^,]+,?/, "").toLowerCase();
this.selector = selector;
}
exports.ElemHideBase = ElemHideBase;
ElemHideBase.prototype =
{
__proto__: ActiveFilter.prototype,
/**
* @see ActiveFilter.domainSeparator
*/
domainSeparator: ",",
/**
* @see ActiveFilter.ignoreTrailingDot
*/
ignoreTrailingDot: false,
/**
* Host name or domain the filter should be restricted to (can be null for no restriction)
* @type String
*/
selectorDomain: null,
/**
* CSS selector for the HTML elements that should be hidden
* @type String
*/
selector: null
};
/**
* Creates an element hiding filter from a pre-parsed text representation
*
* @param {String} text same as in Filter()
* @param {String} domain domain part of the text representation (can be empty)
* @param {Boolean} isException exception rule indicator
* @param {String} tagName tag name part (can be empty)
* @param {String} attrRules attribute matching rules (can be empty)
* @param {String} selector raw CSS selector (can be empty)
* @return {ElemHideFilter|ElemHideException|CSSPropertyFilter|InvalidFilter}
*/
ElemHideBase.fromText = function(text, domain, isException, tagName, attrRules, selector)
{
if (!selector)
{
if (tagName == "*")
tagName = "";
let id = null;
let additional = "";
if (attrRules)
{
attrRules = attrRules.match(/\([\w\-]+(?:[$^*]?=[^\(\)"]*)?\)/g);
for (let rule of attrRules)
{
rule = rule.substr(1, rule.length - 2);
let separatorPos = rule.indexOf("=");
if (separatorPos > 0)
{
rule = rule.replace(/=/, '="') + '"';
additional += "[" + rule + "]";
}
else
{
if (id)
return new InvalidFilter(text, "filter_elemhide_duplicate_id");
id = rule;
}
}
}
if (id)
selector = tagName + "." + id + additional + "," + tagName + "#" + id + additional;
else if (tagName || additional)
selector = tagName + additional;
else
return new InvalidFilter(text, "filter_elemhide_nocriteria");
}
if (isException)
return new ElemHideException(text, domain, selector);
let match = Filter.csspropertyRegExp.exec(selector);
if (match)
{
// CSS property filters are inefficient so we need to make sure that
// they're only applied if they specify active domains
if (!/,[^~][^,.]*\.[^,]/.test("," + domain))
return new InvalidFilter(text, "filter_cssproperty_nodomain");
return new CSSPropertyFilter(text, domain, selector, match[2],
selector.substr(0, match.index),
selector.substr(match.index + match[0].length));
}
return new ElemHideFilter(text, domain, selector);
};
/**
* Class for element hiding filters
* @param {String} text see Filter()
* @param {String} domains see ElemHideBase()
* @param {String} selector see ElemHideBase()
* @constructor
* @augments ElemHideBase
*/
function ElemHideFilter(text, domains, selector)
{
ElemHideBase.call(this, text, domains, selector);
}
exports.ElemHideFilter = ElemHideFilter;
ElemHideFilter.prototype =
{
__proto__: ElemHideBase.prototype,
type: "elemhide"
};
/**
* Class for element hiding exceptions
* @param {String} text see Filter()
* @param {String} domains see ElemHideBase()
* @param {String} selector see ElemHideBase()
* @constructor
* @augments ElemHideBase
*/
function ElemHideException(text, domains, selector)
{
ElemHideBase.call(this, text, domains, selector);
}
exports.ElemHideException = ElemHideException;
ElemHideException.prototype =
{
__proto__: ElemHideBase.prototype,
type: "elemhideexception"
};
/**
* Class for CSS property filters
* @param {String} text see Filter()
* @param {String} domains see ElemHideBase()
* @param {String} selector see ElemHideBase()
* @param {String} regexpSource see CSSPropertyFilter.regexpSource
* @param {String} selectorPrefix see CSSPropertyFilter.selectorPrefix
* @param {String} selectorSuffix see CSSPropertyFilter.selectorSuffix
* @constructor
* @augments ElemHideBase
*/
function CSSPropertyFilter(text, domains, selector, regexpSource,
selectorPrefix, selectorSuffix)
{
ElemHideBase.call(this, text, domains, selector);
this.regexpSource = regexpSource;
this.selectorPrefix = selectorPrefix;
this.selectorSuffix = selectorSuffix;
}
exports.CSSPropertyFilter = CSSPropertyFilter;
CSSPropertyFilter.prototype =
{
__proto__: ElemHideBase.prototype,
type: "cssproperty",
/**
* Expression from which a regular expression should be generated for matching
* CSS properties - for delayed creation of the regexpString property
* @type String
*/
regexpSource: null,
/**
* Substring of CSS selector before properties for the HTML elements that
* should be hidden
* @type String
*/
selectorPrefix: null,
/**
* Substring of CSS selector after properties for the HTML elements that
* should be hidden
* @type String
*/
selectorSuffix: null,
/**
* Raw regular expression string to be used when testing CSS properties
* against this filter
* @type String
*/
get regexpString()
{
// Despite this property being cached, the getter is called
// several times on Safari, due to WebKit bug 132872
let prop = Object.getOwnPropertyDescriptor(this, "regexpString");
if (prop)
return prop.value;
let regexp = Filter.toRegExp(this.regexpSource);
Object.defineProperty(this, "regexpString", {value: regexp});
return regexp;
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/filterListener.js 0000664 0000000 0000000 00000017533 12707711122 0026066 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Component synchronizing filter storage with Matcher instances and ElemHide.
*/
"use strict";
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
let {FilterStorage} = require("filterStorage");
let {FilterNotifier} = require("filterNotifier");
let {ElemHide} = require("elemHide");
let {CSSRules} = require("cssRules");
let {defaultMatcher} = require("matcher");
let {ActiveFilter, RegExpFilter, ElemHideBase, CSSPropertyFilter} =
require("filterClasses");
let {Prefs} = require("prefs");
/**
* Value of the FilterListener.batchMode property.
* @type Boolean
*/
let batchMode = false;
/**
* Increases on filter changes, filters will be saved if it exceeds 1.
* @type Integer
*/
let isDirty = 0;
/**
* This object can be used to change properties of the filter change listeners.
* @class
*/
let FilterListener =
{
/**
* Set to true when executing many changes, changes will only be fully applied after this variable is set to false again.
* @type Boolean
*/
get batchMode()
{
return batchMode;
},
set batchMode(value)
{
batchMode = value;
flushElemHide();
},
/**
* Increases "dirty factor" of the filters and calls FilterStorage.saveToDisk()
* if it becomes 1 or more. Save is executed delayed to prevent multiple
* subsequent calls. If the parameter is 0 it forces saving filters if any
* changes were recorded after the previous save.
*/
setDirty: function(/**Integer*/ factor)
{
if (factor == 0 && isDirty > 0)
isDirty = 1;
else
isDirty += factor;
if (isDirty >= 1)
{
isDirty = 0;
FilterStorage.saveToDisk();
}
}
};
/**
* Observer listening to history purge actions.
* @class
*/
let HistoryPurgeObserver =
{
observe: function(subject, topic, data)
{
if (topic == "browser:purge-session-history" && Prefs.clearStatsOnHistoryPurge)
{
FilterStorage.resetHitCounts();
FilterListener.setDirty(0); // Force saving to disk
Prefs.recentReports = [];
}
},
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupportsWeakReference, Ci.nsIObserver])
};
/**
* Initializes filter listener on startup, registers the necessary hooks.
*/
function init()
{
FilterNotifier.on("filter.hitCount", onFilterHitCount);
FilterNotifier.on("filter.lastHit", onFilterLastHit);
FilterNotifier.on("filter.added", onFilterAdded);
FilterNotifier.on("filter.removed", onFilterRemoved);
FilterNotifier.on("filter.disabled", onFilterDisabled);
FilterNotifier.on("filter.moved", onGenericChange);
FilterNotifier.on("subscription.added", onSubscriptionAdded);
FilterNotifier.on("subscription.removed", onSubscriptionRemoved);
FilterNotifier.on("subscription.disabled", onSubscriptionDisabled);
FilterNotifier.on("subscription.updated", onSubscriptionUpdated);
FilterNotifier.on("subscription.moved", onGenericChange);
FilterNotifier.on("subscription.title", onGenericChange);
FilterNotifier.on("subscription.fixedTitle", onGenericChange);
FilterNotifier.on("subscription.homepage", onGenericChange);
FilterNotifier.on("subscription.downloadStatus", onGenericChange);
FilterNotifier.on("subscription.lastCheck", onGenericChange);
FilterNotifier.on("subscription.errors", onGenericChange);
FilterNotifier.on("load", onLoad);
FilterNotifier.on("save", onSave);
if ("nsIStyleSheetService" in Ci)
ElemHide.init();
else
flushElemHide = function() {}; // No global stylesheet in Chrome & Co.
FilterStorage.loadFromDisk();
Services.obs.addObserver(HistoryPurgeObserver, "browser:purge-session-history", true);
onShutdown.add(function()
{
Services.obs.removeObserver(HistoryPurgeObserver, "browser:purge-session-history");
});
}
init();
/**
* Calls ElemHide.apply() if necessary.
*/
function flushElemHide()
{
if (!batchMode && ElemHide.isDirty)
ElemHide.apply();
}
/**
* Notifies Matcher instances or ElemHide object about a new filter
* if necessary.
* @param {Filter} filter filter that has been added
*/
function addFilter(filter)
{
if (!(filter instanceof ActiveFilter) || filter.disabled)
return;
let hasEnabled = false;
for (let i = 0; i < filter.subscriptions.length; i++)
if (!filter.subscriptions[i].disabled)
hasEnabled = true;
if (!hasEnabled)
return;
if (filter instanceof RegExpFilter)
defaultMatcher.add(filter);
else if (filter instanceof ElemHideBase)
{
if (filter instanceof CSSPropertyFilter)
CSSRules.add(filter);
else
ElemHide.add(filter);
}
}
/**
* Notifies Matcher instances or ElemHide object about removal of a filter
* if necessary.
* @param {Filter} filter filter that has been removed
*/
function removeFilter(filter)
{
if (!(filter instanceof ActiveFilter))
return;
if (!filter.disabled)
{
let hasEnabled = false;
for (let i = 0; i < filter.subscriptions.length; i++)
if (!filter.subscriptions[i].disabled)
hasEnabled = true;
if (hasEnabled)
return;
}
if (filter instanceof RegExpFilter)
defaultMatcher.remove(filter);
else if (filter instanceof ElemHideBase)
{
if (filter instanceof CSSPropertyFilter)
CSSRules.remove(filter);
else
ElemHide.remove(filter);
}
}
function onSubscriptionAdded(subscription)
{
FilterListener.setDirty(1);
if (!subscription.disabled)
{
subscription.filters.forEach(addFilter);
flushElemHide();
}
}
function onSubscriptionRemoved(subscription)
{
FilterListener.setDirty(1);
if (!subscription.disabled)
{
subscription.filters.forEach(removeFilter);
flushElemHide();
}
}
function onSubscriptionDisabled(subscription, newValue)
{
FilterListener.setDirty(1);
if (subscription.url in FilterStorage.knownSubscriptions)
{
if (newValue == false)
subscription.filters.forEach(addFilter);
else
subscription.filters.forEach(removeFilter);
flushElemHide();
}
}
function onSubscriptionUpdated(subscription)
{
FilterListener.setDirty(1);
if (subscription.url in FilterStorage.knownSubscriptions &&
!subscription.disabled)
{
subscription.oldFilters.forEach(removeFilter);
subscription.filters.forEach(addFilter);
flushElemHide();
}
}
function onFilterHitCount(filter, newValue)
{
if (newValue == 0)
FilterListener.setDirty(0);
else
FilterListener.setDirty(0.002);
}
function onFilterLastHit()
{
FilterListener.setDirty(0.002);
}
function onFilterAdded(filter)
{
FilterListener.setDirty(1);
if (!filter.disabled)
{
addFilter(filter);
flushElemHide();
}
}
function onFilterRemoved(filter)
{
FilterListener.setDirty(1);
if (!filter.disabled)
{
removeFilter(filter);
flushElemHide();
}
}
function onFilterDisabled(filter, newValue)
{
FilterListener.setDirty(1);
if (newValue == false)
addFilter(filter);
else
removeFilter(filter);
flushElemHide();
}
function onGenericChange()
{
FilterListener.setDirty(1);
}
function onLoad()
{
isDirty = 0;
defaultMatcher.clear();
ElemHide.clear();
CSSRules.clear();
for (let subscription of FilterStorage.subscriptions)
if (!subscription.disabled)
subscription.filters.forEach(addFilter);
flushElemHide();
}
function onSave()
{
isDirty = 0;
}
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/filterNotifier.js 0000664 0000000 0000000 00000004722 12707711122 0026054 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview This component manages listeners and calls them to distributes
* messages about filter changes.
*/
let {EventEmitter} = require("events");
const CATCH_ALL = "__all";
/**
* This class allows registering and triggering listeners for filter events.
* @class
*/
exports.FilterNotifier =
{
__proto__: new EventEmitter(),
/**
* Adds a listener
*
* @deprecated use FilterNotifier.on(action, callback)
*/
addListener: function(/**function(action, item, newValue, oldValue)*/ listener)
{
let listeners = this._listeners[CATCH_ALL];
if (!listeners || listeners.indexOf(listener) == -1)
this.on(CATCH_ALL, listener);
},
/**
* Removes a listener that was previosly added via addListener
*
* @deprecated use FilterNotifier.off(action, callback)
*/
removeListener: function(/**function(action, item, newValue, oldValue)*/ listener)
{
this.off(CATCH_ALL, listener);
},
/**
* Notifies listeners about an event
* @param {String} action event code ("load", "save", "elemhideupdate",
* "subscription.added", "subscription.removed",
* "subscription.disabled", "subscription.title",
* "subscription.lastDownload", "subscription.downloadStatus",
* "subscription.homepage", "subscription.updated",
* "filter.added", "filter.removed", "filter.moved",
* "filter.disabled", "filter.hitCount", "filter.lastHit")
* @param {Subscription|Filter} item item that the change applies to
* @deprecated use FilterNotifier.emit(action)
*/
triggerListeners: function(action, item, param1, param2, param3)
{
this.emit(action, item, param1, param2, param3);
this.emit(CATCH_ALL, action, item, param1, param2, param3);
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/filterStorage.js 0000664 0000000 0000000 00000056511 12707711122 0025704 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview FilterStorage class responsible for managing user's subscriptions and filters.
*/
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/FileUtils.jsm");
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
let {IO} = require("io");
let {Prefs} = require("prefs");
let {Filter, ActiveFilter} = require("filterClasses");
let {Subscription, SpecialSubscription, ExternalSubscription} = require("subscriptionClasses");
let {FilterNotifier} = require("filterNotifier");
let {Utils} = require("utils");
/**
* Version number of the filter storage file format.
* @type Integer
*/
let formatVersion = 4;
/**
* This class reads user's filters from disk, manages them in memory and writes them back.
* @class
*/
let FilterStorage = exports.FilterStorage =
{
/**
* Version number of the patterns.ini format used.
* @type Integer
*/
get formatVersion()
{
return formatVersion;
},
/**
* File that the filter list has been loaded from and should be saved to
* @type nsIFile
*/
get sourceFile()
{
let file = null;
if (Prefs.patternsfile)
{
// Override in place, use it instead of placing the file in the regular data dir
file = IO.resolveFilePath(Prefs.patternsfile);
}
if (!file)
{
// Place the file in the data dir
file = IO.resolveFilePath(Prefs.data_directory);
if (file)
file.append("patterns.ini");
}
if (!file)
{
// Data directory pref misconfigured? Try the default value
try
{
file = IO.resolveFilePath(Services.prefs.getDefaultBranch("extensions.adblockplus.").getCharPref("data_directory"));
if (file)
file.append("patterns.ini");
} catch(e) {}
}
if (!file)
Cu.reportError("Adblock Plus: Failed to resolve filter file location from extensions.adblockplus.patternsfile preference");
// Property is configurable because of the test suite.
Object.defineProperty(this, "sourceFile", {value: file, configurable: true});
return file;
},
/**
* Will be set to true if no patterns.ini file exists.
* @type Boolean
*/
firstRun: false,
/**
* Map of properties listed in the filter storage file before the sections
* start. Right now this should be only the format version.
*/
fileProperties: Object.create(null),
/**
* List of filter subscriptions containing all filters
* @type Subscription[]
*/
subscriptions: [],
/**
* Map of subscriptions already on the list, by their URL/identifier
* @type Object
*/
knownSubscriptions: Object.create(null),
/**
* Finds the filter group that a filter should be added to by default. Will
* return null if this group doesn't exist yet.
*/
getGroupForFilter: function(/**Filter*/ filter) /**SpecialSubscription*/
{
let generalSubscription = null;
for (let subscription of FilterStorage.subscriptions)
{
if (subscription instanceof SpecialSubscription && !subscription.disabled)
{
// Always prefer specialized subscriptions
if (subscription.isDefaultFor(filter))
return subscription;
// If this is a general subscription - store it as fallback
if (!generalSubscription && (!subscription.defaults || !subscription.defaults.length))
generalSubscription = subscription;
}
}
return generalSubscription;
},
/**
* Adds a filter subscription to the list
* @param {Subscription} subscription filter subscription to be added
* @param {Boolean} silent if true, no listeners will be triggered (to be used when filter list is reloaded)
*/
addSubscription: function(subscription, silent)
{
if (subscription.url in FilterStorage.knownSubscriptions)
return;
FilterStorage.subscriptions.push(subscription);
FilterStorage.knownSubscriptions[subscription.url] = subscription;
addSubscriptionFilters(subscription);
if (!silent)
FilterNotifier.triggerListeners("subscription.added", subscription);
},
/**
* Removes a filter subscription from the list
* @param {Subscription} subscription filter subscription to be removed
* @param {Boolean} silent if true, no listeners will be triggered (to be used when filter list is reloaded)
*/
removeSubscription: function(subscription, silent)
{
for (let i = 0; i < FilterStorage.subscriptions.length; i++)
{
if (FilterStorage.subscriptions[i].url == subscription.url)
{
removeSubscriptionFilters(subscription);
FilterStorage.subscriptions.splice(i--, 1);
delete FilterStorage.knownSubscriptions[subscription.url];
if (!silent)
FilterNotifier.triggerListeners("subscription.removed", subscription);
return;
}
}
},
/**
* Moves a subscription in the list to a new position.
* @param {Subscription} subscription filter subscription to be moved
* @param {Subscription} [insertBefore] filter subscription to insert before
* (if omitted the subscription will be put at the end of the list)
*/
moveSubscription: function(subscription, insertBefore)
{
let currentPos = FilterStorage.subscriptions.indexOf(subscription);
if (currentPos < 0)
return;
let newPos = insertBefore ? FilterStorage.subscriptions.indexOf(insertBefore) : -1;
if (newPos < 0)
newPos = FilterStorage.subscriptions.length;
if (currentPos < newPos)
newPos--;
if (currentPos == newPos)
return;
FilterStorage.subscriptions.splice(currentPos, 1);
FilterStorage.subscriptions.splice(newPos, 0, subscription);
FilterNotifier.triggerListeners("subscription.moved", subscription);
},
/**
* Replaces the list of filters in a subscription by a new list
* @param {Subscription} subscription filter subscription to be updated
* @param {Filter[]} filters new filter list
*/
updateSubscriptionFilters: function(subscription, filters)
{
removeSubscriptionFilters(subscription);
subscription.oldFilters = subscription.filters;
subscription.filters = filters;
addSubscriptionFilters(subscription);
FilterNotifier.triggerListeners("subscription.updated", subscription);
delete subscription.oldFilters;
},
/**
* Adds a user-defined filter to the list
* @param {Filter} filter
* @param {SpecialSubscription} [subscription] particular group that the filter should be added to
* @param {Integer} [position] position within the subscription at which the filter should be added
* @param {Boolean} silent if true, no listeners will be triggered (to be used when filter list is reloaded)
*/
addFilter: function(filter, subscription, position, silent)
{
if (!subscription)
{
if (filter.subscriptions.some(s => s instanceof SpecialSubscription && !s.disabled))
return; // No need to add
subscription = FilterStorage.getGroupForFilter(filter);
}
if (!subscription)
{
// No group for this filter exists, create one
subscription = SpecialSubscription.createForFilter(filter);
this.addSubscription(subscription);
return;
}
if (typeof position == "undefined")
position = subscription.filters.length;
if (filter.subscriptions.indexOf(subscription) < 0)
filter.subscriptions.push(subscription);
subscription.filters.splice(position, 0, filter);
if (!silent)
FilterNotifier.triggerListeners("filter.added", filter, subscription, position);
},
/**
* Removes a user-defined filter from the list
* @param {Filter} filter
* @param {SpecialSubscription} [subscription] a particular filter group that
* the filter should be removed from (if ommited will be removed from all subscriptions)
* @param {Integer} [position] position inside the filter group at which the
* filter should be removed (if ommited all instances will be removed)
*/
removeFilter: function(filter, subscription, position)
{
let subscriptions = (subscription ? [subscription] : filter.subscriptions.slice());
for (let i = 0; i < subscriptions.length; i++)
{
let subscription = subscriptions[i];
if (subscription instanceof SpecialSubscription)
{
let positions = [];
if (typeof position == "undefined")
{
let index = -1;
do
{
index = subscription.filters.indexOf(filter, index + 1);
if (index >= 0)
positions.push(index);
} while (index >= 0);
}
else
positions.push(position);
for (let j = positions.length - 1; j >= 0; j--)
{
let position = positions[j];
if (subscription.filters[position] == filter)
{
subscription.filters.splice(position, 1);
if (subscription.filters.indexOf(filter) < 0)
{
let index = filter.subscriptions.indexOf(subscription);
if (index >= 0)
filter.subscriptions.splice(index, 1);
}
FilterNotifier.triggerListeners("filter.removed", filter, subscription, position);
}
}
}
}
},
/**
* Moves a user-defined filter to a new position
* @param {Filter} filter
* @param {SpecialSubscription} subscription filter group where the filter is located
* @param {Integer} oldPosition current position of the filter
* @param {Integer} newPosition new position of the filter
*/
moveFilter: function(filter, subscription, oldPosition, newPosition)
{
if (!(subscription instanceof SpecialSubscription) || subscription.filters[oldPosition] != filter)
return;
newPosition = Math.min(Math.max(newPosition, 0), subscription.filters.length - 1);
if (oldPosition == newPosition)
return;
subscription.filters.splice(oldPosition, 1);
subscription.filters.splice(newPosition, 0, filter);
FilterNotifier.triggerListeners("filter.moved", filter, subscription, oldPosition, newPosition);
},
/**
* Increases the hit count for a filter by one
* @param {Filter} filter
*/
increaseHitCount: function(filter)
{
if (!Prefs.savestats || !(filter instanceof ActiveFilter))
return;
filter.hitCount++;
filter.lastHit = Date.now();
},
/**
* Resets hit count for some filters
* @param {Filter[]} filters filters to be reset, if null all filters will be reset
*/
resetHitCounts: function(filters)
{
if (!filters)
{
filters = [];
for (let text in Filter.knownFilters)
filters.push(Filter.knownFilters[text]);
}
for (let filter of filters)
{
filter.hitCount = 0;
filter.lastHit = 0;
}
},
_loading: false,
/**
* Loads all subscriptions from the disk
* @param {nsIFile} [sourceFile] File to read from
*/
loadFromDisk: function(sourceFile)
{
if (this._loading)
return;
this._loading = true;
let readFile = function(sourceFile, backupIndex)
{
let parser = new INIParser();
IO.readFromFile(sourceFile, parser, function(e)
{
if (!e && parser.subscriptions.length == 0)
{
// No filter subscriptions in the file, this isn't right.
e = new Error("No data in the file");
}
if (e)
Cu.reportError(e);
if (e && !explicitFile)
{
// Attempt to load a backup
sourceFile = this.sourceFile;
if (sourceFile)
{
let [, part1, part2] = /^(.*)(\.\w+)$/.exec(sourceFile.leafName) || [null, sourceFile.leafName, ""];
sourceFile = sourceFile.clone();
sourceFile.leafName = part1 + "-backup" + (++backupIndex) + part2;
IO.statFile(sourceFile, function(e, statData)
{
if (!e && statData.exists)
readFile(sourceFile, backupIndex);
else
doneReading(parser);
});
return;
}
}
doneReading(parser);
}.bind(this));
}.bind(this);
var doneReading = function(parser)
{
// Old special groups might have been converted, remove them if they are empty
let specialMap = {"~il~": true, "~wl~": true, "~fl~": true, "~eh~": true};
let knownSubscriptions = Object.create(null);
for (let i = 0; i < parser.subscriptions.length; i++)
{
let subscription = parser.subscriptions[i];
if (subscription instanceof SpecialSubscription && subscription.filters.length == 0 && subscription.url in specialMap)
parser.subscriptions.splice(i--, 1);
else
knownSubscriptions[subscription.url] = subscription;
}
this.fileProperties = parser.fileProperties;
this.subscriptions = parser.subscriptions;
this.knownSubscriptions = knownSubscriptions;
Filter.knownFilters = parser.knownFilters;
Subscription.knownSubscriptions = parser.knownSubscriptions;
if (parser.userFilters)
{
for (let i = 0; i < parser.userFilters.length; i++)
{
let filter = Filter.fromText(parser.userFilters[i]);
this.addFilter(filter, null, undefined, true);
}
}
this._loading = false;
FilterNotifier.triggerListeners("load");
if (sourceFile != this.sourceFile)
this.saveToDisk();
}.bind(this);
let explicitFile;
if (sourceFile)
{
explicitFile = true;
readFile(sourceFile, 0);
}
else
{
explicitFile = false;
sourceFile = FilterStorage.sourceFile;
let callback = function(e, statData)
{
if (e || !statData.exists)
{
this.firstRun = true;
this._loading = false;
FilterNotifier.triggerListeners("load");
}
else
readFile(sourceFile, 0);
}.bind(this);
if (sourceFile)
IO.statFile(sourceFile, callback);
else
callback(true);
}
},
_generateFilterData: function*(subscriptions)
{
yield "# Adblock Plus preferences";
yield "version=" + formatVersion;
let saved = Object.create(null);
let buf = [];
// Save filter data
for (let i = 0; i < subscriptions.length; i++)
{
let subscription = subscriptions[i];
for (let j = 0; j < subscription.filters.length; j++)
{
let filter = subscription.filters[j];
if (!(filter.text in saved))
{
filter.serialize(buf);
saved[filter.text] = filter;
for (let k = 0; k < buf.length; k++)
yield buf[k];
buf.splice(0);
}
}
}
// Save subscriptions
for (let i = 0; i < subscriptions.length; i++)
{
let subscription = subscriptions[i];
yield "";
subscription.serialize(buf);
if (subscription.filters.length)
{
buf.push("", "[Subscription filters]")
subscription.serializeFilters(buf);
}
for (let k = 0; k < buf.length; k++)
yield buf[k];
buf.splice(0);
}
},
/**
* Will be set to true if saveToDisk() is running (reentrance protection).
* @type Boolean
*/
_saving: false,
/**
* Will be set to true if a saveToDisk() call arrives while saveToDisk() is
* already running (delayed execution).
* @type Boolean
*/
_needsSave: false,
/**
* Saves all subscriptions back to disk
* @param {nsIFile} [targetFile] File to be written
*/
saveToDisk: function(targetFile)
{
let explicitFile = true;
if (!targetFile)
{
targetFile = FilterStorage.sourceFile;
explicitFile = false;
}
if (!targetFile)
return;
if (!explicitFile && this._saving)
{
this._needsSave = true;
return;
}
// Make sure the file's parent directory exists
try {
targetFile.parent.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
} catch (e) {}
let writeFilters = function()
{
IO.writeToFile(targetFile, this._generateFilterData(subscriptions), function(e)
{
if (!explicitFile)
this._saving = false;
if (e)
Cu.reportError(e);
if (!explicitFile && this._needsSave)
{
this._needsSave = false;
this.saveToDisk();
}
else
FilterNotifier.triggerListeners("save");
}.bind(this));
}.bind(this);
let checkBackupRequired = function(callbackNotRequired, callbackRequired)
{
if (explicitFile || Prefs.patternsbackups <= 0)
callbackNotRequired();
else
{
IO.statFile(targetFile, function(e, statData)
{
if (e || !statData.exists)
callbackNotRequired();
else
{
let [, part1, part2] = /^(.*)(\.\w+)$/.exec(targetFile.leafName) || [null, targetFile.leafName, ""];
let newestBackup = targetFile.clone();
newestBackup.leafName = part1 + "-backup1" + part2;
IO.statFile(newestBackup, function(e, statData)
{
if (!e && (!statData.exists || (Date.now() - statData.lastModified) / 3600000 >= Prefs.patternsbackupinterval))
callbackRequired(part1, part2)
else
callbackNotRequired();
});
}
});
}
}.bind(this);
let removeLastBackup = function(part1, part2)
{
let file = targetFile.clone();
file.leafName = part1 + "-backup" + Prefs.patternsbackups + part2;
IO.removeFile(file, (e) => renameBackup(part1, part2, Prefs.patternsbackups - 1));
}.bind(this);
let renameBackup = function(part1, part2, index)
{
if (index > 0)
{
let fromFile = targetFile.clone();
fromFile.leafName = part1 + "-backup" + index + part2;
let toName = part1 + "-backup" + (index + 1) + part2;
IO.renameFile(fromFile, toName, (e) => renameBackup(part1, part2, index - 1));
}
else
{
let toFile = targetFile.clone();
toFile.leafName = part1 + "-backup" + (index + 1) + part2;
IO.copyFile(targetFile, toFile, writeFilters);
}
}.bind(this);
// Do not persist external subscriptions
let subscriptions = this.subscriptions.filter((s) => !(s instanceof ExternalSubscription));
if (!explicitFile)
this._saving = true;
checkBackupRequired(writeFilters, removeLastBackup);
},
/**
* Returns the list of existing backup files.
*/
getBackupFiles: function() /**nsIFile[]*/
{
// TODO: This method should be asynchronous
let result = [];
let [, part1, part2] = /^(.*)(\.\w+)$/.exec(FilterStorage.sourceFile.leafName) || [null, FilterStorage.sourceFile.leafName, ""];
for (let i = 1; ; i++)
{
let file = FilterStorage.sourceFile.clone();
file.leafName = part1 + "-backup" + i + part2;
if (file.exists())
result.push(file);
else
break;
}
return result;
}
};
/**
* Joins subscription's filters to the subscription without any notifications.
* @param {Subscription} subscription filter subscription that should be connected to its filters
*/
function addSubscriptionFilters(subscription)
{
if (!(subscription.url in FilterStorage.knownSubscriptions))
return;
for (let filter of subscription.filters)
filter.subscriptions.push(subscription);
}
/**
* Removes subscription's filters from the subscription without any notifications.
* @param {Subscription} subscription filter subscription to be removed
*/
function removeSubscriptionFilters(subscription)
{
if (!(subscription.url in FilterStorage.knownSubscriptions))
return;
for (let filter of subscription.filters)
{
let i = filter.subscriptions.indexOf(subscription);
if (i >= 0)
filter.subscriptions.splice(i, 1);
}
}
/**
* IO.readFromFile() listener to parse filter data.
* @constructor
*/
function INIParser()
{
this.fileProperties = this.curObj = {};
this.subscriptions = [];
this.knownFilters = Object.create(null);
this.knownSubscriptions = Object.create(null);
}
INIParser.prototype =
{
linesProcessed: 0,
subscriptions: null,
knownFilters: null,
knownSubscriptions : null,
wantObj: true,
fileProperties: null,
curObj: null,
curSection: null,
userFilters: null,
process: function(val)
{
let origKnownFilters = Filter.knownFilters;
Filter.knownFilters = this.knownFilters;
let origKnownSubscriptions = Subscription.knownSubscriptions;
Subscription.knownSubscriptions = this.knownSubscriptions;
let match;
try
{
if (this.wantObj === true && (match = /^(\w+)=(.*)$/.exec(val)))
this.curObj[match[1]] = match[2];
else if (val === null || (match = /^\s*\[(.+)\]\s*$/.exec(val)))
{
if (this.curObj)
{
// Process current object before going to next section
switch (this.curSection)
{
case "filter":
case "pattern":
if ("text" in this.curObj)
Filter.fromObject(this.curObj);
break;
case "subscription":
let subscription = Subscription.fromObject(this.curObj);
if (subscription)
this.subscriptions.push(subscription);
break;
case "subscription filters":
case "subscription patterns":
if (this.subscriptions.length)
{
let subscription = this.subscriptions[this.subscriptions.length - 1];
for (let text of this.curObj)
{
let filter = Filter.fromText(text);
subscription.filters.push(filter);
filter.subscriptions.push(subscription);
}
}
break;
case "user patterns":
this.userFilters = this.curObj;
break;
}
}
if (val === null)
return;
this.curSection = match[1].toLowerCase();
switch (this.curSection)
{
case "filter":
case "pattern":
case "subscription":
this.wantObj = true;
this.curObj = {};
break;
case "subscription filters":
case "subscription patterns":
case "user patterns":
this.wantObj = false;
this.curObj = [];
break;
default:
this.wantObj = undefined;
this.curObj = null;
}
}
else if (this.wantObj === false && val)
this.curObj.push(val.replace(/\\\[/g, "["));
}
finally
{
Filter.knownFilters = origKnownFilters;
Subscription.knownSubscriptions = origKnownSubscriptions;
}
// Allow events to be processed every now and then.
// Note: IO.readFromFile() will deal with the potential reentrance here.
this.linesProcessed++;
if (this.linesProcessed % 1000 == 0)
Utils.yield();
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/matcher.js 0000664 0000000 0000000 00000024507 12707711122 0024515 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Matcher class implementing matching addresses against a list of filters.
*/
let {Filter, RegExpFilter, WhitelistFilter} = require("filterClasses");
/**
* Blacklist/whitelist filter matching
* @constructor
*/
function Matcher()
{
this.clear();
}
exports.Matcher = Matcher;
Matcher.prototype = {
/**
* Lookup table for filters by their associated keyword
* @type Object
*/
filterByKeyword: null,
/**
* Lookup table for keywords by the filter text
* @type Object
*/
keywordByFilter: null,
/**
* Removes all known filters
*/
clear: function()
{
this.filterByKeyword = Object.create(null);
this.keywordByFilter = Object.create(null);
},
/**
* Adds a filter to the matcher
* @param {RegExpFilter} filter
*/
add: function(filter)
{
if (filter.text in this.keywordByFilter)
return;
// Look for a suitable keyword
let keyword = this.findKeyword(filter);
let oldEntry = this.filterByKeyword[keyword];
if (typeof oldEntry == "undefined")
this.filterByKeyword[keyword] = filter;
else if (oldEntry.length == 1)
this.filterByKeyword[keyword] = [oldEntry, filter];
else
oldEntry.push(filter);
this.keywordByFilter[filter.text] = keyword;
},
/**
* Removes a filter from the matcher
* @param {RegExpFilter} filter
*/
remove: function(filter)
{
if (!(filter.text in this.keywordByFilter))
return;
let keyword = this.keywordByFilter[filter.text];
let list = this.filterByKeyword[keyword];
if (list.length <= 1)
delete this.filterByKeyword[keyword];
else
{
let index = list.indexOf(filter);
if (index >= 0)
{
list.splice(index, 1);
if (list.length == 1)
this.filterByKeyword[keyword] = list[0];
}
}
delete this.keywordByFilter[filter.text];
},
/**
* Chooses a keyword to be associated with the filter
* @param {String} text text representation of the filter
* @return {String} keyword (might be empty string)
*/
findKeyword: function(filter)
{
let result = "";
let text = filter.text;
if (Filter.regexpRegExp.test(text))
return result;
// Remove options
let match = Filter.optionsRegExp.exec(text);
if (match)
text = match.input.substr(0, match.index);
// Remove whitelist marker
if (text.substr(0, 2) == "@@")
text = text.substr(2);
let candidates = text.toLowerCase().match(/[^a-z0-9%*][a-z0-9%]{3,}(?=[^a-z0-9%*])/g);
if (!candidates)
return result;
let hash = this.filterByKeyword;
let resultCount = 0xFFFFFF;
let resultLength = 0;
for (let i = 0, l = candidates.length; i < l; i++)
{
let candidate = candidates[i].substr(1);
let count = (candidate in hash ? hash[candidate].length : 0);
if (count < resultCount || (count == resultCount && candidate.length > resultLength))
{
result = candidate;
resultCount = count;
resultLength = candidate.length;
}
}
return result;
},
/**
* Checks whether a particular filter is being matched against.
*/
hasFilter: function(/**RegExpFilter*/ filter) /**Boolean*/
{
return (filter.text in this.keywordByFilter);
},
/**
* Returns the keyword used for a filter, null for unknown filters.
*/
getKeywordForFilter: function(/**RegExpFilter*/ filter) /**String*/
{
if (filter.text in this.keywordByFilter)
return this.keywordByFilter[filter.text];
else
return null;
},
/**
* Checks whether the entries for a particular keyword match a URL
*/
_checkEntryMatch: function(keyword, location, typeMask, docDomain, thirdParty, sitekey, specificOnly)
{
let list = this.filterByKeyword[keyword];
for (let i = 0; i < list.length; i++)
{
let filter = list[i];
if (specificOnly && filter.isGeneric() &&
!(filter instanceof WhitelistFilter))
continue;
if (filter.matches(location, typeMask, docDomain, thirdParty, sitekey))
return filter;
}
return null;
},
/**
* Tests whether the URL matches any of the known filters
* @param {String} location URL to be tested
* @param {number} typeMask bitmask of content / request types to match
* @param {String} docDomain domain name of the document that loads the URL
* @param {Boolean} thirdParty should be true if the URL is a third-party request
* @param {String} sitekey public key provided by the document
* @param {Boolean} specificOnly should be true if generic matches should be ignored
* @return {RegExpFilter} matching filter or null
*/
matchesAny: function(location, typeMask, docDomain, thirdParty, sitekey, specificOnly)
{
let candidates = location.toLowerCase().match(/[a-z0-9%]{3,}/g);
if (candidates === null)
candidates = [];
candidates.push("");
for (let i = 0, l = candidates.length; i < l; i++)
{
let substr = candidates[i];
if (substr in this.filterByKeyword)
{
let result = this._checkEntryMatch(substr, location, typeMask, docDomain, thirdParty, sitekey, specificOnly);
if (result)
return result;
}
}
return null;
}
};
/**
* Combines a matcher for blocking and exception rules, automatically sorts
* rules into two Matcher instances.
* @constructor
*/
function CombinedMatcher()
{
this.blacklist = new Matcher();
this.whitelist = new Matcher();
this.resultCache = Object.create(null);
}
exports.CombinedMatcher = CombinedMatcher;
/**
* Maximal number of matching cache entries to be kept
* @type Number
*/
CombinedMatcher.maxCacheEntries = 1000;
CombinedMatcher.prototype =
{
/**
* Matcher for blocking rules.
* @type Matcher
*/
blacklist: null,
/**
* Matcher for exception rules.
* @type Matcher
*/
whitelist: null,
/**
* Lookup table of previous matchesAny results
* @type Object
*/
resultCache: null,
/**
* Number of entries in resultCache
* @type Number
*/
cacheEntries: 0,
/**
* @see Matcher#clear
*/
clear: function()
{
this.blacklist.clear();
this.whitelist.clear();
this.resultCache = Object.create(null);
this.cacheEntries = 0;
},
/**
* @see Matcher#add
*/
add: function(filter)
{
if (filter instanceof WhitelistFilter)
this.whitelist.add(filter);
else
this.blacklist.add(filter);
if (this.cacheEntries > 0)
{
this.resultCache = Object.create(null);
this.cacheEntries = 0;
}
},
/**
* @see Matcher#remove
*/
remove: function(filter)
{
if (filter instanceof WhitelistFilter)
this.whitelist.remove(filter);
else
this.blacklist.remove(filter);
if (this.cacheEntries > 0)
{
this.resultCache = Object.create(null);
this.cacheEntries = 0;
}
},
/**
* @see Matcher#findKeyword
*/
findKeyword: function(filter)
{
if (filter instanceof WhitelistFilter)
return this.whitelist.findKeyword(filter);
else
return this.blacklist.findKeyword(filter);
},
/**
* @see Matcher#hasFilter
*/
hasFilter: function(filter)
{
if (filter instanceof WhitelistFilter)
return this.whitelist.hasFilter(filter);
else
return this.blacklist.hasFilter(filter);
},
/**
* @see Matcher#getKeywordForFilter
*/
getKeywordForFilter: function(filter)
{
if (filter instanceof WhitelistFilter)
return this.whitelist.getKeywordForFilter(filter);
else
return this.blacklist.getKeywordForFilter(filter);
},
/**
* Checks whether a particular filter is slow
*/
isSlowFilter: function(/**RegExpFilter*/ filter) /**Boolean*/
{
let matcher = (filter instanceof WhitelistFilter ? this.whitelist : this.blacklist);
if (matcher.hasFilter(filter))
return !matcher.getKeywordForFilter(filter);
else
return !matcher.findKeyword(filter);
},
/**
* Optimized filter matching testing both whitelist and blacklist matchers
* simultaneously. For parameters see Matcher.matchesAny().
* @see Matcher#matchesAny
*/
matchesAnyInternal: function(location, typeMask, docDomain, thirdParty, sitekey, specificOnly)
{
let candidates = location.toLowerCase().match(/[a-z0-9%]{3,}/g);
if (candidates === null)
candidates = [];
candidates.push("");
let blacklistHit = null;
for (let i = 0, l = candidates.length; i < l; i++)
{
let substr = candidates[i];
if (substr in this.whitelist.filterByKeyword)
{
let result = this.whitelist._checkEntryMatch(substr, location, typeMask, docDomain, thirdParty, sitekey);
if (result)
return result;
}
if (substr in this.blacklist.filterByKeyword && blacklistHit === null)
blacklistHit = this.blacklist._checkEntryMatch(substr, location, typeMask, docDomain, thirdParty, sitekey, specificOnly);
}
return blacklistHit;
},
/**
* @see Matcher#matchesAny
*/
matchesAny: function(location, typeMask, docDomain, thirdParty, sitekey, specificOnly)
{
let key = location + " " + typeMask + " " + docDomain + " " + thirdParty + " " + sitekey + " " + specificOnly;
if (key in this.resultCache)
return this.resultCache[key];
let result = this.matchesAnyInternal(location, typeMask, docDomain, thirdParty, sitekey, specificOnly);
if (this.cacheEntries >= CombinedMatcher.maxCacheEntries)
{
this.resultCache = Object.create(null);
this.cacheEntries = 0;
}
this.resultCache[key] = result;
this.cacheEntries++;
return result;
}
}
/**
* Shared CombinedMatcher instance that should usually be used.
* @type CombinedMatcher
*/
let defaultMatcher = exports.defaultMatcher = new CombinedMatcher();
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/notification.js 0000664 0000000 0000000 00000031211 12707711122 0025546 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Handles notifications.
*/
Cu.import("resource://gre/modules/Services.jsm");
var {Prefs} = require("prefs");
var {Downloader, Downloadable, MILLIS_IN_MINUTE, MILLIS_IN_HOUR, MILLIS_IN_DAY} = require("downloader");
var {Utils} = require("utils");
var {Matcher, defaultMatcher} = require("matcher");
var {Filter, RegExpFilter, WhitelistFilter} = require("filterClasses");
var INITIAL_DELAY = 1 * MILLIS_IN_MINUTE;
var CHECK_INTERVAL = 1 * MILLIS_IN_HOUR;
var EXPIRATION_INTERVAL = 1 * MILLIS_IN_DAY;
var TYPE = {
information: 0,
question: 1,
critical: 2
};
var showListeners = [];
var questionListeners = {};
function getNumericalSeverity(notification)
{
return (notification.type in TYPE ? TYPE[notification.type] : TYPE.information);
}
function saveNotificationData()
{
// HACK: JSON values aren't saved unless they are assigned a different object.
Prefs.notificationdata = JSON.parse(JSON.stringify(Prefs.notificationdata));
}
function localize(translations, locale)
{
if (locale in translations)
return translations[locale];
let languagePart = locale.substring(0, locale.indexOf("-"));
if (languagePart && languagePart in translations)
return translations[languagePart];
let defaultLocale = "en-US";
return translations[defaultLocale];
}
/**
* The object providing actual downloading functionality.
* @type Downloader
*/
var downloader = null;
var localData = [];
/**
* Regularly fetches notifications and decides which to show.
* @class
*/
var Notification = exports.Notification =
{
/**
* Called on module startup.
*/
init: function()
{
downloader = new Downloader(this._getDownloadables.bind(this), INITIAL_DELAY, CHECK_INTERVAL);
downloader.onExpirationChange = this._onExpirationChange.bind(this);
downloader.onDownloadSuccess = this._onDownloadSuccess.bind(this);
downloader.onDownloadError = this._onDownloadError.bind(this);
onShutdown.add(() => downloader.cancel());
},
/**
* Yields a Downloadable instances for the notifications download.
*/
_getDownloadables: function*()
{
let downloadable = new Downloadable(Prefs.notificationurl);
if (typeof Prefs.notificationdata.lastError === "number")
downloadable.lastError = Prefs.notificationdata.lastError;
if (typeof Prefs.notificationdata.lastCheck === "number")
downloadable.lastCheck = Prefs.notificationdata.lastCheck;
if (typeof Prefs.notificationdata.data === "object" && "version" in Prefs.notificationdata.data)
downloadable.lastVersion = Prefs.notificationdata.data.version;
if (typeof Prefs.notificationdata.softExpiration === "number")
downloadable.softExpiration = Prefs.notificationdata.softExpiration;
if (typeof Prefs.notificationdata.hardExpiration === "number")
downloadable.hardExpiration = Prefs.notificationdata.hardExpiration;
if (typeof Prefs.notificationdata.downloadCount === "number")
downloadable.downloadCount = Prefs.notificationdata.downloadCount;
yield downloadable;
},
_onExpirationChange: function(downloadable)
{
Prefs.notificationdata.lastCheck = downloadable.lastCheck;
Prefs.notificationdata.softExpiration = downloadable.softExpiration;
Prefs.notificationdata.hardExpiration = downloadable.hardExpiration;
saveNotificationData();
},
_onDownloadSuccess: function(downloadable, responseText, errorCallback, redirectCallback)
{
try
{
let data = JSON.parse(responseText);
for (let notification of data.notifications)
{
if ("severity" in notification)
{
if (!("type" in notification))
notification.type = notification.severity;
delete notification.severity;
}
}
Prefs.notificationdata.data = data;
}
catch (e)
{
Cu.reportError(e);
errorCallback("synchronize_invalid_data");
return;
}
Prefs.notificationdata.lastError = 0;
Prefs.notificationdata.downloadStatus = "synchronize_ok";
[Prefs.notificationdata.softExpiration, Prefs.notificationdata.hardExpiration] = downloader.processExpirationInterval(EXPIRATION_INTERVAL);
Prefs.notificationdata.downloadCount = downloadable.downloadCount;
saveNotificationData();
Notification.showNext();
},
_onDownloadError: function(downloadable, downloadURL, error, channelStatus, responseStatus, redirectCallback)
{
Prefs.notificationdata.lastError = Date.now();
Prefs.notificationdata.downloadStatus = error;
saveNotificationData();
},
/**
* Adds a listener for notifications to be shown.
* @param {Function} listener Listener to be invoked when a notification is
* to be shown
*/
addShowListener: function(listener)
{
if (showListeners.indexOf(listener) == -1)
showListeners.push(listener);
},
/**
* Removes the supplied listener.
* @param {Function} listener Listener that was added via addShowListener()
*/
removeShowListener: function(listener)
{
let index = showListeners.indexOf(listener);
if (index != -1)
showListeners.splice(index, 1);
},
/**
* Determines which notification is to be shown next.
* @param {String} url URL to match notifications to (optional)
* @return {Object} notification to be shown, or null if there is none
*/
_getNextToShow: function(url)
{
function checkTarget(target, parameter, name, version)
{
let minVersionKey = parameter + "MinVersion";
let maxVersionKey = parameter + "MaxVersion";
return !((parameter in target && target[parameter] != name) ||
(minVersionKey in target && Services.vc.compare(version, target[minVersionKey]) < 0) ||
(maxVersionKey in target && Services.vc.compare(version, target[maxVersionKey]) > 0));
}
let remoteData = [];
if (typeof Prefs.notificationdata.data == "object" && Prefs.notificationdata.data.notifications instanceof Array)
remoteData = Prefs.notificationdata.data.notifications;
let notifications = localData.concat(remoteData);
if (notifications.length === 0)
return null;
let {addonName, addonVersion, application, applicationVersion, platform, platformVersion} = require("info");
let notificationToShow = null;
for (let notification of notifications)
{
if (typeof notification.type === "undefined" || notification.type !== "critical")
{
let shown = Prefs.notificationdata.shown;
if (shown instanceof Array && shown.indexOf(notification.id) != -1)
continue;
if (Prefs.notifications_ignoredcategories.indexOf("*") != -1)
continue;
}
if (typeof url === "string" || notification.urlFilters instanceof Array)
{
if (Prefs.enabled && typeof url === "string" && notification.urlFilters instanceof Array)
{
let host;
try
{
host = new URL(url).hostname;
}
catch (e)
{
host = "";
}
let exception = defaultMatcher.matchesAny(url, RegExpFilter.typeMap.DOCUMENT, host, false, null);
if (exception instanceof WhitelistFilter)
continue;
let matcher = new Matcher();
for (let urlFilter of notification.urlFilters)
matcher.add(Filter.fromText(urlFilter));
if (!matcher.matchesAny(url, RegExpFilter.typeMap.DOCUMENT, host, false, null))
continue;
}
else
continue;
}
if (notification.targets instanceof Array)
{
let match = false;
for (let target of notification.targets)
{
if (checkTarget(target, "extension", addonName, addonVersion) &&
checkTarget(target, "application", application, applicationVersion) &&
checkTarget(target, "platform", platform, platformVersion))
{
match = true;
break;
}
}
if (!match)
continue;
}
if (!notificationToShow
|| getNumericalSeverity(notification) > getNumericalSeverity(notificationToShow))
notificationToShow = notification;
}
return notificationToShow;
},
/**
* Invokes the listeners added via addShowListener() with the next
* notification to be shown.
* @param {String} url URL to match notifications to (optional)
*/
showNext: function(url)
{
let notification = Notification._getNextToShow(url);
if (notification)
for (let showListener of showListeners)
showListener(notification);
},
/**
* Marks a notification as shown.
* @param {String} id ID of the notification to be marked as shown
*/
markAsShown: function(id)
{
var data = Prefs.notificationdata;
if (!(data.shown instanceof Array))
data.shown = [];
if (data.shown.indexOf(id) != -1)
return;
data.shown.push(id);
saveNotificationData();
},
/**
* Localizes the texts of the supplied notification.
* @param {Object} notification notification to translate
* @param {String} locale the target locale (optional, defaults to the
* application locale)
* @return {Object} the translated texts
*/
getLocalizedTexts: function(notification, locale)
{
locale = locale || Utils.appLocale;
let textKeys = ["title", "message"];
let localizedTexts = [];
for (let key of textKeys)
{
if (key in notification)
{
if (typeof notification[key] == "string")
localizedTexts[key] = notification[key];
else
localizedTexts[key] = localize(notification[key], locale);
}
}
return localizedTexts;
},
/**
* Adds a local notification.
* @param {Object} notification notification to add
*/
addNotification: function(notification)
{
if (localData.indexOf(notification) == -1)
localData.push(notification);
},
/**
* Removes an existing local notification.
* @param {Object} notification notification to remove
*/
removeNotification: function(notification)
{
let index = localData.indexOf(notification);
if (index > -1)
localData.splice(index, 1);
},
/**
* Adds a listener for question-type notifications
*/
addQuestionListener: function(/**string*/ id, /**function(approved)*/ listener)
{
if (!(id in questionListeners))
questionListeners[id] = [];
if (questionListeners[id].indexOf(listener) === -1)
questionListeners[id].push(listener);
},
/**
* Removes a listener that was previously added via addQuestionListener
*/
removeQuestionListener: function(/**string*/ id, /**function(approved)*/ listener)
{
if (!(id in questionListeners))
return;
let index = questionListeners[id].indexOf(listener);
if (index > -1)
questionListeners[id].splice(index, 1);
if (questionListeners[id].length === 0)
delete questionListeners[id];
},
/**
* Notifies question listeners about interactions with a notification
* @param {String} id notification ID
* @param {Boolean} approved indicator whether notification has been approved or not
*/
triggerQuestionListeners: function(id, approved)
{
if (!(id in questionListeners))
return;
let listeners = questionListeners[id];
for (let listener of listeners)
listener(approved);
},
/**
* Toggles whether notifications of a specific category should be ignored
* @param {String} category notification category identifier
* @param {Boolean} [forceValue] force specified value
*/
toggleIgnoreCategory: function(category, forceValue)
{
let categories = Prefs.notifications_ignoredcategories;
let index = categories.indexOf(category);
if (index == -1 && forceValue !== false)
{
categories.push(category);
Prefs.notifications_showui = true;
}
else if (index != -1 && forceValue !== true)
categories.splice(index, 1);
// HACK: JSON values aren't saved unless they are assigned a different object.
Prefs.notifications_ignoredcategories = JSON.parse(JSON.stringify(categories));
}
};
Notification.init();
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/subscriptionClasses.js 0000664 0000000 0000000 00000033562 12707711122 0027135 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Definition of Subscription class and its subclasses.
*/
let {ActiveFilter, BlockingFilter, WhitelistFilter, ElemHideBase} = require("filterClasses");
let {FilterNotifier} = require("filterNotifier");
/**
* Abstract base class for filter subscriptions
*
* @param {String} url download location of the subscription
* @param {String} [title] title of the filter subscription
* @constructor
*/
function Subscription(url, title)
{
this.url = url;
this.filters = [];
if (title)
this._title = title;
Subscription.knownSubscriptions[url] = this;
}
exports.Subscription = Subscription;
Subscription.prototype =
{
/**
* Download location of the subscription
* @type String
*/
url: null,
/**
* Filters contained in the filter subscription
* @type Filter[]
*/
filters: null,
_title: null,
_fixedTitle: false,
_disabled: false,
/**
* Title of the filter subscription
* @type String
*/
get title()
{
return this._title;
},
set title(value)
{
if (value != this._title)
{
let oldValue = this._title;
this._title = value;
FilterNotifier.triggerListeners("subscription.title", this, value, oldValue);
}
return this._title;
},
/**
* Determines whether the title should be editable
* @type Boolean
*/
get fixedTitle()
{
return this._fixedTitle;
},
set fixedTitle(value)
{
if (value != this._fixedTitle)
{
let oldValue = this._fixedTitle;
this._fixedTitle = value;
FilterNotifier.triggerListeners("subscription.fixedTitle", this, value, oldValue);
}
return this._fixedTitle;
},
/**
* Defines whether the filters in the subscription should be disabled
* @type Boolean
*/
get disabled()
{
return this._disabled;
},
set disabled(value)
{
if (value != this._disabled)
{
let oldValue = this._disabled;
this._disabled = value;
FilterNotifier.triggerListeners("subscription.disabled", this, value, oldValue);
}
return this._disabled;
},
/**
* Serializes the subscription to an array of strings for writing out on the disk.
* @param {string[]} buffer buffer to push the serialization results into
*/
serialize: function(buffer)
{
buffer.push("[Subscription]");
buffer.push("url=" + this.url);
if (this._title)
buffer.push("title=" + this._title);
if (this._fixedTitle)
buffer.push("fixedTitle=true");
if (this._disabled)
buffer.push("disabled=true");
},
serializeFilters: function(buffer)
{
for (let filter of this.filters)
buffer.push(filter.text.replace(/\[/g, "\\["));
},
toString: function()
{
let buffer = [];
this.serialize(buffer);
return buffer.join("\n");
}
};
/**
* Cache for known filter subscriptions, maps URL to subscription objects.
* @type Object
*/
Subscription.knownSubscriptions = Object.create(null);
/**
* Returns a subscription from its URL, creates a new one if necessary.
* @param {String} url URL of the subscription
* @return {Subscription} subscription or null if the subscription couldn't be created
*/
Subscription.fromURL = function(url)
{
if (url in Subscription.knownSubscriptions)
return Subscription.knownSubscriptions[url];
if (url[0] != "~")
return new DownloadableSubscription(url, null);
else
return new SpecialSubscription(url);
};
/**
* Deserializes a subscription
*
* @param {Object} obj map of serialized properties and their values
* @return {Subscription} subscription or null if the subscription couldn't be created
*/
Subscription.fromObject = function(obj)
{
let result;
if (obj.url[0] != "~")
{
// URL is valid - this is a downloadable subscription
result = new DownloadableSubscription(obj.url, obj.title);
if ("downloadStatus" in obj)
result._downloadStatus = obj.downloadStatus;
if ("lastSuccess" in obj)
result.lastSuccess = parseInt(obj.lastSuccess, 10) || 0;
if ("lastCheck" in obj)
result._lastCheck = parseInt(obj.lastCheck, 10) || 0;
if ("expires" in obj)
result.expires = parseInt(obj.expires, 10) || 0;
if ("softExpiration" in obj)
result.softExpiration = parseInt(obj.softExpiration, 10) || 0;
if ("errors" in obj)
result._errors = parseInt(obj.errors, 10) || 0;
if ("version" in obj)
result.version = parseInt(obj.version, 10) || 0;
if ("requiredVersion" in obj)
result.requiredVersion = obj.requiredVersion;
if ("homepage" in obj)
result._homepage = obj.homepage;
if ("lastDownload" in obj)
result._lastDownload = parseInt(obj.lastDownload, 10) || 0;
if ("downloadCount" in obj)
result.downloadCount = parseInt(obj.downloadCount, 10) || 0;
}
else
{
result = new SpecialSubscription(obj.url, obj.title);
if ("defaults" in obj)
result.defaults = obj.defaults.split(" ");
}
if ("fixedTitle" in obj)
result._fixedTitle = (obj.fixedTitle == "true");
if ("disabled" in obj)
result._disabled = (obj.disabled == "true");
return result;
};
/**
* Class for special filter subscriptions (user's filters)
* @param {String} url see Subscription()
* @param {String} [title] see Subscription()
* @constructor
* @augments Subscription
*/
function SpecialSubscription(url, title)
{
Subscription.call(this, url, title);
}
exports.SpecialSubscription = SpecialSubscription;
SpecialSubscription.prototype =
{
__proto__: Subscription.prototype,
/**
* Filter types that should be added to this subscription by default
* (entries should correspond to keys in SpecialSubscription.defaultsMap).
* @type string[]
*/
defaults: null,
/**
* Tests whether a filter should be added to this group by default
* @param {Filter} filter filter to be tested
* @return {Boolean}
*/
isDefaultFor: function(filter)
{
if (this.defaults && this.defaults.length)
{
for (let type of this.defaults)
{
if (filter instanceof SpecialSubscription.defaultsMap[type])
return true;
if (!(filter instanceof ActiveFilter) && type == "blacklist")
return true;
}
}
return false;
},
/**
* See Subscription.serialize()
*/
serialize: function(buffer)
{
Subscription.prototype.serialize.call(this, buffer);
if (this.defaults && this.defaults.length)
buffer.push("defaults=" + this.defaults.filter((type) => type in SpecialSubscription.defaultsMap).join(" "));
if (this._lastDownload)
buffer.push("lastDownload=" + this._lastDownload);
}
};
SpecialSubscription.defaultsMap = {
__proto__: null,
"whitelist": WhitelistFilter,
"blocking": BlockingFilter,
"elemhide": ElemHideBase
};
/**
* Creates a new user-defined filter group.
* @param {String} [title] title of the new filter group
* @result {SpecialSubscription}
*/
SpecialSubscription.create = function(title)
{
let url;
do
{
url = "~user~" + Math.round(Math.random()*1000000);
} while (url in Subscription.knownSubscriptions);
return new SpecialSubscription(url, title);
};
/**
* Creates a new user-defined filter group and adds the given filter to it.
* This group will act as the default group for this filter type.
*/
SpecialSubscription.createForFilter = function(/**Filter*/ filter) /**SpecialSubscription*/
{
let subscription = SpecialSubscription.create();
subscription.filters.push(filter);
for (let type in SpecialSubscription.defaultsMap)
{
if (filter instanceof SpecialSubscription.defaultsMap[type])
subscription.defaults = [type];
}
if (!subscription.defaults)
subscription.defaults = ["blocking"];
return subscription;
};
/**
* Abstract base class for regular filter subscriptions (both internally and externally updated)
* @param {String} url see Subscription()
* @param {String} [title] see Subscription()
* @constructor
* @augments Subscription
*/
function RegularSubscription(url, title)
{
Subscription.call(this, url, title || url);
}
exports.RegularSubscription = RegularSubscription;
RegularSubscription.prototype =
{
__proto__: Subscription.prototype,
_homepage: null,
_lastDownload: 0,
/**
* Filter subscription homepage if known
* @type String
*/
get homepage()
{
return this._homepage;
},
set homepage(value)
{
if (value != this._homepage)
{
let oldValue = this._homepage;
this._homepage = value;
FilterNotifier.triggerListeners("subscription.homepage", this, value, oldValue);
}
return this._homepage;
},
/**
* Time of the last subscription download (in seconds since the beginning of the epoch)
* @type Number
*/
get lastDownload()
{
return this._lastDownload;
},
set lastDownload(value)
{
if (value != this._lastDownload)
{
let oldValue = this._lastDownload;
this._lastDownload = value;
FilterNotifier.triggerListeners("subscription.lastDownload", this, value, oldValue);
}
return this._lastDownload;
},
/**
* See Subscription.serialize()
*/
serialize: function(buffer)
{
Subscription.prototype.serialize.call(this, buffer);
if (this._homepage)
buffer.push("homepage=" + this._homepage);
if (this._lastDownload)
buffer.push("lastDownload=" + this._lastDownload);
}
};
/**
* Class for filter subscriptions updated externally (by other extension)
* @param {String} url see Subscription()
* @param {String} [title] see Subscription()
* @constructor
* @augments RegularSubscription
*/
function ExternalSubscription(url, title)
{
RegularSubscription.call(this, url, title);
}
exports.ExternalSubscription = ExternalSubscription;
ExternalSubscription.prototype =
{
__proto__: RegularSubscription.prototype,
/**
* See Subscription.serialize()
*/
serialize: function(buffer)
{
throw new Error("Unexpected call, external subscriptions should not be serialized");
}
};
/**
* Class for filter subscriptions updated externally (by other extension)
* @param {String} url see Subscription()
* @param {String} [title] see Subscription()
* @constructor
* @augments RegularSubscription
*/
function DownloadableSubscription(url, title)
{
RegularSubscription.call(this, url, title);
}
exports.DownloadableSubscription = DownloadableSubscription;
DownloadableSubscription.prototype =
{
__proto__: RegularSubscription.prototype,
_downloadStatus: null,
_lastCheck: 0,
_errors: 0,
/**
* Status of the last download (ID of a string)
* @type String
*/
get downloadStatus()
{
return this._downloadStatus;
},
set downloadStatus(value)
{
let oldValue = this._downloadStatus;
this._downloadStatus = value;
FilterNotifier.triggerListeners("subscription.downloadStatus", this, value, oldValue);
return this._downloadStatus;
},
/**
* Time of the last successful download (in seconds since the beginning of the
* epoch).
*/
lastSuccess: 0,
/**
* Time when the subscription was considered for an update last time (in seconds
* since the beginning of the epoch). This will be used to increase softExpiration
* if the user doesn't use Adblock Plus for some time.
* @type Number
*/
get lastCheck()
{
return this._lastCheck;
},
set lastCheck(value)
{
if (value != this._lastCheck)
{
let oldValue = this._lastCheck;
this._lastCheck = value;
FilterNotifier.triggerListeners("subscription.lastCheck", this, value, oldValue);
}
return this._lastCheck;
},
/**
* Hard expiration time of the filter subscription (in seconds since the beginning of the epoch)
* @type Number
*/
expires: 0,
/**
* Soft expiration time of the filter subscription (in seconds since the beginning of the epoch)
* @type Number
*/
softExpiration: 0,
/**
* Number of download failures since last success
* @type Number
*/
get errors()
{
return this._errors;
},
set errors(value)
{
if (value != this._errors)
{
let oldValue = this._errors;
this._errors = value;
FilterNotifier.triggerListeners("subscription.errors", this, value, oldValue);
}
return this._errors;
},
/**
* Version of the subscription data retrieved on last successful download
* @type Number
*/
version: 0,
/**
* Minimal Adblock Plus version required for this subscription
* @type String
*/
requiredVersion: null,
/**
* Number indicating how often the object was downloaded.
* @type Number
*/
downloadCount: 0,
/**
* See Subscription.serialize()
*/
serialize: function(buffer)
{
RegularSubscription.prototype.serialize.call(this, buffer);
if (this.downloadStatus)
buffer.push("downloadStatus=" + this.downloadStatus);
if (this.lastSuccess)
buffer.push("lastSuccess=" + this.lastSuccess);
if (this.lastCheck)
buffer.push("lastCheck=" + this.lastCheck);
if (this.expires)
buffer.push("expires=" + this.expires);
if (this.softExpiration)
buffer.push("softExpiration=" + this.softExpiration);
if (this.errors)
buffer.push("errors=" + this.errors);
if (this.version)
buffer.push("version=" + this.version);
if (this.requiredVersion)
buffer.push("requiredVersion=" + this.requiredVersion);
if (this.downloadCount)
buffer.push("downloadCount=" + this.downloadCount);
}
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/lib/synchronizer.js 0000664 0000000 0000000 00000025367 12707711122 0025634 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
/**
* @fileOverview Manages synchronization of filter subscriptions.
*/
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
var {Downloader, Downloadable,
MILLIS_IN_SECOND, MILLIS_IN_MINUTE, MILLIS_IN_HOUR, MILLIS_IN_DAY} = require("downloader");
var {Filter, CommentFilter} = require("filterClasses");
var {FilterStorage} = require("filterStorage");
var {FilterNotifier} = require("filterNotifier");
var {Prefs} = require("prefs");
var {Subscription, DownloadableSubscription} = require("subscriptionClasses");
var {Utils} = require("utils");
var INITIAL_DELAY = 1 * MILLIS_IN_MINUTE;
var CHECK_INTERVAL = 1 * MILLIS_IN_HOUR;
var DEFAULT_EXPIRATION_INTERVAL = 5 * MILLIS_IN_DAY;
/**
* The object providing actual downloading functionality.
* @type Downloader
*/
var downloader = null;
/**
* This object is responsible for downloading filter subscriptions whenever
* necessary.
* @class
*/
var Synchronizer = exports.Synchronizer =
{
/**
* Called on module startup.
*/
init: function()
{
downloader = new Downloader(this._getDownloadables.bind(this), INITIAL_DELAY, CHECK_INTERVAL);
onShutdown.add(function()
{
downloader.cancel();
});
downloader.onExpirationChange = this._onExpirationChange.bind(this);
downloader.onDownloadStarted = this._onDownloadStarted.bind(this);
downloader.onDownloadSuccess = this._onDownloadSuccess.bind(this);
downloader.onDownloadError = this._onDownloadError.bind(this);
},
/**
* Checks whether a subscription is currently being downloaded.
* @param {String} url URL of the subscription
* @return {Boolean}
*/
isExecuting: function(url)
{
return downloader.isDownloading(url);
},
/**
* Starts the download of a subscription.
* @param {DownloadableSubscription} subscription Subscription to be downloaded
* @param {Boolean} manual true for a manually started download (should not trigger fallback requests)
*/
execute: function(subscription, manual)
{
downloader.download(this._getDownloadable(subscription, manual));
},
/**
* Yields Downloadable instances for all subscriptions that can be downloaded.
*/
_getDownloadables: function*()
{
if (!Prefs.subscriptions_autoupdate)
return;
for (let subscription of FilterStorage.subscriptions)
{
if (subscription instanceof DownloadableSubscription)
yield this._getDownloadable(subscription, false);
}
},
/**
* Creates a Downloadable instance for a subscription.
*/
_getDownloadable: function(/**Subscription*/ subscription, /**Boolean*/ manual) /**Downloadable*/
{
let result = new Downloadable(subscription.url);
if (subscription.lastDownload != subscription.lastSuccess)
result.lastError = subscription.lastDownload * MILLIS_IN_SECOND;
result.lastCheck = subscription.lastCheck * MILLIS_IN_SECOND;
result.lastVersion = subscription.version;
result.softExpiration = subscription.softExpiration * MILLIS_IN_SECOND;
result.hardExpiration = subscription.expires * MILLIS_IN_SECOND;
result.manual = manual;
result.downloadCount = subscription.downloadCount;
return result;
},
_onExpirationChange: function(downloadable)
{
let subscription = Subscription.fromURL(downloadable.url);
subscription.lastCheck = Math.round(downloadable.lastCheck / MILLIS_IN_SECOND);
subscription.softExpiration = Math.round(downloadable.softExpiration / MILLIS_IN_SECOND);
subscription.expires = Math.round(downloadable.hardExpiration / MILLIS_IN_SECOND);
},
_onDownloadStarted: function(downloadable)
{
let subscription = Subscription.fromURL(downloadable.url);
FilterNotifier.triggerListeners("subscription.downloading", subscription);
},
_onDownloadSuccess: function(downloadable, responseText, errorCallback, redirectCallback)
{
let lines = responseText.split(/[\r\n]+/);
let match = /\[Adblock(?:\s*Plus\s*([\d\.]+)?)?\]/i.exec(lines[0]);
if (!match)
return errorCallback("synchronize_invalid_data");
let minVersion = match[1];
// Don't remove parameter comments immediately but add them to a list first,
// they need to be considered in the checksum calculation.
let remove = [];
let params = {
redirect: null,
homepage: null,
title: null,
version: null,
expires: null
};
for (let i = 0; i < lines.length; i++)
{
let match = /^\s*!\s*(\w+)\s*:\s*(.*)/.exec(lines[i]);
if (match)
{
let keyword = match[1].toLowerCase();
let value = match[2];
if (keyword in params)
{
params[keyword] = value;
remove.push(i);
}
else if (keyword == "checksum")
{
lines.splice(i--, 1);
let checksum = Utils.generateChecksum(lines);
if (checksum && checksum != value.replace(/=+$/, ""))
return errorCallback("synchronize_checksum_mismatch");
}
}
}
if (params.redirect)
return redirectCallback(params.redirect);
// Handle redirects
let subscription = Subscription.fromURL(downloadable.redirectURL || downloadable.url);
if (downloadable.redirectURL && downloadable.redirectURL != downloadable.url)
{
let oldSubscription = Subscription.fromURL(downloadable.url);
subscription.title = oldSubscription.title;
subscription.disabled = oldSubscription.disabled;
subscription.lastCheck = oldSubscription.lastCheck;
let listed = (oldSubscription.url in FilterStorage.knownSubscriptions);
if (listed)
FilterStorage.removeSubscription(oldSubscription);
delete Subscription.knownSubscriptions[oldSubscription.url];
if (listed)
FilterStorage.addSubscription(subscription);
}
// The download actually succeeded
subscription.lastSuccess = subscription.lastDownload = Math.round(Date.now() / MILLIS_IN_SECOND);
subscription.downloadStatus = "synchronize_ok";
subscription.downloadCount = downloadable.downloadCount;
subscription.errors = 0;
// Remove lines containing parameters
for (let i = remove.length - 1; i >= 0; i--)
lines.splice(remove[i], 1);
// Process parameters
if (params.homepage)
{
let url;
try
{
url = new URL(params.homepage);
}
catch (e)
{
url = null;
}
if (url && (url.protocol == "http:" || url.protocol == "https:"))
subscription.homepage = url.href;
}
if (params.title)
{
subscription.title = params.title;
subscription.fixedTitle = true;
}
else
subscription.fixedTitle = false;
subscription.version = (params.version ? parseInt(params.version, 10) : 0);
let expirationInterval = DEFAULT_EXPIRATION_INTERVAL;
if (params.expires)
{
let match = /^(\d+)\s*(h)?/.exec(params.expires);
if (match)
{
let interval = parseInt(match[1], 10);
if (match[2])
expirationInterval = interval * MILLIS_IN_HOUR;
else
expirationInterval = interval * MILLIS_IN_DAY;
}
}
let [softExpiration, hardExpiration] = downloader.processExpirationInterval(expirationInterval);
subscription.softExpiration = Math.round(softExpiration / MILLIS_IN_SECOND);
subscription.expires = Math.round(hardExpiration / MILLIS_IN_SECOND);
if (minVersion)
subscription.requiredVersion = minVersion;
else
delete subscription.requiredVersion;
// Process filters
lines.shift();
let filters = [];
for (let line of lines)
{
line = Filter.normalize(line);
if (line)
filters.push(Filter.fromText(line));
}
FilterStorage.updateSubscriptionFilters(subscription, filters);
return undefined;
},
_onDownloadError: function(downloadable, downloadURL, error, channelStatus, responseStatus, redirectCallback)
{
let subscription = Subscription.fromURL(downloadable.url);
subscription.lastDownload = Math.round(Date.now() / MILLIS_IN_SECOND);
subscription.downloadStatus = error;
// Request fallback URL if necessary - for automatic updates only
if (!downloadable.manual)
{
subscription.errors++;
if (redirectCallback && subscription.errors >= Prefs.subscriptions_fallbackerrors && /^https?:\/\//i.test(subscription.url))
{
subscription.errors = 0;
let fallbackURL = Prefs.subscriptions_fallbackurl;
let {addonVersion} = require("info");
fallbackURL = fallbackURL.replace(/%VERSION%/g, encodeURIComponent(addonVersion));
fallbackURL = fallbackURL.replace(/%SUBSCRIPTION%/g, encodeURIComponent(subscription.url));
fallbackURL = fallbackURL.replace(/%URL%/g, encodeURIComponent(downloadURL));
fallbackURL = fallbackURL.replace(/%ERROR%/g, encodeURIComponent(error));
fallbackURL = fallbackURL.replace(/%CHANNELSTATUS%/g, encodeURIComponent(channelStatus));
fallbackURL = fallbackURL.replace(/%RESPONSESTATUS%/g, encodeURIComponent(responseStatus));
let request = new XMLHttpRequest();
request.mozBackgroundRequest = true;
request.open("GET", fallbackURL);
request.overrideMimeType("text/plain");
request.channel.loadFlags = request.channel.loadFlags |
request.channel.INHIBIT_CACHING |
request.channel.VALIDATE_ALWAYS;
request.addEventListener("load", function(ev)
{
if (onShutdown.done)
return;
if (!(subscription.url in FilterStorage.knownSubscriptions))
return;
let match = /^(\d+)(?:\s+(\S+))?$/.exec(request.responseText);
if (match && match[1] == "301" && match[2] && /^https?:\/\//i.test(match[2])) // Moved permanently
redirectCallback(match[2]);
else if (match && match[1] == "410") // Gone
{
let data = "[Adblock]\n" + subscription.filters.map((f) => f.text).join("\n");
redirectCallback("data:text/plain," + encodeURIComponent(data));
}
}, false);
request.send(null);
}
}
},
};
Synchronizer.init();
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/package.json 0000664 0000000 0000000 00000000354 12707711122 0024246 0 ustar 00root root 0000000 0000000 {
"name": "adblockpluscore",
"license": "GPL-3.0",
"dependencies": {},
"devDependencies": {
"node-babel": "0.1.2",
"nodeunit": "0.9.1"
},
"scripts": {
"test": "NODE_PATH=lib node --harmony test_wrapper.js"
}
}
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/test/ 0000775 0000000 0000000 00000000000 12707711122 0022735 5 ustar 00root root 0000000 0000000 adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/test/filterClasses.js 0000664 0000000 0000000 00000043506 12707711122 0026106 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
"use strict";
let {
Filter, InvalidFilter, CommentFilter, ActiveFilter, RegExpFilter,
BlockingFilter, WhitelistFilter, ElemHideBase, ElemHideFilter,
ElemHideException, CSSPropertyFilter
} = require("../lib/filterClasses");
function serializeFilter(filter)
{
// Filter serialization only writes out essential properties, need to do a full serialization here
let result = [];
result.push("text=" + filter.text);
if (filter instanceof InvalidFilter)
{
result.push("type=invalid");
result.push("reason=" + filter.reason);
}
else if (filter instanceof CommentFilter)
{
result.push("type=comment");
}
else if (filter instanceof ActiveFilter)
{
result.push("disabled=" + filter.disabled);
result.push("lastHit=" + filter.lastHit);
result.push("hitCount=" + filter.hitCount);
let domains = [];
if (filter.domains)
{
for (let domain in filter.domains)
if (domain != "")
domains.push(filter.domains[domain] ? domain : "~" + domain);
}
result.push("domains=" + domains.sort().join("|"));
if (filter instanceof RegExpFilter)
{
result.push("regexp=" + filter.regexp.source);
result.push("contentType=" + filter.contentType);
result.push("matchCase=" + filter.matchCase);
let sitekeys = filter.sitekeys || [];
result.push("sitekeys=" + sitekeys.slice().sort().join("|"));
result.push("thirdParty=" + filter.thirdParty);
if (filter instanceof BlockingFilter)
{
result.push("type=filterlist");
result.push("collapse=" + filter.collapse);
}
else if (filter instanceof WhitelistFilter)
{
result.push("type=whitelist");
}
}
else if (filter instanceof ElemHideBase)
{
if (filter instanceof ElemHideFilter)
result.push("type=elemhide");
else if (filter instanceof ElemHideException)
result.push("type=elemhideexception");
else if (filter instanceof CSSPropertyFilter)
{
result.push("type=cssrule");
result.push("prefix=" + (filter.selectorPrefix || ""));
result.push("regexp=" + filter.regexpString);
result.push("suffix=" + (filter.selectorSuffix || ""));
}
result.push("selectorDomain=" + (filter.selectorDomain || ""));
result.push("selector=" + filter.selector);
}
}
return result;
}
function addDefaults(expected)
{
let type = null;
let hasProperty = {};
for (let entry of expected)
{
if (/^type=(.*)/.test(entry))
type = RegExp.$1;
else if (/^(\w+)/.test(entry))
hasProperty[RegExp.$1] = true;
}
function addProperty(prop, value)
{
if (!(prop in hasProperty))
expected.push(prop + "=" + value);
}
if (type == "whitelist" || type == "filterlist" || type == "elemhide" || type == "elemhideexception" || type == "cssrule")
{
addProperty("disabled", "false");
addProperty("lastHit", "0");
addProperty("hitCount", "0");
}
if (type == "whitelist" || type == "filterlist")
{
addProperty("contentType", 0x7FFFFFFF & ~(
RegExpFilter.typeMap.DOCUMENT | RegExpFilter.typeMap.ELEMHIDE |
RegExpFilter.typeMap.POPUP | RegExpFilter.typeMap.GENERICHIDE |
RegExpFilter.typeMap.GENERICBLOCK
));
addProperty("matchCase", "false");
addProperty("thirdParty", "null");
addProperty("domains", "");
addProperty("sitekeys", "");
}
if (type == "filterlist")
{
addProperty("collapse", "null");
}
if (type == "elemhide" || type == "elemhideexception" || type == "cssrule")
{
addProperty("selectorDomain", "");
addProperty("domains", "");
}
if (type == "cssrule")
{
addProperty("regexp", "");
addProperty("prefix", "");
addProperty("suffix", "");
}
}
function compareFilter(test, text, expected, postInit)
{
addDefaults(expected);
let filter = Filter.fromText(text);
if (postInit)
postInit(filter)
let result = serializeFilter(filter);
test.equal(result.sort().join("\n"), expected.sort().join("\n"), text);
// Test round-trip
let filter2;
let buffer = [];
filter.serialize(buffer);
if (buffer.length)
{
let map = Object.create(null);
for (let line of buffer.slice(1))
{
if (/(.*?)=(.*)/.test(line))
map[RegExp.$1] = RegExp.$2;
}
filter2 = Filter.fromObject(map);
}
else
{
filter2 = Filter.fromText(filter.text);
}
test.equal(serializeFilter(filter).join("\n"), serializeFilter(filter2).join("\n"), text + " deserialization");
}
exports.testFilterClassDefinitions = function(test)
{
test.equal(typeof Filter, "function", "typeof Filter");
test.equal(typeof InvalidFilter, "function", "typeof InvalidFilter");
test.equal(typeof CommentFilter, "function", "typeof CommentFilter");
test.equal(typeof ActiveFilter, "function", "typeof ActiveFilter");
test.equal(typeof RegExpFilter, "function", "typeof RegExpFilter");
test.equal(typeof BlockingFilter, "function", "typeof BlockingFilter");
test.equal(typeof WhitelistFilter, "function", "typeof WhitelistFilter");
test.equal(typeof ElemHideBase, "function", "typeof ElemHideBase");
test.equal(typeof ElemHideFilter, "function", "typeof ElemHideFilter");
test.equal(typeof ElemHideException, "function", "typeof ElemHideException");
test.equal(typeof CSSPropertyFilter, "function", "typeof CSSPropertyFilter");
test.done();
};
exports.testComments = function(test)
{
compareFilter(test, "!asdf", ["type=comment", "text=!asdf"]);
compareFilter(test, "!foo#bar", ["type=comment", "text=!foo#bar"]);
compareFilter(test, "!foo##bar", ["type=comment", "text=!foo##bar"]);
test.done();
};
exports.testInvalidFilters = function(test)
{
compareFilter(test, "/??/", ["type=invalid", "text=/??/", "reason=filter_invalid_regexp"]);
compareFilter(test, "asd$foobar", ["type=invalid", "text=asd$foobar", "reason=filter_unknown_option"]);
compareFilter(test, "#dd(asd)(ddd)", ["type=invalid", "text=#dd(asd)(ddd)", "reason=filter_elemhide_duplicate_id"]);
compareFilter(test, "#*", ["type=invalid", "text=#*", "reason=filter_elemhide_nocriteria"]);
function compareCSSRule(domains)
{
let filterText = domains + "##[-abp-properties='abc']";
compareFilter(test, filterText, ["type=invalid", "text=" + filterText, "reason=filter_cssproperty_nodomain"]);
}
compareCSSRule("");
compareCSSRule("~foo.com");
compareCSSRule("~foo.com,~bar.com");
compareCSSRule("foo");
compareCSSRule("~foo.com,bar");
test.done();
};
exports.testFiltersWithState = function(test)
{
compareFilter(test, "blabla", ["type=filterlist", "text=blabla", "regexp=blabla"]);
compareFilter(test, "blabla_default", ["type=filterlist", "text=blabla_default", "regexp=blabla_default"], function(filter)
{
filter.disabled = false;
filter.hitCount = 0;
filter.lastHit = 0;
});
compareFilter(test, "blabla_non_default", ["type=filterlist", "text=blabla_non_default", "regexp=blabla_non_default", "disabled=true", "hitCount=12", "lastHit=20"], function(filter)
{
filter.disabled = true;
filter.hitCount = 12;
filter.lastHit = 20;
});
test.done();
};
let t = RegExpFilter.typeMap;
let defaultTypes = 0x7FFFFFFF & ~(t.ELEMHIDE | t.DOCUMENT | t.POPUP | t.GENERICHIDE | t.GENERICBLOCK);
exports.testSpecialCharacters = function(test)
{
compareFilter(test, "/ddd|f?a[s]d/", ["type=filterlist", "text=/ddd|f?a[s]d/", "regexp=ddd|f?a[s]d"]);
compareFilter(test, "*asdf*d**dd*", ["type=filterlist", "text=*asdf*d**dd*", "regexp=asdf.*d.*dd"]);
compareFilter(test, "|*asd|f*d**dd*|", ["type=filterlist", "text=|*asd|f*d**dd*|", "regexp=^.*asd\\|f.*d.*dd.*$"]);
compareFilter(test, "dd[]{}$%<>&()d", ["type=filterlist", "text=dd[]{}$%<>&()d", "regexp=dd\\[\\]\\{\\}\\$\\%\\<\\>\\&\\(\\)d"]);
compareFilter(test, "@@/ddd|f?a[s]d/", ["type=whitelist", "text=@@/ddd|f?a[s]d/", "regexp=ddd|f?a[s]d", "contentType=" + defaultTypes]);
compareFilter(test, "@@*asdf*d**dd*", ["type=whitelist", "text=@@*asdf*d**dd*", "regexp=asdf.*d.*dd", "contentType=" + defaultTypes]);
compareFilter(test, "@@|*asd|f*d**dd*|", ["type=whitelist", "text=@@|*asd|f*d**dd*|", "regexp=^.*asd\\|f.*d.*dd.*$", "contentType=" + defaultTypes]);
compareFilter(test, "@@dd[]{}$%<>&()d", ["type=whitelist", "text=@@dd[]{}$%<>&()d", "regexp=dd\\[\\]\\{\\}\\$\\%\\<\\>\\&\\(\\)d", "contentType=" + defaultTypes]);
test.done();
};
exports.testFilterOptions = function(test)
{
compareFilter(test, "bla$match-case,script,other,third-party,domain=foo.com,sitekey=foo", ["type=filterlist", "text=bla$match-case,script,other,third-party,domain=foo.com,sitekey=foo", "regexp=bla", "matchCase=true", "contentType=" + (t.SCRIPT | t.OTHER), "thirdParty=true", "domains=FOO.COM", "sitekeys=FOO"]);
compareFilter(test, "bla$~match-case,~script,~other,~third-party,domain=~bar.com", ["type=filterlist", "text=bla$~match-case,~script,~other,~third-party,domain=~bar.com", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER)), "thirdParty=false", "domains=~BAR.COM"]);
compareFilter(test, "@@bla$match-case,script,other,third-party,domain=foo.com|bar.com|~bar.foo.com|~foo.bar.com,sitekey=foo|bar", ["type=whitelist", "text=@@bla$match-case,script,other,third-party,domain=foo.com|bar.com|~bar.foo.com|~foo.bar.com,sitekey=foo|bar", "regexp=bla", "matchCase=true", "contentType=" + (t.SCRIPT | t.OTHER), "thirdParty=true", "domains=BAR.COM|FOO.COM|~BAR.FOO.COM|~FOO.BAR.COM", "sitekeys=BAR|FOO"]);
// background and image should be the same for backwards compatibility
compareFilter(test, "bla$image", ["type=filterlist", "text=bla$image", "regexp=bla", "contentType=" + (t.IMAGE)]);
compareFilter(test, "bla$background", ["type=filterlist", "text=bla$background", "regexp=bla", "contentType=" + (t.IMAGE)]);
compareFilter(test, "bla$~image", ["type=filterlist", "text=bla$~image", "regexp=bla", "contentType=" + (defaultTypes & ~t.IMAGE)]);
compareFilter(test, "bla$~background", ["type=filterlist", "text=bla$~background", "regexp=bla", "contentType=" + (defaultTypes & ~t.IMAGE)]);
compareFilter(test, "@@bla$~script,~other", ["type=whitelist", "text=@@bla$~script,~other", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER))]);
compareFilter(test, "@@http://bla$~script,~other", ["type=whitelist", "text=@@http://bla$~script,~other", "regexp=http\\:\\/\\/bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER))]);
compareFilter(test, "@@|ftp://bla$~script,~other", ["type=whitelist", "text=@@|ftp://bla$~script,~other", "regexp=^ftp\\:\\/\\/bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER))]);
compareFilter(test, "@@bla$~script,~other,document", ["type=whitelist", "text=@@bla$~script,~other,document", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER) | t.DOCUMENT)]);
compareFilter(test, "@@bla$~script,~other,~document", ["type=whitelist", "text=@@bla$~script,~other,~document", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER))]);
compareFilter(test, "@@bla$document", ["type=whitelist", "text=@@bla$document", "regexp=bla", "contentType=" + t.DOCUMENT]);
compareFilter(test, "@@bla$~script,~other,elemhide", ["type=whitelist", "text=@@bla$~script,~other,elemhide", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER) | t.ELEMHIDE)]);
compareFilter(test, "@@bla$~script,~other,~elemhide", ["type=whitelist", "text=@@bla$~script,~other,~elemhide", "regexp=bla", "contentType=" + (defaultTypes & ~(t.SCRIPT | t.OTHER))]);
compareFilter(test, "@@bla$elemhide", ["type=whitelist", "text=@@bla$elemhide", "regexp=bla", "contentType=" + t.ELEMHIDE]);
compareFilter(test, "@@bla$~script,~other,donottrack", ["type=invalid", "text=@@bla$~script,~other,donottrack", "reason=filter_unknown_option"]);
compareFilter(test, "@@bla$~script,~other,~donottrack", ["type=invalid", "text=@@bla$~script,~other,~donottrack", "reason=filter_unknown_option"]);
compareFilter(test, "@@bla$donottrack", ["type=invalid", "text=@@bla$donottrack", "reason=filter_unknown_option"]);
compareFilter(test, "@@bla$foobar", ["type=invalid", "text=@@bla$foobar", "reason=filter_unknown_option"]);
compareFilter(test, "@@bla$image,foobar", ["type=invalid", "text=@@bla$image,foobar", "reason=filter_unknown_option"]);
compareFilter(test, "@@bla$foobar,image", ["type=invalid", "text=@@bla$foobar,image", "reason=filter_unknown_option"]);
test.done();
};
exports.testElementHidingRules = function(test)
{
compareFilter(test, "#ddd", ["type=elemhide", "text=#ddd", "selector=ddd"]);
compareFilter(test, "#ddd(fff)", ["type=elemhide", "text=#ddd(fff)", "selector=ddd.fff,ddd#fff"]);
compareFilter(test, "#ddd(foo=bar)(foo2^=bar2)(foo3*=bar3)(foo4$=bar4)", ["type=elemhide", "text=#ddd(foo=bar)(foo2^=bar2)(foo3*=bar3)(foo4$=bar4)", 'selector=ddd[foo="bar"][foo2^="bar2"][foo3*="bar3"][foo4$="bar4"]']);
compareFilter(test, "#ddd(fff)(foo=bar)", ["type=elemhide", "text=#ddd(fff)(foo=bar)", 'selector=ddd.fff[foo="bar"],ddd#fff[foo="bar"]']);
compareFilter(test, "#*(fff)", ["type=elemhide", "text=#*(fff)", "selector=.fff,#fff"]);
compareFilter(test, "#*(foo=bar)", ["type=elemhide", "text=#*(foo=bar)", 'selector=[foo="bar"]']);
compareFilter(test, "##body > div:first-child", ["type=elemhide", "text=##body > div:first-child", "selector=body > div:first-child"]);
compareFilter(test, "foo#ddd", ["type=elemhide", "text=foo#ddd", "selectorDomain=foo", "selector=ddd", "domains=FOO"]);
compareFilter(test, "foo,bar#ddd", ["type=elemhide", "text=foo,bar#ddd", "selectorDomain=foo,bar", "selector=ddd", "domains=BAR|FOO"]);
compareFilter(test, "foo,~bar#ddd", ["type=elemhide", "text=foo,~bar#ddd", "selectorDomain=foo", "selector=ddd", "domains=FOO|~BAR"]);
compareFilter(test, "foo,~baz,bar#ddd", ["type=elemhide", "text=foo,~baz,bar#ddd", "selectorDomain=foo,bar", "selector=ddd", "domains=BAR|FOO|~BAZ"]);
test.done();
};
exports.testElementHidingExceptions = function(test)
{
compareFilter(test, "#@ddd", ["type=elemhideexception", "text=#@ddd", "selector=ddd"]);
compareFilter(test, "#@ddd(fff)", ["type=elemhideexception", "text=#@ddd(fff)", "selector=ddd.fff,ddd#fff"]);
compareFilter(test, "#@ddd(foo=bar)(foo2^=bar2)(foo3*=bar3)(foo4$=bar4)", ["type=elemhideexception", "text=#@ddd(foo=bar)(foo2^=bar2)(foo3*=bar3)(foo4$=bar4)", 'selector=ddd[foo="bar"][foo2^="bar2"][foo3*="bar3"][foo4$="bar4"]']);
compareFilter(test, "#@ddd(fff)(foo=bar)", ["type=elemhideexception", "text=#@ddd(fff)(foo=bar)", 'selector=ddd.fff[foo="bar"],ddd#fff[foo="bar"]']);
compareFilter(test, "#@*(fff)", ["type=elemhideexception", "text=#@*(fff)", "selector=.fff,#fff"]);
compareFilter(test, "#@*(foo=bar)", ["type=elemhideexception", "text=#@*(foo=bar)", 'selector=[foo="bar"]']);
compareFilter(test, "#@#body > div:first-child", ["type=elemhideexception", "text=#@#body > div:first-child", "selector=body > div:first-child"]);
compareFilter(test, "foo#@ddd", ["type=elemhideexception", "text=foo#@ddd", "selectorDomain=foo", "selector=ddd", "domains=FOO"]);
compareFilter(test, "foo,bar#@ddd", ["type=elemhideexception", "text=foo,bar#@ddd", "selectorDomain=foo,bar", "selector=ddd", "domains=BAR|FOO"]);
compareFilter(test, "foo,~bar#@ddd", ["type=elemhideexception", "text=foo,~bar#@ddd", "selectorDomain=foo", "selector=ddd", "domains=FOO|~BAR"]);
compareFilter(test, "foo,~baz,bar#@ddd", ["type=elemhideexception", "text=foo,~baz,bar#@ddd", "selectorDomain=foo,bar", "selector=ddd", "domains=BAR|FOO|~BAZ"]);
test.done();
};
exports.testCSSPropertyFilters = function(test)
{
// Check valid domain combinations
compareFilter(test, "foo.com##[-abp-properties='abc']", ["type=cssrule", "text=foo.com##[-abp-properties='abc']", "selectorDomain=foo.com", "selector=[-abp-properties='abc']", "domains=FOO.COM", "regexp=abc"]);
compareFilter(test, "foo.com,~bar.com##[-abp-properties='abc']", ["type=cssrule", "text=foo.com,~bar.com##[-abp-properties='abc']", "selectorDomain=foo.com", "selector=[-abp-properties='abc']", "domains=FOO.COM|~BAR.COM", "regexp=abc"]);
compareFilter(test, "foo.com,~bar##[-abp-properties='abc']", ["type=cssrule", "text=foo.com,~bar##[-abp-properties='abc']", "selectorDomain=foo.com", "selector=[-abp-properties='abc']", "domains=FOO.COM|~BAR", "regexp=abc"]);
compareFilter(test, "~foo.com,bar.com##[-abp-properties='abc']", ["type=cssrule", "text=~foo.com,bar.com##[-abp-properties='abc']", "selectorDomain=bar.com", "selector=[-abp-properties='abc']", "domains=BAR.COM|~FOO.COM", "regexp=abc"]);
compareFilter(test, "##[-abp-properties='']", ["type=elemhide", "text=##[-abp-properties='']", "selector=[-abp-properties='']"]);
compareFilter(test, "foo.com#@#[-abp-properties='abc']", ["type=elemhideexception", "text=foo.com#@#[-abp-properties='abc']", "selectorDomain=foo.com", "selector=[-abp-properties='abc']", "domains=FOO.COM"]);
compareFilter(test, "foo.com##aaa [-abp-properties='abc'] bbb", ["type=cssrule", "text=foo.com##aaa [-abp-properties='abc'] bbb", "selectorDomain=foo.com", "selector=aaa [-abp-properties='abc'] bbb", "domains=FOO.COM", "prefix=aaa ", "regexp=abc", "suffix= bbb"]);
compareFilter(test, "foo.com##[-abp-properties='|background-image: url(data:*)']", ["type=cssrule", "text=foo.com##[-abp-properties='|background-image: url(data:*)']", "selectorDomain=foo.com", "selector=[-abp-properties='|background-image: url(data:*)']", "domains=FOO.COM", "regexp=^background\\-image\\:\\ url\\(data\\:.*\\)"]);
test.done();
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/test/subscriptionClasses.js 0000664 0000000 0000000 00000006440 12707711122 0027341 0 ustar 00root root 0000000 0000000 /*
* This file is part of Adblock Plus ,
* Copyright (C) 2006-2016 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Adblock Plus. If not, see .
*/
"use strict";
let {
Subscription, SpecialSubscription, DownloadableSubscription,
RegularSubscription, ExternalSubscription
} = require("../lib/subscriptionClasses");
function compareSubscription(test, url, expected, postInit)
{
expected.push("[Subscription]")
let subscription = Subscription.fromURL(url);
if (postInit)
postInit(subscription)
let result = [];
subscription.serialize(result);
test.equal(result.sort().join("\n"), expected.sort().join("\n"), url);
let map = Object.create(null);
for (let line of result.slice(1))
{
if (/(.*?)=(.*)/.test(line))
map[RegExp.$1] = RegExp.$2;
}
let subscription2 = Subscription.fromObject(map);
test.equal(subscription.toString(), subscription2.toString(), url + " deserialization");
}
exports.testSubscriptionClassDefinitions = function(test)
{
test.equal(typeof Subscription, "function", "typeof Subscription");
test.equal(typeof SpecialSubscription, "function", "typeof SpecialSubscription");
test.equal(typeof RegularSubscription, "function", "typeof RegularSubscription");
test.equal(typeof ExternalSubscription, "function", "typeof ExternalSubscription");
test.equal(typeof DownloadableSubscription, "function", "typeof DownloadableSubscription");
test.done();
};
exports.testSubscriptionsWithState = function(test)
{
compareSubscription(test, "~fl~", ["url=~fl~"]);
compareSubscription(test, "http://test/default", ["url=http://test/default", "title=http://test/default"]);
compareSubscription(test, "http://test/default_titled", ["url=http://test/default_titled", "title=test"], function(subscription)
{
subscription.title = "test";
});
compareSubscription(test, "http://test/non_default", ["url=http://test/non_default", "title=test",
"disabled=true", "lastSuccess=8", "lastDownload=12", "lastCheck=16", "softExpiration=18", "expires=20", "downloadStatus=foo",
"errors=3", "version=24", "requiredVersion=0.6"], function(subscription)
{
subscription.title = "test";
subscription.disabled = true;
subscription.lastSuccess = 8;
subscription.lastDownload = 12;
subscription.lastCheck = 16;
subscription.softExpiration = 18;
subscription.expires = 20;
subscription.downloadStatus = "foo";
subscription.errors = 3;
subscription.version = 24
subscription.requiredVersion = "0.6";
});
compareSubscription(test, "~wl~", ["url=~wl~", "disabled=true", "title=Test group"], function(subscription)
{
subscription.title = "Test group";
subscription.disabled = true;
});
test.done();
};
adblockpluscore-0f979e7077bc1ba27778db0f2bb7bba059b1659c/test_wrapper.js 0000664 0000000 0000000 00000000122 12707711122 0025026 0 ustar 00root root 0000000 0000000 "use strict";
require("node-babel")();
require("./node_modules/.bin/nodeunit");