[DRE-commits] [SCM] ruby-railties-3.2.git branch, master, updated. debian/3.2.3-1-3-g1b60900
Ondřej Surý
ondrej at sury.org
Wed May 23 11:41:46 UTC 2012
The following commit has been merged in the master branch:
commit 96cb7a1f7ff3b7cef516f3dd626da0c19aa85f61
Author: Ondřej Surý <ondrej at sury.org>
Date: Wed May 23 13:41:24 2012 +0200
Add raw source code for SyntaxHighlighter
diff --git a/debian/patches/series b/debian/patches/series
index 7458898..c06c7e5 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +1,2 @@
+syntaxhighlighter-source.patch
remove-rubygems.patch
diff --git a/debian/patches/syntaxhighlighter-source.patch b/debian/patches/syntaxhighlighter-source.patch
new file mode 100644
index 0000000..50dbd9c
--- /dev/null
+++ b/debian/patches/syntaxhighlighter-source.patch
@@ -0,0 +1,2017 @@
+--- /dev/null
++++ b/guides/assets/javascripts/syntaxhighlighter/src/shAutoloader.js
+@@ -0,0 +1,130 @@
++/**
++ * SyntaxHighlighter
++ * http://alexgorbatchev.com/SyntaxHighlighter
++ *
++ * SyntaxHighlighter is donationware. If you are using it, please donate.
++ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
++ *
++ * @version
++ * 3.0.83 (July 02 2010)
++ *
++ * @copyright
++ * Copyright (C) 2004-2010 Alex Gorbatchev.
++ *
++ * @license
++ * Dual licensed under the MIT and GPL licenses.
++ */
++(function() {
++
++var sh = SyntaxHighlighter;
++
++/**
++ * Provides functionality to dynamically load only the brushes that a needed to render the current page.
++ *
++ * There are two syntaxes that autoload understands. For example:
++ *
++ * SyntaxHighlighter.autoloader(
++ * [ 'applescript', 'Scripts/shBrushAppleScript.js' ],
++ * [ 'actionscript3', 'as3', 'Scripts/shBrushAS3.js' ]
++ * );
++ *
++ * or a more easily comprehendable one:
++ *
++ * SyntaxHighlighter.autoloader(
++ * 'applescript Scripts/shBrushAppleScript.js',
++ * 'actionscript3 as3 Scripts/shBrushAS3.js'
++ * );
++ */
++sh.autoloader = function()
++{
++ var list = arguments,
++ elements = sh.findElements(),
++ brushes = {},
++ scripts = {},
++ all = SyntaxHighlighter.all,
++ allCalled = false,
++ allParams = null,
++ i
++ ;
++
++ SyntaxHighlighter.all = function(params)
++ {
++ allParams = params;
++ allCalled = true;
++ };
++
++ function addBrush(aliases, url)
++ {
++ for (var i = 0; i < aliases.length; i++)
++ brushes[aliases[i]] = url;
++ };
++
++ function getAliases(item)
++ {
++ return item.pop
++ ? item
++ : item.split(/\s+/)
++ ;
++ }
++
++ // create table of aliases and script urls
++ for (i = 0; i < list.length; i++)
++ {
++ var aliases = getAliases(list[i]),
++ url = aliases.pop()
++ ;
++
++ addBrush(aliases, url);
++ }
++
++ // dynamically add <script /> tags to the document body
++ for (i = 0; i < elements.length; i++)
++ {
++ var url = brushes[elements[i].params.brush];
++
++ if (!url)
++ continue;
++
++ scripts[url] = false;
++ loadScript(url);
++ }
++
++ function loadScript(url)
++ {
++ var script = document.createElement('script'),
++ done = false
++ ;
++
++ script.src = url;
++ script.type = 'text/javascript';
++ script.language = 'javascript';
++ script.onload = script.onreadystatechange = function()
++ {
++ if (!done && (!this.readyState || this.readyState == 'loaded' || this.readyState == 'complete'))
++ {
++ done = true;
++ scripts[url] = true;
++ checkAll();
++
++ // Handle memory leak in IE
++ script.onload = script.onreadystatechange = null;
++ script.parentNode.removeChild(script);
++ }
++ };
++
++ // sync way of adding script tags to the page
++ document.body.appendChild(script);
++ };
++
++ function checkAll()
++ {
++ for(var url in scripts)
++ if (scripts[url] == false)
++ return;
++
++ if (allCalled)
++ SyntaxHighlighter.highlight(allParams);
++ };
++};
++
++})();
+--- /dev/null
++++ b/guides/assets/javascripts/syntaxhighlighter/src/shCore.js
+@@ -0,0 +1,1721 @@
++/**
++ * SyntaxHighlighter
++ * http://alexgorbatchev.com/SyntaxHighlighter
++ *
++ * SyntaxHighlighter is donationware. If you are using it, please donate.
++ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
++ *
++ * @version
++ * 3.0.83 (July 02 2010)
++ *
++ * @copyright
++ * Copyright (C) 2004-2010 Alex Gorbatchev.
++ *
++ * @license
++ * Dual licensed under the MIT and GPL licenses.
++ */
++//
++// Begin anonymous function. This is used to contain local scope variables without polutting global scope.
++//
++var SyntaxHighlighter = function() {
++
++// CommonJS
++if (typeof(require) != 'undefined' && typeof(XRegExp) == 'undefined')
++{
++ XRegExp = require('XRegExp').XRegExp;
++}
++
++// Shortcut object which will be assigned to the SyntaxHighlighter variable.
++// This is a shorthand for local reference in order to avoid long namespace
++// references to SyntaxHighlighter.whatever...
++var sh = {
++ defaults : {
++ /** Additional CSS class names to be added to highlighter elements. */
++ 'class-name' : '',
++
++ /** First line number. */
++ 'first-line' : 1,
++
++ /**
++ * Pads line numbers. Possible values are:
++ *
++ * false - don't pad line numbers.
++ * true - automaticaly pad numbers with minimum required number of leading zeroes.
++ * [int] - length up to which pad line numbers.
++ */
++ 'pad-line-numbers' : false,
++
++ /** Lines to highlight. */
++ 'highlight' : null,
++
++ /** Title to be displayed above the code block. */
++ 'title' : null,
++
++ /** Enables or disables smart tabs. */
++ 'smart-tabs' : true,
++
++ /** Gets or sets tab size. */
++ 'tab-size' : 4,
++
++ /** Enables or disables gutter. */
++ 'gutter' : true,
++
++ /** Enables or disables toolbar. */
++ 'toolbar' : true,
++
++ /** Enables quick code copy and paste from double click. */
++ 'quick-code' : true,
++
++ /** Forces code view to be collapsed. */
++ 'collapse' : false,
++
++ /** Enables or disables automatic links. */
++ 'auto-links' : true,
++
++ /** Gets or sets light mode. Equavalent to turning off gutter and toolbar. */
++ 'light' : false,
++
++ 'html-script' : false
++ },
++
++ config : {
++ space : ' ',
++
++ /** Enables use of <SCRIPT type="syntaxhighlighter" /> tags. */
++ useScriptTags : true,
++
++ /** Blogger mode flag. */
++ bloggerMode : false,
++
++ stripBrs : false,
++
++ /** Name of the tag that SyntaxHighlighter will automatically look for. */
++ tagName : 'pre',
++
++ strings : {
++ expandSource : 'expand source',
++ help : '?',
++ alert: 'SyntaxHighlighter\n\n',
++ noBrush : 'Can\'t find brush for: ',
++ brushNotHtmlScript : 'Brush wasn\'t configured for html-script option: ',
++
++ // this is populated by the build script
++ aboutDialog : '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>About SyntaxHighlighter</title></head><body style="font-family:Geneva,Arial,Helvetica,sans-serif;background-color:#fff;color:#000;font-size:1em;text-align:center;"><div style="text-align:center;margin-top:1.5em;"><div style="font-size:xx-large;">SyntaxHighlighter</div><div style="font-size:.75em;margin-bottom:3em;"><div>version 3.0.83 (July 02 2010)</div><div><a href="http://alexgorbatchev.com/SyntaxHighlighter" target="_blank" style="color:#005896">http://alexgorbatchev.com/SyntaxHighlighter</a></div><div>JavaScript code syntax highlighter.</div><div>Copyright 2004-2010 Alex Gorbatchev.</div></div><div>If you like this script, please <a href="https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=2930402" style="color:#005896">donate</a> to <br/>keep development active!</div></div></body></html>'
++ }
++ },
++
++ /** Internal 'global' variables. */
++ vars : {
++ discoveredBrushes : null,
++ highlighters : {}
++ },
++
++ /** This object is populated by user included external brush files. */
++ brushes : {},
++
++ /** Common regular expressions. */
++ regexLib : {
++ multiLineCComments : /\/\*[\s\S]*?\*\//gm,
++ singleLineCComments : /\/\/.*$/gm,
++ singleLinePerlComments : /#.*$/gm,
++ doubleQuotedString : /"([^\\"\n]|\\.)*"/g,
++ singleQuotedString : /'([^\\'\n]|\\.)*'/g,
++ multiLineDoubleQuotedString : new XRegExp('"([^\\\\"]|\\\\.)*"', 'gs'),
++ multiLineSingleQuotedString : new XRegExp("'([^\\\\']|\\\\.)*'", 'gs'),
++ xmlComments : /(<|<)!--[\s\S]*?--(>|>)/gm,
++ url : /\w+:\/\/[\w-.\/?%&=:@;]*/g,
++
++ /** <?= ?> tags. */
++ phpScriptTags : { left: /(<|<)\?=?/g, right: /\?(>|>)/g },
++
++ /** <%= %> tags. */
++ aspScriptTags : { left: /(<|<)%=?/g, right: /%(>|>)/g },
++
++ /** <script></script> tags. */
++ scriptScriptTags : { left: /(<|<)\s*script.*?(>|>)/gi, right: /(<|<)\/\s*script\s*(>|>)/gi }
++ },
++
++ toolbar: {
++ /**
++ * Generates HTML markup for the toolbar.
++ * @param {Highlighter} highlighter Highlighter instance.
++ * @return {String} Returns HTML markup.
++ */
++ getHtml: function(highlighter)
++ {
++ var html = '<div class="toolbar">',
++ items = sh.toolbar.items,
++ list = items.list
++ ;
++
++ function defaultGetHtml(highlighter, name)
++ {
++ return sh.toolbar.getButtonHtml(highlighter, name, sh.config.strings[name]);
++ };
++
++ for (var i = 0; i < list.length; i++)
++ html += (items[list[i]].getHtml || defaultGetHtml)(highlighter, list[i]);
++
++ html += '</div>';
++
++ return html;
++ },
++
++ /**
++ * Generates HTML markup for a regular button in the toolbar.
++ * @param {Highlighter} highlighter Highlighter instance.
++ * @param {String} commandName Command name that would be executed.
++ * @param {String} label Label text to display.
++ * @return {String} Returns HTML markup.
++ */
++ getButtonHtml: function(highlighter, commandName, label)
++ {
++ return '<span><a href="#" class="toolbar_item'
++ + ' command_' + commandName
++ + ' ' + commandName
++ + '">' + label + '</a></span>'
++ ;
++ },
++
++ /**
++ * Event handler for a toolbar anchor.
++ */
++ handler: function(e)
++ {
++ var target = e.target,
++ className = target.className || ''
++ ;
++
++ function getValue(name)
++ {
++ var r = new RegExp(name + '_(\\w+)'),
++ match = r.exec(className)
++ ;
++
++ return match ? match[1] : null;
++ };
++
++ var highlighter = getHighlighterById(findParentElement(target, '.syntaxhighlighter').id),
++ commandName = getValue('command')
++ ;
++
++ // execute the toolbar command
++ if (highlighter && commandName)
++ sh.toolbar.items[commandName].execute(highlighter);
++
++ // disable default A click behaviour
++ e.preventDefault();
++ },
++
++ /** Collection of toolbar items. */
++ items : {
++ // Ordered lis of items in the toolbar. Can't expect `for (var n in items)` to be consistent.
++ list: ['expandSource', 'help'],
++
++ expandSource: {
++ getHtml: function(highlighter)
++ {
++ if (highlighter.getParam('collapse') != true)
++ return '';
++
++ var title = highlighter.getParam('title');
++ return sh.toolbar.getButtonHtml(highlighter, 'expandSource', title ? title : sh.config.strings.expandSource);
++ },
++
++ execute: function(highlighter)
++ {
++ var div = getHighlighterDivById(highlighter.id);
++ removeClass(div, 'collapsed');
++ }
++ },
++
++ /** Command to display the about dialog window. */
++ help: {
++ execute: function(highlighter)
++ {
++ var wnd = popup('', '_blank', 500, 250, 'scrollbars=0'),
++ doc = wnd.document
++ ;
++
++ doc.write(sh.config.strings.aboutDialog);
++ doc.close();
++ wnd.focus();
++ }
++ }
++ }
++ },
++
++ /**
++ * Finds all elements on the page which should be processes by SyntaxHighlighter.
++ *
++ * @param {Object} globalParams Optional parameters which override element's
++ * parameters. Only used if element is specified.
++ *
++ * @param {Object} element Optional element to highlight. If none is
++ * provided, all elements in the current document
++ * are returned which qualify.
++ *
++ * @return {Array} Returns list of <code>{ target: DOMElement, params: Object }</code> objects.
++ */
++ findElements: function(globalParams, element)
++ {
++ var elements = element ? [element] : toArray(document.getElementsByTagName(sh.config.tagName)),
++ conf = sh.config,
++ result = []
++ ;
++
++ // support for <SCRIPT TYPE="syntaxhighlighter" /> feature
++ if (conf.useScriptTags)
++ elements = elements.concat(getSyntaxHighlighterScriptTags());
++
++ if (elements.length === 0)
++ return result;
++
++ for (var i = 0; i < elements.length; i++)
++ {
++ var item = {
++ target: elements[i],
++ // local params take precedence over globals
++ params: merge(globalParams, parseParams(elements[i].className))
++ };
++
++ if (item.params['brush'] == null)
++ continue;
++
++ result.push(item);
++ }
++
++ return result;
++ },
++
++ /**
++ * Shorthand to highlight all elements on the page that are marked as
++ * SyntaxHighlighter source code.
++ *
++ * @param {Object} globalParams Optional parameters which override element's
++ * parameters. Only used if element is specified.
++ *
++ * @param {Object} element Optional element to highlight. If none is
++ * provided, all elements in the current document
++ * are highlighted.
++ */
++ highlight: function(globalParams, element)
++ {
++ var elements = this.findElements(globalParams, element),
++ propertyName = 'innerHTML',
++ highlighter = null,
++ conf = sh.config
++ ;
++
++ if (elements.length === 0)
++ return;
++
++ for (var i = 0; i < elements.length; i++)
++ {
++ var element = elements[i],
++ target = element.target,
++ params = element.params,
++ brushName = params.brush,
++ code
++ ;
++
++ if (brushName == null)
++ continue;
++
++ // Instantiate a brush
++ if (params['html-script'] == 'true' || sh.defaults['html-script'] == true)
++ {
++ highlighter = new sh.HtmlScript(brushName);
++ brushName = 'htmlscript';
++ }
++ else
++ {
++ var brush = findBrush(brushName);
++
++ if (brush)
++ highlighter = new brush();
++ else
++ continue;
++ }
++
++ code = target[propertyName];
++
++ // remove CDATA from <SCRIPT/> tags if it's present
++ if (conf.useScriptTags)
++ code = stripCData(code);
++
++ // Inject title if the attribute is present
++ if ((target.title || '') != '')
++ params.title = target.title;
++
++ params['brush'] = brushName;
++ highlighter.init(params);
++ element = highlighter.getDiv(code);
++
++ // carry over ID
++ if ((target.id || '') != '')
++ element.id = target.id;
++
++ target.parentNode.replaceChild(element, target);
++ }
++ },
++
++ /**
++ * Main entry point for the SyntaxHighlighter.
++ * @param {Object} params Optional params to apply to all highlighted elements.
++ */
++ all: function(params)
++ {
++ attachEvent(
++ window,
++ 'load',
++ function() { sh.highlight(params); }
++ );
++ }
++}; // end of sh
++
++sh['all'] = sh.all;
++sh['highlight'] = sh.highlight;
++
++/**
++ * Checks if target DOM elements has specified CSS class.
++ * @param {DOMElement} target Target DOM element to check.
++ * @param {String} className Name of the CSS class to check for.
++ * @return {Boolean} Returns true if class name is present, false otherwise.
++ */
++function hasClass(target, className)
++{
++ return target.className.indexOf(className) != -1;
++};
++
++/**
++ * Adds CSS class name to the target DOM element.
++ * @param {DOMElement} target Target DOM element.
++ * @param {String} className New CSS class to add.
++ */
++function addClass(target, className)
++{
++ if (!hasClass(target, className))
++ target.className += ' ' + className;
++};
++
++/**
++ * Removes CSS class name from the target DOM element.
++ * @param {DOMElement} target Target DOM element.
++ * @param {String} className CSS class to remove.
++ */
++function removeClass(target, className)
++{
++ target.className = target.className.replace(className, '');
++};
++
++/**
++ * Converts the source to array object. Mostly used for function arguments and
++ * lists returned by getElementsByTagName() which aren't Array objects.
++ * @param {List} source Source list.
++ * @return {Array} Returns array.
++ */
++function toArray(source)
++{
++ var result = [];
++
++ for (var i = 0; i < source.length; i++)
++ result.push(source[i]);
++
++ return result;
++};
++
++/**
++ * Splits block of text into lines.
++ * @param {String} block Block of text.
++ * @return {Array} Returns array of lines.
++ */
++function splitLines(block)
++{
++ return block.split('\n');
++}
++
++/**
++ * Generates HTML ID for the highlighter.
++ * @param {String} highlighterId Highlighter ID.
++ * @return {String} Returns HTML ID.
++ */
++function getHighlighterId(id)
++{
++ var prefix = 'highlighter_';
++ return id.indexOf(prefix) == 0 ? id : prefix + id;
++};
++
++/**
++ * Finds Highlighter instance by ID.
++ * @param {String} highlighterId Highlighter ID.
++ * @return {Highlighter} Returns instance of the highlighter.
++ */
++function getHighlighterById(id)
++{
++ return sh.vars.highlighters[getHighlighterId(id)];
++};
++
++/**
++ * Finds highlighter's DIV container.
++ * @param {String} highlighterId Highlighter ID.
++ * @return {Element} Returns highlighter's DIV element.
++ */
++function getHighlighterDivById(id)
++{
++ return document.getElementById(getHighlighterId(id));
++};
++
++/**
++ * Stores highlighter so that getHighlighterById() can do its thing. Each
++ * highlighter must call this method to preserve itself.
++ * @param {Highilghter} highlighter Highlighter instance.
++ */
++function storeHighlighter(highlighter)
++{
++ sh.vars.highlighters[getHighlighterId(highlighter.id)] = highlighter;
++};
++
++/**
++ * Looks for a child or parent node which has specified classname.
++ * Equivalent to jQuery's $(container).find(".className")
++ * @param {Element} target Target element.
++ * @param {String} search Class name or node name to look for.
++ * @param {Boolean} reverse If set to true, will go up the node tree instead of down.
++ * @return {Element} Returns found child or parent element on null.
++ */
++function findElement(target, search, reverse /* optional */)
++{
++ if (target == null)
++ return null;
++
++ var nodes = reverse != true ? target.childNodes : [ target.parentNode ],
++ propertyToFind = { '#' : 'id', '.' : 'className' }[search.substr(0, 1)] || 'nodeName',
++ expectedValue,
++ found
++ ;
++
++ expectedValue = propertyToFind != 'nodeName'
++ ? search.substr(1)
++ : search.toUpperCase()
++ ;
++
++ // main return of the found node
++ if ((target[propertyToFind] || '').indexOf(expectedValue) != -1)
++ return target;
++
++ for (var i = 0; nodes && i < nodes.length && found == null; i++)
++ found = findElement(nodes[i], search, reverse);
++
++ return found;
++};
++
++/**
++ * Looks for a parent node which has specified classname.
++ * This is an alias to <code>findElement(container, className, true)</code>.
++ * @param {Element} target Target element.
++ * @param {String} className Class name to look for.
++ * @return {Element} Returns found parent element on null.
++ */
++function findParentElement(target, className)
++{
++ return findElement(target, className, true);
++};
++
++/**
++ * Finds an index of element in the array.
++ * @ignore
++ * @param {Object} searchElement
++ * @param {Number} fromIndex
++ * @return {Number} Returns index of element if found; -1 otherwise.
++ */
++function indexOf(array, searchElement, fromIndex)
++{
++ fromIndex = Math.max(fromIndex || 0, 0);
++
++ for (var i = fromIndex; i < array.length; i++)
++ if(array[i] == searchElement)
++ return i;
++
++ return -1;
++};
++
++/**
++ * Generates a unique element ID.
++ */
++function guid(prefix)
++{
++ return (prefix || '') + Math.round(Math.random() * 1000000).toString();
++};
++
++/**
++ * Merges two objects. Values from obj2 override values in obj1.
++ * Function is NOT recursive and works only for one dimensional objects.
++ * @param {Object} obj1 First object.
++ * @param {Object} obj2 Second object.
++ * @return {Object} Returns combination of both objects.
++ */
++function merge(obj1, obj2)
++{
++ var result = {}, name;
++
++ for (name in obj1)
++ result[name] = obj1[name];
++
++ for (name in obj2)
++ result[name] = obj2[name];
++
++ return result;
++};
++
++/**
++ * Attempts to convert string to boolean.
++ * @param {String} value Input string.
++ * @return {Boolean} Returns true if input was "true", false if input was "false" and value otherwise.
++ */
++function toBoolean(value)
++{
++ var result = { "true" : true, "false" : false }[value];
++ return result == null ? value : result;
++};
++
++/**
++ * Opens up a centered popup window.
++ * @param {String} url URL to open in the window.
++ * @param {String} name Popup name.
++ * @param {int} width Popup width.
++ * @param {int} height Popup height.
++ * @param {String} options window.open() options.
++ * @return {Window} Returns window instance.
++ */
++function popup(url, name, width, height, options)
++{
++ var x = (screen.width - width) / 2,
++ y = (screen.height - height) / 2
++ ;
++
++ options += ', left=' + x +
++ ', top=' + y +
++ ', width=' + width +
++ ', height=' + height
++ ;
++ options = options.replace(/^,/, '');
++
++ var win = window.open(url, name, options);
++ win.focus();
++ return win;
++};
++
++/**
++ * Adds event handler to the target object.
++ * @param {Object} obj Target object.
++ * @param {String} type Name of the event.
++ * @param {Function} func Handling function.
++ */
++function attachEvent(obj, type, func, scope)
++{
++ function handler(e)
++ {
++ e = e || window.event;
++
++ if (!e.target)
++ {
++ e.target = e.srcElement;
++ e.preventDefault = function()
++ {
++ this.returnValue = false;
++ };
++ }
++
++ func.call(scope || window, e);
++ };
++
++ if (obj.attachEvent)
++ {
++ obj.attachEvent('on' + type, handler);
++ }
++ else
++ {
++ obj.addEventListener(type, handler, false);
++ }
++};
++
++/**
++ * Displays an alert.
++ * @param {String} str String to display.
++ */
++function alert(str)
++{
++ window.alert(sh.config.strings.alert + str);
++};
++
++/**
++ * Finds a brush by its alias.
++ *
++ * @param {String} alias Brush alias.
++ * @param {Boolean} showAlert Suppresses the alert if false.
++ * @return {Brush} Returns bursh constructor if found, null otherwise.
++ */
++function findBrush(alias, showAlert)
++{
++ var brushes = sh.vars.discoveredBrushes,
++ result = null
++ ;
++
++ if (brushes == null)
++ {
++ brushes = {};
++
++ // Find all brushes
++ for (var brush in sh.brushes)
++ {
++ var info = sh.brushes[brush],
++ aliases = info.aliases
++ ;
++
++ if (aliases == null)
++ continue;
++
++ // keep the brush name
++ info.brushName = brush.toLowerCase();
++
++ for (var i = 0; i < aliases.length; i++)
++ brushes[aliases[i]] = brush;
++ }
++
++ sh.vars.discoveredBrushes = brushes;
++ }
++
++ result = sh.brushes[brushes[alias]];
++
++ if (result == null && showAlert != false)
++ alert(sh.config.strings.noBrush + alias);
++
++ return result;
++};
++
++/**
++ * Executes a callback on each line and replaces each line with result from the callback.
++ * @param {Object} str Input string.
++ * @param {Object} callback Callback function taking one string argument and returning a string.
++ */
++function eachLine(str, callback)
++{
++ var lines = splitLines(str);
++
++ for (var i = 0; i < lines.length; i++)
++ lines[i] = callback(lines[i], i);
++
++ return lines.join('\n');
++};
++
++/**
++ * This is a special trim which only removes first and last empty lines
++ * and doesn't affect valid leading space on the first line.
++ *
++ * @param {String} str Input string
++ * @return {String} Returns string without empty first and last lines.
++ */
++function trimFirstAndLastLines(str)
++{
++ return str.replace(/^[ ]*[\n]+|[\n]*[ ]*$/g, '');
++};
++
++/**
++ * Parses key/value pairs into hash object.
++ *
++ * Understands the following formats:
++ * - name: word;
++ * - name: [word, word];
++ * - name: "string";
++ * - name: 'string';
++ *
++ * For example:
++ * name1: value; name2: [value, value]; name3: 'value'
++ *
++ * @param {String} str Input string.
++ * @return {Object} Returns deserialized object.
++ */
++function parseParams(str)
++{
++ var match,
++ result = {},
++ arrayRegex = new XRegExp("^\\[(?<values>(.*?))\\]$"),
++ regex = new XRegExp(
++ "(?<name>[\\w-]+)" +
++ "\\s*:\\s*" +
++ "(?<value>" +
++ "[\\w-%#]+|" + // word
++ "\\[.*?\\]|" + // [] array
++ '".*?"|' + // "" string
++ "'.*?'" + // '' string
++ ")\\s*;?",
++ "g"
++ )
++ ;
++
++ while ((match = regex.exec(str)) != null)
++ {
++ var value = match.value
++ .replace(/^['"]|['"]$/g, '') // strip quotes from end of strings
++ ;
++
++ // try to parse array value
++ if (value != null && arrayRegex.test(value))
++ {
++ var m = arrayRegex.exec(value);
++ value = m.values.length > 0 ? m.values.split(/\s*,\s*/) : [];
++ }
++
++ result[match.name] = value;
++ }
++
++ return result;
++};
++
++/**
++ * Wraps each line of the string into <code/> tag with given style applied to it.
++ *
++ * @param {String} str Input string.
++ * @param {String} css Style name to apply to the string.
++ * @return {String} Returns input string with each line surrounded by <span/> tag.
++ */
++function wrapLinesWithCode(str, css)
++{
++ if (str == null || str.length == 0 || str == '\n')
++ return str;
++
++ str = str.replace(/</g, '<');
++
++ // Replace two or more sequential spaces with leaving last space untouched.
++ str = str.replace(/ {2,}/g, function(m)
++ {
++ var spaces = '';
++
++ for (var i = 0; i < m.length - 1; i++)
++ spaces += sh.config.space;
++
++ return spaces + ' ';
++ });
++
++ // Split each line and apply <span class="...">...</span> to them so that
++ // leading spaces aren't included.
++ if (css != null)
++ str = eachLine(str, function(line)
++ {
++ if (line.length == 0)
++ return '';
++
++ var spaces = '';
++
++ line = line.replace(/^( | )+/, function(s)
++ {
++ spaces = s;
++ return '';
++ });
++
++ if (line.length == 0)
++ return spaces;
++
++ return spaces + '<code class="' + css + '">' + line + '</code>';
++ });
++
++ return str;
++};
++
++/**
++ * Pads number with zeros until it's length is the same as given length.
++ *
++ * @param {Number} number Number to pad.
++ * @param {Number} length Max string length with.
++ * @return {String} Returns a string padded with proper amount of '0'.
++ */
++function padNumber(number, length)
++{
++ var result = number.toString();
++
++ while (result.length < length)
++ result = '0' + result;
++
++ return result;
++};
++
++/**
++ * Replaces tabs with spaces.
++ *
++ * @param {String} code Source code.
++ * @param {Number} tabSize Size of the tab.
++ * @return {String} Returns code with all tabs replaces by spaces.
++ */
++function processTabs(code, tabSize)
++{
++ var tab = '';
++
++ for (var i = 0; i < tabSize; i++)
++ tab += ' ';
++
++ return code.replace(/\t/g, tab);
++};
++
++/**
++ * Replaces tabs with smart spaces.
++ *
++ * @param {String} code Code to fix the tabs in.
++ * @param {Number} tabSize Number of spaces in a column.
++ * @return {String} Returns code with all tabs replaces with roper amount of spaces.
++ */
++function processSmartTabs(code, tabSize)
++{
++ var lines = splitLines(code),
++ tab = '\t',
++ spaces = ''
++ ;
++
++ // Create a string with 1000 spaces to copy spaces from...
++ // It's assumed that there would be no indentation longer than that.
++ for (var i = 0; i < 50; i++)
++ spaces += ' '; // 20 spaces * 50
++
++ // This function inserts specified amount of spaces in the string
++ // where a tab is while removing that given tab.
++ function insertSpaces(line, pos, count)
++ {
++ return line.substr(0, pos)
++ + spaces.substr(0, count)
++ + line.substr(pos + 1, line.length) // pos + 1 will get rid of the tab
++ ;
++ };
++
++ // Go through all the lines and do the 'smart tabs' magic.
++ code = eachLine(code, function(line)
++ {
++ if (line.indexOf(tab) == -1)
++ return line;
++
++ var pos = 0;
++
++ while ((pos = line.indexOf(tab)) != -1)
++ {
++ // This is pretty much all there is to the 'smart tabs' logic.
++ // Based on the position within the line and size of a tab,
++ // calculate the amount of spaces we need to insert.
++ var spaces = tabSize - pos % tabSize;
++ line = insertSpaces(line, pos, spaces);
++ }
++
++ return line;
++ });
++
++ return code;
++};
++
++/**
++ * Performs various string fixes based on configuration.
++ */
++function fixInputString(str)
++{
++ var br = /<br\s*\/?>|<br\s*\/?>/gi;
++
++ if (sh.config.bloggerMode == true)
++ str = str.replace(br, '\n');
++
++ if (sh.config.stripBrs == true)
++ str = str.replace(br, '');
++
++ return str;
++};
++
++/**
++ * Removes all white space at the begining and end of a string.
++ *
++ * @param {String} str String to trim.
++ * @return {String} Returns string without leading and following white space characters.
++ */
++function trim(str)
++{
++ return str.replace(/^\s+|\s+$/g, '');
++};
++
++/**
++ * Unindents a block of text by the lowest common indent amount.
++ * @param {String} str Text to unindent.
++ * @return {String} Returns unindented text block.
++ */
++function unindent(str)
++{
++ var lines = splitLines(fixInputString(str)),
++ indents = new Array(),
++ regex = /^\s*/,
++ min = 1000
++ ;
++
++ // go through every line and check for common number of indents
++ for (var i = 0; i < lines.length && min > 0; i++)
++ {
++ var line = lines[i];
++
++ if (trim(line).length == 0)
++ continue;
++
++ var matches = regex.exec(line);
++
++ // In the event that just one line doesn't have leading white space
++ // we can't unindent anything, so bail completely.
++ if (matches == null)
++ return str;
++
++ min = Math.min(matches[0].length, min);
++ }
++
++ // trim minimum common number of white space from the begining of every line
++ if (min > 0)
++ for (var i = 0; i < lines.length; i++)
++ lines[i] = lines[i].substr(min);
++
++ return lines.join('\n');
++};
++
++/**
++ * Callback method for Array.sort() which sorts matches by
++ * index position and then by length.
++ *
++ * @param {Match} m1 Left object.
++ * @param {Match} m2 Right object.
++ * @return {Number} Returns -1, 0 or -1 as a comparison result.
++ */
++function matchesSortCallback(m1, m2)
++{
++ // sort matches by index first
++ if(m1.index < m2.index)
++ return -1;
++ else if(m1.index > m2.index)
++ return 1;
++ else
++ {
++ // if index is the same, sort by length
++ if(m1.length < m2.length)
++ return -1;
++ else if(m1.length > m2.length)
++ return 1;
++ }
++
++ return 0;
++};
++
++/**
++ * Executes given regular expression on provided code and returns all
++ * matches that are found.
++ *
++ * @param {String} code Code to execute regular expression on.
++ * @param {Object} regex Regular expression item info from <code>regexList</code> collection.
++ * @return {Array} Returns a list of Match objects.
++ */
++function getMatches(code, regexInfo)
++{
++ function defaultAdd(match, regexInfo)
++ {
++ return match[0];
++ };
++
++ var index = 0,
++ match = null,
++ matches = [],
++ func = regexInfo.func ? regexInfo.func : defaultAdd
++ ;
++
++ while((match = regexInfo.regex.exec(code)) != null)
++ {
++ var resultMatch = func(match, regexInfo);
++
++ if (typeof(resultMatch) == 'string')
++ resultMatch = [new sh.Match(resultMatch, match.index, regexInfo.css)];
++
++ matches = matches.concat(resultMatch);
++ }
++
++ return matches;
++};
++
++/**
++ * Turns all URLs in the code into <a/> tags.
++ * @param {String} code Input code.
++ * @return {String} Returns code with </a> tags.
++ */
++function processUrls(code)
++{
++ var gt = /(.*)((>|<).*)/;
++
++ return code.replace(sh.regexLib.url, function(m)
++ {
++ var suffix = '',
++ match = null
++ ;
++
++ // We include < and > in the URL for the common cases like <http://google.com>
++ // The problem is that they get transformed into <http://google.com>
++ // Where as > easily looks like part of the URL string.
++
++ if (match = gt.exec(m))
++ {
++ m = match[1];
++ suffix = match[2];
++ }
++
++ return '<a href="' + m + '">' + m + '</a>' + suffix;
++ });
++};
++
++/**
++ * Finds all <SCRIPT TYPE="syntaxhighlighter" /> elementss.
++ * @return {Array} Returns array of all found SyntaxHighlighter tags.
++ */
++function getSyntaxHighlighterScriptTags()
++{
++ var tags = document.getElementsByTagName('script'),
++ result = []
++ ;
++
++ for (var i = 0; i < tags.length; i++)
++ if (tags[i].type == 'syntaxhighlighter')
++ result.push(tags[i]);
++
++ return result;
++};
++
++/**
++ * Strips <![CDATA[]]> from <SCRIPT /> content because it should be used
++ * there in most cases for XHTML compliance.
++ * @param {String} original Input code.
++ * @return {String} Returns code without leading <![CDATA[]]> tags.
++ */
++function stripCData(original)
++{
++ var left = '<![CDATA[',
++ right = ']]>',
++ // for some reason IE inserts some leading blanks here
++ copy = trim(original),
++ changed = false,
++ leftLength = left.length,
++ rightLength = right.length
++ ;
++
++ if (copy.indexOf(left) == 0)
++ {
++ copy = copy.substring(leftLength);
++ changed = true;
++ }
++
++ var copyLength = copy.length;
++
++ if (copy.indexOf(right) == copyLength - rightLength)
++ {
++ copy = copy.substring(0, copyLength - rightLength);
++ changed = true;
++ }
++
++ return changed ? copy : original;
++};
++
++
++/**
++ * Quick code mouse double click handler.
++ */
++function quickCodeHandler(e)
++{
++ var target = e.target,
++ highlighterDiv = findParentElement(target, '.syntaxhighlighter'),
++ container = findParentElement(target, '.container'),
++ textarea = document.createElement('textarea'),
++ highlighter
++ ;
++
++ if (!container || !highlighterDiv || findElement(container, 'textarea'))
++ return;
++
++ highlighter = getHighlighterById(highlighterDiv.id);
++
++ // add source class name
++ addClass(highlighterDiv, 'source');
++
++ // Have to go over each line and grab it's text, can't just do it on the
++ // container because Firefox loses all \n where as Webkit doesn't.
++ var lines = container.childNodes,
++ code = []
++ ;
++
++ for (var i = 0; i < lines.length; i++)
++ code.push(lines[i].innerText || lines[i].textContent);
++
++ // using \r instead of \r or \r\n makes this work equally well on IE, FF and Webkit
++ code = code.join('\r');
++
++ // inject <textarea/> tag
++ textarea.appendChild(document.createTextNode(code));
++ container.appendChild(textarea);
++
++ // preselect all text
++ textarea.focus();
++ textarea.select();
++
++ // set up handler for lost focus
++ attachEvent(textarea, 'blur', function(e)
++ {
++ textarea.parentNode.removeChild(textarea);
++ removeClass(highlighterDiv, 'source');
++ });
++};
++
++/**
++ * Match object.
++ */
++sh.Match = function(value, index, css)
++{
++ this.value = value;
++ this.index = index;
++ this.length = value.length;
++ this.css = css;
++ this.brushName = null;
++};
++
++sh.Match.prototype.toString = function()
++{
++ return this.value;
++};
++
++/**
++ * Simulates HTML code with a scripting language embedded.
++ *
++ * @param {String} scriptBrushName Brush name of the scripting language.
++ */
++sh.HtmlScript = function(scriptBrushName)
++{
++ var brushClass = findBrush(scriptBrushName),
++ scriptBrush,
++ xmlBrush = new sh.brushes.Xml(),
++ bracketsRegex = null,
++ ref = this,
++ methodsToExpose = 'getDiv getHtml init'.split(' ')
++ ;
++
++ if (brushClass == null)
++ return;
++
++ scriptBrush = new brushClass();
++
++ for(var i = 0; i < methodsToExpose.length; i++)
++ // make a closure so we don't lose the name after i changes
++ (function() {
++ var name = methodsToExpose[i];
++
++ ref[name] = function()
++ {
++ return xmlBrush[name].apply(xmlBrush, arguments);
++ };
++ })();
++
++ if (scriptBrush.htmlScript == null)
++ {
++ alert(sh.config.strings.brushNotHtmlScript + scriptBrushName);
++ return;
++ }
++
++ xmlBrush.regexList.push(
++ { regex: scriptBrush.htmlScript.code, func: process }
++ );
++
++ function offsetMatches(matches, offset)
++ {
++ for (var j = 0; j < matches.length; j++)
++ matches[j].index += offset;
++ }
++
++ function process(match, info)
++ {
++ var code = match.code,
++ matches = [],
++ regexList = scriptBrush.regexList,
++ offset = match.index + match.left.length,
++ htmlScript = scriptBrush.htmlScript,
++ result
++ ;
++
++ // add all matches from the code
++ for (var i = 0; i < regexList.length; i++)
++ {
++ result = getMatches(code, regexList[i]);
++ offsetMatches(result, offset);
++ matches = matches.concat(result);
++ }
++
++ // add left script bracket
++ if (htmlScript.left != null && match.left != null)
++ {
++ result = getMatches(match.left, htmlScript.left);
++ offsetMatches(result, match.index);
++ matches = matches.concat(result);
++ }
++
++ // add right script bracket
++ if (htmlScript.right != null && match.right != null)
++ {
++ result = getMatches(match.right, htmlScript.right);
++ offsetMatches(result, match.index + match[0].lastIndexOf(match.right));
++ matches = matches.concat(result);
++ }
++
++ for (var j = 0; j < matches.length; j++)
++ matches[j].brushName = brushClass.brushName;
++
++ return matches;
++ }
++};
++
++/**
++ * Main Highlither class.
++ * @constructor
++ */
++sh.Highlighter = function()
++{
++ // not putting any code in here because of the prototype inheritance
++};
++
++sh.Highlighter.prototype = {
++ /**
++ * Returns value of the parameter passed to the highlighter.
++ * @param {String} name Name of the parameter.
++ * @param {Object} defaultValue Default value.
++ * @return {Object} Returns found value or default value otherwise.
++ */
++ getParam: function(name, defaultValue)
++ {
++ var result = this.params[name];
++ return toBoolean(result == null ? defaultValue : result);
++ },
++
++ /**
++ * Shortcut to document.createElement().
++ * @param {String} name Name of the element to create (DIV, A, etc).
++ * @return {HTMLElement} Returns new HTML element.
++ */
++ create: function(name)
++ {
++ return document.createElement(name);
++ },
++
++ /**
++ * Applies all regular expression to the code and stores all found
++ * matches in the `this.matches` array.
++ * @param {Array} regexList List of regular expressions.
++ * @param {String} code Source code.
++ * @return {Array} Returns list of matches.
++ */
++ findMatches: function(regexList, code)
++ {
++ var result = [];
++
++ if (regexList != null)
++ for (var i = 0; i < regexList.length; i++)
++ // BUG: length returns len+1 for array if methods added to prototype chain (oising at gmail.com)
++ if (typeof (regexList[i]) == "object")
++ result = result.concat(getMatches(code, regexList[i]));
++
++ // sort and remove nested the matches
++ return this.removeNestedMatches(result.sort(matchesSortCallback));
++ },
++
++ /**
++ * Checks to see if any of the matches are inside of other matches.
++ * This process would get rid of highligted strings inside comments,
++ * keywords inside strings and so on.
++ */
++ removeNestedMatches: function(matches)
++ {
++ // Optimized by Jose Prado (http://joseprado.com)
++ for (var i = 0; i < matches.length; i++)
++ {
++ if (matches[i] === null)
++ continue;
++
++ var itemI = matches[i],
++ itemIEndPos = itemI.index + itemI.length
++ ;
++
++ for (var j = i + 1; j < matches.length && matches[i] !== null; j++)
++ {
++ var itemJ = matches[j];
++
++ if (itemJ === null)
++ continue;
++ else if (itemJ.index > itemIEndPos)
++ break;
++ else if (itemJ.index == itemI.index && itemJ.length > itemI.length)
++ matches[i] = null;
++ else if (itemJ.index >= itemI.index && itemJ.index < itemIEndPos)
++ matches[j] = null;
++ }
++ }
++
++ return matches;
++ },
++
++ /**
++ * Creates an array containing integer line numbers starting from the 'first-line' param.
++ * @return {Array} Returns array of integers.
++ */
++ figureOutLineNumbers: function(code)
++ {
++ var lines = [],
++ firstLine = parseInt(this.getParam('first-line'))
++ ;
++
++ eachLine(code, function(line, index)
++ {
++ lines.push(index + firstLine);
++ });
++
++ return lines;
++ },
++
++ /**
++ * Determines if specified line number is in the highlighted list.
++ */
++ isLineHighlighted: function(lineNumber)
++ {
++ var list = this.getParam('highlight', []);
++
++ if (typeof(list) != 'object' && list.push == null)
++ list = [ list ];
++
++ return indexOf(list, lineNumber.toString()) != -1;
++ },
++
++ /**
++ * Generates HTML markup for a single line of code while determining alternating line style.
++ * @param {Integer} lineNumber Line number.
++ * @param {String} code Line HTML markup.
++ * @return {String} Returns HTML markup.
++ */
++ getLineHtml: function(lineIndex, lineNumber, code)
++ {
++ var classes = [
++ 'line',
++ 'number' + lineNumber,
++ 'index' + lineIndex,
++ 'alt' + (lineNumber % 2 == 0 ? 1 : 2).toString()
++ ];
++
++ if (this.isLineHighlighted(lineNumber))
++ classes.push('highlighted');
++
++ if (lineNumber == 0)
++ classes.push('break');
++
++ return '<div class="' + classes.join(' ') + '">' + code + '</div>';
++ },
++
++ /**
++ * Generates HTML markup for line number column.
++ * @param {String} code Complete code HTML markup.
++ * @param {Array} lineNumbers Calculated line numbers.
++ * @return {String} Returns HTML markup.
++ */
++ getLineNumbersHtml: function(code, lineNumbers)
++ {
++ var html = '',
++ count = splitLines(code).length,
++ firstLine = parseInt(this.getParam('first-line')),
++ pad = this.getParam('pad-line-numbers')
++ ;
++
++ if (pad == true)
++ pad = (firstLine + count - 1).toString().length;
++ else if (isNaN(pad) == true)
++ pad = 0;
++
++ for (var i = 0; i < count; i++)
++ {
++ var lineNumber = lineNumbers ? lineNumbers[i] : firstLine + i,
++ code = lineNumber == 0 ? sh.config.space : padNumber(lineNumber, pad)
++ ;
++
++ html += this.getLineHtml(i, lineNumber, code);
++ }
++
++ return html;
++ },
++
++ /**
++ * Splits block of text into individual DIV lines.
++ * @param {String} code Code to highlight.
++ * @param {Array} lineNumbers Calculated line numbers.
++ * @return {String} Returns highlighted code in HTML form.
++ */
++ getCodeLinesHtml: function(html, lineNumbers)
++ {
++ html = trim(html);
++
++ var lines = splitLines(html),
++ padLength = this.getParam('pad-line-numbers'),
++ firstLine = parseInt(this.getParam('first-line')),
++ html = '',
++ brushName = this.getParam('brush')
++ ;
++
++ for (var i = 0; i < lines.length; i++)
++ {
++ var line = lines[i],
++ indent = /^( |\s)+/.exec(line),
++ spaces = null,
++ lineNumber = lineNumbers ? lineNumbers[i] : firstLine + i;
++ ;
++
++ if (indent != null)
++ {
++ spaces = indent[0].toString();
++ line = line.substr(spaces.length);
++ spaces = spaces.replace(' ', sh.config.space);
++ }
++
++ line = trim(line);
++
++ if (line.length == 0)
++ line = sh.config.space;
++
++ html += this.getLineHtml(
++ i,
++ lineNumber,
++ (spaces != null ? '<code class="' + brushName + ' spaces">' + spaces + '</code>' : '') + line
++ );
++ }
++
++ return html;
++ },
++
++ /**
++ * Returns HTML for the table title or empty string if title is null.
++ */
++ getTitleHtml: function(title)
++ {
++ return title ? '<caption>' + title + '</caption>' : '';
++ },
++
++ /**
++ * Finds all matches in the source code.
++ * @param {String} code Source code to process matches in.
++ * @param {Array} matches Discovered regex matches.
++ * @return {String} Returns formatted HTML with processed mathes.
++ */
++ getMatchesHtml: function(code, matches)
++ {
++ var pos = 0,
++ result = '',
++ brushName = this.getParam('brush', '')
++ ;
++
++ function getBrushNameCss(match)
++ {
++ var result = match ? (match.brushName || brushName) : brushName;
++ return result ? result + ' ' : '';
++ };
++
++ // Finally, go through the final list of matches and pull the all
++ // together adding everything in between that isn't a match.
++ for (var i = 0; i < matches.length; i++)
++ {
++ var match = matches[i],
++ matchBrushName
++ ;
++
++ if (match === null || match.length === 0)
++ continue;
++
++ matchBrushName = getBrushNameCss(match);
++
++ result += wrapLinesWithCode(code.substr(pos, match.index - pos), matchBrushName + 'plain')
++ + wrapLinesWithCode(match.value, matchBrushName + match.css)
++ ;
++
++ pos = match.index + match.length + (match.offset || 0);
++ }
++
++ // don't forget to add whatever's remaining in the string
++ result += wrapLinesWithCode(code.substr(pos), getBrushNameCss() + 'plain');
++
++ return result;
++ },
++
++ /**
++ * Generates HTML markup for the whole syntax highlighter.
++ * @param {String} code Source code.
++ * @return {String} Returns HTML markup.
++ */
++ getHtml: function(code)
++ {
++ var html = '',
++ classes = [ 'syntaxhighlighter' ],
++ tabSize,
++ matches,
++ lineNumbers
++ ;
++
++ // process light mode
++ if (this.getParam('light') == true)
++ this.params.toolbar = this.params.gutter = false;
++
++ className = 'syntaxhighlighter';
++
++ if (this.getParam('collapse') == true)
++ classes.push('collapsed');
++
++ if ((gutter = this.getParam('gutter')) == false)
++ classes.push('nogutter');
++
++ // add custom user style name
++ classes.push(this.getParam('class-name'));
++
++ // add brush alias to the class name for custom CSS
++ classes.push(this.getParam('brush'));
++
++ code = trimFirstAndLastLines(code)
++ .replace(/\r/g, ' ') // IE lets these buggers through
++ ;
++
++ tabSize = this.getParam('tab-size');
++
++ // replace tabs with spaces
++ code = this.getParam('smart-tabs') == true
++ ? processSmartTabs(code, tabSize)
++ : processTabs(code, tabSize)
++ ;
++
++ // unindent code by the common indentation
++ code = unindent(code);
++
++ if (gutter)
++ lineNumbers = this.figureOutLineNumbers(code);
++
++ // find matches in the code using brushes regex list
++ matches = this.findMatches(this.regexList, code);
++ // processes found matches into the html
++ html = this.getMatchesHtml(code, matches);
++ // finally, split all lines so that they wrap well
++ html = this.getCodeLinesHtml(html, lineNumbers);
++
++ // finally, process the links
++ if (this.getParam('auto-links'))
++ html = processUrls(html);
++
++ if (typeof(navigator) != 'undefined' && navigator.userAgent && navigator.userAgent.match(/MSIE/))
++ classes.push('ie');
++
++ html =
++ '<div id="' + getHighlighterId(this.id) + '" class="' + classes.join(' ') + '">'
++ + (this.getParam('toolbar') ? sh.toolbar.getHtml(this) : '')
++ + '<table border="0" cellpadding="0" cellspacing="0">'
++ + this.getTitleHtml(this.getParam('title'))
++ + '<tbody>'
++ + '<tr>'
++ + (gutter ? '<td class="gutter">' + this.getLineNumbersHtml(code) + '</td>' : '')
++ + '<td class="code">'
++ + '<div class="container">'
++ + html
++ + '</div>'
++ + '</td>'
++ + '</tr>'
++ + '</tbody>'
++ + '</table>'
++ + '</div>'
++ ;
++
++ return html;
++ },
++
++ /**
++ * Highlights the code and returns complete HTML.
++ * @param {String} code Code to highlight.
++ * @return {Element} Returns container DIV element with all markup.
++ */
++ getDiv: function(code)
++ {
++ if (code === null)
++ code = '';
++
++ this.code = code;
++
++ var div = this.create('div');
++
++ // create main HTML
++ div.innerHTML = this.getHtml(code);
++
++ // set up click handlers
++ if (this.getParam('toolbar'))
++ attachEvent(findElement(div, '.toolbar'), 'click', sh.toolbar.handler);
++
++ if (this.getParam('quick-code'))
++ attachEvent(findElement(div, '.code'), 'dblclick', quickCodeHandler);
++
++ return div;
++ },
++
++ /**
++ * Initializes the highlighter/brush.
++ *
++ * Constructor isn't used for initialization so that nothing executes during necessary
++ * `new SyntaxHighlighter.Highlighter()` call when setting up brush inheritence.
++ *
++ * @param {Hash} params Highlighter parameters.
++ */
++ init: function(params)
++ {
++ this.id = guid();
++
++ // register this instance in the highlighters list
++ storeHighlighter(this);
++
++ // local params take precedence over defaults
++ this.params = merge(sh.defaults, params || {})
++
++ // process light mode
++ if (this.getParam('light') == true)
++ this.params.toolbar = this.params.gutter = false;
++ },
++
++ /**
++ * Converts space separated list of keywords into a regular expression string.
++ * @param {String} str Space separated keywords.
++ * @return {String} Returns regular expression string.
++ */
++ getKeywords: function(str)
++ {
++ str = str
++ .replace(/^\s+|\s+$/g, '')
++ .replace(/\s+/g, '|')
++ ;
++
++ return '\\b(?:' + str + ')\\b';
++ },
++
++ /**
++ * Makes a brush compatible with the `html-script` functionality.
++ * @param {Object} regexGroup Object containing `left` and `right` regular expressions.
++ */
++ forHtmlScript: function(regexGroup)
++ {
++ this.htmlScript = {
++ left : { regex: regexGroup.left, css: 'script' },
++ right : { regex: regexGroup.right, css: 'script' },
++ code : new XRegExp(
++ "(?<left>" + regexGroup.left.source + ")" +
++ "(?<code>.*?)" +
++ "(?<right>" + regexGroup.right.source + ")",
++ "sgi"
++ )
++ };
++ }
++}; // end of Highlighter
++
++return sh;
++}(); // end of anonymous function
++
++// CommonJS
++typeof(exports) != 'undefined' ? exports['SyntaxHighlighter'] = SyntaxHighlighter : null;
+--- /dev/null
++++ b/guides/assets/javascripts/syntaxhighlighter/src/shLegacy.js
+@@ -0,0 +1,157 @@
++/**
++ * SyntaxHighlighter
++ * http://alexgorbatchev.com/SyntaxHighlighter
++ *
++ * SyntaxHighlighter is donationware. If you are using it, please donate.
++ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
++ *
++ * @version
++ * 3.0.83 (July 02 2010)
++ *
++ * @copyright
++ * Copyright (C) 2004-2010 Alex Gorbatchev.
++ *
++ * @license
++ * Dual licensed under the MIT and GPL licenses.
++ */
++var dp = {
++ SyntaxHighlighter : {}
++};
++
++dp.SyntaxHighlighter = {
++ parseParams: function(
++ input,
++ showGutter,
++ showControls,
++ collapseAll,
++ firstLine,
++ showColumns
++ )
++ {
++ function getValue(list, name)
++ {
++ var regex = new XRegExp('^' + name + '\\[(?<value>\\w+)\\]$', 'gi'),
++ match = null
++ ;
++
++ for (var i = 0; i < list.length; i++)
++ if ((match = regex.exec(list[i])) != null)
++ return match.value;
++
++ return null;
++ };
++
++ function defaultValue(value, def)
++ {
++ return value != null ? value : def;
++ };
++
++ function asString(value)
++ {
++ return value != null ? value.toString() : null;
++ };
++
++ var parts = input.split(':'),
++ brushName = parts[0],
++ options = {},
++ straight = { 'true' : true }
++ reverse = { 'true' : false },
++ result = null,
++ defaults = SyntaxHighlighter.defaults
++ ;
++
++ for (var i in parts)
++ options[parts[i]] = 'true';
++
++ showGutter = asString(defaultValue(showGutter, defaults.gutter));
++ showControls = asString(defaultValue(showControls, defaults.toolbar));
++ collapseAll = asString(defaultValue(collapseAll, defaults.collapse));
++ showColumns = asString(defaultValue(showColumns, defaults.ruler));
++ firstLine = asString(defaultValue(firstLine, defaults['first-line']));
++
++ return {
++ brush : brushName,
++ gutter : defaultValue(reverse[options.nogutter], showGutter),
++ toolbar : defaultValue(reverse[options.nocontrols], showControls),
++ collapse : defaultValue(straight[options.collapse], collapseAll),
++ // ruler : defaultValue(straight[options.showcolumns], showColumns),
++ 'first-line' : defaultValue(getValue(parts, 'firstline'), firstLine)
++ };
++ },
++
++ HighlightAll: function(
++ name,
++ showGutter /* optional */,
++ showControls /* optional */,
++ collapseAll /* optional */,
++ firstLine /* optional */,
++ showColumns /* optional */
++ )
++ {
++ function findValue()
++ {
++ var a = arguments;
++
++ for (var i = 0; i < a.length; i++)
++ {
++ if (a[i] === null)
++ continue;
++
++ if (typeof(a[i]) == 'string' && a[i] != '')
++ return a[i] + '';
++
++ if (typeof(a[i]) == 'object' && a[i].value != '')
++ return a[i].value + '';
++ }
++
++ return null;
++ };
++
++ function findTagsByName(list, name, tagName)
++ {
++ var tags = document.getElementsByTagName(tagName);
++
++ for (var i = 0; i < tags.length; i++)
++ if (tags[i].getAttribute('name') == name)
++ list.push(tags[i]);
++ }
++
++ var elements = [],
++ highlighter = null,
++ registered = {},
++ propertyName = 'innerHTML'
++ ;
++
++ // for some reason IE doesn't find <pre/> by name, however it does see them just fine by tag name...
++ findTagsByName(elements, name, 'pre');
++ findTagsByName(elements, name, 'textarea');
++
++ if (elements.length === 0)
++ return;
++
++ for (var i = 0; i < elements.length; i++)
++ {
++ var element = elements[i],
++ params = findValue(
++ element.attributes['class'], element.className,
++ element.attributes['language'], element.language
++ ),
++ language = ''
++ ;
++
++ if (params === null)
++ continue;
++
++ params = dp.SyntaxHighlighter.parseParams(
++ params,
++ showGutter,
++ showControls,
++ collapseAll,
++ firstLine,
++ showColumns
++ );
++
++ SyntaxHighlighter.highlight(params, element);
++ }
++ }
++};
--
ruby-railties-3.2.git
More information about the Pkg-ruby-extras-commits
mailing list