1
0
mirror of https://github.com/gryf/pentadactyl-pm.git synced 2026-04-26 07:11:25 +02:00

Recfactoring:

* Standard module format. All modules are explicitly declared
   as modules, they're created via a constructor and
   instantiated automatically. They're dependency aware. They
   stringify properly.

 * Classes are declared the same way (rather like Structs
   already were). They also stringify properly. Plus, each
   instance has a rather nifty closure member that closes all
   of its methods around 'this', so you can pass them to map,
   forEach, setTimeout, etc. Modules are themselves classes,
   with a special metaclass, as it were.

 * Doug Crockford is dead, metaphorically speaking.
   Closure-based classes just don't fit into any of the common
   JavaScript frameworks, and they're inefficient and
   confusing. Now, all class and module members are accessed
   explicitly via 'this', which makes it very clear that
   they're class members and not (e.g.) local variables,
   without anything nasty like Hungarian notation.

 * Strictly one module per file. Classes that belong to a
   module live in the same file.

 * For the moment, there are quite a few utility functions
   sitting in base.c, because my class implementation used
   them, and I haven't had the time or inclination to sort them
   out. I plan to reconcile them with the current mess that is
   the util namespace.

 * Changed bracing style.
This commit is contained in:
Kris Maglione
2009-11-08 20:54:31 -05:00
parent 46b7a29fb7
commit 6a25312c7d
46 changed files with 15950 additions and 17909 deletions
+206 -249
View File
@@ -13,254 +13,36 @@
// FIXME:
// - finish 1.9.0 support if we're going to support sanitizing in Xulmus
function Sanitizer() //{{{
{
////////////////////////////////////////////////////////////////////////////////
////////////////////// PRIVATE SECTION /////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////{{{
const Sanitizer = Module("sanitizer", {
requires: ["liberator"],
const local = {}; // XXX: is there some reason liberator.loadModule doesn't create modules with new?
services.get("subscriptLoader").loadSubScript("chrome://browser/content/sanitize.js", local);
const Sanitizer = local.Sanitizer;
init: function () {
const self = this;
liberator.loadScript("chrome://browser/content/sanitize.js", Sanitizer);
this.__proto__.__proto__ = new Sanitizer.Sanitizer; // Good enough.
var prefArgList = [["commandLine", "commandline"],
["offlineApps", "offlineapps"],
["siteSettings", "sitesettings"]];
// TODO: remove this version test
if (/^1.9.1/.test(services.get("xulAppInfo").platformVersion))
self.prefDomain = "privacy.cpd.";
else
self.prefDomain = "privacy.item.";
function prefToArg(pref)
{
let pref = pref.replace(/.*\./, "");
return util.Array.toObject(prefArgList)[pref] || pref;
}
function argToPref(arg) [k for ([, [k, v]] in Iterator(prefArgList)) if (v == arg)][0] || arg
/////////////////////////////////////////////////////////////////////////////}}}
////////////////////// OPTIONS /////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////{{{
options.add(["sanitizeitems", "si"],
"The default list of private items to sanitize",
"stringlist", "cache,commandline,cookies,formdata,history,marks,sessions",
{
setter: function (values)
{
for (let [, pref] in Iterator(sanitizer.prefNames))
{
options.setPref(pref, false);
for (let [, value] in Iterator(this.parseValues(values)))
{
if (prefToArg(pref) == value)
{
options.setPref(pref, true);
break;
}
}
}
return values;
},
getter: function () sanitizer.prefNames.filter(function (pref) options.getPref(pref)).map(prefToArg).join(","),
completer: function (value) [
["cache", "Cache"],
["commandline", "Command-line history"],
["cookies", "Cookies"],
["downloads", "Download history"],
["formdata", "Saved form and search history"],
["history", "Browsing history"],
["macros", "Saved macros"],
["marks", "Local and URL marks"],
["offlineapps", "Offline website data"],
["passwords", "Saved passwords"],
["sessions", "Authenticated sessions"],
["sitesettings", "Site preferences"],
],
validator: Option.validateCompleter
});
options.add(["sanitizetimespan", "sts"],
"The default sanitizer time span",
"number", 1,
{
setter: function (value)
{
options.setPref("privacy.sanitize.timeSpan", value);
return value;
},
getter: function () options.getPref("privacy.sanitize.timeSpan", this.defaultValue),
completer: function (value) [
["0", "Everything"],
["1", "Last hour"],
["2", "Last two hours"],
["3", "Last four hours"],
["4", "Today"]
],
validator: Option.validateCompleter
});
/////////////////////////////////////////////////////////////////////////////}}}
////////////////////// COMMANDS ////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////{{{
commands.add(["sa[nitize]"],
"Clear private data",
function (args)
{
if (options['private'])
return void liberator.echomsg("Cannot sanitize items in private mode");
let timespan = args["-timespan"] || options["sanitizetimespan"];
sanitizer.range = Sanitizer.getClearRange(timespan);
sanitizer.ignoreTimespan = !sanitizer.range;
if (args.bang)
{
liberator.assert(args.length == 0, "E488: Trailing characters");
liberator.log("Sanitizing all items in 'sanitizeitems'...");
let errors = sanitizer.sanitize();
if (errors)
{
for (let item in errors)
liberator.echoerr("Error sanitizing " + item + ": " + errors[item]);
}
}
else
{
liberator.assert(args.length > 0, "E471: Argument required");
for (let [, item] in Iterator(args.map(argToPref)))
{
liberator.log("Sanitizing " + item + " items...");
if (sanitizer.canClearItem(item))
{
try
{
sanitizer.items[item].range = sanitizer.range;
sanitizer.clearItem(item);
}
catch (e)
{
liberator.echoerr("Error sanitizing " + item + ": " + e);
}
}
else
liberator.echomsg("Cannot sanitize " + item);
}
}
},
{
argCount: "*", // FIXME: should be + and 0
bang: true,
completer: function (context) {
context.title = ["Privacy Item", "Description"];
context.completions = options.get("sanitizeitems").completer();
},
options: [
[["-timespan", "-t"],
commands.OPTION_INT,
function (arg) /^[0-4]$/.test(arg),
function () options.get("sanitizetimespan").completer()]
]
});
/////////////////////////////////////////////////////////////////////////////}}}
////////////////////// PUBLIC SECTION //////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////{{{
var self = new Sanitizer();
// TODO: remove this version test
if (/^1.9.1/.test(services.get("xulAppInfo").platformVersion))
self.prefDomain = "privacy.cpd.";
else
self.prefDomain = "privacy.item.";
self.prefDomain2 = "extensions.liberator.privacy.cpd.";
// add liberator-specific private items
[
{
name: "commandLine",
action: function ()
{
let stores = ["command", "search"];
if (self.range)
{
stores.forEach(function (store) {
storage["history-" + store].mutate("filter", function (item) {
let timestamp = item.timestamp * 1000;
return timestamp < self.range[0] || timestamp > self.range[1];
});
});
}
else
stores.forEach(function (store) { storage["history-" + store].truncate(0); });
}
},
{
name: "macros",
action: function () { storage["macros"].clear(); }
},
{
name: "marks",
action: function ()
{
storage["local-marks"].clear();
storage["url-marks"].clear();
}
}
].forEach(function (item) {
let pref = self.prefDomain2 + item.name;
if (options.getPref(pref) == null)
options.setPref(pref, false);
self.items[item.name] = {
canClear: true,
clear: item.action
}
});
// call Sanitize autocommand
for (let [name, item] in Iterator(self.items))
{
let arg = prefToArg(name);
if (item.clear)
{
let func = item.clear;
item.clear = function () {
autocommands.trigger("Sanitize", { name: arg })
func.call(item);
}
}
}
self.getClearRange = Sanitizer.getClearRange;
self.prefDomain2 = "extensions.liberator.privacy.cpd.";
},
// Largely ripped from from browser/base/content/sanitize.js so we can override
// the pref strategy without stepping on the global prefs namespace.
self.sanitize = function () {
sanitize: function () {
const prefService = services.get("pref");
let branch = prefService.getBranch(this.prefDomain);
let branch2 = prefService.getBranch(this.prefDomain2);
let errors = null;
function prefSet(name)
{
try
{
function prefSet(name) {
try {
return branch.getBoolPref(name);
}
catch (e)
{
catch (e) {
return branch2.getBoolPref(name);
}
}
@@ -271,25 +53,21 @@ function Sanitizer() //{{{
else
range = this.range || Sanitizer.getClearRange();
for (let itemName in this.items)
{
for (let itemName in this.items) {
let item = this.items[itemName];
item.range = range;
if ("clear" in item && item.canClear && prefSet(itemName))
{
if ("clear" in item && item.canClear && prefSet(itemName)) {
liberator.log("Sanitizing " + itemName + " items...");
// Some of these clear() may raise exceptions (see bug #265028)
// to sanitize as much as possible, we catch and store them,
// rather than fail fast.
// Callers should check returned errors and give user feedback
// about items that could not be sanitized
try
{
try {
item.clear();
}
catch (e)
{
catch (e) {
if (!errors)
errors = {};
errors[itemName] = e;
@@ -299,14 +77,193 @@ function Sanitizer() //{{{
}
return errors;
};
},
self.__defineGetter__("prefNames",
function () util.Array.flatten([self.prefDomain, self.prefDomain2].map(options.allPrefs)));
//}}}
get prefNames() util.Array.flatten([this.prefDomain, this.prefDomain2].map(options.allPrefs)),
}, {
prefArgList: [["commandLine", "commandline"],
["offlineApps", "offlineapps"],
["siteSettings", "sitesettings"]],
prefToArg: function (pref) {
let pref = pref.replace(/.*\./, "");
return util.Array.toObject(Sanitizer.prefArgList)[pref] || pref;
},
return self;
argToPref: function (arg) [k for ([k, v] in values(Sanitizer.prefArgList)) if (v == arg)][0] || arg,
}, {
commands: function () {
commands.add(["sa[nitize]"],
"Clear private data",
function (args) {
if (options['private'])
return void liberator.echomsg("Cannot sanitize items in private mode");
} //}}}
let timespan = args["-timespan"] || options["sanitizetimespan"];
sanitizer.range = Sanitizer.getClearRange(timespan);
sanitizer.ignoreTimespan = !sanitizer.range;
if (args.bang) {
liberator.assert(args.length == 0, "E488: Trailing characters");
liberator.log("Sanitizing all items in 'sanitizeitems'...");
let errors = sanitizer.sanitize();
if (errors) {
for (let item in errors)
liberator.echoerr("Error sanitizing " + item + ": " + errors[item]);
}
}
else {
liberator.assert(args.length > 0, "E471: Argument required");
for (let [, item] in Iterator(args.map(Sanitizer.argToPref))) {
liberator.log("Sanitizing " + item + " items...");
if (sanitizer.canClearItem(item)) {
try {
sanitizer.items[item].range = sanitizer.range;
sanitizer.clearItem(item);
}
catch (e) {
liberator.echoerr("Error sanitizing " + item + ": " + e);
}
}
else
liberator.echomsg("Cannot sanitize " + item);
}
}
},
{
argCount: "*", // FIXME: should be + and 0
bang: true,
completer: function (context) {
context.title = ["Privacy Item", "Description"];
context.completions = options.get("sanitizeitems").completer();
},
options: [
[["-timespan", "-t"],
commands.OPTION_INT,
function (arg) /^[0-4]$/.test(arg),
function () options.get("sanitizetimespan").completer()]
]
});
},
options: function () {
const self = this;
// add liberator-specific private items
[
{
name: "commandLine",
action: function () {
let stores = ["command", "search"];
if (self.range) {
stores.forEach(function (store) {
storage["history-" + store].mutate("filter", function (item) {
let timestamp = item.timestamp * 1000;
return timestamp < self.range[0] || timestamp > self.range[1];
});
});
}
else
stores.forEach(function (store) { storage["history-" + store].truncate(0); });
}
},
{
name: "macros",
action: function () { storage["macros"].clear(); }
},
{
name: "marks",
action: function () {
storage["local-marks"].clear();
storage["url-marks"].clear();
}
}
].forEach(function (item) {
let pref = self.prefDomain2 + item.name;
if (options.getPref(pref) == null)
options.setPref(pref, false);
self.items[item.name] = {
canClear: true,
clear: item.action
}
});
// call Sanitize autocommand
for (let [name, item] in Iterator(self.items)) {
let arg = Sanitizer.prefToArg(name);
if (item.clear) {
let func = item.clear;
item.clear = function () {
autocommands.trigger("Sanitize", { name: arg })
func.call(item);
}
}
}
options.add(["sanitizeitems", "si"],
"The default list of private items to sanitize",
"stringlist", "cache,commandline,cookies,formdata,history,marks,sessions",
{
setter: function (values) {
for (let [, pref] in Iterator(sanitizer.prefNames)) {
continue;
options.setPref(pref, false);
for (let [, value] in Iterator(this.parseValues(values))) {
if (Sanitizer.prefToArg(pref) == value) {
options.setPref(pref, true);
break;
}
}
}
return values;
},
getter: function () sanitizer.prefNames.filter(function (pref) options.getPref(pref)).map(Sanitizer.prefToArg).join(","),
completer: function (value) [
["cache", "Cache"],
["commandline", "Command-line history"],
["cookies", "Cookies"],
["downloads", "Download history"],
["formdata", "Saved form and search history"],
["history", "Browsing history"],
["macros", "Saved macros"],
["marks", "Local and URL marks"],
["offlineapps", "Offline website data"],
["passwords", "Saved passwords"],
["sessions", "Authenticated sessions"],
["sitesettings", "Site preferences"],
],
validator: Option.validateCompleter
});
options.add(["sanitizetimespan", "sts"],
"The default sanitizer time span",
"number", 1,
{
setter: function (value) {
options.setPref("privacy.sanitize.timeSpan", value);
return value;
},
getter: function () options.getPref("privacy.sanitize.timeSpan", this.defaultValue),
completer: function (value) [
["0", "Everything"],
["1", "Last hour"],
["2", "Last two hours"],
["3", "Last four hours"],
["4", "Today"]
],
validator: Option.validateCompleter
});
},
});
// vim: set fdm=marker sw=4 ts=4 et: