vinova_sunspot_autocomplete 1.0.1

data/assets/javascripts/solr-autocomplete/ajax-solr/core/ParameterStore.js

@@ -0,0 +1,354 @@
+// $Id$
+
+/**
+ * The ParameterStore, as its name suggests, stores Solr parameters. Widgets
+ * expose some of these parameters to the user. Whenever the user changes the
+ * values of these parameters, the state of the application changes. In order to
+ * allow the user to move back and forth between these states with the browser's
+ * Back and Forward buttons, and to bookmark these states, each state needs to
+ * be stored. The easiest method is to store the exposed parameters in the URL
+ * hash (see the <tt>ParameterHashStore</tt> class). However, you may implement
+ * your own storage method by extending this class.
+ *
+ * <p>For a list of possible parameters, please consult the links below.</p>
+ *
+ * @see http://wiki.apache.org/solr/CoreQueryParameters
+ * @see http://wiki.apache.org/solr/CommonQueryParameters
+ * @see http://wiki.apache.org/solr/SimpleFacetParameters
+ * @see http://wiki.apache.org/solr/HighlightingParameters
+ * @see http://wiki.apache.org/solr/MoreLikeThis
+ * @see http://wiki.apache.org/solr/SpellCheckComponent
+ * @see http://wiki.apache.org/solr/StatsComponent
+ * @see http://wiki.apache.org/solr/TermsComponent
+ * @see http://wiki.apache.org/solr/TermVectorComponent
+ * @see http://wiki.apache.org/solr/LocalParams
+ *
+ * @param properties A map of fields to set. Refer to the list of public fields.
+ * @class ParameterStore
+ */
+AjaxSolr.ParameterStore = AjaxSolr.Class.extend(
+  /** @lends AjaxSolr.ParameterStore.prototype */
+  {
+  /**
+   * The names of the exposed parameters. Any parameters that your widgets
+   * expose to the user, directly or indirectly, should be listed here.
+   *
+   * @field
+   * @public
+   * @type String[]
+   * @default []
+   */
+  exposed: [],
+
+  /**
+   * The Solr parameters.
+   *
+   * @field
+   * @private
+   * @type Object
+   * @default {}
+   */
+  params: {},
+
+  /**
+   * A reference to the parameter store's manager. For internal use only.
+   *
+   * @field
+   * @private
+   * @type AjaxSolr.AbstractManager
+   */
+  manager: null,
+
+  /**
+   * An abstract hook for child implementations.
+   *
+   * <p>This method should do any necessary one-time initializations.</p>
+   */
+  init: function () {},
+
+  /**
+   * Some Solr parameters may be specified multiple times. It is easiest to
+   * hard-code a list of such parameters. You may change the list by passing
+   * <code>{ multiple: /pattern/ }</code> as an argument to the constructor of
+   * this class or one of its children, e.g.:
+   *
+   * <p><code>new ParameterStore({ multiple: /pattern/ })</code>
+   *
+   * @param {String} name The name of the parameter.
+   * @returns {Boolean} Whether the parameter may be specified multiple times.
+   */
+  isMultiple: function (name) {
+    return name.match(/^(?:bf|bq|facet\.date|facet\.date\.other|facet\.field|facet\.query|fq|pf|qf)$/);
+  },
+
+  /**
+   * Returns a parameter. If the parameter doesn't exist, creates it.
+   *
+   * @param {String} name The name of the parameter.
+   * @returns {AjaxSolr.Parameter|AjaxSolr.Parameter[]} The parameter.
+   */
+  get: function (name) {
+    if (this.params[name] === undefined) {
+      var param = new AjaxSolr.Parameter({ name: name });
+      if (this.isMultiple(name)) {
+        this.params[name] = [ param ];
+      }
+      else {
+        this.params[name] = param;
+      }
+    }
+    return this.params[name];
+  },
+
+  /**
+   * If the parameter may be specified multiple times, returns the values of
+   * all identically-named parameters. If the parameter may be specified only
+   * once, returns the value of that parameter.
+   *
+   * @param {String} name The name of the parameter.
+   * @returns {String[]|Number[]} The value(s) of the parameter.
+   */
+  values: function (name) {
+    if (this.params[name] !== undefined) {
+      if (this.isMultiple(name)) {
+        var values = [];
+        for (var i = 0, l = this.params[name].length; i < l; i++) {
+          values.push(this.params[name][i].val());
+        }
+        return values;
+      }
+      else {
+        return [ this.params[name].val() ];
+      }
+    }
+    return [];
+  },
+
+  /**
+   * If the parameter may be specified multiple times, adds the given parameter
+   * to the list of identically-named parameters, unless one already exists with
+   * the same value. If it may be specified only once, replaces the parameter.
+   *
+   * @param {String} name The name of the parameter.
+   * @param {AjaxSolr.Parameter} [param] The parameter.
+   * @returns {AjaxSolr.Parameter|Boolean} The parameter, or false.
+   */
+  add: function (name, param) {
+    if (param === undefined) {
+      param = new AjaxSolr.Parameter({ name: name });
+    }
+    if (this.isMultiple(name)) {
+      if (this.params[name] === undefined) {
+        this.params[name] = [ param ];
+      }
+      else {
+        if (AjaxSolr.inArray(param.val(), this.values(name)) == -1) {
+          this.params[name].push(param);
+        }
+        else {
+          return false;
+        }
+      }
+    }
+    else {
+      this.params[name] = param;
+    }
+    return param;
+  },
+
+  /**
+   * Deletes a parameter.
+   *
+   * @param {String} name The name of the parameter.
+   * @param {Number} [index] The index of the parameter.
+   */
+  remove: function (name, index) {
+    if (index === undefined) {
+      delete this.params[name];
+    }
+    else {
+      this.params[name].splice(index, 1);
+      if (this.params[name].length == 0) {
+        delete this.params[name];
+      }
+    }
+  },
+
+  /**
+   * Finds all parameters with matching values.
+   *
+   * @param {String} name The name of the parameter.
+   * @param {String|Number|String[]|Number[]|RegExp} value The value.
+   * @returns {String|Number[]} The indices of the parameters found.
+   */
+  find: function (name, value) {
+    if (this.params[name] !== undefined) {
+      if (this.isMultiple(name)) {
+        var indices = [];
+        for (var i = 0, l = this.params[name].length; i < l; i++) {
+          if (AjaxSolr.equals(this.params[name][i].val(), value)) {
+            indices.push(i);
+          }
+        }
+        return indices.length ? indices : false;
+      }
+      else {
+        if (AjaxSolr.equals(this.params[name].val(), value)) {
+          return name;
+        }
+      }
+    }
+    return false;
+  },
+
+  /**
+   * If the parameter may be specified multiple times, creates a parameter using
+   * the given name and value, and adds it to the list of identically-named
+   * parameters, unless one already exists with the same value. If it may be
+   * specified only once, replaces the parameter.
+   *
+   * @param {String} name The name of the parameter.
+   * @param {String|Number|String[]|Number[]} value The value.
+   * @returns {AjaxSolr.Parameter|Boolean} The parameter, or false.
+   */
+  addByValue: function (name, value) {
+    if (this.isMultiple(name) && AjaxSolr.isArray(value)) {
+      var ret = [];
+      for (var i = 0, l = value.length; i < l; i++) {
+        ret.push(this.add(name, new AjaxSolr.Parameter({ name: name, value: value[i] })));
+      }
+      return ret;
+    }
+    else {
+      return this.add(name, new AjaxSolr.Parameter({ name: name, value: value }))
+    }
+  },
+
+  /**
+   * Deletes any parameter with a matching value.
+   *
+   * @param {String} name The name of the parameter.
+   * @param {String|Number|String[]|Number[]|RegExp} value The value.
+   * @returns {String|Number[]} The indices deleted.
+   */
+  removeByValue: function (name, value) {
+    var indices = this.find(name, value);
+    if (indices) {
+      if (AjaxSolr.isArray(indices)) {
+        for (var i = indices.length - 1; i >= 0; i--) {
+          this.remove(name, indices[i]);
+        }
+      }
+      else {
+        this.remove(indices);
+      }
+    }
+    return indices;
+  },
+
+  /**
+   * Returns the Solr parameters as a query string.
+   *
+   * <p>IE6 calls the default toString() if you write <tt>store.toString()
+   * </tt>. So, we need to choose another name for toString().</p>
+   */
+  string: function () {
+    var params = [];
+    for (var name in this.params) {
+      if (this.isMultiple(name)) {
+        for (var i = 0, l = this.params[name].length; i < l; i++) {
+          params.push(this.params[name][i].string());
+        }
+      }
+      else {
+        params.push(this.params[name].string());
+      }
+    }
+    return AjaxSolr.compact(params).join('&');
+  },
+
+  /**
+   * Parses a query string into Solr parameters.
+   *
+   * @param {String} str The string to parse.
+   */
+  parseString: function (str) {
+    var pairs = str.split('&');
+    for (var i = 0, l = pairs.length; i < l; i++) {
+      if (pairs[i]) { // ignore leading, trailing, and consecutive &'s
+        var param = new AjaxSolr.Parameter();
+        param.parseString(pairs[i]);
+        this.add(param.name, param);
+      }
+    }
+  },
+
+  /**
+   * Returns the exposed parameters as a query string.
+   *
+   * @returns {String} A string representation of the exposed parameters.
+   */
+  exposedString: function () {
+    var params = [];
+    for (var i = 0, l = this.exposed.length; i < l; i++) {
+      if (this.params[this.exposed[i]] !== undefined) {
+        if (this.isMultiple(this.exposed[i])) {
+          for (var j = 0, m = this.params[this.exposed[i]].length; j < m; j++) {
+            params.push(this.params[this.exposed[i]][j].string());
+          }
+        }
+        else {
+          params.push(this.params[this.exposed[i]].string());
+        }
+      }
+    }
+    return AjaxSolr.compact(params).join('&');
+  },
+
+  /**
+   * Resets the values of the exposed parameters.
+   */
+  exposedReset: function () {
+    for (var i = 0, l = this.exposed.length; i < l; i++) {
+      this.remove(this.exposed[i]);
+    }
+  },
+
+  /**
+   * Loads the values of exposed parameters from persistent storage. It is
+   * necessary, in most cases, to reset the values of exposed parameters before
+   * setting the parameters to the values in storage. This is to ensure that a
+   * parameter whose name is not present in storage is properly reset.
+   *
+   * @param {Boolean} [reset=true] Whether to reset the exposed parameters.
+   *   before loading new values from persistent storage. Default: true.
+   */
+  load: function (reset) {
+    if (reset === undefined) {
+      reset = true;
+    }
+    if (reset) {
+      this.exposedReset();
+    }
+    this.parseString(this.storedString());
+  },
+  
+  /**
+   * An abstract hook for child implementations.
+   *
+   * <p>Stores the values of the exposed parameters in persistent storage. This
+   * method should usually be called before each Solr request.</p>
+   */
+  save: function () {},
+
+  /**
+   * An abstract hook for child implementations.
+   *
+   * <p>Returns the string to parse from persistent storage.</p>
+   *
+   * @returns {String} The string from persistent storage.
+   */
+  storedString: function () {
+    return '';
+  }
+});

