From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001
From: mensonge
Date: Thu, 13 Nov 2008 09:49:11 +0000
Subject: New feature: basic Ajax suggestion for tags and implementation of
 Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
---
 includes/js/dojox/dtl/filter/dates.js       |  54 +++++
 includes/js/dojox/dtl/filter/htmlstrings.js |  59 +++++
 includes/js/dojox/dtl/filter/integers.js    |  32 +++
 includes/js/dojox/dtl/filter/lists.js       | 137 ++++++++++++
 includes/js/dojox/dtl/filter/logic.js       |  34 +++
 includes/js/dojox/dtl/filter/misc.js        |  59 +++++
 includes/js/dojox/dtl/filter/strings.js     | 327 ++++++++++++++++++++++++++++
 7 files changed, 702 insertions(+)
 create mode 100644 includes/js/dojox/dtl/filter/dates.js
 create mode 100644 includes/js/dojox/dtl/filter/htmlstrings.js
 create mode 100644 includes/js/dojox/dtl/filter/integers.js
 create mode 100644 includes/js/dojox/dtl/filter/lists.js
 create mode 100644 includes/js/dojox/dtl/filter/logic.js
 create mode 100644 includes/js/dojox/dtl/filter/misc.js
 create mode 100644 includes/js/dojox/dtl/filter/strings.js

(limited to 'includes/js/dojox/dtl/filter')

