~ubuntu-branches/ubuntu/trusty/yelp-xsl/trusty

// Return the inner text of an element - must preserve whitespace.

// Avoid returning \r characters.

Syntax.innerText = function(element) {

        var text;

        

        if (!element) {

                return "";

        }

        

        if (element.nodeName == 'BR') {

                return '\n';

        } else if (element.textContent) {

                // W3C: FF, Safari, Chrome, etc.

                text = element.textContent;

        } else if (document.body.innerText) {

                // IE, other older browsers.

                text = element.innerText;

        }

        

        return text.replace(/\r\n?/g, '\n');

                                var text = Syntax.innerText(elem);

                                matches.push(new Syntax.Match(offset, text.length, {

                                        klass: elem.className,

                                        force: true,

                                        element: elem,

                                        allow: '*'

                                }, text));

                        if (elem.nodeType !== 8 && elem.children) {

// Basic layout doesn't do anything e.g. identity layout.

// Should be obvious right?

// This function converts from a compressed set of offsets of the form:

//      [

//              [offset, width, totalOffset],

//              ...

//      ]

// This means that at a $offset, a tab (single character) was expanded to $width

// single space characters.

// This function produces a lookup table of offsets, where a given character offset

// is mapped to how far the character has been offset.

                        // Is there a next offset?

                        if (offsets[current+1]) {

                                // Is the index less than the start of the next offset?

                                if (i <= offsets[current+1][0]) {

                                        changes.push(offsets[current][2]);

                                } else {

                                        // If so, move to the next offset.

                                        current += 1;

                                        i -= 1;

                                }

                        } else {

                                // If there is no next offset we assume this one to the end.

// Used for tab expansion process, by shifting matches when tab charaters were converted to

// spaces.

// A helper function which automatically matches expressions with capture groups from the regular expression match.

// Each argument position corresponds to the same index regular expression group.

// Or, override by providing rule.index

                                        matches.push(Syntax.Brush.buildTree(rule, match[index], RegExp.indexOf(match, index)));

// Used to create processing functions that automatically link to remote documentation.

        return function (element, match, options) {

                // Per-code block linkification control.

                if (options.linkify === false)

                        return element;

                

                var a = document.createElement('a');

                a.href = queryURI + encodeURIComponent(Syntax.innerText(element));

                a.className = element.className;

                

                // Move children from <element> to <a>

                while (element.childNodes.length > 0)

                        a.appendChild(element.childNodes[0]);

                

                return a;

// Global brush registration function.

// Library of helper patterns

Syntax.lib.perlStyleRegularExpression = {pattern: /\B\/([^\/]|\\\/)*?\/[a-z]*(?=\s*($|[^\w\s'"\(]))/gm, klass: 'constant', incremental: true};

Syntax.lib.cStyleType = {pattern: /\b[_a-z][_\w]*_t\b/gi, klass: 'type'};

// Main match constructor. Make sure value is the correct size.

// Sort helper for sorting matches in forward order (e.g. same as the text that they were extracted from)

// Is the given match contained in the range of the parent match?

// Reduce a givent tree node into an html node.

        container.appendChild(node);

// Convert a tree of matches into some flat form (typically HTML nodes).

        var container = document.createElement('span');

                if (container.className.length > 0)

                        container.className += ' ';

                

                container.className += this.expression.klass;

// Main nesting check - can a match contain the given match?

// Return true if the given match can be spliced in as a child.

// Checked automatically when calling _splice.

// Add a child into the list of children for a given match, if it is acceptable to do so.

// Updates the owner of the match.

// Returns null if splice failed.

// the tree, thus some parts of the tree may need to be split. This behavior is controlled

// by whole - if true, the tree is split, if false, the match is split.

Syntax.Match.prototype.insert = function(match, whole) {

        if (whole) {

                var top = this, i = 0;

                while (i < top.children.length) {

                        if (top.children[i].contains(match)) {

                                top = top.children[i];

                                i = 0;

                        } else {

                                i += 1;

                        }

                }

                

                return top._insertWhole(match);

        } else {

                return this._insert(match);

        }

}

 

Syntax.Match.prototype._insertWhole = function(match) {

        var parts = this.bisectAtOffsets([match.offset, match.endOffset])

        this.children = [];

        

        if (parts[0]) {

                this.children = this.children.concat(parts[0].children);

        }

        

        if (parts[1]) {

                match.children = [];

                

                // Update the match's expression based on the current position in the tree:

                if (this.expression && this.expression.owner) {

                        match.expression = this.expression.owner.getRuleForKlass(match.expression.klass) || match.expression;

                }

                

                // This probably isn't ideal, it would be better to convert all children and children-of-children

                // into a linear array and reinsert - it would be slightly more accurate in many cases.

                for (var i = 0; i < parts[1].children.length; i += 1) {

                        var child = parts[1].children[i];

                        

                        if (match.canContain(child)) {

                                match.children.push(child);

                        }

                }

                

                this.children.push(match);

        }

        

        if (parts[2]) {

                this.children = this.children.concat(parts[2].children);

        }

        

        return this;

Syntax.Match.prototype.insertAtEnd = function(match) {

// several children. This function is used infrequently and is mostly for completeness. However,

// it might be possible to remove it to reduce code.

                // console.log("Bisect at offsets", match, child.offset, child.endOffset);

                // console.log("parts =", parts);

// Split a match at points in the tree that match a specific regular expression pattern.

// Uses the fast tree bisection algorithm, performance should be bounded O(S log N) where N is

// the total number of matches and S is the number of splits (?).

                apply: function(text, expr) {

                        return Syntax.brushes[name].getMatches(text);

Syntax.Brush.convertStringToTokenPattern = function (pattern, escape) {

        var prefix = "\\b", postfix = "\\b";

        

        if (!pattern.match(/^\w/)) {

                if (!pattern.match(/\w$/)) {

                        prefix = postfix = "";

                } else {

                        prefix = "\\B";

                }

        } else {

                if (!pattern.match(/\w$/)) {

                        postfix = "\\B";

                }

        }

        

        if (escape)

                pattern = RegExp.escape(pattern)

        

        return prefix + pattern + postfix;

}

 

Syntax.Brush.MatchPattern = function (text, rule) {

        if (!rule.pattern)

                return [];

        

        // Duplicate the pattern so that the function is reentrant.

        var matches = [], pattern = new RegExp;

        pattern.compile(rule.pattern);

        

        while((match = pattern.exec(text)) !== null) {

                if (rule.matches) {

                        matches = matches.concat(rule.matches(match, rule));

                } else if (rule.brush) {

                        matches.push(Syntax.Brush.buildTree(rule, match[0], match.index));

                } else {

                        matches.push(new Syntax.Match(match.index, match[0].length, rule, match[0]));

                }

                

                if (rule.incremental) {

                        // Don't start scanning from the end of the match..

                        pattern.lastIndex = match.index + 1;

                }

        }

        

        return matches;

}

 

                var all = "(";

                

                        if (i > 0) all += "|";

                        

                        var p = patterns[i];

                        

                        if (p instanceof RegExp) {

                                all += p.source;

                        } else {

                                all += Syntax.Brush.convertStringToTokenPattern(p, true);

                        }

                

                all += ")";

                

                this.push(jQuery.extend({

                        pattern: new RegExp(all, rule.options || 'g')

                }, rule));

                

                // Default pattern extraction algorithm

                rule.apply = rule.apply || Syntax.Brush.MatchPattern;

                if (rule.pattern && rule.pattern.global || typeof(rule.pattern) == 'undefined') {

                } else {

Syntax.Brush.prototype.getMatchesForRule = function (text, rule) {

        if (typeof(rule.apply) != 'undefined') {

                matches = rule.apply(text, rule);

                Syntax.log("Syntax matches:", rule, text, matches);

Syntax.Brush.prototype.getRuleForKlass = function (klass) {

        for (var i = 0; i < this.rules.length; i += 1) {

                if (this.rules[i].klass == klass) {

                        return this.rules[i];

                }

        }

        

        return null;

}

 

// Get all matches from a given block of text.

Syntax.Brush.prototype.getMatches = function(text) {

                matches = matches.concat(this.getMatchesForRule(text, this.rules[i]));

// A helper function for building a tree from a specific rule.

// Typically used where sub-trees are required, e.g. CSS brush in HTML brush.

Syntax.Brush.buildTree = function(rule, text, offset, additionalMatches) {

        var match = Syntax.brushes[rule.brush].buildTree(text, offset, additionalMatches);

        

        jQuery.extend(match.expression, rule);

        

        return match;

}

 

// This function builds a tree from a given block of text.

// This is done by applying all rules to the text to get a complete list of matches,

// sorting them in order, and inserting them into a syntax tree data structure.

// Additional matches are forcefully inserted into the tree.

// Provide an offset if the text is offset in a larger block of text. Matches

// will be shifted along appropriately.

        text = text.replace(/\r/g, '');

        

        var matches = this.getMatches(text);

        

        // Shift matches if offset is provided.

        if (offset && offset > 0) {

                for (var i = 0; i < matches.length; i += 1) {

                        matches[i].shift(offset);

                }

        }

// This function builds a syntax tree from the given text and matches (optional).

// The syntax tree is then flattened into html using a variety of functions.

//

// By default, you can't control reduction process through this function, but

// it is possible to control the element conversion process by replace

// .reduce(null, ...) with  .reduce(reduceCallback, ...)

// See Syntax.Match.defaultReduceCallback for more details about interface.

//

// Matches is optional, and provides a set of pre-existing matches to add

// to the tree.

// Options are passed to element level processing functions.

Syntax.Brush.prototype.process = function(text, matches, options) {

        var html = document.createElement('pre');

        html.className = 'syntax';

                                        container = match.expression.process(container, match, options);

                                if (match.expression.owner) {

                                        var process = match.expression.owner.processes[match.expression.klass];

                                        if (process) {

                                                container = process(container, match, options);

                                        }

                html.appendChild(line);

// Highlights a given block of text with a given set of options.

// options.brush should specify the brush to use, either by direct reference

// or name.

// Callback will be called with (highlighted_html, brush_used, original_text, options)

Syntax.highlightText = function(text, options, callback) {

        var brushName = (options.brush || 'plain').toLowerCase();

        

        brushName = Syntax.aliases[brushName] || brushName;

        

        Syntax.brushes.get(brushName, function(brush) {

                if (options.tabWidth) {

                        // Calculate the tab expansion and offsets

                        replacement = Syntax.convertTabsToSpaces(text, options.tabWidth);

                        

                        // Update any existing matches

                        if (options.matches && options.matches.length) {

                                var linearOffsets = Syntax.convertToLinearOffsets(replacement.offsets, text.length);

                                options.matches = Syntax.updateMatchesWithOffsets(options.matches, linearOffsets, replacement.text);

                        }

                        

                        text = replacement.text;

                }

                

                var html = brush.process(text, options.matches, options);

                

                if (options.linkify !== false) {

                        jQuery('span.href', html).each(function(){

                                jQuery(this).replaceWith(jQuery('<a>').attr('href', this.innerHTML).text(this.innerHTML));

                        });

                }

                

                callback(html, brush, text, options);

        });

}

 

// Highlight a given set of elements with a set of options.

// Callback will be called once per element with (options, highlighted_html, original_container)

        options.matches = [];

                // We can augment the plain text to extract existing annotations (e.g. <span class="foo">...</span>).

                options.matches = options.matches.concat(Syntax.extractElementMatches(container));

                

                var text = Syntax.innerText(this);

 

 

 

 

                Syntax.highlightText(text, options, function(html, brush/*, text, options*/) {

                                html = layout(options, $(html), $(container));

 

                                // If there is a theme specified, ensure it is added to the top level class.

                                if (options.theme) {

                                        // Load dependencies

                                        var themes = Syntax.themes[options.theme];

                                        for (var i = 0; i < themes.length; i += 1) {

                                                html.addClass("syntax-theme-" + themes[i]);

                                        }

 

                                        // Add the base theme

                                        html.addClass("syntax-theme-" + options.theme);

                                }