data/assets/javascripts/solr-autocomplete/ajax-solr/managers/Manager.jquery.js

@@ -0,0 +1,20 @@
+// $Id$
+
+/**
+ * @see http://wiki.apache.org/solr/SolJSON#JSON_specific_parameters
+ * @class Manager
+ * @augments AjaxSolr.AbstractManager
+ */
+AjaxSolr.Manager = AjaxSolr.AbstractManager.extend(
+  /** @lends AjaxSolr.Manager.prototype */
+  {
+  executeRequest: function (servlet) {
+    var self = this;
+    if (this.proxyUrl) {
+      jQuery.post(this.proxyUrl, { query: this.store.string() }, function (data) { self.handleResponse(data); }, 'json');
+    }
+    else {
+      jQuery.getJSON(this.solrUrl + servlet + '?' + this.store.string() + '&wt=json&json.wrf=?', {}, function (data) { self.handleResponse(data); });
+    }
+  }
+});

data/assets/javascripts/solr-autocomplete/jquery-autocomplete/jquery.autocomplete.css

@@ -0,0 +1,49 @@
+.ac_results {
+	padding: 0px;
+	border: 1px solid black;
+	background-color: white;
+	overflow: hidden;
+	z-index: 99999;
+	text-align: left;
+}
+
+.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;
+	/* 
+	if width will be 100% horizontal scrollbar will apear 
+	when scroll mode will be used
+	*/
+	/*width: 100%;*/
+	font: menu;
+	font-size: 12px;
+	/* 
+	it is very important, if line-height not setted or setted 
+	in relative units scroll will be broken in firefox
+	*/
+	line-height: 16px;
+	overflow: hidden;
+}
+
+.ac_loading {
+	background: white url('indicator.gif') right center no-repeat;
+}
+
+.ac_odd {
+	background-color: #eee;
+}
+
+.ac_over {
+	background-color: #0A246A;
+	color: white;
+}

