gryf/pentadactyl-pm
1
0
Fork 0
mirror of https://github.com/gryf/pentadactyl-pm.git synced 2026-02-16 23:35:47 +01:00
Code Issues Projects Releases Wiki Activity

Context-specific completer options. Option refactoring.

Browse Source 
New review
Owner: dougkearns
Hopefully the changeset hash will actually be linked this time. If
not, it's the tip of the testing branch, presumably r4161.
I've been meaning to do this for a while. It allows case matching,
sorting, and auto completion options to be assigned on a per context
basis, with fine grained control. It also adds builtin regex support
to options since it's used fairly extensively. There are definitely
other options that would benefit from the regexlist type, if I can
dig them up. The interface (and perhaps the doc wording) is the only
place I'm really ambivalent.

--HG--
branch : testing
This commit is contained in:
Kris Maglione
2009-11-20 15:37:39 -05:00
parent db1fb981cc
commit 61002641a3
14 changed files with 469 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
common/content/bookmarks.js
View File

@@ -598,6 +598,18 @@ const Bookmarks = Module("bookmarks", {
context.completions = [["", "Don't perform searches by default"]].concat(context.completions);
}
});
options.add(["suggestengines"],
"Engine Alias which has a feature of suggest",
"stringlist", "google",
{
completer: function completer(value) {
let engines = services.get("browserSearch").getEngines({})
.filter(function (engine) engine.supportsResponseType("application/x-suggestions+json"));
return engines.map(function (engine) [engine.alias, engine.description]);
}
});
},
completion: function () {
completion.bookmark = function bookmark(context, tags, extra) {

80
common/content/commandline.js
View File

@@ -102,7 +102,7 @@ const CommandLine = Module("commandline", {
});
this._autocompleteTimer = new Timer(200, 500, function autocompleteTell(tabPressed) {
if (!events.feedingKeys && self._completions && options.get("wildoptions").has("auto")) {
if (!events.feedingKeys && self._completions && options.get("autocomplete").values.length) {
self._completions.complete(true, false);
self._completions.itemList.show();
}
@@ -1516,84 +1516,6 @@ const CommandLine = Module("commandline", {
options.add(["showmode", "smd"],
"Show the current mode in the command line",
"boolean", true);
options.add(["suggestengines"],
"Engine Alias which has a feature of suggest",
"stringlist", "google",
{
completer: function completer(value) {
let engines = services.get("browserSearch").getEngines({})
.filter(function (engine) engine.supportsResponseType("application/x-suggestions+json"));
return engines.map(function (engine) [engine.alias, engine.description]);
}
});
options.add(["complete", "cpt"],
"Items which are completed at the :open prompts",
"charlist", typeof(config.defaults["complete"]) == "string" ? config.defaults["complete"] : "slf",
{
completer: function (context) array(values(completion.urlCompleters))
});
options.add(["wildcase", "wic"],
"Completion case matching mode",
"string", "smart",
{
completer: function () [
["smart", "Case is significant when capital letters are typed"],
["match", "Case is always significant"],
["ignore", "Case is never significant"]
]
});
options.add(["wildignore", "wig"],
"List of file patterns to ignore when completing files",
"stringlist", "",
{
validator: function validator(values) {
// TODO: allow for escaping the ","
try {
RegExp("^(" + values.join("|") + ")$");
return true;
}
catch (e) {
return false;
}
}
});
options.add(["wildmode", "wim"],
"Define how command line completion works",
"stringlist", "list:full",
{
completer: function (context) [
// Why do we need ""?
["", "Complete only the first match"],
["full", "Complete the next full match"],
["longest", "Complete to longest common string"],
["list", "If more than one match, list all matches"],
["list:full", "List all and complete first match"],
["list:longest", "List all and complete common string"]
],
checkHas: function (value, val) {
let [first, second] = value.split(":", 2);
return first == val || second == val;
}
});
options.add(["wildoptions", "wop"],
"Change how command line completion is done",
"stringlist", "",
{
completer: function completer(value) {
return [
["", "Default completion that won't show or sort the results"],
["auto", "Automatically show this._completions while you are typing"],
["sort", "Always sort the completion list"]
];
}
});
},
styles: function () {
let fontSize = util.computedStyle(document.getElementById(config.mainWindowId)).fontSize;

4
common/content/commands.js
View File

@@ -894,10 +894,10 @@ const Commands = Module("commands", {
}
[prefix] = context.filter.match(/^(?:\w*[\s!]|!)\s*/);
let cmdContext = context.fork(cmd, prefix.length);
let cmdContext = context.fork(command.name, prefix.length);
let argContext = context.fork("args", prefix.length);
args = command.parseArgs(cmdContext.filter, argContext, { count: count, bang: bang });
if (args) {
if (args && !cmdContext.waitingForTab) {
// FIXME: Move to parseCommand
args.count = count;
args.bang = bang;

93
common/content/completion.js
View File

@@ -34,6 +34,11 @@ const CompletionContext = Class("CompletionContext", {
if (editor instanceof this.constructor) {
let parent = editor;
name = parent.name + "/" + name;
this.autoComplete = options.get("autocomplete").getKey(name);
this.sortResults = options.get("wildsort").getKey(name);
this.wildcase = options.get("wildcase").getKey(name);
this.contexts = parent.contexts;
if (name in this.contexts)
self = this.contexts[name];
@@ -146,6 +151,8 @@ const CompletionContext = Class("CompletionContext", {
this.top = this;
this.__defineGetter__("incomplete", function () this.contextList.some(function (c) c.parent && c.incomplete));
this.__defineGetter__("waitingForTab", function () this.contextList.some(function (c) c.parent && c.waitingForTab));
this.__defineSetter__("incomplete", function (val) {});
this.__defineSetter__("waitingForTab", function (val) {});
this.reset();
}
/**
@@ -333,7 +340,7 @@ const CompletionContext = Class("CompletionContext", {
get ignoreCase() {
if ("_ignoreCase" in this)
return this._ignoreCase;
let mode = options["wildcase"];
let mode = this.wildcase;
if (mode == "match")
return this._ignoreCase = false;
if (mode == "ignore")
@@ -367,7 +374,7 @@ const CompletionContext = Class("CompletionContext", {
if (this.maxItems)
filtered = filtered.slice(0, this.maxItems);
if (options.get("wildoptions").has("sort") && this.compare)
if (this.sortResults && this.compare)
filtered.sort(this.compare);
let quote = this.quote;
if (quote)
@@ -498,8 +505,14 @@ const CompletionContext = Class("CompletionContext", {
completer = self[completer];
let context = CompletionContext(this, name, offset);
this.contextList.push(context);
if (completer)
if (!context.autoComplete && !context.tabPressed && context.editor)
context.waitingForTab = true;
else if (completer)
return completer.apply(self || this, [context].concat(Array.slice(arguments, arguments.callee.length)));
if (completer)
return null;
return context;
},
@@ -741,6 +754,80 @@ const Completion = Module("completion", {
//}}}
}, {
UrlCompleter: Struct("name", "description", "completer")
}, {
commands: function () {
commands.add(["contexts"],
"List the completion contexts used during completion of an ex command",
function (args) {
commandline.echo(template.commandOutput(
<div highlight="Completions">
{ template.completionRow(["Context", "Title"], "CompTitle") }
{ template.map(completion.contextList || [], function (item) template.completionRow(item, "CompItem")) }
</div>),
null, commandline.FORCE_MULTILINE);
},
{
argCount: "1",
completer: function (context, args) {
let PREFIX = "/ex/contexts";
context.fork("ex", 0, completion, "ex");
completion.contextList = [[k.substr(PREFIX.length), v.title[0]] for ([k, v] in iter(context.contexts)) if (k.substr(0, PREFIX.length) == PREFIX)];
},
literal: 0
});
},
options: function () {
options.add(["autocomplete", "au"],
"Automatically update the completion list on any key press",
"regexlist", ".*");
options.add(["complete", "cpt"],
"Items which are completed at the :open prompts",
"charlist", typeof(config.defaults["complete"]) == "string" ? config.defaults["complete"] : "slf",
{
completer: function (context) array(values(completion.urlCompleters))
});
options.add(["wildcase", "wic"],
"Completion case matching mode",
"regexmap", "smart",
{
completer: function () [
["smart", "Case is significant when capital letters are typed"],
["match", "Case is always significant"],
["ignore", "Case is never significant"]
]
});
options.add(["wildmode", "wim"],
"Define how command line completion works",
"stringlist", "list:full",
{
completer: function (context) [
// Why do we need ""?
// Because its description is useful during completion. --Kris
["", "Complete only the first match"],
["full", "Complete the next full match"],
["longest", "Complete to longest common string"],
["list", "If more than one match, list all matches"],
["list:full", "List all and complete first match"],
["list:longest", "List all and complete common string"]
],
checkHas: function (value, val) {
let [first, second] = value.split(":", 2);
return first == val || second == val;
},
has: function () {
test = function (val) this.values.some(function (value) this.checkHas(value, val), this);
return Array.some(arguments, test, this);
}
});
options.add(["wildsort", "wis"],
"Regexp list of which contexts to sort",
"regexlist", ".*");
}
});
// vim: set fdm=marker sw=4 ts=4 et:

12
common/content/help.xsl
View File

@@ -202,7 +202,7 @@
<xsl:variable name="type" select="preceding-sibling::liberator:type[1] | following-sibling::liberator:type[1]"/>
<span liberator:highlight="HelpDefault">(default:<xsl:text> </xsl:text>
<xsl:choose>
<xsl:when test="starts-with($type, 'string')">
<xsl:when test="starts-with($type, 'string') or starts-with($type, 'regex')">
<span liberator:highlight="HelpString"><xsl:apply-templates/></span>
</xsl:when>
<xsl:otherwise>
@@ -351,9 +351,13 @@
<xsl:template match="liberator:ex" mode="pass-2">
<span liberator:highlight="HelpEx">
<xsl:call-template name="linkify-tag">
<xsl:with-param name="contents" select="."/>
</xsl:call-template>
<xsl:variable name="tag" select="str:tokenize(text(), ' [!')[1]"/>
<a href="liberator://help-tag/{$tag}" style="color: inherit;">
<xsl:if test="contains($tags, concat(' ', $tag, ' '))">
<xsl:attribute name="href">#<xsl:value-of select="$tag"/></xsl:attribute>
</xsl:if>
<xsl:apply-templates/>
</a>
</span>
</xsl:template>

10
common/content/io.js
View File

@@ -240,7 +240,7 @@ const File = Class("File", {
*/
MODE_EXCL: 0x80,
expandPathList: function (list) list.split(",").map(this.expandPath).join(","),
expandPathList: function (list) list.map(this.expandPath),
expandPath: function (path, relative) {
@@ -1028,8 +1028,8 @@ lookup:
b.isdir - a.isdir || String.localeCompare(a.text, b.text);
if (options["wildignore"]) {
let wigRegexp = RegExp("(^" + options.get("wildignore").values.join("|") + ")$");
context.filters.push(function ({item: f}) f.isDirectory() || !wigRegexp.test(f.leafName));
let wig = options.get("wildignore");
context.filters.push(function ({item: f}) f.isDirectory() || !wig.getKey(this.name));
}
// context.background = true;
@@ -1099,6 +1099,10 @@ lookup:
options.add(["shellcmdflag", "shcf"],
"Flag passed to shell when executing :! and :run commands",
"string", shellcmdflag);
options.add(["wildignore", "wig"],
"List of file patterns to ignore when completing files",
"regexlist", "");
}
});

405
common/content/options.js
View File

@@ -22,7 +22,6 @@
* getter - see {@link Option#getter}
* completer - see {@link Option#completer}
* valdator - see {@link Option#validator}
* checkHas - see {@link Option#checkHas}
* @optional
* @private
*/
@@ -33,6 +32,17 @@ const Option = Class("Option", {
this.type = type;
this.description = description;
if (this.type in Option.getKey)
this.getKey = Option.getKey[this.type];
if (this.type in Option.parseValues)
this.parseValues = Option.parseValues[this.type];
if (this.type in Option.joinValues)
this.joinValues = Option.joinValues[this.type];
this._op = Option.ops[this.type];
if (arguments.length > 3)
this.defaultValue = defaultValue;
@@ -44,7 +54,7 @@ const Option = Class("Option", {
this.names = array([name, "no" + name] for (name in values(names))).flatten().__proto__;
if (this.globalValue == undefined)
this.globalValue = this.defaultValue;
this.globalValue = this.parseValues(this.defaultValue);
},
/** @property {value} The option's global value. @see #scope */
@@ -58,13 +68,7 @@ const Option = Class("Option", {
* @param {value} value The option value.
* @returns {value|string[]}
*/
parseValues: function (value) {
if (this.type == "stringlist")
return (value === "") ? [] : value.split(",");
if (this.type == "charlist")
return Array.slice(value);
return value;
},
parseValues: function (value) value,
/**
* Returns <b>values</b> packed in the appropriate format for the option
@@ -73,16 +77,10 @@ const Option = Class("Option", {
* @param {value|string[]} values The option value.
* @returns {value}
*/
joinValues: function (values) {
if (this.type == "stringlist")
return values.join(",");
if (this.type == "charlist")
return values.join("");
return values;
},
joinValues: function (vals) vals,
/** @property {value|string[]} The option value or array of values. */
get values() this.parseValues(this.value),
get values() this.getValues(this.scope),
set values(values) this.setValues(values, this.scope),
/**
@@ -93,7 +91,26 @@ const Option = Class("Option", {
* {@link Option#scope}).
* @returns {value|string[]}
*/
getValues: function (scope) this.parseValues(this.get(scope)),
getValues: function (scope) {
if (scope) {
if ((scope & this.scope) == 0) // option doesn't exist in this scope
return null;
}
else
scope = this.scope;
let values;
if (liberator.has("tabs") && (scope & Option.SCOPE_LOCAL))
values = tabs.options[this.name];
if ((scope & Option.SCOPE_GLOBAL) && (values == undefined))
values = this.globalValue;
if (this.getter)
return liberator.trapErrors(this.getter, this, values);
return values;
},
/**
* Sets the option's value from an array of values if the option type is
@@ -102,8 +119,22 @@ const Option = Class("Option", {
* @param {number} scope The scope to apply these values to (see
* {@link Option#scope}).
*/
setValues: function (values, scope) {
this.set(this.joinValues(values), scope || this.scope);
setValues: function (newValues, scope, skipGlobal) {
scope = scope || this.scope;
if ((scope & this.scope) == 0) // option doesn't exist in this scope
return;
if (this.setter)
newValues = liberator.trapErrors(this.setter, this, newValues);
if (newValues === undefined)
return;
if (liberator.has("tabs") && (scope & Option.SCOPE_LOCAL))
tabs.options[this.name] = newValues;
if ((scope & Option.SCOPE_GLOBAL) && !skipGlobal)
this.globalValue = newValues;
this.hasChanged = true;
},
/**
@@ -115,26 +146,7 @@ const Option = Class("Option", {
* {@link Option#scope}).
* @returns {value}
*/
get: function (scope) {
if (scope) {
if ((scope & this.scope) == 0) // option doesn't exist in this scope
return null;
}
else
scope = this.scope;
let value;
if (liberator.has("tabs") && (scope & Option.SCOPE_LOCAL))
value = tabs.options[this.name];
if ((scope & Option.SCOPE_GLOBAL) && (value == undefined))
value = this.globalValue;
if (this.getter)
return liberator.trapErrors(this.getter, this, value);
return value;
},
get: function (scope) this.joinValues(this.getValues(scope)),
/**
* Sets the option value to <b>newValue</b> for the specified <b>scope</b>.
@@ -145,21 +157,7 @@ const Option = Class("Option", {
* @param {number} scope The scope to apply this value to (see
* {@link Option#scope}).
*/
set: function (newValue, scope) {
scope = scope || this.scope;
if ((scope & this.scope) == 0) // option doesn't exist in this scope
return;
if (this.setter)
newValue = liberator.trapErrors(this.setter, this, newValue);
if (liberator.has("tabs") && (scope & Option.SCOPE_LOCAL))
tabs.options[this.name] = newValue;
if ((scope & Option.SCOPE_GLOBAL) && newValue != this.globalValue)
this.globalValue = newValue;
this.hasChanged = true;
},
set: function (newValue, scope) this.setValues(this.parseValues(newValue), scope),
/**
* @property {value} The option's current value. The option's local value,
@@ -169,21 +167,15 @@ const Option = Class("Option", {
get value() this.get(),
set value(val) this.set(val),
getKey: function (key) undefined,
/**
* Returns whether the option value contains one or more of the specified
* arguments.
*
* @returns {boolean}
*/
has: function () {
let self = this;
let test = function (val) values.indexOf(val) >= 0;
if (this.checkHas)
test = function (val) values.some(function (value) self.checkHas(value, val));
let values = this.values;
// return whether some argument matches
return Array.some(arguments, function (val) test(val));
},
has: function () Array.some(arguments, function (val) this.values.indexOf(val) >= 0, this),
/**
* Returns whether this option is identified by <b>name</b>.
@@ -216,97 +208,16 @@ const Option = Class("Option", {
* @param {boolean} invert Whether this is an invert boolean operation.
*/
op: function (operator, values, scope, invert) {
let newValue = null;
let self = this;
switch (this.type) {
case "boolean":
if (operator != "=")
break;
let newValues = this._op(operator, values, scope, invert);
if (invert)
newValue = !this.value;
else
newValue = values;
break;
case "number":
// TODO: support floats? Validators need updating.
if (!/^[+-]?(?:0x[0-9a-f]+|0[0-7]+|0|[1-9]\d*)$/i.test(values))
return "E521: Number required after := " + this.name + "=" + values;
let value = parseInt(values/* deduce radix */);
switch (operator) {
case "+":
newValue = this.value + value;
break;
case "-":
newValue = this.value - value;
break;
case "^":
newValue = this.value * value;
break;
case "=":
newValue = value;
break;
}
break;
case "charlist":
case "stringlist":
values = Array.concat(values);
switch (operator) {
case "+":
newValue = util.Array.uniq(Array.concat(this.values, values), true);
break;
case "^":
// NOTE: Vim doesn't prepend if there's a match in the current value
newValue = util.Array.uniq(Array.concat(values, this.values), true);
break;
case "-":
newValue = this.values.filter(function (item) values.indexOf(item) == -1);
break;
case "=":
newValue = values;
if (invert) {
let keepValues = this.values.filter(function (item) values.indexOf(item) == -1);
let addValues = values.filter(function (item) self.values.indexOf(item) == -1);
newValue = addValues.concat(keepValues);
}
break;
}
break;
case "string":
switch (operator) {
case "+":
newValue = this.value + values;
break;
case "-":
newValue = this.value.replace(values, "");
break;
case "^":
newValue = values + this.value;
break;
case "=":
newValue = values;
break;
}
break;
default:
return "E685: Internal error: option type `" + this.type + "' not supported";
}
if (newValue == null)
if (newValues == null)
return "Operator " + operator + " not supported for option type " + this.type;
if (!this.isValidValue(newValue))
if (!this.isValidValue(newValues))
return "E474: Invalid argument: " + values;
this.setValues(newValue, scope);
this.setValues(newValues, scope);
return null;
},
@@ -319,11 +230,13 @@ const Option = Class("Option", {
/**
* @property {string} The option's data type. One of:
* "boolean" - Boolean E.g. true
* "number" - Integer E.g. 1
* "string" - String E.g. "Vimperator"
* "charlist" - Character list E.g. "rb"
* "stringlist" - String list E.g. "homepage,quickmark,tabopen,paste"
* "boolean" - Boolean, e.g., true
* "number" - Integer, e.g., 1
* "string" - String, e.g., "Vimperator"
* "charlist" - Character list, e.g., "rb"
* "regexlist" - Regex list, e.g., "^foo,bar$"
* "stringmap" - String map, e.g., "key=v,foo=bar"
* "regexmap" - Regex map, e.g., "^key=v,foo$=bar"
*/
type: null,
@@ -370,12 +283,6 @@ const Option = Class("Option", {
return Option.validateCompleter.apply(this, arguments);
return true;
},
/**
* @property The function called to determine whether the option already
* contains a specified value.
* @see #has
*/
checkHas: null,
/**
* @property {boolean} Set to true whenever the option is first set. This
@@ -410,6 +317,131 @@ const Option = Class("Option", {
*/
SCOPE_BOTH: 3,
parseRegex: function (val, result) {
let [, bang, val] = /^(!?)(.*)/.exec(val);
let re = RegExp(val);
re.bang = bang;
re.result = arguments.length == 2 ? result : !bang;
return re;
},
unparseRegex: function (re) re.bang + re.source + (typeof re.result == "string" ? "=" + re.result : ""),
getKey: {
stringlist: function (k) this.values.indexOf(k) >= 0,
regexlist: function (k) {
for (let re in values(this.values))
if (re.test(k))
return re.result;
return null;
}
},
joinValues: {
charlist: function (vals) vals.join(""),
stringlist: function (vals) vals.join(","),
stringmap: function (vals) [k + "=" + v for ([k, v] in Iterator(vals))].join(","),
regexlist: function (vals) vals.map(Option.unparseRegex).join(","),
},
parseValues: {
number: function (value) Number(value),
boolean: function (value) value == "true" || value == true ? true : false,
charlist: function (value) Array.slice(value),
stringlist: function (value) (value === "") ? [] : value.split(","),
stringmap: function (value) array(v.split("=") for (v in values(value.split(",")))).toObject(),
regexlist: function (value) (value === "") ? [] : value.split(",").map(Option.parseRegex),
regexmap: function (value) value.split(",").map(function (v) v.split("="))
.map(function ([k, v]) v != null ? Option.parseRegex(k, v) : Option.parseRegex('.?', k))
},
ops: {
boolean: function (operator, values, scope, invert) {
if (operator != "=")
return null;
if (invert)
return !this.value;
return values;
},
number: function (operator, values, scope, invert) {
// TODO: support floats? Validators need updating.
if (!/^[+-]?(?:0x[0-9a-f]+|0[0-7]*|[1-9]+)$/i.test(values))
return "E521: Number required after := " + this.name + "=" + values;
let value = parseInt(values);
switch (operator) {
case "+":
return this.value + value;
case "-":
return this.value - value;
case "^":
return this.value * value;
case "=":
return value;
}
return null;
},
stringmap: function (operator, values, scope, invert) {
values = Array.concat(values);
orig = [k + "=" + v for ([k, v] in Iterator(this.values))];
switch (operator) {
case "+":
return util.Array.uniq(Array.concat(orig, values), true);
case "^":
// NOTE: Vim doesn't prepend if there's a match in the current value
return util.Array.uniq(Array.concat(values, orig), true);
case "-":
return orig.filter(function (item) values.indexOf(item) == -1);
case "=":
if (invert) {
let keepValues = orig.filter(function (item) values.indexOf(item) == -1);
let addValues = values.filter(function (item) self.values.indexOf(item) == -1);
return addValues.concat(keepValues);
}
return values;
}
return null;
},
stringlist: function (operator, values, scope, invert) {
values = Array.concat(values);
switch (operator) {
case "+":
return util.Array.uniq(Array.concat(this.values, values), true);
case "^":
// NOTE: Vim doesn't prepend if there's a match in the current value
return util.Array.uniq(Array.concat(values, this.values), true);
case "-":
return this.values.filter(function (item) values.indexOf(item) == -1);
case "=":
if (invert) {
let keepValues = this.values.filter(function (item) values.indexOf(item) == -1);
let addValues = values.filter(function (item) self.values.indexOf(item) == -1);
return addValues.concat(keepValues);
}
return values;
}
return null;
},
string: function (operator, values, scope, invert) {
switch (operator) {
case "+":
return this.value + values;
case "-":
return this.value.replace(values, "");
case "^":
return values + this.value;
case "=":
return values;
}
return null;
}
},
// TODO: Run this by default?
/**
* Validates the specified <b>values</b> against values generated by the
@@ -423,10 +455,21 @@ const Option = Class("Option", {
let res = context.fork("", 0, this, this.completer);
if (!res)
res = context.allItems.items.map(function (item) [item.text]);
if (this.type == "regexmap")
return Array.concat(values).every(function (re) res.some(function (item) item[0] == re.result));
return Array.concat(values).every(function (value) res.some(function (item) item[0] == value));
}
});
Option.joinValues["regexmap"] = Option.joinValues["regexlist"];
Option.getKey["charlist"] = Option.getKey["stringlist"];
Option.getKey["regexmap"] = Option.getKey["regexlist"];
Option.ops["charlist"] = Option.ops["stringlist"];
Option.ops["regexlist"] = Option.ops["stringlist"];
Option.ops["regexmap"] = Option.ops["stringlist"];
/**
* @instance options
*/
@@ -462,7 +505,7 @@ const Options = Module("options", {
// Trigger any setters.
let opt = options.get(option);
if (event == "change" && opt)
opt.set(opt.value, Option.SCOPE_GLOBAL);
opt.setValues(opt.globalValue, Option.SCOPE_GLOBAL, true);
}
storage.newMap("options", { store: false });
@@ -1008,8 +1051,6 @@ const Options = Module("options", {
}
}
// write access
// NOTE: the behavior is generally Vim compatible but could be
// improved. i.e. Vim's behavior is pretty sloppy to no real benefit
else {
option.setFrom = modifiers.setFrom || null;
@@ -1017,7 +1058,12 @@ const Options = Module("options", {
liberator.assert(!opt.valueGiven, "E474: Invalid argument: " + arg);
opt.values = !opt.unsetBoolean;
}
let res = opt.option.op(opt.operator || "=", opt.values, opt.scope, opt.invert);
try {
var res = opt.option.op(opt.operator || "=", opt.values, opt.scope, opt.invert);
}
catch (e) {
res = e;
}
if (res)
liberator.echoerr(res);
}
@@ -1244,8 +1290,15 @@ const Options = Module("options", {
if (!completer)
return;
let curValues = curValue != null ? opt.parseValues(curValue) : opt.values;
let newValues = opt.parseValues(context.filter);
try {
var curValues = curValue != null ? opt.parseValues(curValue) : opt.values;
var newValues = opt.parseValues(context.filter);
}
catch (e) {
context.message = "Error: " + e;
context.completions = [];
return;
}
let len = context.filter.length;
switch (opt.type) {
@@ -1253,9 +1306,18 @@ const Options = Module("options", {
if (!completer)
completer = function () [["true", ""], ["false", ""]];
break;
case "regexlist":
newValues = context.filter.split(",");
// Fallthrough
case "stringlist":
let target = newValues.pop();
len = target ? target.length : 0;
let target = newValues.pop() || "";
len = target.length;
break;
case "stringmap":
case "regexmap":
let vals = context.filter.split(",");
target = vals.pop() || "";
len = target.length - (target.indexOf("=") + 1);
break;
case "charlist":
len = 0;
@@ -1268,9 +1330,10 @@ const Options = Module("options", {
let completions = completer(context);
if (!completions)
return;
// Not Vim compatible, but is a significant enough improvement
// that it's worth breaking compatibility.
if (newValues instanceof Array) {
if (isarray(newValues)) {
completions = completions.filter(function (val) newValues.indexOf(val[0]) == -1);
switch (op) {
case "+":

5
common/content/sanitizer.js
View File

@@ -213,10 +213,9 @@ const Sanitizer = Module("sanitizer", {
{
setter: function (values) {
for (let [, pref] in Iterator(sanitizer.prefNames)) {
continue;
options.setPref(pref, false);
for (let [, value] in Iterator(this.parseValues(values))) {
for (let [, value] in Iterator(values)) {
if (Sanitizer.prefToArg(pref) == value) {
options.setPref(pref, true);
break;
@@ -226,7 +225,7 @@ const Sanitizer = Module("sanitizer", {
return values;
},
getter: function () sanitizer.prefNames.filter(function (pref) options.getPref(pref)).map(Sanitizer.prefToArg).join(","),
getter: function () sanitizer.prefNames.filter(function (pref) options.getPref(pref)).map(Sanitizer.prefToArg),
completer: function (value) [
["cache", "Cache"],
["commandline", "Command-line history"],

2
common/content/style.js
View File

@@ -167,6 +167,8 @@ Highlights.prototype.CSS = <![CDATA[
HelpString display: inline-block; color: green; font-weight: normal; vertical-align: text-top;
HelpString::before content: '"';
HelpString::after content: '"';
HelpString[delim]::before content: attr(delim);
HelpString[delim]::after content: attr(delim);
HelpHead,html|h1,liberator://help/* {
display: block;

6
common/content/tabs.js
View File

@@ -1094,9 +1094,9 @@ const Tabs = Module("tabs", {
"Where to show requested popup windows",
"stringlist", "tab",
{
setter: function (value) {
setter: function (values) {
let [open, restriction] = [1, 0];
for (let [, opt] in Iterator(this.parseValues(value))) {
for (let [, opt] in Iterator(values)) {
if (opt == "tab")
open = 3;
else if (opt == "window")
@@ -1107,7 +1107,7 @@ const Tabs = Module("tabs", {
options.safeSetPref("browser.link.open_newwindow", open, "See 'popups' option.");
options.safeSetPref("browser.link.open_newwindow.restriction", restriction, "See 'popups' option.");
return value;
return values;
},
completer: function (context) [
["tab", "Open popups in a new tab"],

2
common/content/template.js
View File

@@ -194,8 +194,6 @@ const Template = Module("template", {
return <>:{commandline.command}<br/>{xml}</>;
},
// every item must have a .xml property which defines how to draw itself
// @param headers is an array of strings, the text for the header columns
genericTable: function genericTable(items, format) {
completion.listCompleter(function (context) {
context.filterFunc = null;