diff --git a/includes/js/dojox/dtl/filter/dates.js b/includes/js/dojox/dtl/filter/dates.js
new file mode 100644
index 0000000..3ca2022
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/dates.js
@@ -0,0 +1,54 @@
+if(!dojo._hasResource["dojox.dtl.filter.dates"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.dates"] = true;
+dojo.provide("dojox.dtl.filter.dates");
+
+dojo.require("dojox.dtl.utils.date");
+
+(function(){
+	var ddfd = dojox.dtl.filter.dates;
+
+	dojo.mixin(ddfd, {
+		_toDate: function(value){
+			if(value instanceof Date){
+				return value;
+			}
+			value = new Date(value);
+			if(value.getTime() == new Date(0).getTime()){
+				return "";
+			}
+			return value;
+		},
+		date: function(value, arg){
+			// summary: Formats a date according to the given format
+			value = ddfd._toDate(value);
+			if(!value) return "";
+			arg = arg || "N j, Y";
+			return dojox.dtl.utils.date.format(value, arg);
+		},
+		time: function(value, arg){
+			// summary: Formats a time according to the given format
+			value = ddfd._toDate(value);
+			if(!value) return "";
+			arg = arg || "P";
+			return dojox.dtl.utils.date.format(value, arg);
+		},
+		timesince: function(value, arg){
+			// summary: Formats a date as the time since that date (i.e. "4 days, 6 hours")
+			value = ddfd._toDate(value);
+			if(!value) return "";
+			var timesince = dojox.dtl.utils.date.timesince;
+			if(arg) return timesince(arg, value);
+			return timesince(value);
+		},
+		timeuntil: function(value, arg){
+			// summary: Formats a date as the time until that date (i.e. "4 days, 6 hours")
+			value = ddfd._toDate(value);
+			if(!value) return "";
+			var timesince = dojox.dtl.utils.date.timesince;
+			if(arg) return timesince(arg, value);
+			return timesince(new Date(), value);
+		}
+	});
+})();
+
+}
diff --git a/includes/js/dojox/dtl/filter/htmlstrings.js b/includes/js/dojox/dtl/filter/htmlstrings.js
new file mode 100644
index 0000000..d4feb93
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/htmlstrings.js
@@ -0,0 +1,59 @@
+if(!dojo._hasResource["dojox.dtl.filter.htmlstrings"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.htmlstrings"] = true;
+dojo.provide("dojox.dtl.filter.htmlstrings");
+
+dojo.require("dojox.dtl._base");
+
+dojo.mixin(dojox.dtl.filter.htmlstrings, {
+	_escapeamp: /&/g,
+	_escapelt: /</g,
+	_escapegt: />/g,
+	_escapeqt: /'/g,
+	_escapedblqt: /"/g,
+	_linebreaksrn: /(\r\n|\n\r)/g,
+	_linebreaksn: /\n{2,}/g,
+	_linebreakss: /(^\s+|\s+$)/g,
+	_linebreaksbr: /\n/g,
+	_removetagsfind: /[a-z0-9]+/g,
+	_striptags: /<[^>]*?>/g,
+	escape: function(value){
+		// summary: Escapes a string's HTML
+		var dh = dojox.dtl.filter.htmlstrings;
+		return value.replace(dh._escapeamp, '&amp;').replace(dh._escapelt, '&lt;').replace(dh._escapegt, '&gt;').replace(dh._escapedblqt, '&quot;').replace(dh._escapeqt, '&#39;');
+	},
+	linebreaks: function(value){
+		// summary: Converts newlines into <p> and <br />s
+		var output = [];
+		var dh = dojox.dtl.filter.htmlstrings;
+		value = value.replace(dh._linebreaksrn, "\n");
+		var parts = value.split(dh._linebreaksn);
+		for(var i = 0; i < parts.length; i++){
+			var part = parts[i].replace(dh._linebreakss, "").replace(dh._linebreaksbr, "<br />")
+			output.push("<p>" + part + "</p>");
+		}
+
+		return output.join("\n\n");
+	},
+	linebreaksbr: function(value){
+		// summary: Converts newlines into <br />s
+		var dh = dojox.dtl.filter.htmlstrings;
+		return value.replace(dh._linebreaksrn, "\n").replace(dh._linebreaksbr, "<br />");
+	},
+	removetags: function(value, arg){
+		// summary: Removes a space separated list of [X]HTML tags from the output"
+		var dh = dojox.dtl.filter.htmlstrings;
+		var tags = [];
+		var group;
+		while(group = dh._removetagsfind.exec(arg)){
+			tags.push(group[0]);
+		}
+		tags = "(" + tags.join("|") + ")";
+		return value.replace(new RegExp("</?\s*" + tags + "\s*[^>]*>", "gi"), "");
+	},
+	striptags: function(value){
+		// summary: Strips all [X]HTML tags
+		return value.replace(dojox.dtl.filter.htmlstrings._striptags, "");
+	}
+});
+
+}
diff --git a/includes/js/dojox/dtl/filter/integers.js b/includes/js/dojox/dtl/filter/integers.js
new file mode 100644
index 0000000..0c54a90
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/integers.js
@@ -0,0 +1,32 @@
+if(!dojo._hasResource["dojox.dtl.filter.integers"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.integers"] = true;
+dojo.provide("dojox.dtl.filter.integers");
+
+dojo.mixin(dojox.dtl.filter.integers, {
+	add: function(value, arg){
+		value = parseInt(value);
+		arg = parseInt(arg);
+		return isNaN(arg) ? value : value + arg;
+	},
+	get_digit: function(value, arg){
+		// summary:
+		//		Given a whole number, returns the 1-based requested digit of it
+		// desciprtion:
+		//		1 is the right-most digit, 2 is the second-right-most digit, etc. Returns the
+		//		original value for invalid input (if input or argument is not an integer,
+		//		or if argument is less than 1). Otherwise, output is always an integer.
+		value = parseInt(value);
+		arg = parseInt(arg) - 1;
+		if(arg >= 0){
+			value += "";
+			if(arg < value.length){
+				value = parseInt(value.charAt(arg));
+			}else{
+				value = 0;
+			}
+		}
+		return (isNaN(value) ? 0 : value);
+	}
+});
+
+}
diff --git a/includes/js/dojox/dtl/filter/lists.js b/includes/js/dojox/dtl/filter/lists.js
new file mode 100644
index 0000000..b095242
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/lists.js
@@ -0,0 +1,137 @@
+if(!dojo._hasResource["dojox.dtl.filter.lists"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.lists"] = true;
+dojo.provide("dojox.dtl.filter.lists")
+
+dojo.require("dojox.dtl._base");
+
+dojo.mixin(dojox.dtl.filter.lists, {
+	_dictsort: function(a, b){
+		if(a[0] == b[0]) return 0;
+		return (a[0] < b[0]) ? -1 : 1;
+	},
+	dictsort: function(value, arg){
+		// summary: Takes a list of dicts, returns that list sorted by the property given in the argument.
+		if(!arg) return value;
+
+		var i, item, items = [];
+		if(!dojo.isArray(value)){
+			var obj = value, value = [];
+			for(var key in obj){
+				value.push(obj[k]);
+			}
+		}
+		for(i = 0; i < value.length; i++){
+			items.push([new dojox.dtl._Filter('var.' + arg).resolve(new dojox.dtl._Context({ 'var' : value[i]})), value[i]]);
+		}
+		items.sort(dojox.dtl.filter.lists._dictsort);
+		var output = [];
+		for(i = 0; item = items[i]; i++){
+			output.push(item[1]);
+		}
+		return output;
+	},
+	dictsortreversed: function(value, arg){
+		// summary: Takes a list of dicts, returns that list sorted in reverse order by the property given in the argument.
+		if(!arg) return value;
+
+		var dictsort = dojox.dtl.filter.lists.dictsort(value, arg);
+		return dictsort.reverse();
+	},
+	first: function(value){
+		// summary: Returns the first item in a list
+		return (value.length) ? value[0] : "";
+	},
+	join: function(value, arg){
+		// summary: Joins a list with a string, like Python's ``str.join(list)``
+		// description:
+		//		Django throws a compile error, but JS can't do arg checks
+		//		so we're left with run time errors, which aren't wise for something
+		//		as trivial here as an empty arg.
+		return value.join(arg || ",");
+	},
+	length: function(value){
+		// summary: Returns the length of the value - useful for lists
+		return (isNaN(value.length)) ? (value + "").length : value.length;
+	},
+	length_is: function(value, arg){
+		// summary: Returns a boolean of whether the value's length is the argument
+		return value.length == parseInt(arg);
+	},
+	random: function(value){
+		// summary: Returns a random item from the list
+		return value[Math.floor(Math.random() * value.length)];
+	},
+	slice: function(value, arg){
+		// summary: Returns a slice of the list.
+		// description:
+		//		Uses the same syntax as Python's list slicing; see
+		//		http://diveintopython.org/native_data_types/lists.html#odbchelper.list.slice
+		//		for an introduction.
+		//		Also uses the optional third value to denote every X item.
+		arg = arg || "";
+		var parts = arg.split(":");
+		var bits = [];
+		for(var i = 0; i < parts.length; i++){
+			if(!parts[i].length){
+				bits.push(null);
+			}else{
+				bits.push(parseInt(parts[i]));
+			}
+		}
+
+		if(bits[0] === null){
+			bits[0] = 0;
+		}
+		if(bits[0] < 0){
+			bits[0] = value.length + bits[0];
+		}
+		if(bits.length < 2 || bits[1] === null){
+			bits[1] = value.length;
+		}
+		if(bits[1] < 0){
+			bits[1] = value.length + bits[1];
+		}
+		
+		return value.slice(bits[0], bits[1]);
+	},
+	_unordered_list: function(value, tabs){
+		var ddl = dojox.dtl.filter.lists;
+		var i, indent = "";
+		for(i = 0; i < tabs; i++){
+			indent += "\t";
+		}
+		if(value[1] && value[1].length){
+			var recurse = [];
+			for(i = 0; i < value[1].length; i++){
+				recurse.push(ddl._unordered_list(value[1][i], tabs + 1))
+			}
+			return indent + "<li>" + value[0] + "\n" + indent + "<ul>\n" + recurse.join("\n") + "\n" + indent + "</ul>\n" + indent + "</li>";
+		}else{
+			return indent + "<li>" + value[0] + "</li>";
+		}
+	},
+	unordered_list: function(value){
+		// summary:
+		//		Recursively takes a self-nested list and returns an HTML unordered list --
+		//		WITHOUT opening and closing <ul> tags.
+		//	description:
+		//		The list is assumed to be in the proper format. For example, if ``var`` contains
+		//		``['States', [['Kansas', [['Lawrence', []], ['Topeka', []]]], ['Illinois', []]]]``,
+		//		then ``{{ var|unordered_list }}`` would return::
+		//
+		//		|	<li>States
+		//		|	<ul>
+		//		|		<li>Kansas
+		//		|		<ul>
+		//		|			<li>Lawrence</li>
+		//		|			<li>Topeka</li>
+		//		|		</ul>
+		//		|		</li>
+		//		|		<li>Illinois</li>
+		//		|	</ul>
+		//		|	</li>
+		return dojox.dtl.filter.lists._unordered_list(value, 1);
+	}
+});
+
+}
diff --git a/includes/js/dojox/dtl/filter/logic.js b/includes/js/dojox/dtl/filter/logic.js
new file mode 100644
index 0000000..b69a1a8
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/logic.js
@@ -0,0 +1,34 @@
+if(!dojo._hasResource["dojox.dtl.filter.logic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.logic"] = true;
+dojo.provide("dojox.dtl.filter.logic");
+
+dojo.mixin(dojox.dtl.filter.logic, {
+	default_: function(value, arg){
+		// summary: If value is unavailable, use given default
+		return value || arg || "";
+	},
+	default_if_none: function(value, arg){
+		// summary: If value is null, use given default
+		return (value === null) ? arg || "" : value || "";
+	},
+	divisibleby: function(value, arg){
+		// summary: Returns true if the value is devisible by the argument"
+		return (parseInt(value) % parseInt(arg)) == 0;
+	},
+	_yesno: /\s*,\s*/g,
+	yesno: function(value, arg){
+		// summary:
+		//		arg being a comma-delimited string, value of true/false/none
+		//		chooses the appropriate item from the string
+		if(!arg) arg = 'yes,no,maybe';
+		var parts = arg.split(dojox.dtl.filter.logic._yesno);
+		if(parts.length < 2){
+			return value;
+		}
+		if(value) return parts[0];
+		if((!value && value !== null) || parts.length < 3) return parts[1];
+		return parts[2];
+	}
+});
+
+}
diff --git a/includes/js/dojox/dtl/filter/misc.js b/includes/js/dojox/dtl/filter/misc.js
new file mode 100644
index 0000000..0704d25
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/misc.js
@@ -0,0 +1,59 @@
+if(!dojo._hasResource["dojox.dtl.filter.misc"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.misc"] = true;
+dojo.provide("dojox.dtl.filter.misc");
+
+dojo.mixin(dojox.dtl.filter.misc, {
+	filesizeformat: function(value){
+		// summary: Format the value like a 'human-readable' file size (i.e. 13 KB, 4.1 MB, 102bytes, etc).
+		value = parseFloat(value);
+		if(value < 1024){
+			return (value == 1) ? value + " byte" : value + " bytes";
+		}else if(value < 1024 * 1024){
+			return (value / 1024).toFixed(1) + " KB";
+		}else if(value < 1024 * 1024 * 1024){
+			return (value / 1024 / 1024).toFixed(1) + " MB";
+		}
+		return (value / 1024 / 1024 / 1024).toFixed(1) + " GB";
+	},
+	pluralize: function(value, arg){
+		// summary:
+		//		Returns a plural suffix if the value is not 1, for '1 vote' vs. '2 votes'
+		//	description:
+		//		By default, 's' is used as a suffix; if an argument is provided, that string
+		//		is used instead. If the provided argument contains a comma, the text before
+		//		the comma is used for the singular case.
+		arg = arg || 's';
+		if(arg.indexOf(",") == -1){
+			arg = "," + arg;
+		}
+		var parts = arg.split(",");
+		if(parts.length > 2){
+			return "";
+		}
+		var singular = parts[0];
+		var plural = parts[1];
+
+		if(parseInt(value) != 1){
+			return plural;
+		}
+		return singular;
+	},
+	_phone2numeric: { a: 2, b: 2, c: 2, d: 3, e: 3, f: 3, g: 4, h: 4, i: 4, j: 5, k: 5, l: 5, m: 6, n: 6, o: 6, p: 7, r: 7, s: 7, t: 8, u: 8, v: 8, w: 9, x: 9, y: 9 },
+	phone2numeric: function(value){
+		// summary: Takes a phone number and converts it in to its numerical equivalent
+		var dm = dojox.dtl.filter.misc;
+		value = value + "";
+		var output = "";
+		for(var i = 0; i < value.length; i++){
+			var chr = value.charAt(i).toLowerCase();
+			(dm._phone2numeric[chr]) ? output += dm._phone2numeric[chr] : output += value.charAt(i);
+		}
+		return output;
+	},
+	pprint: function(value){
+		// summary: A wrapper around toJson unless something better comes along
+		return dojo.toJson(value);
+	}
+});
+
+}
diff --git a/includes/js/dojox/dtl/filter/strings.js b/includes/js/dojox/dtl/filter/strings.js
new file mode 100644
index 0000000..1270574
--- /dev/null
+++ b/includes/js/dojox/dtl/filter/strings.js
@@ -0,0 +1,327 @@
+if(!dojo._hasResource["dojox.dtl.filter.strings"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.filter.strings"] = true;
+dojo.provide("dojox.dtl.filter.strings");
+
+dojo.require("dojox.dtl.filter.htmlstrings");
+dojo.require("dojox.string.sprintf");
+dojo.require("dojox.string.tokenize");
+
+dojo.mixin(dojox.dtl.filter.strings, {
+	_urlquote: function(/*String*/ url, /*String?*/ safe){
+		if(!safe){
+			safe = "/";
+		}
+		return dojox.string.tokenize(url, /([^\w-_.])/g, function(token){
+			if(safe.indexOf(token) == -1){
+				if(token == " "){
+					return "+";
+				}else{
+					return "%" + token.charCodeAt(0).toString(16).toUpperCase();
+				}
+			}
+			return token;
+		}).join("");
+	},
+	addslashes: function(value){
+		// summary: Adds slashes - useful for passing strings to JavaScript, for example.
+		return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'");
+	},
+	capfirst: function(value){
+		// summary: Capitalizes the first character of the value
+		value = "" + value;
+		return value.charAt(0).toUpperCase() + value.substring(1);
+	},
+	center: function(value, arg){
+		// summary: Centers the value in a field of a given width
+		arg = arg || value.length;
+		value = value + "";
+		var diff = arg - value.length;
+		if(diff % 2){
+			value = value + " ";
+			diff -= 1;
+		}
+		for(var i = 0; i < diff; i += 2){
+			value = " " + value + " ";
+		}
+		return value;
+	},
+	cut: function(value, arg){
+		// summary: Removes all values of arg from the given string
+		arg = arg + "" || "";
+		value = value + "";
+		return value.replace(new RegExp(arg, "g"), "");
+	},
+	_fix_ampersands: /&(?!(\w+|#\d+);)/g,
+	fix_ampersands: function(value){
+		// summary: Replaces ampersands with ``&amp;`` entities
+		return value.replace(dojox.dtl.filter.strings._fix_ampersands, "&amp;");
+	},
+	floatformat: function(value, arg){
+		// summary: Format a number according to arg
+		// description:
+		//		If called without an argument, displays a floating point
+		//		number as 34.2 -- but only if there's a point to be displayed.
+		//		With a positive numeric argument, it displays that many decimal places
+		//		always.
+		//		With a negative numeric argument, it will display that many decimal
+		//		places -- but only if there's places to be displayed.
+		arg = parseInt(arg || -1);
+		value = parseFloat(value);
+		var m = value - value.toFixed(0);
+		if(!m && arg < 0){
+			return value.toFixed();
+		}
+		value = value.toFixed(Math.abs(arg));
+		return (arg < 0) ? parseFloat(value) + "" : value;
+	},
+	iriencode: function(value){
+		return dojox.dtl.filter.strings._urlquote(value, "/#%[]=:;$&()+,!");
+	},
+	linenumbers: function(value){
+		// summary: Displays text with line numbers
+		var df = dojox.dtl.filter;
+		var lines = value.split("\n");
+		var output = [];
+		var width = (lines.length + "").length;
+		for(var i = 0, line; i < lines.length; i++){
+			line = lines[i];
+			output.push(df.strings.ljust(i + 1, width) + ". " + df.htmlstrings.escape(line));
+		}
+		return output.join("\n");
+	},
+	ljust: function(value, arg){
+		value = value + "";
+		arg = parseInt(arg);
+		while(value.length < arg){
+			value = value + " ";
+		}
+		return value;
+	},
+	lower: function(value){
+		// summary: Converts a string into all lowercase
+		return (value + "").toLowerCase();
+	},
+	make_list: function(value){
+		// summary:
+		//		Returns the value turned into a list. For an integer, it's a list of
+		//		digits. For a string, it's a list of characters.
+		var output = [];
+		if(typeof value == "number"){
+			value = value + "";
+		}
+		if(value.charAt){
+			for(var i = 0; i < value.length; i++){
+				output.push(value.charAt(i));
+			}
+			return output;
+		}
+		if(typeof value == "object"){
+			for(var key in value){
+				output.push(value[key]);
+			}
+			return output;
+		}
+		return [];
+	},
+	rjust: function(value, arg){
+		value = value + "";
+		arg = parseInt(arg);
+		while(value.length < arg){
+			value = " " + value;
+		}
+		return value;
+	},
+	slugify: function(value){
+		// summary: Converts to lowercase, removes
+		//		non-alpha chars and converts spaces to hyphens
+		value = value.replace(/[^\w\s-]/g, "").toLowerCase();
+		return value.replace(/[\-\s]+/g, "-");
+	},
+	_strings: {},
+	stringformat: function(value, arg){
+		// summary:
+		//		Formats the variable according to the argument, a string formatting specifier.
+		//		This specifier uses Python string formating syntax, with the exception that
+		//		the leading "%" is dropped.
+		arg = "" + arg;
+		var strings = dojox.dtl.filter.strings._strings;
+		if(!strings[arg]){
+			strings[arg] = new dojox.string.sprintf.Formatter("%" + arg);
+		}
+		return strings[arg].format(value);
+	},
+	title: function(value){
+		// summary: Converts a string into titlecase
+		var last, title = "";
+		for(var i = 0, current; i < value.length; i++){
+			current = value.charAt(i);
+			if(last == " " || last == "\n" || last == "\t" || !last){
+				title += current.toUpperCase();
+			}else{
+				title += current.toLowerCase();
+			}
+			last = current;
+		}
+		return title;
+	},
+	_truncatewords: /[ \n\r\t]/,
+	truncatewords: function(value, arg){
+		// summary: Truncates a string after a certain number of words
+		// arg: Integer
+		//		Number of words to truncate after
+		arg = parseInt(arg);
+		if(!arg){
+			return value;
+		}
+
+		for(var i = 0, j = value.length, count = 0, current, last; i < value.length; i++){
+			current = value.charAt(i);
+			if(dojox.dtl.filter.strings._truncatewords.test(last)){
+				if(!dojox.dtl.filter.strings._truncatewords.test(current)){
+					++count;
+					if(count == arg){
+						return value.substring(0, j + 1);
+					}
+				}
+			}else if(!dojox.dtl.filter.strings._truncatewords.test(current)){
+				j = i;
+			}
+			last = current;
+		}
+		return value;
+	},
+	_truncate_words: /(&.*?;|<.*?>|(\w[\w\-]*))/g,
+	_truncate_tag: /<(\/)?([^ ]+?)(?: (\/)| .*?)?>/,
+	_truncate_singlets: { br: true, col: true, link: true, base: true, img: true, param: true, area: true, hr: true, input: true },
+	truncatewords_html: function(value, arg){
+		arg = parseInt(arg);
+
+		if(arg <= 0){
+			return "";
+		}
+
+		var strings = dojox.dtl.filter.strings;
+		var words = 0;
+		var open = [];
+
+		var output = dojox.string.tokenize(value, strings._truncate_words, function(all, word){
+			if(word){
+				// It's an actual non-HTML word
+				++words;
+				if(words < arg){
+					return word;
+				}else if(words == arg){
+					return word + " ...";
+				}
+			}
+			// Check for tag
+			var tag = all.match(strings._truncate_tag);
+			if(!tag || words >= arg){
+				// Don't worry about non tags or tags after our truncate point
+				return;
+			}
+			var closing = tag[1];
+			var tagname = tag[2].toLowerCase();
+			var selfclosing = tag[3];
+			if(closing || strings._truncate_singlets[tagname]){
+			}else if(closing){
+				var i = dojo.indexOf(open, tagname);
+				if(i != -1){
+					open = open.slice(i + 1);
+				}
+			}else{
+				open.unshift(tagname);
+			}
+			return all;
+		}).join("");
+
+		output = output.replace(/\s+$/g, "");
+
+		for(var i = 0, tag; tag = open[i]; i++){
+			output += "</" + tag + ">";
+		}
+
+		return output;
+	},
+	upper: function(value){
+		return value.toUpperCase();
+	},
+	urlencode: function(value){
+		return dojox.dtl.filter.strings._urlquote(value);
+	},
+	_urlize: /^((?:[(>]|&lt;)*)(.*?)((?:[.,)>\n]|&gt;)*)$/,
+	_urlize2: /^\S+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9._-]+$/,
+	urlize: function(value){
+		return dojox.dtl.filter.strings.urlizetrunc(value);
+	},
+	urlizetrunc: function(value, arg){
+		arg = parseInt(arg);
+		return dojox.string.tokenize(value, /(\S+)/g, function(word){
+			var matches = dojox.dtl.filter.strings._urlize.exec(word);
+			if(!matches){
+				return word;
+			}
+			var lead = matches[1];
+			var middle = matches[2];
+			var trail = matches[3];
+
+			var startsWww = middle.indexOf("www.") == 0;
+			var hasAt = middle.indexOf("@") != -1;
+			var hasColon = middle.indexOf(":") != -1;
+			var startsHttp = middle.indexOf("http://") == 0;
+			var startsHttps = middle.indexOf("https://") == 0;
+			var firstAlpha = /[a-zA-Z0-9]/.test(middle.charAt(0));
+			var last4 = middle.substring(middle.length - 4);
+
+			var trimmed = middle;
+			if(arg > 3){
+				trimmed = trimmed.substring(0, arg - 3) + "...";
+			}
+
+			if(startsWww || (!hasAt && !startsHttp && middle.length && firstAlpha && (last4 == ".org" || last4 == ".net" || last4 == ".com"))){
+				return '<a href="http://' + middle + '" rel="nofollow">' + trimmed + '</a>';
+			}else if(startsHttp || startsHttps){
+				return '<a href="' + middle + '" rel="nofollow">' + trimmed + '</a>';
+			}else if(hasAt && !startsWww && !hasColon && dojox.dtl.filter.strings._urlize2.test(middle)){
+				return '<a href="mailto:' + middle + '">' + middle + '</a>';
+			}
+			return word;
+		}).join("");
+	},
+	wordcount: function(value){
+		return dojox.dtl.text.pySplit(value).length;
+	},
+	wordwrap: function(value, arg){
+		arg = parseInt(arg);
+		// summary: Wraps words at specified line length
+		var output = [];
+		var parts = value.split(/ /g);
+		if(parts.length){
+			var word = parts.shift();
+			output.push(word);
+			var pos = word.length - word.lastIndexOf("\n") - 1;
+			for(var i = 0; i < parts.length; i++){
+				word = parts[i];
+				if(word.indexOf("\n") != -1){
+					var lines = word.split(/\n/g);
+				}else{
+					var lines = [word];
+				}
+				pos += lines[0].length + 1;
+				if(arg && pos > arg){
+					output.push("\n");
+					pos = lines[lines.length - 1].length;
+				}else{
+					output.push(" ");
+					if(lines.length > 1){
+						pos = lines[lines.length - 1].length;
+					}
+				}
+				output.push(word);
+			}
+		}
+		return output.join("");
+	}
+});
+
+}
-- 
cgit v1.2.3-54-g00ecf