cortex-reaver 0.0.8 → 0.0.9

data/lib/cortex_reaver/controller/tag.rb

@@ -36,6 +36,17 @@ module CortexReaver
       end
     end
 
+    # Returns a few autocomplete candidates for a given tag by title, separated
+    # by newlines.
+    def autocomplete
+      q = request[:q].gsub(/[^A-Za-z0-9 -_]/, '')
+      if q.empty?
+        respond ''
+      else
+        respond Tag.filter(:title.like(/^#{q}/i)).limit(8).map(:title).join("\n")
+      end
+    end
+    
     def show(*ids)
       # Find tags
       tags = []

data/lib/cortex_reaver/helper/auth.rb

@@ -48,7 +48,7 @@ module Ramaze
 
       # Shortcut for current user or an anonymous proxy
       def user
-        session[:user] || CortexReaver::User.new(:name => 'Anonymous')
+        session[:user] || CortexReaver::User.anonymous
       end
 
       def error_403

data/lib/cortex_reaver/helper/navigation.rb

@@ -2,6 +2,43 @@ module Ramaze
   module Helper
     # Provides navigation rendering shortcuts
     module Navigation
+
+      # An HTML author/creation line for a model
+      def author_info(model)
+        s = '<span class="author-info">'
+        if model.respond_to? :creator and creator = model.creator
+          c = creator
+        end
+        if model.respond_to? :updater and updater = model.updater
+          u = updater
+        end
+
+        s << '<span class="creator">'
+        s << user_link(model, :creator)
+        s << '</span>'
+        s << ' on <span class="date">'
+        s << model.created_on.strftime('%e %B %Y')
+        s << '</span>'
+
+        ct = model.created_on
+        ut = model.updated_on
+        unless ut.year == ct.year and ut.month == ct.month and ut.day == ct.day
+          # Show the update time as well
+          if u.nil? or c == u
+            s << ' (updated'
+          else
+            s << ' (updated by '
+            s << '<span class="updater">'
+            s << user_link(model, :updater)
+            s << '</span>'
+          end
+          s << ' on <span class="date">'
+          s << ut.strftime('%e %B %Y')
+          s << '</span>)'
+        end
+        s << '</span>'
+      end
+
       # Returns a div with next/up/previous links for the record.
       def model_nav(model)
         n = '<div class="navigation actions">'

data/lib/cortex_reaver/helper/tags.rb

@@ -6,16 +6,22 @@ module Ramaze
         name = opts[:name]
         title = opts[:title] || name.to_s.titleize
         
-        s = "<p><label for=\"#{name}\">#{title}</label>"
+        s = "<p><label for=\"#{name}\">#{title}</label>\n"
+        s << "<ul id=\"#{name}-holder\" class=\"acfb-holder\">\n"
         s << "<input name=\"#{name}\" id=\"#{name}\" type=\"text\" class=\"acfb-input\" value=\"#{attr_h(tags_on(model, false))}\" />"
-        s << "</p>"
+        s << "</ul></p>"
 
         s << <<EOF
-
 <script type="text/javascript">
-/* <![CDATA[ */
-/* ]]> */
-</script>
+    /* <![CDATA[ */
+    $(document).ready(function() {
+      $("##{name}-holder").autoCompletefb({
+        urlLookup:'/tags/autocomplete',
+        acOptions:{extraParams:{id:'title'}}
+      });
+    });
+    /* ]]> */
+  </script>
 EOF
       end
 

data/lib/cortex_reaver/model/user.rb

@@ -52,7 +52,27 @@ module CortexReaver
         nil
       end
     end
-    
+
+    # An anonymous proxy user, with no permissions.
+    def self.anonymous
+      # Return singleton if stored
+      return @anonymous_user if @anonymous_user
+
+      # Create anonymous user
+      @anonymous_user = self.new(:name => "Anonymous")
+      def @anonymous_user.can_create? other
+        false
+      end
+      def @anonymous_user.can_edit? other
+        false
+      end
+      def @anonymous_user.can_delete? other
+        false
+      end
+      
+      @anonymous_user
+    end
+
     # CRUD uses this to construct URLs. Even though we don't need the full
     # power of Canonical, CRUD is pretty useful. :)
     def self.canonical_name_attr

data/lib/cortex_reaver/public/css/form.css

@@ -49,3 +49,108 @@ textarea {
 }
 
 /* Autocomplete */
+
+.ac_results {
+	padding: 0px;
+	border: 1px solid black;
+	background-color: Window;
+	overflow: hidden;
+	z-index: 99999;
+}
+.ac_results ul {
+	width: 100%;
+	list-style-position: outside;
+	list-style: none;
+	padding: 0;
+	margin: 0;
+}
+.ac_results li {
+	margin: 0px;
+	padding: 2px 5px;
+	cursor: default;
+	display: block;
+	font: menu;
+	font-size: 12px;
+	line-height: 16px;
+	overflow: hidden;
+}
+.ac_loading {
+	background : Window url('/images/indicator.gif') right center no-repeat;
+}
+.ac_odd {
+	background-color: #eee;
+}
+.ac_over {
+	background-color: Highlight;
+	color: HighlightText;
+}
+.ac_moreItems {
+	text-align: center;
+	background-color: #fff;
+	color: InactiveCaptionText;
+	margin: 0px;
+	padding: 0px 5px;
+	cursor: default;
+	display: block;
+	width: 100%;
+	font: bold menu 12px;
+	overflow: hidden;
+	-moz-user-select: none;
+	-khtml-user-select: none;
+}
+
+.p {cursor: pointer;}
+
+.acfb-input{
+	width: 10em;
+	border-radius: 6px; 
+	-moz-border-radius: 6px; 
+	-webkit-border-radius: 6px; 
+	border: 1px solid #CAD8F3; 
+	padding: 1px 5px 2px; 
+	background: transparent;
+  margin: 0 5px 4px 0; 
+	font: 11px "Lucida Grande", "Verdana";
+}
+
+* html ul.acfb-holder,*:first-child+html ul.acfb-holder { 
+	padding-bottom: 2px; 
+}
+
+ul.acfb-holder { 
+	margin  : 0; 
+	padding : 4px 5px 0; 
+	border  : 1px solid #999; 
+	height  : auto !important; 
+	height  : 1%; 
+	overflow: hidden; 
+	font    : 11px "Lucida Grande", "Verdana";
+}
+
+ul.acfb-holder li { 
+	float   : left; 
+	margin  : 0 5px 4px 0; 
+	list-style-type: none; 
+}
+
+ul.acfb-holder li.acfb-data { 
+	border-radius         : 6px; 
+	-moz-border-radius    : 6px; 
+	-webkit-border-radius : 6px; 
+	border     : 1px solid #CAD8F3; 
+	padding    : 1px 5px 2px; 
+	background : #DEE7F8; 
+}
+
+.acfb-add {
+	border-radius         : 6px; 
+	-moz-border-radius    : 6px; 
+	-webkit-border-radius : 6px; 
+	border     : 1px solid #CAD8F3; 
+	padding    : 1px 5px 2px; 
+	background : #DEE7F8;
+  margin: 0 5px 4px 0; 
+  display: inline-block;
+  text-align: center;
+  cursor: pointer;
+}

data/lib/cortex_reaver/public/css/text.css

@@ -15,7 +15,7 @@
   right: 0px;
 }
 
-.text-entry .written {
+.text-entry .author-info {
   position: absolute;
   left: 0px;
 }

data/lib/cortex_reaver/public/js/jquery.autocomplete.js

@@ -0,0 +1,849 @@
+/*
+ * Autocomplete - jQuery plugin 1.0 Beta
+ *
+ * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Revision: $Id: jquery.autocomplete.js 4485 2008-01-20 13:52:47Z joern.zaefferer $
+ *
+ */
+
+/**
+ * Provide autocomplete for text-inputs or textareas.
+ *
+ * Depends on dimensions plugin's offset method for correct positioning of the select box and bgiframe plugin
+ * to fix IE's problem with selects.
+ *
+ * @example $("#input_box").autocomplete("my_autocomplete_backend.php");
+ * @before <input id="input_box" />
+ * @desc Autocomplete a text-input with remote data. For small to giant datasets.
+ *
+ * When the user starts typing, a request is send to the specified backend ("my_autocomplete_backend.php"),
+ * with a GET parameter named q that contains the current value of the input box and a paremeter "limit" with
+ * the value specified for the max option.
+ *
+ * A value of "foo" would result in this request url: my_autocomplete_backend.php?q=foo&limit=10
+ *
+ * The result must return with one value on each line. The result is presented in the order
+ * the backend sends it.
+ *
+ * @example $("#input_box").autocomplete(["Cologne", "Berlin", "Munich"]);
+ * @before <input id="input_box" />
+ * @desc Autcomplete a text-input with local data. For small datasets.
+ *
+ * @example $.getJSON("my_backend.php", function(data) {
+ *   $("#input_box").autocomplete(data);
+ * });
+ * @before <input id="input_box" />
+ * @desc Autcomplete a text-input with data received via AJAX. For small to medium sized datasets.
+ *
+ * @example $("#mytextarea").autocomplete(["Cologne", "Berlin", "Munich"], {
+ *  multiple: true
+ * });
+ * @before <textarea id="mytextarea" />
+ * @desc Autcomplete a textarea with local data (for small datasets). Once the user chooses one
+ * value, a separator is appended (by default a comma, see multipleSeparator option) and more values
+ * are autocompleted.
+ *
+ * @name autocomplete
+ * @cat Plugins/Autocomplete
+ * @type $
+ * @param String|Array urlOrData Pass either an URL for remote-autocompletion or an array of data for local auto-completion
+ * @param Map options Optional settings
+ * @option String inputClass This class will be added to the input box. Default: "ac_input"
+ * @option String resultsClass The class for the UL that will contain the result items (result items are LI elements). Default: "ac_results"
+ * @option String loadingClass The class for the input box while results are being fetched from the server. Default: "ac_loading"
+ * @option Number minChars The minimum number of characters a user has to type before the autocompleter activates. Default: 1
+ * @option Number delay The delay in milliseconds the autocompleter waits after a keystroke to activate itself. Default: 400 for remote, 10 for local
+ * @option Number cacheLength The number of backend query results to store in cache. If set to 1 (the current result), no caching will happen. Do not set below 1. Default: 10
+ * @option Boolean matchSubset Whether or not the autocompleter can use a cache for more specific queries. This means that all matches of "foot" are a subset of all matches for "foo". Usually this is true, and using this options decreases server load and increases performance. Only useful with cacheLength settings bigger than one, like 10. Default: true
+ * @option Boolean matchCase Whether or not the comparison is case sensitive. Important only if you use caching. Default: false
+ * @option Boolean matchContains Whether or not the comparison looks inside (i.e. does "ba" match "foo bar") the search results. Important only if you use caching. Don't mix with autofill. Default: false
+ * @option Booolean mustMatch If set to true, the autocompleter will only allow results that are presented by the backend. Note that illegal values result in an empty input box. Default: false
+ * @option Object extraParams Extra parameters for the backend. If you were to specify { bar:4 }, the autocompleter would call my_autocomplete_backend.php?q=foo&bar=4 (assuming the input box contains "foo"). The param can be a function that is called to calculate the param before each request. Default: none
+ * @option Boolean selectFirst If this is set to true, the first autocomplete value will be automatically selected on tab/return, even if it has not been handpicked by keyboard or mouse action. If there is a handpicked (highlighted) result, that result will take precedence. Default: true
+ * @option Function formatItem Provides advanced markup for an item. For each row of results, this function will be called. The returned value will be displayed inside an LI element in the results list. Autocompleter will provide 4 parameters: the results row, the position of the row in the list of results (starting at 1), the number of items in the list of results and the search term. Default: none, assumes that a single row contains a single value.
+ * @option Function formatResult Similar to formatItem, but provides the formatting for the value to be put into the input field. Again three arguments: Data, position (starting with one) and total number of data. Default: none, assumes either plain data to use as result or uses the same value as provided by formatItem.
+ * @option Boolean multiple Whether to allow more than one autocomplted-value to enter. Default: false
+ * @option String multipleSeparator Seperator to put between values when using multiple option. Default: ", "
+ * @option Number width Specify a custom width for the select box. Default: width of the input element
+ * @option Boolean autoFill Fill the textinput while still selecting a value, replacing the value if more is typed or something else is selected. Default: false
+ * @option Number max Limit the number of items in the select box. Is also sent as a "limit" parameter with a remote request. Default: 10
+ * @option Boolean|Function highlight Whether and how to highlight matches in the select box. Set to false to disable. Set to a function to customize. The function gets the value as the first argument and the search term as the second and must return the formatted value. Default: Wraps the search term in a <strong> element 
+ * @option Boolean scroll Whether to scroll when more results than configured via scrollHeight are available. Default: true 
+ * @option Number scrollHeight height of scrolled autocomplete control in pixels
+ * @option String attachTo The element to attach the autocomplete list to. Useful if used inside a modal window like Thickbox. Default: body -MM
+ */
+
+/**
+ * Handle the result of a search event. Is executed when the user selects a value or a
+ * programmatic search event is triggered (see search()).
+ *
+ * You can add and remove (using unbind("result")) this event at any time.
+ *
+ * @example $('input#suggest').result(function(event, data, formatted) {
+ *   $("#result").html( !data ? "No match!" : "Selected: " + formatted);
+ * });
+ * @desc Bind a handler to the result event to display the selected value in a #result element.
+ *    The first argument is a generic event object, in this case with type "result".
+ *    The second argument refers to the selected data, which can be a plain string value or an array or object.
+ *    The third argument is the formatted value that is inserted into the input field.
+ *
+ * @param Function handler The event handler, gets a default event object as first and
+ * 		the selected list item as second argument.
+ * @name result
+ * @cat Plugins/Autocomplete
+ * @type $
+ */
+
+/**
+ * Trigger a search event. See result(Function) for binding to that event.
+ *
+ * A search event mimics the same behaviour as when the user selects a value from
+ * the list of autocomplete items. You can use it to execute anything that does something
+ * with the selected value, beyond simply putting the value into the input and submitting it.
+ *
+ * @example $('input#suggest').search();
+ * @desc Triggers a search event.
+ *
+ * @name search
+ * @cat Plugins/Autocomplete
+ * @type $
+ */
+ 
+/**
+ * Flush (empty) the cache of matched input's autocompleters.
+ *
+ * @example $('input#suggest').flushCache();
+ *
+ * @name flushCache
+ * @cat Plugins/Autocomplete
+ * @type $
+ */
+
+/**
+ * Updates the options for the current autocomplete field. This allows 
+ * you to change things like the URL, max items to display, etc. If you're
+ * changing the URL, be sure to remember to call the flushCache() method.
+ *
+ * @example $('input#suggest').setOptions({
+ *  max: 15
+ * });
+ * @desc Changes the maximum number of items to display to 15.
+ *
+ * @name setOptions
+ * @cat Plugins/Autocomplete
+ * @type $
+ */
+
+;(function($) {
+	
+$.fn.extend({
+	autocomplete: function(urlOrData, options) {
+		var isUrl = typeof urlOrData == "string";
+		options = $.extend({}, $.Autocompleter.defaults, {
+			url: isUrl ? urlOrData : null,
+			data: isUrl ? null : urlOrData,
+			delay: isUrl ? $.Autocompleter.defaults.delay : 10,
+			max: options && !options.scroll ? 10 : 150
+		}, options);
+		
+		// if highlight is set to false, replace it with a do-nothing function
+		options.highlight = options.highlight || function(value) { return value; };
+		
+		return this.each(function() {
+			new $.Autocompleter(this, options);
+		});
+	},
+	result: function(handler) {
+		return this.bind("result", handler);
+	},
+	search: function(handler) {
+		return this.trigger("search", [handler]);
+	},
+	flushCache: function() {
+		return this.trigger("flushCache");
+	},
+	setOptions: function(options){
+		return this.trigger("setOptions", [options]);
+	},
+	unautocomplete: function() {
+		return this.trigger("unautocomplete");
+	}
+});
+
+$.Autocompleter = function(input, options) {
+
+	var KEY = {
+		UP: 38,
+		DOWN: 40,
+		DEL: 46,
+		TAB: 9,
+		RETURN: 13,
+		ESC: 27,
+		COMMA: 188,
+		PAGEUP: 33,
+		PAGEDOWN: 34
+	};
+
+	// Create $ object for input element
+	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);
+
+	var timeout;
+	var previousValue = "";
+	var cache = $.Autocompleter.Cache(options);
+	var hasFocus = 0;
+	var lastKeyPressCode;
+	var config = {
+		mouseDownOnSelect: false
+	};
+	var select = $.Autocompleter.Select(options, input, selectCurrent, config);
+	
+	$input.keydown(function(event) {
+		// track last key pressed
+		lastKeyPressCode = event.keyCode;
+		switch(event.keyCode) {
+		
+			case KEY.UP:
+				event.preventDefault();
+				if ( select.visible() ) {
+					select.prev();
+				} else {
+					onChange(0, true);
+				}
+				break;
+				
+			case KEY.DOWN:
+				event.preventDefault();
+				if ( select.visible() ) {
+					select.next();
+				} else {
+					onChange(0, true);
+				}
+				break;
+				
+			case KEY.PAGEUP:
+				event.preventDefault();
+				if ( select.visible() ) {
+					select.pageUp();
+				} else {
+					onChange(0, true);
+				}
+				break;
+				
+			case KEY.PAGEDOWN:
+				event.preventDefault();
+				if ( select.visible() ) {
+					select.pageDown();
+				} else {
+					onChange(0, true);
+				}
+				break;
+			
+			// matches also semicolon
+			case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
+			case KEY.TAB:
+			case KEY.RETURN:
+				if( selectCurrent() ){
+					// make sure to blur off the current field
+					if( !options.multiple )
+						$input.blur();
+					event.preventDefault();
+				}
+				break;
+				
+			case KEY.ESC:
+				select.hide();
+				break;
+				
+			default:
+				clearTimeout(timeout);
+				timeout = setTimeout(onChange, options.delay);
+				break;
+		}
+	}).keypress(function() {
+		// having fun with opera - remove this binding and Opera submits the form when we select an entry via return
+	}).focus(function(){
+		// track whether the field has focus, we shouldn't process any
+		// results if the field no longer has focus
+		hasFocus++;
+	}).blur(function() {
+		hasFocus = 0;
+		if (!config.mouseDownOnSelect) {
+			hideResults();
+		}
+	}).click(function() {
+		// show select when clicking in a focused field
+		if ( hasFocus++ > 1 && !select.visible() ) {
+			onChange(0, true);
+		}
+	}).bind("search", function() {
+		// TODO why not just specifying both arguments?
+		var fn = (arguments.length > 1) ? arguments[1] : null;
+		function findValueCallback(q, data) {
+			var result;
+			if( data && data.length ) {
+				for (var i=0; i < data.length; i++) {
+					if( data[i].result.toLowerCase() == q.toLowerCase() ) {
+						result = data[i];
+						break;
+					}
+				}
+			}
+			if( typeof fn == "function" ) fn(result);
+			else $input.trigger("result", result && [result.data, result.value]);
+		}
+		$.each(trimWords($input.val()), function(i, value) {
+			request(value, findValueCallback, findValueCallback);
+		});
+	}).bind("flushCache", function() {
+		cache.flush();
+	}).bind("setOptions", function() {
+		$.extend(options, arguments[1]);
+		// if we've updated the data, repopulate
+		if ( "data" in arguments[1] )
+			cache.populate();
+	}).bind("unautocomplete", function() {
+		select.unbind();
+		$input.unbind();
+	});
+	
+	
+	function selectCurrent() {
+		var selected = select.selected();
+		if( !selected )
+			return false;
+		
+		var v = selected.result;
+		previousValue = v;
+		
+		if ( options.multiple ) {
+			var words = trimWords($input.val());
+			if ( words.length > 1 ) {
+				v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;
+			}
+			v += options.multipleSeparator;
+		}
+		
+		$input.val(v);
+		hideResultsNow();
+		$input.trigger("result", [selected.data, selected.value]);
+		return true;
+	}
+	
+	function onChange(crap, skipPrevCheck) {
+		if( lastKeyPressCode == KEY.DEL ) {
+			select.hide();
+			return;
+		}
+		
+		var currentValue = $input.val();
+		
+		if ( !skipPrevCheck && currentValue == previousValue )
+			return;
+		
+		previousValue = currentValue;
+		
+		currentValue = lastWord(currentValue);
+		if ( currentValue.length >= options.minChars) {
+			$input.addClass(options.loadingClass);
+			if (!options.matchCase)
+				currentValue = currentValue.toLowerCase();
+			request(currentValue, receiveData, hideResultsNow);
+		} else {
+			stopLoading();
+			select.hide();
+		}
+	};
+	
+	function trimWords(value) {
+		if ( !value ) {
+			return [""];
+		}
+		var words = value.split( $.trim( options.multipleSeparator ) );
+		var result = [];
+		$.each(words, function(i, value) {
+			if ( $.trim(value) )
+				result[i] = $.trim(value);
+		});
+		return result;
+	}
+	
+	function lastWord(value) {
+		if ( !options.multiple )
+			return value;
+		var words = trimWords(value);
+		return words[words.length - 1];
+	}
+	
+	// fills in the input box w/the first match (assumed to be the best match)
+	function autoFill(q, sValue){
+		// autofill in the complete box w/the first match as long as the user hasn't entered in more data
+		// if the last user key pressed was backspace, don't autofill
+		if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != 8 ) {
+			// fill in the value (keep the case the user has typed)
+			$input.val($input.val() + sValue.substring(lastWord(previousValue).length));
+			// select the portion of the value not typed by the user (so the next character will erase)
+			$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);
+		}
+	};
+
+	function hideResults() {
+		clearTimeout(timeout);
+		timeout = setTimeout(hideResultsNow, 200);
+	};
+
+	function hideResultsNow() {
+		select.hide();
+		clearTimeout(timeout);
+		stopLoading();
+		if (options.mustMatch) {
+			// call search and run callback
+			$input.search(
+				function (result){
+					// if no value found, clear the input box
+					if( !result ) $input.val("");
+				}
+			);
+		}
+	};
+
+	function receiveData(q, data) {
+		if ( data && data.length && hasFocus ) {
+			stopLoading();
+			select.display(data, q);
+			autoFill(q, data[0].value);
+			select.show();
+		} else {
+			hideResultsNow();
+		}
+	};
+
+	function request(term, success, failure) {
+		if (!options.matchCase)
+			term = term.toLowerCase();
+		var data = cache.load(term);
+		// recieve the cached data
+		if (data && data.length) {
+			success(term, data);
+		// if an AJAX url has been supplied, try loading the data now
+		} else if( (typeof options.url == "string") && (options.url.length > 0) ){
+			
+			var extraParams = {};
+			$.each(options.extraParams, function(key, param) {
+				extraParams[key] = typeof param == "function" ? param() : param;
+			});
+			
+			$.ajax({
+				// try to leverage ajaxQueue plugin to abort previous requests
+				mode: "abort",
+				// limit abortion to this input
+				port: "autocomplete" + input.name,
+				dataType: options.dataType,
+				url: options.url,
+				data: $.extend({
+					q: lastWord(term),
+					limit: options.max
+				}, extraParams),
+				success: function(data) {
+					var parsed = options.parse && options.parse(data) || parse(data);
+					cache.add(term, parsed);
+					success(term, parsed);
+				}
+			});
+		} else {
+			failure(term);
+		}
+	};
+	
+	function parse(data) {
+		var parsed = [];
+		var rows = data.split("\n");
+		for (var i=0; i < rows.length; i++) {
+			var row = $.trim(rows[i]);
+			if (row) {
+				row = row.split("|");
+				parsed[parsed.length] = {
+					data: row,
+					value: row[0],
+					result: options.formatResult && options.formatResult(row, row[0]) || row[0]
+				};
+			}
+		}
+		return parsed;
+	};
+
+	function stopLoading() {
+		$input.removeClass(options.loadingClass);
+	};
+
+};
+
+$.Autocompleter.defaults = {
+	inputClass: "ac_input",
+	resultsClass: "ac_results",
+	loadingClass: "ac_loading",
+	minChars: 1,
+	delay: 400,
+	matchCase: false,
+	matchSubset: true,
+	matchContains: false,
+	cacheLength: 10,
+	max: 100,
+	mustMatch: false,
+	extraParams: {},
+	selectFirst: true,
+	formatItem: function(row) { return row[0]; },
+	autoFill: false,
+	width: 0,
+	multiple: false,
+	multipleSeparator: ", ",
+	highlight: function(value, term) {
+		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
+	},
+    scroll: true,
+    scrollHeight: 180,
+	attachTo: 'body'
+};
+
+$.Autocompleter.Cache = function(options) {
+
+	var data = {};
+	var length = 0;
+	
+	function matchSubset(s, sub) {
+		if (!options.matchCase) 
+			s = s.toLowerCase();
+		var i = s.indexOf(sub);
+		if (i == -1) return false;
+		return i == 0 || options.matchContains;
+	};
+	
+	function add(q, value) {
+		if (length > options.cacheLength){
+			flush();
+		}
+		if (!data[q]){ 
+			length++;
+		}
+		data[q] = value;
+	}
+	
+	function populate(){
+		if( !options.data ) return false;
+		// track the matches
+		var stMatchSets = {},
+			nullData = 0;
+
+		// no url was specified, we need to adjust the cache length to make sure it fits the local data store
+		if( !options.url ) options.cacheLength = 1;
+		
+		// track all options for minChars = 0
+		stMatchSets[""] = [];
+		
+		// loop through the array and create a lookup structure
+		for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
+			var rawValue = options.data[i];
+			// if rawValue is a string, make an array otherwise just reference the array
+			rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;
+			
+			var value = options.formatItem(rawValue, i+1, options.data.length);
+			if ( value === false )
+				continue;
+				
+			var firstChar = value.charAt(0).toLowerCase();
+			// if no lookup array for this character exists, look it up now
+			if( !stMatchSets[firstChar] ) 
+				stMatchSets[firstChar] = [];
+
+			// if the match is a string
+			var row = {
+				value: value,
+				data: rawValue,
+				result: options.formatResult && options.formatResult(rawValue) || value
+			};
+			
+			// push the current match into the set list
+			stMatchSets[firstChar].push(row);
+
+			// keep track of minChars zero items
+			if ( nullData++ < options.max ) {
+				stMatchSets[""].push(row);
+			}
+		};
+
+		// add the data items to the cache
+		$.each(stMatchSets, function(i, value) {
+			// increase the cache size
+			options.cacheLength++;
+			// add to the cache
+			add(i, value);
+		});
+	}
+	
+	// populate any existing data
+	setTimeout(populate, 25);
+	
+	function flush(){
+		data = {};
+		length = 0;
+	}
+	
+	return {
+		flush: flush,
+		add: add,
+		populate: populate,
+		load: function(q) {
+			if (!options.cacheLength || !length)
+				return null;
+			/* 
+			 * if dealing w/local data and matchContains than we must make sure
+			 * to loop through all the data collections looking for matches
+			 */
+			if( !options.url && options.matchContains ){
+				// track all matches
+				var csub = [];
+				// loop through all the data grids for matches
+				for( var k in data ){
+					// don't search through the stMatchSets[""] (minChars: 0) cache
+					// this prevents duplicates
+					if( k.length > 0 ){
+						var c = data[k];
+						$.each(c, function(i, x) {
+							// if we've got a match, add it to the array
+							if (matchSubset(x.value, q)) {
+								csub.push(x);
+							}
+						});
+					}
+				}				
+				return csub;
+			} else 
+			// if the exact item exists, use it
+			if (data[q]){
+				return data[q];
+			} else
+			if (options.matchSubset) {
+				for (var i = q.length - 1; i >= options.minChars; i--) {
+					var c = data[q.substr(0, i)];
+					if (c) {
+						var csub = [];
+						$.each(c, function(i, x) {
+							if (matchSubset(x.value, q)) {
+								csub[csub.length] = x;
+							}
+						});
+						return csub;
+					}
+				}
+			}
+			return null;
+		}
+	};
+};
+
+$.Autocompleter.Select = function (options, input, select, config) {
+	var CLASSES = {
+		ACTIVE: "ac_over"
+	};
+	
+	var listItems,
+		active = -1,
+		data,
+		term = "",
+		needsInit = true,
+		element,
+		list;
+	
+	// Create results
+	function init() {
+		if (!needsInit)
+			return;
+		element = $("<div/>")
+		.hide()
+		.addClass(options.resultsClass)
+		.css("position", "absolute")
+		.appendTo(options.attachTo);
+	
+		list = $("<ul>").appendTo(element).mouseover( function(event) {
+			if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
+	            active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
+			    $(target(event)).addClass(CLASSES.ACTIVE);            
+	        }
+		}).click(function(event) {
+			$(target(event)).addClass(CLASSES.ACTIVE);
+			select();
+			input.focus();
+			return false;
+		}).mousedown(function() {
+			config.mouseDownOnSelect = true;
+		}).mouseup(function() {
+			config.mouseDownOnSelect = false;
+		});
+		
+		if( options.width > 0 )
+			element.css("width", options.width);
+			
+		needsInit = false;
+	} 
+	
+	function target(event) {
+		var element = event.target;
+		while(element && element.tagName != "LI")
+			element = element.parentNode;
+		// more fun with IE, sometimes event.target is empty, just ignore it then
+		if(!element)
+			return [];
+		return element;
+	}
+
+	function moveSelect(step) {
+		listItems.slice(active, active + 1).removeClass();
+		movePosition(step);
+        var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
+        if(options.scroll) {
+            var offset = 0;
+            listItems.slice(0, active).each(function() {
+				offset += this.offsetHeight;
+			});
+            if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
+                list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
+            } else if(offset < list.scrollTop()) {
+                list.scrollTop(offset);
+            }
+        }
+	};
+	
+	function movePosition(step) {
+		active += step;
+		if (active < 0) {
+			active = listItems.size() - 1;
+		} else if (active >= listItems.size()) {
+			active = 0;
+		}
+	}
+	
+	function limitNumberOfItems(available) {
+		return options.max && options.max < available
+			? options.max
+			: available;
+	}
+	
+	function fillList() {
+		list.empty();
+		var max = limitNumberOfItems(data.length);
+		for (var i=0; i < max; i++) {
+			if (!data[i])
+				continue;
+			var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
+			if ( formatted === false )
+				continue;
+			var li = $("<li>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_event" : "ac_odd").appendTo(list)[0];
+			$.data(li, "ac_data", data[i]);
+		}
+		listItems = list.find("li");
+		if ( options.selectFirst ) {
+			listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
+			active = 0;
+		}
+		list.bgiframe();
+	}
+	
+	return {
+		display: function(d, q) {
+			init();
+			data = d;
+			term = q;
+			fillList();
+		},
+		next: function() {
+			moveSelect(1);
+		},
+		prev: function() {
+			moveSelect(-1);
+		},
+		pageUp: function() {
+			if (active != 0 && active - 8 < 0) {
+				moveSelect( -active );
+			} else {
+				moveSelect(-8);
+			}
+		},
+		pageDown: function() {
+			if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
+				moveSelect( listItems.size() - 1 - active );
+			} else {
+				moveSelect(8);
+			}
+		},
+		hide: function() {
+			element && element.hide();
+			active = -1;
+		},
+		visible : function() {
+			return element && element.is(":visible");
+		},
+		current: function() {
+			return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);
+		},
+		show: function() {
+			var offset = $(input).offset();
+			element.css({
+				width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),
+				top: offset.top + input.offsetHeight,
+				left: offset.left
+			}).show();
+            if(options.scroll) {
+                list.scrollTop(0);
+                list.css({
+					maxHeight: options.scrollHeight,
+					overflow: 'auto'
+				});
+				
+                if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
+					var listHeight = 0;
+					listItems.each(function() {
+						listHeight += this.offsetHeight;
+					});
+					var scrollbarsVisible = listHeight > options.scrollHeight;
+                    list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
+					if (!scrollbarsVisible) {
+						// IE doesn't recalculate width when scrollbar disappears
+						listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
+					}
+                }
+                
+            }
+		},
+		selected: function() {
+			var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
+			return selected && selected.length && $.data(selected[0], "ac_data");
+		},
+		unbind: function() {
+			element && element.remove();
+		}
+	};
+};
+
+$.Autocompleter.Selection = function(field, start, end) {
+	if( field.createTextRange ){
+		var selRange = field.createTextRange();
+		selRange.collapse(true);
+		selRange.moveStart("character", start);
+		selRange.moveEnd("character", end);
+		selRange.select();
+	} else if( field.setSelectionRange ){
+		field.setSelectionRange(start, end);
+	} else {
+		if( field.selectionStart ){
+			field.selectionStart = start;
+			field.selectionEnd = end;
+		}
+	}
+	field.focus();
+};
+
+})(jQuery);