munger.js - mozsearch

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

 * 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/. */

/* Constructs a new munger entry, using a regexp or lambda match function, and

 * a class name (to be applied by the munger itself) or lambda replace

 * function, and the default enabled state and a start priority (used if two

 * rules match at the same index), as well as a default tag (when the munger

 * adds it based on the class name) name.

 * Regular Expressions for matching should ensure that the first capturing

 * group is the one that contains the matched text. Non-capturing groups, of

 * zero-width or otherwise can be used before and after, to ensure the right

 * things are matched (e.g. to ensure whitespace before something).

 * Note that for RegExp matching, the munger will search for the matched text

 * (from the first capturing group) from the leftmost point of the entire

 * match. This means that if the text that matched the first group occurs in

 * any part of the match before the group, the munger will apply to the wrong

 * bit. This is not usually a problem, but if it is you should use a

 * lambdaMatch function and be sure to return the new style return value,

 * which specifically indicates the start.

 * The lambda match and lambda replace functions have this signature:

 *   lambdaMatch(text, containerTag, data, mungerEntry)

 *   lambdaReplace(text, containerTag, data, mungerEntry)

 *     - text is the entire text to find a match in/that has matched

 *     - containerTag is the element containing the text (not useful?)

 *     - data is a generic object containing properties kept throughout

 *     - mungerEntry is the CMungerEntry object for the munger itself

 *   The lambdaReplace function is expected to do everything needed to put

 *   |text| into |containerTab| ready for display.

 *   The return value for lambda match functions should be either:

 *     - (old style) just the text that matched

 *       (the munger will search for this text, and uses the first match)

 *     - (new style) an object with properties:

 *       - start (start index, 0 = first character)

 *       - text  (matched text)

 *       (note that |text| must start at index |start|)

 *   The return value for lambda replace functions are not used.

*/

function CMungerEntry(name, regex, className, priority, startPriority,

                      enable, tagName)

    this.name = name;

    if (name[0] != ".")

        this.description = getMsg("munger." + name, null, null);

    this.enabled = (typeof enable == "undefined" ? true : enable);

    this.enabledDefault = this.enabled;

    this.startPriority = (startPriority) ? startPriority : 0;

    this.priority = priority;

    this.tagName = (tagName) ? tagName : "html:span";

    if (isinstance(regex, RegExp))

        this.regex = regex;

    else

        this.lambdaMatch = regex;

    if (typeof className == "function")

        this.lambdaReplace = className;

    else

        this.className = className;

function CMunger(textMunger)

    this.entries = new Array();

    this.tagName = "html:span";

    this.enabled = true;

    if (textMunger)

        this.insertPlainText = textMunger;

CMunger.prototype.enabled = true;

CMunger.prototype.insertPlainText = insertText;

CMunger.prototype.getRule =

function mng_getrule(name)

    for (var p in this.entries)

        if (isinstance(this.entries[p], Object))

            if (name in this.entries[p])

                return this.entries[p][name];

    return null;

CMunger.prototype.addRule =

function mng_addrule(name, regex, className, priority, startPriority, enable)

    if (typeof this.entries[priority] != "object")

        this.entries[priority] = new Object();

    var entry = new CMungerEntry(name, regex, className, priority,

                                 startPriority, enable);

    this.entries[priority][name] = entry;

CMunger.prototype.delRule =

function mng_delrule(name)

    for (var i in this.entries)

        if (typeof this.entries[i] == "object")

            if (name in this.entries[i])

                delete this.entries[i][name];

CMunger.prototype.munge =

function mng_munge(text, containerTag, data)

    if (!containerTag)

        containerTag = document.createElementNS(XHTML_NS, this.tagName);

    // Starting from the top, for each valid priority, check all the rules,

    // return as soon as something matches.

    if (this.enabled)

        for (var i = this.entries.length - 1; i >= 0; i--)

            if (i in this.entries)

                if (this.mungePriority(i, text, containerTag, data))

                    return containerTag;

    // If nothing matched, we don't have to do anything,

    // just insert text (if any).

    if (text)

        this.insertPlainText(text, containerTag, data);

    return containerTag;

CMunger.prototype.mungePriority =

function mng_mungePriority(priority, text, containerTag, data)

    var matches = new Object();

    var entry;

    // Find all the matches in this priority

    for (entry in this.entries[priority])

        var munger = this.entries[priority][entry];

        if (!munger.enabled)

            continue;

        var match = null;

        if (typeof munger.lambdaMatch == "function")

            var rval = munger.lambdaMatch(text, containerTag, data, munger);

            if (typeof rval == "string")

                match = { start: text.indexOf(rval), text: rval };

            else if (typeof rval == "object")

                match = rval;

        else

            var ary = text.match(munger.regex);

            if ((ary != null) && (ary[1]))

                match = { start: text.indexOf(ary[1]), text: ary[1] };

        if (match && (match.start >= 0))

            match.munger = munger;

            matches[entry] = match;

    // Find the first matching entry...

    var firstMatch = { start: text.length, munger: null };

    var firstPriority = 0;

    for (entry in matches)

        // If it matches before the existing first, or at the same spot but

        // with a higher start-priority, this is a better match.

        if (matches[entry].start < firstMatch.start ||

            ((matches[entry].start == firstMatch.start) &&

             (this.entries[priority][entry].startPriority > firstPriority)))

            firstMatch = matches[entry];

            firstPriority = this.entries[priority][entry].startPriority;

    // Replace it.

    if (firstMatch.munger)

        var munger = firstMatch.munger;

        firstMatch.end = firstMatch.start + firstMatch.text.length;

        // Need to deal with the text before the match, if there is any.

        var beforeText = text.substr(0, firstMatch.start);

        if (firstMatch.start > 0)

            this.munge(beforeText, containerTag, data);

        if (typeof munger.lambdaReplace == "function")

            // The munger rule itself should take care of munging the 'inside'

            // of the match.

            munger.lambdaReplace(firstMatch.text, containerTag, data, munger);

            this.munge(text.substr(firstMatch.end), containerTag, data);

            return containerTag;

        else

            var tag = document.createElementNS(XHTML_NS, munger.tagName);

            tag.setAttribute("class", munger.className + calcClass(data));

            // Don't let this rule match again when we recurse.

            munger.enabled = false;

            this.munge(firstMatch.text, tag, data);

            munger.enabled = true;

            containerTag.appendChild(tag);

            this.munge(text.substr(firstMatch.end), containerTag, data);

            return containerTag;

    return null;

function insertText(text, containerTag, data)

    var textNode = document.createTextNode(text);

    containerTag.appendChild(textNode);