539 lines
17 KiB
JavaScript
539 lines
17 KiB
JavaScript
/*
|
|
* JavaScript Creole 1.0 Wiki Markup Parser
|
|
* $Id: creole.js 14 2009-03-21 16:15:08Z ifomichev $
|
|
*
|
|
* Copyright (c) 2009 Ivan Fomichev
|
|
*
|
|
* Portions Copyright (c) 2007 Chris Purcell
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
if (!Parse) { var Parse = {}; }
|
|
if (!Parse.Simple) { Parse.Simple = {}; }
|
|
|
|
Parse.Simple.Base = function(grammar, options) {
|
|
if (!arguments.length) { return; }
|
|
|
|
this.grammar = grammar;
|
|
this.grammar.root = new this.ruleConstructor(this.grammar.root);
|
|
this.options = options;
|
|
};
|
|
|
|
Parse.Simple.Base.prototype = {
|
|
ruleConstructor: null,
|
|
grammar: null,
|
|
options: null,
|
|
|
|
parse: function(node, data, options) {
|
|
if (options) {
|
|
for (i in this.options) {
|
|
if (typeof options[i] == 'undefined') { options[i] = this.options[i]; }
|
|
}
|
|
}
|
|
else {
|
|
options = this.options;
|
|
}
|
|
data = data.replace(/\r\n?/g, '\n');
|
|
this.grammar.root.apply(node, data, options);
|
|
if (options && options.forIE) { node.innerHTML = node.innerHTML.replace(/\r?\n/g, '\r\n'); }
|
|
}
|
|
};
|
|
|
|
Parse.Simple.Base.prototype.constructor = Parse.Simple.Base;
|
|
|
|
Parse.Simple.Base.Rule = function(params) {
|
|
if (!arguments.length) { return; }
|
|
|
|
for (var p in params) { this[p] = params[p]; }
|
|
if (!this.children) { this.children = []; }
|
|
};
|
|
|
|
Parse.Simple.Base.prototype.ruleConstructor = Parse.Simple.Base.Rule;
|
|
|
|
Parse.Simple.Base.Rule.prototype = {
|
|
regex: null,
|
|
capture: null,
|
|
replaceRegex: null,
|
|
replaceString: null,
|
|
tag: null,
|
|
attrs: null,
|
|
children: null,
|
|
|
|
match: function(data, options) {
|
|
return data.match(this.regex);
|
|
},
|
|
|
|
build: function(node, r, options) {
|
|
var data;
|
|
if (this.capture !== null) {
|
|
data = r[this.capture];
|
|
}
|
|
|
|
var target;
|
|
if (this.tag) {
|
|
target = document.createElement(this.tag);
|
|
node.appendChild(target);
|
|
}
|
|
else { target = node; }
|
|
|
|
if (data) {
|
|
if (this.replaceRegex) {
|
|
data = data.replace(this.replaceRegex, this.replaceString);
|
|
}
|
|
this.apply(target, data, options);
|
|
}
|
|
|
|
if (this.attrs) {
|
|
for (var i in this.attrs) {
|
|
target.setAttribute(i, this.attrs[i]);
|
|
if (options && options.forIE && i == 'class') { target.className = this.attrs[i]; }
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
apply: function(node, data, options) {
|
|
var tail = '' + data;
|
|
var matches = [];
|
|
|
|
if (!this.fallback.apply) {
|
|
this.fallback = new this.constructor(this.fallback);
|
|
}
|
|
|
|
while (true) {
|
|
var best = false;
|
|
var rule = false;
|
|
for (var i = 0; i < this.children.length; i++) {
|
|
if (typeof matches[i] == 'undefined') {
|
|
if (!this.children[i].match) {
|
|
this.children[i] = new this.constructor(this.children[i]);
|
|
}
|
|
matches[i] = this.children[i].match(tail, options);
|
|
}
|
|
if (matches[i] && (!best || best.index > matches[i].index)) {
|
|
best = matches[i];
|
|
rule = this.children[i];
|
|
if (best.index == 0) { break; }
|
|
}
|
|
}
|
|
|
|
var pos = best ? best.index : tail.length;
|
|
if (pos > 0) {
|
|
this.fallback.apply(node, tail.substring(0, pos), options);
|
|
}
|
|
|
|
if (!best) { break; }
|
|
|
|
if (!rule.build) { rule = new this.constructor(rule); }
|
|
rule.build(node, best, options);
|
|
|
|
var chopped = best.index + best[0].length;
|
|
tail = tail.substring(chopped);
|
|
for (var i = 0; i < this.children.length; i++) {
|
|
if (matches[i]) {
|
|
if (matches[i].index >= chopped) {
|
|
matches[i].index -= chopped;
|
|
}
|
|
else {
|
|
matches[i] = void 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
fallback: {
|
|
apply: function(node, data, options) {
|
|
if (options && options.forIE) {
|
|
// workaround for bad IE
|
|
data = data.replace(/\n/g, ' \r');
|
|
}
|
|
node.appendChild(document.createTextNode(data));
|
|
}
|
|
}
|
|
};
|
|
|
|
Parse.Simple.Base.Rule.prototype.constructor = Parse.Simple.Base.Rule;
|
|
|
|
Parse.Simple.Creole = function(options) {
|
|
var rx = {};
|
|
rx.link = '[^\\]|~\\n]*(?:(?:\\](?!\\])|~.)[^\\]|~\\n]*)*';
|
|
rx.linkText = '[^\\]~\\n]*(?:(?:\\](?!\\])|~.)[^\\]~\\n]*)*';
|
|
rx.uriPrefix = '\\b(?:(?:https?|ftp)://|mailto:)';
|
|
rx.uri = rx.uriPrefix + rx.link;
|
|
rx.rawUri = rx.uriPrefix + '\\S*[^\\s!"\',.:;?]';
|
|
rx.interwikiPrefix = '[\\w.]+:';
|
|
rx.interwikiLink = rx.interwikiPrefix + rx.link;
|
|
rx.img = '\\{\\{((?!\\{)[^|}\\n]*(?:}(?!})[^|}\\n]*)*)' +
|
|
(options && options.strict ? '' : '(?:') +
|
|
'\\|([^}~\\n]*((}(?!})|~.)[^}~\\n]*)*)' +
|
|
(options && options.strict ? '' : ')?') +
|
|
'}}';
|
|
|
|
var asciiToHex = function (x,dir) {
|
|
|
|
var r="";
|
|
|
|
if (dir == "A2H")
|
|
{
|
|
var i;
|
|
for(i=0; i<x.length; i++)
|
|
{
|
|
var tmp = x.charCodeAt(i).toString(16);
|
|
if (tmp.length == 1) r += "0";
|
|
r += tmp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
alert ("H2A NOT IMPLEMENTED....");
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
|
|
var Url = {
|
|
|
|
// public method for url encoding
|
|
encode : function (string) {
|
|
return asciiToHex(this._utf8_encode(string), "A2H");
|
|
},
|
|
|
|
// public method for url decoding
|
|
decode : function (string) {
|
|
return this._utf8_decode(asciiToHex(string, "H2A"));
|
|
},
|
|
|
|
// private method for UTF-8 encoding
|
|
_utf8_encode : function (string) {
|
|
string = string.replace(/\r\n/g,"\n");
|
|
var utftext = "";
|
|
|
|
for (var n = 0; n < string.length; n++) {
|
|
|
|
var c = string.charCodeAt(n);
|
|
|
|
if (c < 128) {
|
|
utftext += String.fromCharCode(c);
|
|
}
|
|
else if((c > 127) && (c < 2048)) {
|
|
utftext += String.fromCharCode((c >> 6) | 192);
|
|
utftext += String.fromCharCode((c & 63) | 128);
|
|
}
|
|
else {
|
|
utftext += String.fromCharCode((c >> 12) | 224);
|
|
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
|
|
utftext += String.fromCharCode((c & 63) | 128);
|
|
}
|
|
|
|
}
|
|
|
|
return utftext;
|
|
},
|
|
|
|
// private method for UTF-8 decoding
|
|
_utf8_decode : function (utftext) {
|
|
var string = "";
|
|
var i = 0;
|
|
var c = c1 = c2 = 0;
|
|
|
|
while ( i < utftext.length ) {
|
|
|
|
c = utftext.charCodeAt(i);
|
|
|
|
if (c < 128) {
|
|
string += String.fromCharCode(c);
|
|
i++;
|
|
}
|
|
else if((c > 191) && (c < 224)) {
|
|
c2 = utftext.charCodeAt(i+1);
|
|
string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
|
|
i += 2;
|
|
}
|
|
else {
|
|
c2 = utftext.charCodeAt(i+1);
|
|
c3 = utftext.charCodeAt(i+2);
|
|
string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
|
|
i += 3;
|
|
}
|
|
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
}
|
|
|
|
var formatLink = function(link, format) {
|
|
if (format instanceof Function) {
|
|
return format(link);
|
|
}
|
|
|
|
format = format instanceof Array ? format : [ format ];
|
|
if (typeof format[1] == 'undefined') { format[1] = ''; }
|
|
return format[0] + link + format[1];
|
|
};
|
|
|
|
var g = {
|
|
hr: { tag: 'hr', regex: /(^|\n)\s*----\s*(\n|$)/ },
|
|
|
|
br: { tag: 'br', regex: /\\\\/ },
|
|
|
|
// ugly hack to support the ohloh widget
|
|
// it uses the image pattern with special prefix
|
|
// {{__ohloh__!width|height|style|widget-url}}
|
|
// {{__ohloh__!300px!100px!border: none!http://www.ohloh.net/p/140949/widgets/project_partner_badge.js}}
|
|
ohlohWidget: { regex: '\\{\\{__ohloh__!(.+)!(.+)!(.+)!(.+)\\}\\}',
|
|
build: function(node, r, options) {
|
|
var d = document.createElement('iframe');
|
|
d.setAttribute ("width", r[1]);
|
|
d.setAttribute ("height", r[2]);
|
|
d.setAttribute ("style", r[3]);
|
|
node.appendChild (d);
|
|
|
|
var doc = d.contentWindow || d.contentDocument;
|
|
if (doc.document) { doc = doc.document;}
|
|
|
|
doc.open ();
|
|
doc.write ('<script type="text/javascript" src="' + r[4] + '"></script>');
|
|
doc.close ();
|
|
} },
|
|
|
|
preBlock: { tag: 'pre', capture: 2,
|
|
attrs: { 'class': 'wiki' },
|
|
regex: /(^|\n)\{\{\{\n((.*\n)*?)\}\}\}(\n|$)/,
|
|
replaceRegex: /^ ([ \t]*\}\}\})/gm,
|
|
replaceString: '$1' },
|
|
tt: { tag: 'tt',
|
|
regex: /\{\{\{(.*?\}\}\}+)/, capture: 1,
|
|
replaceRegex: /\}\}\}$/, replaceString: '' },
|
|
|
|
ulist: { tag: 'ul', capture: 0,
|
|
regex: /(^|\n)([ \t]*\*[^*#].*(\n|$)([ \t]*[^\s*#].*(\n|$))*([ \t]*[*#]{2}.*(\n|$))*)+/ },
|
|
olist: { tag: 'ol', capture: 0,
|
|
regex: /(^|\n)([ \t]*#[^*#].*(\n|$)([ \t]*[^\s*#].*(\n|$))*([ \t]*[*#]{2}.*(\n|$))*)+/ },
|
|
li: { tag: 'li', capture: 0,
|
|
regex: /[ \t]*([*#]).+(\n[ \t]*[^*#\s].*)*(\n[ \t]*\1[*#].+)*/,
|
|
replaceRegex: /(^|\n)[ \t]*[*#]/g, replaceString: '$1' },
|
|
|
|
table: { tag: 'table', capture: 0,
|
|
regex: /(^|\n)(\|.*?[ \t]*(\n|$))+/,
|
|
attrs: { 'class': 'wiki' } },
|
|
tr: { tag: 'tr', capture: 2, regex: /(^|\n)(\|.*?)\|?[ \t]*(\n|$)/ },
|
|
th: { tag: 'th', regex: /\|+=([^|]*)/, capture: 1 },
|
|
td: { tag: 'td', capture: 1,
|
|
regex: '\\|+([^|~\\[{]*((~(.|(?=\\n)|$)|' +
|
|
'\\[\\[' + rx.link + '(\\|' + rx.linkText + ')?\\]\\]' +
|
|
(options && options.strict ? '' : '|' + rx.img) +
|
|
'|[\\[{])[^|~]*)*)' },
|
|
|
|
singleLine: { regex: /.+/, capture: 0 },
|
|
paragraph: { tag: 'p', capture: 0,
|
|
regex: /(^|\n)([ \t]*\S.*(\n|$))+/,
|
|
attrs: { 'class': 'wiki' } },
|
|
text: { capture: 0, regex: /(^|\n)([ \t]*[^\s].*(\n|$))+/ },
|
|
|
|
strong: { tag: 'strong', capture: 1,
|
|
regex: /\*\*([^*~]*((\*(?!\*)|~(.|(?=\n)|$))[^*~]*)*)(\*\*|\n|$)/ },
|
|
em: { tag: 'em', capture: 1,
|
|
regex: '\\/\\/(((?!' + rx.uriPrefix + ')[^\\/~])*' +
|
|
'((' + rx.rawUri + '|\\/(?!\\/)|~(.|(?=\\n)|$))' +
|
|
'((?!' + rx.uriPrefix + ')[^\\/~])*)*)(\\/\\/|\\n|$)' },
|
|
|
|
img: { regex: rx.img,
|
|
build: function(node, r, options) {
|
|
var img = document.createElement('img');
|
|
|
|
if (r[1].match(rx.uriPrefix))
|
|
{
|
|
img.src = r[1];
|
|
}
|
|
else
|
|
{
|
|
var tmp = r[1].replace(/~(.)/g, '$1');
|
|
tmp = Url.encode (tmp);
|
|
img.src = options && options.imgFormat?
|
|
formatLink (tmp, options.imgFormat): tmp;
|
|
}
|
|
|
|
img.alt = r[2] === undefined
|
|
? (options && options.defaultImageText ? options.defaultImageText : '')
|
|
: r[2].replace(/~(.)/g, '$1');
|
|
node.appendChild(img);
|
|
} },
|
|
|
|
namedUri: { regex: '\\[\\[(' + rx.uri + ')\\|(' + rx.linkText + ')\\]\\]',
|
|
build: function(node, r, options) {
|
|
var link = document.createElement('a');
|
|
link.href = r[1];
|
|
if (options && options.isPlainUri) {
|
|
link.appendChild(document.createTextNode(r[2]));
|
|
}
|
|
else {
|
|
this.apply(link, r[2], options);
|
|
}
|
|
node.appendChild(link);
|
|
} },
|
|
|
|
namedLink: { regex: '\\[\\[(' + rx.link + ')\\|(' + rx.linkText + ')\\]\\]',
|
|
build: function(node, r, options) {
|
|
var link = document.createElement('a');
|
|
|
|
var tmp = r[1].replace(/~(.)/g, '$1');
|
|
tmp = Url.encode (tmp);
|
|
|
|
/*link.href = options && options.linkFormat
|
|
? formatLink(r[1].replace(/~(.)/g, '$1'), options.linkFormat)
|
|
: r[1].replace(/~(.)/g, '$1');*/
|
|
|
|
link.href = options && options.linkFormat?
|
|
formatLink (tmp, options.linkFormat): tmp;
|
|
|
|
this.apply(link, r[2], options);
|
|
|
|
node.appendChild(link);
|
|
} },
|
|
|
|
unnamedUri: { regex: '\\[\\[(' + rx.uri + ')\\]\\]',
|
|
build: 'dummy' },
|
|
unnamedLink: { regex: '\\[\\[(' + rx.link + ')\\]\\]',
|
|
build: 'dummy' },
|
|
unnamedInterwikiLink: { regex: '\\[\\[(' + rx.interwikiLink + ')\\]\\]',
|
|
build: 'dummy' },
|
|
|
|
rawUri: { regex: '(' + rx.rawUri + ')',
|
|
build: 'dummy' },
|
|
|
|
escapedSequence: { regex: '~(' + rx.rawUri + '|.)', capture: 1,
|
|
tag: 'span', attrs: { 'class': 'escaped' } },
|
|
escapedSymbol: { regex: /~(.)/, capture: 1,
|
|
tag: 'span', attrs: { 'class': 'escaped' } }
|
|
};
|
|
g.unnamedUri.build = g.rawUri.build = function(node, r, options) {
|
|
if (!options) { options = {}; }
|
|
options.isPlainUri = true;
|
|
g.namedUri.build.call(this, node, Array(r[0], r[1], r[1]), options);
|
|
};
|
|
g.unnamedLink.build = function(node, r, options) {
|
|
g.namedLink.build.call(this, node, Array(r[0], r[1], r[1]), options);
|
|
};
|
|
g.namedInterwikiLink = { regex: '\\[\\[(' + rx.interwikiLink + ')\\|(' + rx.linkText + ')\\]\\]',
|
|
build: function(node, r, options) {
|
|
var link = document.createElement('a');
|
|
|
|
var m, f;
|
|
if (options && options.interwiki) {
|
|
m = r[1].match(/(.*?):(.*)/);
|
|
f = options.interwiki[m[1]];
|
|
}
|
|
|
|
if (typeof f == 'undefined') {
|
|
if (!g.namedLink.apply) {
|
|
g.namedLink = new this.constructor(g.namedLink);
|
|
}
|
|
return g.namedLink.build.call(g.namedLink, node, r, options);
|
|
}
|
|
|
|
link.href = formatLink(m[2].replace(/~(.)/g, '$1'), f);
|
|
|
|
this.apply(link, r[2], options);
|
|
|
|
node.appendChild(link);
|
|
}
|
|
};
|
|
g.unnamedInterwikiLink.build = function(node, r, options) {
|
|
g.namedInterwikiLink.build.call(this, node, Array(r[0], r[1], r[1]), options);
|
|
};
|
|
g.namedUri.children = g.unnamedUri.children = g.rawUri.children =
|
|
g.namedLink.children = g.unnamedLink.children =
|
|
g.namedInterwikiLink.children = g.unnamedInterwikiLink.children =
|
|
[ g.escapedSymbol, g.img ];
|
|
|
|
for (var i = 1; i <= 6; i++) {
|
|
g['h' + i] = { tag: 'h' + i, capture: 2,
|
|
regex: '(^|\\n)[ \\t]*={' + i + '}[ \\t]' +
|
|
'([^~]*?(~(.|(?=\\n)|$))*)[ \\t]*=*\\s*(\\n|$)'
|
|
};
|
|
}
|
|
|
|
g.ulist.children = g.olist.children = [ g.li ];
|
|
g.li.children = [ g.ulist, g.olist ];
|
|
g.li.fallback = g.text;
|
|
|
|
g.table.children = [ g.tr ];
|
|
g.tr.children = [ g.th, g.td ];
|
|
g.td.children = [ g.singleLine ];
|
|
g.th.children = [ g.singleLine ];
|
|
|
|
g.h1.children = g.h2.children = g.h3.children =
|
|
g.h4.children = g.h5.children = g.h6.children =
|
|
g.singleLine.children = g.paragraph.children =
|
|
g.text.children = g.strong.children = g.em.children =
|
|
[ g.escapedSequence, g.strong, g.em, g.br, g.rawUri,
|
|
g.namedUri, g.namedInterwikiLink, g.namedLink,
|
|
g.unnamedUri, g.unnamedInterwikiLink, g.unnamedLink,
|
|
g.tt, g.img ];
|
|
|
|
g.root = {
|
|
children: [ g.h1, g.h2, g.h3, g.h4, g.h5, g.h6,
|
|
g.hr, g.ulist, g.olist, g.preBlock, g.table, g.ohlohWidget ],
|
|
fallback: { children: [ g.paragraph ] }
|
|
};
|
|
|
|
Parse.Simple.Base.call(this, g, options);
|
|
};
|
|
|
|
Parse.Simple.Creole.prototype = new Parse.Simple.Base();
|
|
|
|
Parse.Simple.Creole.prototype.constructor = Parse.Simple.Creole;
|
|
|
|
function creole_render_wiki (inputid, outputid, linkbase, imgbase)
|
|
{
|
|
function $(id) { return document.getElementById(id); }
|
|
|
|
function decodeEntities(str)
|
|
{
|
|
return str.replace(/&/g, '&').
|
|
replace(/</g, '<').
|
|
replace(/>/g, '>').
|
|
replace(/"/g, '"');
|
|
}
|
|
|
|
var input = $(inputid);
|
|
var output = $(outputid);
|
|
var creole = new Parse.Simple.Creole(
|
|
{
|
|
forIE: document.all,
|
|
/*interwiki: {
|
|
WikiCreole: 'http://www.wikicreole.org/wiki/',
|
|
Wikipedia: 'http://en.wikipedia.org/wiki/'
|
|
},*/
|
|
linkFormat: linkbase,
|
|
imgFormat: imgbase
|
|
} );
|
|
|
|
var xinput = decodeEntities(input.innerHTML);
|
|
output.innerHTML = '';
|
|
creole.parse (output, xinput);
|
|
}
|