data/assets/javascripts/solr-autocomplete/jquery-autocomplete/jquery.autocomplete.js

@@ -0,0 +1,867 @@
+/*
+ *  This part of the library is extended from jQuery Autocomplete plugin by Jörn Zaefferer
+ */
+
+
+jQuery.extend({
+
+	get: function( url, data, callback, type ) {
+		// shift arguments if data argument was omited
+		if ( jQuery.isFunction( data ) ) {
+			type = type || callback;
+			callback = data;
+			data = null;
+		}
+
+		return jQuery.ajax({
+			type: "GET",
+			url: url,
+			data: data,
+			success: callback,
+			dataType: type,
+			jsonpCallback: "applyAjaxSolrCallback"
+		});
+	}
+});
+
+
+;(function($) {
+
+$.fn.extend({
+	autocomplete: function(urlOrData, fieldName, 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; };
+
+		// if the formatMatch option is not specified, then use formatItem for backwards compatibility
+		options.formatMatch = options.formatMatch || options.formatItem;
+
+		return this.each(function() {
+			new $.Autocompleter(this, fieldName, options);
+		});
+	},
+	autosuggest: function(urlOrData, fieldName, options){
+		options = $.extend({}, {suggest: true}, options);
+		this.autocomplete(urlOrData, fieldName, 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");
+	},
+	ajaxSolrCallback: null,
+	ajaxSolrFieldName: null
+});
+
+$.Autocompleter = function(input, fieldName, options) {
+
+	var KEY = {
+		UP: 38,
+		DOWN: 40,
+		DEL: 46,
+		TAB: 9,
+		RETURN: 13,
+		ESC: 27,
+		COMMA: 188,
+		PAGEUP: 33,
+		PAGEDOWN: 34,
+		BACKSPACE: 8
+	};
+
+	// 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);
+
+	var blockSubmit;
+
+	var fieldName = fieldName;
+	var suggest = options.suggest;
+
+	var ajaxSolrManager = new AjaxSolr.Manager({
+	  solrUrl: options.url
+	});
+	ajaxSolrManager.init();
+
+	// prevent form submit in opera when selecting with return key
+	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {
+		if (blockSubmit) {
+			blockSubmit = false;
+			return false;
+		}
+	});
+
+	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
+	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
+		// a keypress means the input has focus
+		// avoids issue where input had focus before the autocomplete was applied
+		hasFocus = 1;
+		// 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() ) {
+					// stop default to prevent a form submit, Opera needs special handling
+					event.preventDefault();
+					blockSubmit = true;
+					return false;
+				}
+				break;
+
+			case KEY.ESC:
+				select.hide();
+				break;
+
+			default:
+				clearTimeout(timeout);
+				timeout = setTimeout(onChange, options.delay);
+				break;
+		}
+	}).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();
+		$(input.form).unbind(".autocomplete");
+	});
+
+
+	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 ) {
+				var seperator = options.multipleSeparator.length;
+				var cursorAt = $(input).selection().start;
+				var wordAt, progress = 0;
+				$.each(words, function(i, word) {
+					progress += word.length;
+					if (cursorAt <= progress) {
+						wordAt = i;
+						return false;
+					}
+					progress += seperator;
+				});
+				words[wordAt] = v;
+				// TODO this should set the cursor to the right position, but it gets overriden somewhere
+				//$.Autocompleter.Selection(input, progress + seperator, progress + seperator);
+				v = words.join( options.multipleSeparator );
+			}
+			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 [""];
+		if (!options.multiple)
+			return [$.trim(value)];
+		return $.map(value.split(options.multipleSeparator), function(word) {
+			return $.trim(value).length ? $.trim(word) : null;
+		});
+	}
+
+	function lastWord(value) {
+		if ( !options.multiple )
+			return value;
+		var words = trimWords(value);
+		if (words.length == 1)
+			return words[0];
+		var cursorAt = $(input).selection().start;
+		if (cursorAt == value.length) {
+			words = trimWords(value)
+		} else {
+			words = trimWords(value.replace(value.substring(cursorAt), ""));
+		}
+		return words[words.length - 1];
+	}
+
+	// fills in the input box w/the first match (assumed to be the best match)
+	// q: the term entered
+	// sValue: the first matching result
+	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 != KEY.BACKSPACE ) {
+			// 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)
+			$(input).selection(previousValue.length, previousValue.length + sValue.length);
+		}
+	};
+
+	function hideResults() {
+		clearTimeout(timeout);
+		timeout = setTimeout(hideResultsNow, 200);
+	};
+
+	function hideResultsNow() {
+		var wasVisible = select.visible();
+		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 ) {
+						if (options.multiple) {
+							var words = trimWords($input.val()).slice(0, -1);
+							$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
+						}
+						else {
+							$input.val( "" );
+							$input.trigger("result", null);
+						}
+					}
+				}
+			);
+		}
+	};
+
+	function receiveData(q, data) {
+		var parsed = options.parse && options.parse(data) || parse(data);
+		cache.add(q, parsed);
+		if ( parsed && parsed.length && hasFocus ) {
+			stopLoading();
+			select.display(parsed, q);
+			autoFill(q, parsed[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 = {
+				timestamp: +new Date()
+			};
+			$.each(options.extraParams, function(key, param) {
+				extraParams[key] = typeof param == "function" ? param() : param;
+			});
+
+                        // work out what fields to request from solr. the one
+                        // required field is the value used for the autocomplete
+                        // while the resultKey is optional and allows the result
+                        // to be identified by other means e.g. primary key
+                        var fl = solrFieldName();
+                        if (options.resultKey)
+                            fl = [fl, options.resultKey].join(" ");
+
+			ajaxSolrManager.store.addByValue('q', makeQuery(lastWord(term)));
+			ajaxSolrManager.store.addByValue('indent', 'on');
+			ajaxSolrManager.store.addByValue('sort', 'score desc');
+			ajaxSolrManager.store.addByValue('fl', fl);
+
+			$.ajaxSolrCallback = success;
+			$.ajaxSolrFieldName = solrFieldName();
+
+			ajaxSolrManager.doRequest();
+
+		} else {
+			// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
+			select.emptyList();
+			failure(term);
+		}
+	};
+
+	function solrFieldName(){
+		return fieldName + (suggest ? '_as' : '_ac' )
+	};
+
+	function makeQuery(phrase){
+		if (suggest){
+			return phrase.trim().split(/\s+/).map(function(word){
+				return solrFieldName() + ":" + word;
+			}).join (" AND ");
+		}else{
+			return solrFieldName() + ":" + phrase.trim().split(/\s+/).join("\\ ");
+		}
+	};
+
+	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]; },
+	formatMatch: null,
+	autoFill: false,
+	width: 0,
+	multiple: false,
+	multipleSeparator: ", ",
+	highlight: function(value, term) {
+		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong class='highlight'>$1</strong>");
+	},
+    scroll: true,
+    scrollHeight: 180,
+	suggest: false
+};
+
+$.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 (options.matchContains == "word"){
+			i = s.toLowerCase().search("\\b" + sub.toLowerCase());
+		}
+		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.formatMatch(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(document.body);
+
+		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();
+			// TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
+			input.focus();
+			return false;
+		}).mousedown(function() {
+			config.mouseDownOnSelect = true;
+		}).mouseup(function() {
+			config.mouseDownOnSelect = false;
+		});
+
+		if( options.width > 0 ) {
+			element.css("width", options.width);
+			list.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(CLASSES.ACTIVE);
+		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; }
+			str = options.highlight(formatted, $(input).val());
+      // /* DEBUG */ console.log(input, $(input).val());
+			var li = $("<li/>").html( str ).addClass(i % 2 == 0 ? "ac_even" : "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;
+		}
+		// apply bgiframe if available
+		if ( $.fn.bgiframe )
+			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();
+			listItems && listItems.removeClass(CLASSES.ACTIVE);
+			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");
+		},
+		emptyList: function (){
+			list && list.empty();
+		},
+		unbind: function() {
+			element && element.remove();
+		}
+	};
+};
+
+$.fn.selection = function(start, end) {
+	if (start !== undefined) {
+		return this.each(function() {
+			if( this.createTextRange ){
+				var selRange = this.createTextRange();
+				if (end === undefined || start == end) {
+					selRange.move("character", start);
+					selRange.select();
+				} else {
+					selRange.collapse(true);
+					selRange.moveStart("character", start);
+					selRange.moveEnd("character", end);
+					selRange.select();
+				}
+			} else if( this.setSelectionRange ){
+				this.setSelectionRange(start, end);
+			} else if( this.selectionStart ){
+				this.selectionStart = start;
+				this.selectionEnd = end;
+			}
+		});
+	}
+	var field = this[0];
+	if ( field.createTextRange ) {
+		var range = document.selection.createRange(),
+			orig = field.value,
+			teststring = "<->",
+			textLength = range.text.length;
+		range.text = teststring;
+		var caretAt = field.value.indexOf(teststring);
+		field.value = orig;
+		this.selection(caretAt, caretAt + textLength);
+		return {
+			start: caretAt,
+			end: caretAt + textLength
+		}
+	} else if( field.selectionStart !== undefined ){
+		return {
+			start: field.selectionStart,
+			end: field.selectionEnd
+		}
+	}
+};
+
+})(jQuery);
+
+//// callback is not encapsulated in any objects
+//// to avoid the (.) anomaly in the url
+var applyAjaxSolrCallback = function(result){
+	var items = "";
+	$(result.response.docs).each(function(index, doc){
+		items = items + doc[$.ajaxSolrFieldName] + "\n";
+	});
+	$.ajaxSolrCallback(result.responseHeader.params.q, items);
+};