twitter-typeahead-rails 0.8.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in twitter-typeahead-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Yousef Ourabi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Twitter typeahead.js jquery plugin
+
+This asset gem packages the [twitter typeahead.js](https://github.com/twitter/typeahead.js) jquery plugin for the Rails asset pipeline.
+
+To learn more about typeahead.js read the post [Twitter's engineering blog](http://engineering.twitter.com/2013/02/twitter-typeaheadjs-you-autocomplete-me.html).
+
+This gem includes the standard and minified versions of the assets.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'twitter-typeahead-rails'
+
+    or
+
+    gem 'twitter-typeahead-rails', :git => "git@github.com:yourabi/twitter-typeahead-rails.git"
+    
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install twitter-typeahead-rails
+
+## Usage
+
+To start using the twitter typeahead.js plugin in your rails app enable it via the asset pipeline (app/assets/javascripts/application.js).
+
+Add one the folllwing to your application.js mainifest:
+
+```js
+
+//= require twitter/typeahead                                                                                                                                                                                                                             
+//= require twitter/typeahead.min                                                                                                                                                                                                                        
+
+```
+
+
+```js
+
+// Twitter typeahead exmaple.
+$(document).ready(function() {
+  $('.typeahead').typeahead( {name: 'planets', local: [ "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune" ] });
+});
+
+```
+
+You'll also probably want to enable include the CSS in your application.css manifest. Include one of the following:
+
+```js
+
+*= require twitter/typeahead
+
+*= require twitter/typeahead.min
+
+```
+
+Currently this version tracks version v0.8.0.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/twitter-typeahead-rails.rb

@@ -0,0 +1,10 @@
+require "twitter-typeahead-rails/version"
+
+module Twitter
+  module Typeahead
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/twitter-typeahead-rails/version.rb

@@ -0,0 +1,7 @@
+module Twitter
+  module Typeahead
+    module Rails
+      VERSION = "0.8.0"
+    end
+  end
+end

data/twitter-typeahead-rails.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'twitter-typeahead-rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "twitter-typeahead-rails"
+  gem.version       = Twitter::Typeahead::Rails::VERSION
+  gem.authors       = ["Yousef Ourabi"]
+  gem.email         = ["yourabi@gmail.com"]
+  gem.description   = %q{twitter-typeahead-rails packages the typeahead.js jquery plugin for rails}
+  gem.summary       = %q{twitter-typeahead-rails packages the typeahead.js jquery plugin for rails}
+  gem.homepage      = "https://github.com/yourabi/twitter-typeahead-rails"
+
+  gem.add_dependency             'railties',   '>= 3.1'
+  gem.add_dependency             'actionpack', '>= 3.1'
+  gem.add_dependency             'jquery-rails'
+  
+  gem.add_development_dependency 'rails', '>= 3.1'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.require_paths = ["lib"]
+end

data/vendor/assets/javascripts/twitter/typeahead.js

@@ -0,0 +1,4 @@
+//=require twitter/typeahead/typeahead.js
+
+
+

data/vendor/assets/javascripts/twitter/typeahead.min.js

@@ -0,0 +1,4 @@
+//=require twitter/typeahead/typeahead.min.js
+
+
+

data/vendor/assets/javascripts/twitter/typeahead/typeahead.js

@@ -0,0 +1,984 @@
+/*!
+ * Twitter Typeahead 0.8.0
+ * https://github.com/twitter/typeahead
+ * Copyright 2013 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+(function() {
+    var VERSION = "0.8.0";
+    var utils = {
+        isMsie: function() {
+            return /msie [\w.]+/i.test(navigator.userAgent);
+        },
+        isString: function(obj) {
+            return typeof obj === "string";
+        },
+        isNumber: function(obj) {
+            return typeof obj === "number";
+        },
+        isArray: $.isArray,
+        isFunction: $.isFunction,
+        isObject: function(obj) {
+            return obj !== Object(obj);
+        },
+        isUndefined: function(obj) {
+            return typeof obj === "undefined";
+        },
+        bind: $.proxy,
+        bindAll: function(obj) {
+            var val;
+            for (var key in obj) {
+                utils.isFunction(val = obj[key]) && (obj[key] = $.proxy(val, obj));
+            }
+        },
+        indexOf: function(haystack, needle) {
+            for (var i = 0; i < haystack.length; i++) {
+                if (haystack[i] === needle) {
+                    return i;
+                }
+            }
+            return -1;
+        },
+        each: $.each,
+        map: $.map,
+        filter: function(obj, test) {
+            var results = [];
+            $.each(obj, function(key, val) {
+                if (test(val, key, obj)) {
+                    results.push(val);
+                }
+            });
+            return results;
+        },
+        every: function(obj, test) {
+            var result = true;
+            if (!obj) {
+                return result;
+            }
+            $.each(obj, function(key, val) {
+                if (!(result = test.call(null, val, key, obj))) {
+                    return false;
+                }
+            });
+            return !!result;
+        },
+        keys: function(obj) {
+            if (!utils.isObject(obj)) {
+                throw new TypeError("invalid object");
+            }
+            return $.map(obj, function(val, key) {
+                return key;
+            });
+        },
+        mixin: $.extend,
+        getUniqueId: function() {
+            var counter = 0;
+            return function() {
+                return counter++;
+            };
+        }(),
+        debounce: function(func, wait, immediate) {
+            var timeout, result;
+            return function() {
+                var context = this, args = arguments, later, callNow;
+                later = function() {
+                    timeout = null;
+                    if (!immediate) {
+                        result = func.apply(context, args);
+                    }
+                };
+                callNow = immediate && !timeout;
+                clearTimeout(timeout);
+                timeout = setTimeout(later, wait);
+                if (callNow) {
+                    result = func.apply(context, args);
+                }
+                return result;
+            };
+        },
+        throttle: function(func, wait) {
+            var context, args, timeout, result, previous, later;
+            previous = 0;
+            later = function() {
+                previous = new Date();
+                timeout = null;
+                result = func.apply(context, args);
+            };
+            return function() {
+                var now = new Date(), remaining = wait - (now - previous);
+                context = this;
+                args = arguments;
+                if (remaining <= 0) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                    previous = now;
+                    result = func.apply(context, args);
+                } else if (!timeout) {
+                    timeout = setTimeout(later, remaining);
+                }
+                return result;
+            };
+        },
+        uniqueArray: function(array) {
+            var u = {}, a = [];
+            for (var i = 0, l = array.length; i < l; ++i) {
+                if (u.hasOwnProperty(array[i])) {
+                    continue;
+                }
+                a.push(array[i]);
+                u[array[i]] = 1;
+            }
+            return a;
+        },
+        tokenizeText: function(str) {
+            return $.trim(str).toLowerCase().split(/[\s\-_]+/);
+        },
+        getProtocol: function() {
+            return location.protocol;
+        },
+        noop: function() {}
+    };
+    var EventTarget = function() {
+        var eventSplitter = /\s+/;
+        return {
+            on: function(events, callback) {
+                var event;
+                if (!callback) {
+                    return this;
+                }
+                this._callbacks = this._callbacks || {};
+                events = events.split(eventSplitter);
+                while (event = events.shift()) {
+                    this._callbacks[event] = this._callbacks[event] || [];
+                    this._callbacks[event].push(callback);
+                }
+                return this;
+            },
+            trigger: function(events, data) {
+                var event, callbacks;
+                if (!this._callbacks) {
+                    return this;
+                }
+                events = events.split(eventSplitter);
+                while (event = events.shift()) {
+                    if (callbacks = this._callbacks[event]) {
+                        for (var i = 0; i < callbacks.length; i += 1) {
+                            callbacks[i].call(this, {
+                                type: event,
+                                data: data
+                            });
+                        }
+                    }
+                }
+                return this;
+            }
+        };
+    }();
+    var PersistentStorage = function() {
+        var ls = window.localStorage, methods;
+        function PersistentStorage(namespace) {
+            this.prefix = [ "__", namespace, "__" ].join("");
+            this.ttlKey = "__ttl__";
+            this.keyMatcher = new RegExp("^" + this.prefix);
+        }
+        if (window.localStorage && window.JSON) {
+            methods = {
+                get: function(key) {
+                    var ttl = decode(ls.getItem(this.prefix + key));
+                    if (utils.isNumber(ttl) && now() > ttl) {
+                        ls.removeItem(this.prefix + key + this.ttlKey);
+                    }
+                    return decode(ls.getItem(this.prefix + key));
+                },
+                set: function(key, val, ttl) {
+                    if (utils.isNumber(ttl)) {
+                        ls.setItem(this.prefix + key + this.ttlKey, encode(now() + ttl));
+                    } else {
+                        ls.removeItem(this.prefix + key + this.ttlKey);
+                    }
+                    return ls.setItem(this.prefix + key, encode(val));
+                },
+                remove: function(key) {
+                    ls.removeItem(this.prefix + key + this.ttlKey);
+                    ls.removeItem(this.prefix + key);
+                    return this;
+                },
+                clear: function() {
+                    var i, key, len = ls.length;
+                    for (i = 0; i < len; i += 1) {
+                        key = ls.key(i);
+                        if (key.match(this.keyMatcher)) {
+                            i -= 1;
+                            len -= 1;
+                            this.remove(key.replace(this.keyMatcher, ""));
+                        }
+                    }
+                    return this;
+                },
+                isExpired: function(key) {
+                    var ttl = decode(ls.getItem(this.prefix + key + this.ttlKey));
+                    return utils.isNumber(ttl) && now() > ttl ? true : false;
+                }
+            };
+        } else {
+            methods = {
+                get: utils.noop,
+                set: utils.noop,
+                remove: utils.noop,
+                clear: utils.noop,
+                isExpired: utils.noop
+            };
+        }
+        utils.mixin(PersistentStorage.prototype, methods);
+        return PersistentStorage;
+        function now() {
+            return new Date().getTime();
+        }
+        function encode(val) {
+            return JSON.stringify(val);
+        }
+        function decode(val) {
+            return utils.isUndefined(val) ? undefined : JSON.parse(val);
+        }
+    }();
+    var RequestCache = function() {
+        function RequestCache(o) {
+            utils.bindAll(this);
+            o = o || {};
+            this.sizeLimit = o.sizeLimit || 10;
+            this.cache = {};
+            this.cachedKeysByAge = [];
+        }
+        utils.mixin(RequestCache.prototype, {
+            get: function(url) {
+                return this.cache[url];
+            },
+            set: function(url, resp) {
+                var requestToEvict;
+                if (this.cachedKeysByAge.length === this.sizeLimit) {
+                    requestToEvict = this.cachedKeysByAge.shift();
+                    delete this.cache[requestToEvict];
+                }
+                this.cache[url] = resp;
+                this.cachedKeysByAge.push(url);
+            }
+        });
+        return RequestCache;
+    }();
+    var Transport = function() {
+        function Transport(o) {
+            var rateLimitFn;
+            utils.bindAll(this);
+            o = o || {};
+            rateLimitFn = /^throttle$/i.test(o.rateLimitFn) ? utils.throttle : utils.debounce;
+            this.wait = o.wait || 300;
+            this.wildcard = o.wildcard || "%QUERY";
+            this.maxConcurrentRequests = o.maxConcurrentRequests || 6;
+            this.concurrentRequests = 0;
+            this.onDeckRequestArgs = null;
+            this.cache = new RequestCache();
+            this.get = rateLimitFn(this.get, this.wait);
+        }
+        utils.mixin(Transport.prototype, {
+            _incrementConcurrentRequests: function() {
+                this.concurrentRequests++;
+            },
+            _decrementConcurrentRequests: function() {
+                this.concurrentRequests--;
+            },
+            _belowConcurrentRequestsThreshold: function() {
+                return this.concurrentRequests < this.maxConcurrentRequests;
+            },
+            get: function(url, query, cb) {
+                var that = this, resp;
+                url = url.replace(this.wildcard, encodeURIComponent(query || ""));
+                if (resp = this.cache.get(url)) {
+                    cb && cb(resp);
+                } else if (this._belowConcurrentRequestsThreshold()) {
+                    $.ajax({
+                        url: url,
+                        type: "GET",
+                        dataType: "json",
+                        beforeSend: function() {
+                            that._incrementConcurrentRequests();
+                        },
+                        success: function(resp) {
+                            cb && cb(resp);
+                            that.cache.set(url, resp);
+                        },
+                        complete: function() {
+                            that._decrementConcurrentRequests();
+                            if (that.onDeckRequestArgs) {
+                                that.get.apply(that, that.onDeckRequestArgs);
+                                that.onDeckRequestArgs = null;
+                            }
+                        }
+                    });
+                } else {
+                    this.onDeckRequestArgs = [].slice.call(arguments, 0);
+                }
+            }
+        });
+        return Transport;
+    }();
+    var Dataset = function() {
+        function Dataset(o) {
+            utils.bindAll(this);
+            this.storage = new PersistentStorage(o.name);
+            this.adjacencyList = {};
+            this.itemHash = {};
+            this.name = o.name;
+            this.resetDataOnProtocolSwitch = o.resetDataOnProtocolSwitch || false;
+            this.prefetchUrl = o.prefetch;
+            this.queryUrl = o.remote;
+            this.rawData = o.local;
+            this.transport = o.transport;
+            this.limit = o.limit || 10;
+            this._customMatcher = o.matcher || null;
+            this._customRanker = o.ranker || null;
+            this._ttl_ms = o.ttl_ms || 3 * 24 * 60 * 60 * 1e3;
+            this.storageAdjacencyList = "adjacencyList";
+            this.storageHash = "itemHash";
+            this.storageProtocol = "protocol";
+            this.storageVersion = "version";
+            this._loadData();
+        }
+        utils.mixin(Dataset.prototype, {
+            _isMetadataExpired: function() {
+                var isExpired = this.storage.isExpired(this.storageProtocol);
+                var isCacheStale = this.storage.isExpired(this.storageAdjacencyList) || this.storage.isExpired(this.storageHash);
+                var resetForProtocolSwitch = this.resetDataOnProtocolSwitch && this.storage.get(this.storageProtocol) != utils.getProtocol();
+                if (VERSION == this.storage.get(this.storageVersion) && !resetForProtocolSwitch && !isExpired && !isCacheStale) {
+                    return false;
+                }
+                return true;
+            },
+            _loadData: function() {
+                this.rawData && this._processRawData(this.rawData);
+                this._getDataFromLocalStorage();
+                if (this._isMetadataExpired() || this.itemHash === {}) {
+                    this.prefetchUrl && this._prefetch(this.prefetchUrl);
+                }
+            },
+            _getDataFromLocalStorage: function() {
+                this.itemHash = this.storage.get(this.storageHash) || this.itemHash;
+                this.adjacencyList = this.storage.get(this.storageAdjacencyList) || this.adjacencyList;
+            },
+            _getPotentiallyMatchingIds: function(terms) {
+                var potentiallyMatchingIds = [];
+                var lists = [];
+                utils.map(terms, utils.bind(function(term) {
+                    var list = this.adjacencyList[term.charAt(0)];
+                    if (!list) {
+                        return;
+                    }
+                    lists.push(list);
+                }, this));
+                if (lists.length === 1) {
+                    return lists[0];
+                }
+                var listLengths = [];
+                $.each(lists, function(i, list) {
+                    listLengths.push(list.length);
+                });
+                var shortestListIndex = utils.indexOf(listLengths, Math.min.apply(null, listLengths)) || 0;
+                var shortestList = lists[shortestListIndex] || [];
+                potentiallyMatchingIds = utils.map(shortestList, function(item) {
+                    var idInEveryList = utils.every(lists, function(list) {
+                        return utils.indexOf(list, item) > -1;
+                    });
+                    if (idInEveryList) {
+                        return item;
+                    }
+                });
+                return potentiallyMatchingIds;
+            },
+            _getItemsFromIds: function(ids) {
+                var items = [];
+                utils.map(ids, utils.bind(function(id) {
+                    var item = this.itemHash[id];
+                    if (item) {
+                        items.push(item);
+                    }
+                }, this));
+                return items;
+            },
+            _matcher: function(terms) {
+                if (this._customMatcher) {
+                    var customMatcher = this._customMatcher;
+                    return function(item) {
+                        return customMatcher(item);
+                    };
+                } else {
+                    return function(item) {
+                        var tokens = item.tokens;
+                        var allTermsMatched = utils.every(terms, function(term) {
+                            var tokensMatched = utils.filter(tokens, function(token) {
+                                return token.indexOf(term) === 0;
+                            });
+                            return tokensMatched.length;
+                        });
+                        if (allTermsMatched) {
+                            return item;
+                        }
+                    };
+                }
+            },
+            _compareItems: function(a, b, areLocalItems) {
+                var aScoreBoost = !a.score_boost ? 0 : a.score_boost, bScoreBoost = !b.score_boost ? 0 : b.score_boost, aScore = !a.score ? 0 : a.score, bScore = !b.score ? 0 : b.score;
+                if (areLocalItems) {
+                    return b.weight + bScoreBoost - (a.weight + aScoreBoost);
+                } else {
+                    return bScore + bScoreBoost - (aScore + aScoreBoost);
+                }
+            },
+            _ranker: function(a, b) {
+                if (this._customRanker) {
+                    return this._customRanker(a, b);
+                } else {
+                    var aIsLocal = a.weight && a.weight !== 0;
+                    var bIsLocal = b.weight && b.weight !== 0;
+                    if (aIsLocal && !bIsLocal) {
+                        return -1;
+                    } else if (bIsLocal && !aIsLocal) {
+                        return 1;
+                    } else {
+                        return aIsLocal && bIsLocal ? this._compareItems(a, b, true) : this._compareItems(a, b, false);
+                    }
+                }
+            },
+            _processRawData: function(data) {
+                this.itemHash = {};
+                this.adjacencyList = {};
+                utils.map(data, utils.bind(function(item) {
+                    var tokens;
+                    if (item.tokens) {
+                        tokens = item.tokens;
+                    } else {
+                        item = {
+                            tokens: utils.tokenizeText(item),
+                            value: item
+                        };
+                        tokens = item.tokens;
+                    }
+                    item.id = utils.getUniqueId(item.value);
+                    utils.map(tokens, utils.bind(function(token) {
+                        var firstChar = token.charAt(0);
+                        if (!this.adjacencyList[firstChar]) {
+                            this.adjacencyList[firstChar] = [ item.id ];
+                        } else {
+                            if (utils.indexOf(this.adjacencyList[firstChar], item.id) === -1) {
+                                this.adjacencyList[firstChar].push(item.id);
+                            }
+                        }
+                    }, this));
+                    this.itemHash[item.id] = item;
+                }, this));
+                this.storage.set(this.storageHash, this.itemHash, this._ttl_ms);
+                this.storage.set(this.storageAdjacencyList, this.adjacencyList, this._ttl_ms);
+                this.storage.set(this.storageVersion, VERSION, this._ttl_ms);
+                this.storage.set(this.storageProtocol, utils.getProtocol(), this._ttl_ms);
+            },
+            _prefetch: function(url) {
+                var processPrefetchSuccess = function(data) {
+                    if (!data) {
+                        return;
+                    }
+                    utils.map(data, function(item) {
+                        if (utils.isString(item)) {
+                            return {
+                                value: item,
+                                tokens: utils.tokenizeText(item.toLowerCase())
+                            };
+                        } else {
+                            utils.map(item.tokens, function(token, i) {
+                                item.tokens[i] = token.toLowerCase();
+                            });
+                            return item;
+                        }
+                    });
+                    this._processRawData(data);
+                };
+                var processPrefetchError = function() {
+                    this._getDataFromLocalStorage();
+                };
+                $.ajax({
+                    url: url,
+                    success: utils.bind(processPrefetchSuccess, this),
+                    error: utils.bind(processPrefetchError, this)
+                });
+            },
+            _processRemoteSuggestions: function(callback, matchedItems) {
+                return function(data) {
+                    var remoteAndLocalSuggestions = {}, dedupedSuggestions = [];
+                    utils.each(data, function(index, item) {
+                        if (utils.isString(item)) {
+                            remoteAndLocalSuggestions[item] = {
+                                value: item
+                            };
+                        } else {
+                            remoteAndLocalSuggestions[item.value] = item;
+                        }
+                    });
+                    utils.each(matchedItems, function(index, item) {
+                        if (remoteAndLocalSuggestions[item.value]) {
+                            return true;
+                        }
+                        if (utils.isString(item)) {
+                            remoteAndLocalSuggestions[item] = {
+                                value: item
+                            };
+                        } else {
+                            remoteAndLocalSuggestions[item.value] = item;
+                        }
+                    });
+                    utils.each(remoteAndLocalSuggestions, function(index, item) {
+                        dedupedSuggestions.push(item);
+                    });
+                    callback && callback(dedupedSuggestions);
+                };
+            },
+            getSuggestions: function(query, callback) {
+                var terms = utils.tokenizeText(query);
+                var potentiallyMatchingIds = this._getPotentiallyMatchingIds(terms);
+                var potentiallyMatchingItems = this._getItemsFromIds(potentiallyMatchingIds);
+                var matchedItems = utils.filter(potentiallyMatchingItems, this._matcher(terms));
+                matchedItems.sort(this._ranker);
+                callback && callback(matchedItems);
+                if (matchedItems.length < this.limit && this.queryUrl) {
+                    this.transport.get(this.queryUrl, query, this._processRemoteSuggestions(callback, matchedItems));
+                }
+            }
+        });
+        return Dataset;
+    }();
+    var InputView = function() {
+        function InputView(o) {
+            var that = this;
+            utils.bindAll(this);
+            this.specialKeyCodeMap = {
+                9: {
+                    event: "tab"
+                },
+                27: {
+                    event: "esc"
+                },
+                37: {
+                    event: "left"
+                },
+                39: {
+                    event: "right"
+                },
+                13: {
+                    event: "enter"
+                },
+                38: {
+                    event: "up",
+                    preventDefault: true
+                },
+                40: {
+                    event: "down",
+                    preventDefault: true
+                }
+            };
+            this.query = "";
+            this.$hint = $(o.hint);
+            this.$input = $(o.input).on("blur", this._handleBlur).on("focus", this._handleFocus).on("keydown", this._handleSpecialKeyEvent);
+            if (!utils.isMsie()) {
+                this.$input.on("input", this._compareQueryToInputValue);
+            } else {
+                this.$input.on("keydown keypress cut paste", function(e) {
+                    if (that.specialKeyCodeMap[e.which || e.keyCode]) {
+                        return;
+                    }
+                    setTimeout(that._compareQueryToInputValue, 0);
+                });
+            }
+        }
+        utils.mixin(InputView.prototype, EventTarget, {
+            _handleFocus: function() {
+                this.trigger("focus");
+            },
+            _handleBlur: function() {
+                this.trigger("blur");
+            },
+            _handleSpecialKeyEvent: function(e) {
+                var keyCode = this.specialKeyCodeMap[e.which || e.keyCode];
+                if (keyCode) {
+                    this.trigger(keyCode.event, e);
+                    keyCode.preventDefault && e.preventDefault();
+                }
+            },
+            _compareQueryToInputValue: function() {
+                var inputValue = this.getInputValue(), isSameQuery = compareQueries(this.query, inputValue), isSameQueryExceptWhitespace = isSameQuery ? this.query.length !== inputValue.length : false;
+                if (isSameQueryExceptWhitespace) {
+                    this.trigger("whitespaceChange", {
+                        value: this.query
+                    });
+                } else if (!isSameQuery) {
+                    this.trigger("queryChange", {
+                        value: this.query = inputValue
+                    });
+                }
+            },
+            focus: function() {
+                this.$input.focus();
+            },
+            blur: function() {
+                this.$input.blur();
+            },
+            setPreventDefaultValueForKey: function(key, value) {
+                this.specialKeyCodeMap[key].preventDefault = !!value;
+            },
+            getQuery: function() {
+                return this.query;
+            },
+            getInputValue: function() {
+                return this.$input.val();
+            },
+            setInputValue: function(value, silent) {
+                this.$input.val(value);
+                if (silent !== true) {
+                    this._compareQueryToInputValue();
+                }
+            },
+            getHintValue: function() {
+                return this.$hint.val();
+            },
+            setHintValue: function(value) {
+                this.$hint.val(value);
+            },
+            getLanguageDirection: function() {
+                return (this.$input.css("direction") || "ltr").toLowerCase();
+            },
+            isCursorAtEnd: function() {
+                var valueLength = this.$input.val().length, selectionStart = this.$input[0].selectionStart, range;
+                if (selectionStart) {
+                    return selectionStart === valueLength;
+                } else if (document.selection) {
+                    range = document.selection.createRange();
+                    range.moveStart("character", -valueLength);
+                    return valueLength === range.text.length;
+                }
+                return true;
+            }
+        });
+        return InputView;
+        function compareQueries(a, b) {
+            a = (a || "").replace(/^\s*/g, "").replace(/\s{2,}/g, " ").toLowerCase();
+            b = (b || "").replace(/^\s*/g, "").replace(/\s{2,}/g, " ").toLowerCase();
+            return a === b;
+        }
+    }();
+    var DropdownView = function() {
+        function DropdownView(o) {
+            utils.bindAll(this);
+            this.isMouseOverDropdown;
+            this.$menu = $(o.menu).on("mouseenter", this._handleMouseenter).on("mouseleave", this._handleMouseleave).on("mouseover", ".tt-suggestions > .tt-suggestion", this._handleMouseover).on("click", ".tt-suggestions > .tt-suggestion", this._handleSelection);
+        }
+        utils.mixin(DropdownView.prototype, EventTarget, {
+            _handleMouseenter: function() {
+                this.isMouseOverDropdown = true;
+            },
+            _handleMouseleave: function() {
+                this.isMouseOverDropdown = false;
+            },
+            _handleMouseover: function(e) {
+                this._getSuggestions().removeClass("tt-is-under-cursor");
+                $(e.currentTarget).addClass("tt-is-under-cursor");
+            },
+            _handleSelection: function(e) {
+                this.trigger("select", formatDataForSuggestion($(e.currentTarget)));
+            },
+            _moveCursor: function(increment) {
+                var $suggestions, $cur, nextIndex, $underCursor;
+                if (!this.$menu.hasClass("tt-is-open")) {
+                    return;
+                }
+                $suggestions = this._getSuggestions();
+                $cur = $suggestions.filter(".tt-is-under-cursor");
+                $cur.removeClass("tt-is-under-cursor");
+                nextIndex = $suggestions.index($cur) + increment;
+                nextIndex = (nextIndex + 1) % ($suggestions.length + 1) - 1;
+                if (nextIndex === -1) {
+                    this.trigger("cursorOff");
+                    return;
+                } else if (nextIndex < -1) {
+                    nextIndex = $suggestions.length - 1;
+                }
+                $underCursor = $suggestions.eq(nextIndex).addClass("tt-is-under-cursor");
+                this.trigger("cursorOn", {
+                    value: $underCursor.data("value")
+                });
+            },
+            _getSuggestions: function() {
+                return this.$menu.find(".tt-suggestions > .tt-suggestion");
+            },
+            hideUnlessMouseIsOverDropdown: function() {
+                if (!this.isMouseOverDropdown) {
+                    this.hide();
+                }
+            },
+            hide: function() {
+                if (this.$menu.hasClass("tt-is-open")) {
+                    this.$menu.removeClass("tt-is-open").find(".tt-suggestions > .tt-suggestion").removeClass("tt-is-under-cursor");
+                    this.trigger("hide");
+                }
+            },
+            show: function() {
+                if (!this.$menu.hasClass("tt-is-open")) {
+                    this.$menu.addClass("tt-is-open");
+                    this.trigger("show");
+                }
+            },
+            isOpen: function() {
+                return this.$menu.hasClass("tt-is-open");
+            },
+            moveCursorUp: function() {
+                this._moveCursor(-1);
+            },
+            moveCursorDown: function() {
+                this._moveCursor(+1);
+            },
+            getSuggestionUnderCursor: function() {
+                var $suggestion = this._getSuggestions().filter(".tt-is-under-cursor").first();
+                return $suggestion.length > 0 ? formatDataForSuggestion($suggestion) : null;
+            },
+            getFirstSuggestion: function() {
+                var $suggestion = this._getSuggestions().first();
+                return $suggestion.length > 0 ? formatDataForSuggestion($suggestion) : null;
+            },
+            renderSuggestions: function(query, dataset, suggestions) {
+                var datasetClassName = "tt-dataset-" + dataset.name, $dataset = this.$menu.find("." + datasetClassName), elBuilder, fragment, el;
+                if ($dataset.length === 0) {
+                    $dataset = $('<li><ol class="tt-suggestions"></ol></li>').addClass(datasetClassName).appendTo(this.$menu);
+                }
+                elBuilder = document.createElement("div");
+                fragment = document.createDocumentFragment();
+                this.clearSuggestions(dataset.name);
+                if (suggestions.length > 0) {
+                    this.$menu.removeClass("tt-is-empty");
+                    utils.each(suggestions, function(i, suggestion) {
+                        elBuilder.innerHTML = dataset.template.render(suggestion);
+                        el = elBuilder.firstChild;
+                        el.setAttribute("data-value", suggestion.value);
+                        fragment.appendChild(el);
+                    });
+                }
+                $dataset.find("> .tt-suggestions").data({
+                    query: query,
+                    dataset: dataset.name
+                }).append(fragment);
+                this.trigger("suggestionsRender");
+            },
+            clearSuggestions: function(datasetName) {
+                var $suggestions = datasetName ? this.$menu.find(".tt-dataset-" + datasetName + " .tt-suggestions") : this.$menu.find(".tt-suggestions");
+                $suggestions.empty();
+                this._getSuggestions().length === 0 && this.$menu.addClass("tt-is-empty");
+            }
+        });
+        return DropdownView;
+        function formatDataForSuggestion($suggestion) {
+            var $suggestions = $suggestion.parents(".tt-suggestions").first();
+            return {
+                value: $suggestion.data("value"),
+                query: $suggestions.data("query"),
+                dataset: $suggestions.data("dataset")
+            };
+        }
+    }();
+    var TypeaheadView = function() {
+        var html = {
+            wrapper: '<span class="twitter-typeahead"></span>',
+            hint: '<input class="tt-hint" type="text" autocomplete="false" spellcheck="false" disabled>',
+            dropdown: '<ol class="tt-dropdown-menu tt-is-empty"></ol>'
+        };
+        function TypeaheadView(o) {
+            utils.bindAll(this);
+            this.$node = wrapInput(o.input);
+            this.datasets = o.datasets;
+            utils.each(this.datasets, function(key, dataset) {
+                var parentTemplate = '<li class="tt-suggestion">%body</li>';
+                if (dataset.template) {
+                    dataset.template = dataset.engine.compile(parentTemplate.replace("%body", dataset.template));
+                } else {
+                    dataset.template = {
+                        render: function(context) {
+                            return parentTemplate.replace("%body", "<p>" + context.value + "</p>");
+                        }
+                    };
+                }
+            });
+            this.inputView = new InputView({
+                input: this.$node.find(".tt-query"),
+                hint: this.$node.find(".tt-hint")
+            });
+            this.dropdownView = new DropdownView({
+                menu: this.$node.find(".tt-dropdown-menu")
+            });
+            this.dropdownView.on("select", this._handleSelection).on("cursorOn", this._clearHint).on("cursorOn", this._setInputValueToSuggestionUnderCursor).on("cursorOff", this._setInputValueToQuery).on("cursorOff", this._updateHint).on("suggestionsRender", this._updateHint).on("show", this._updateHint).on("hide", this._clearHint);
+            this.inputView.on("focus", this._showDropdown).on("blur", this._hideDropdown).on("blur", this._setInputValueToQuery).on("enter", this._handleSelection).on("queryChange", this._clearHint).on("queryChange", this._clearSuggestions).on("queryChange", this._getSuggestions).on("whitespaceChange", this._updateHint).on("queryChange whitespaceChange", this._showDropdown).on("queryChange whitespaceChange", this._setLanguageDirection).on("esc", this._hideDropdown).on("esc", this._setInputValueToQuery).on("up down", this._moveDropdownCursor).on("up down", this._showDropdown).on("tab", this._setPreventDefaultValueForTab).on("tab left right", this._autocomplete);
+        }
+        utils.mixin(TypeaheadView.prototype, EventTarget, {
+            _setPreventDefaultValueForTab: function(e) {
+                var hint = this.inputView.getHintValue(), inputValue = this.inputView.getInputValue(), preventDefault = hint && hint !== inputValue;
+                this.inputView.setPreventDefaultValueForKey("9", preventDefault);
+            },
+            _setLanguageDirection: function() {
+                var dirClassName = "tt-" + this.inputView.getLanguageDirection();
+                if (!this.$node.hasClass(dirClassName)) {
+                    this.$node.removeClass("tt-ltr tt-rtl").addClass(dirClassName);
+                }
+            },
+            _updateHint: function() {
+                var dataForFirstSuggestion = this.dropdownView.getFirstSuggestion(), hint = dataForFirstSuggestion ? dataForFirstSuggestion.value : null, inputValue, query, beginsWithQuery, match;
+                if (hint && this.dropdownView.isOpen()) {
+                    inputValue = this.inputView.getInputValue();
+                    query = inputValue.replace(/\s{2,}/g, " ").replace(/^\s+/g, "");
+                    beginsWithQuery = new RegExp("^(?:" + query + ")(.*$)", "i");
+                    match = beginsWithQuery.exec(hint);
+                    this.inputView.setHintValue(inputValue + (match ? match[1] : ""));
+                }
+            },
+            _clearHint: function() {
+                this.inputView.setHintValue("");
+            },
+            _clearSuggestions: function() {
+                this.dropdownView.clearSuggestions();
+            },
+            _setInputValueToQuery: function() {
+                this.inputView.setInputValue(this.inputView.getQuery());
+            },
+            _setInputValueToSuggestionUnderCursor: function(e) {
+                this.inputView.setInputValue(e.data.value, true);
+            },
+            _showDropdown: function() {
+                this.dropdownView.show();
+            },
+            _hideDropdown: function(e) {
+                this.dropdownView[e.type === "blur" ? "hideUnlessMouseIsOverDropdown" : "hide"]();
+            },
+            _moveDropdownCursor: function(e) {
+                this.dropdownView[e.type === "up" ? "moveCursorUp" : "moveCursorDown"]();
+            },
+            _handleSelection: function(e) {
+                var byClick = e.type === "select", suggestionData = byClick ? e.data : this.dropdownView.getSuggestionUnderCursor();
+                if (suggestionData) {
+                    this.inputView.setInputValue(suggestionData.value);
+                    byClick ? this.inputView.focus() : e.data.preventDefault();
+                    byClick && utils.isMsie() ? setTimeout(this.dropdownView.hide, 0) : this.dropdownView.hide();
+                }
+            },
+            _getSuggestions: function() {
+                var that = this, query = this.inputView.getQuery();
+                utils.each(this.datasets, function(i, dataset) {
+                    dataset.getSuggestions(query, function(suggestions) {
+                        that._renderSuggestions(query, dataset, suggestions);
+                    });
+                });
+            },
+            _renderSuggestions: function(query, dataset, suggestions) {
+                if (query !== this.inputView.getQuery()) {
+                    return;
+                }
+                suggestions = suggestions.slice(0, dataset.limit);
+                this.dropdownView.renderSuggestions(query, dataset, suggestions);
+            },
+            _autocomplete: function(e) {
+                var isCursorAtEnd, ignoreEvent, query, hint;
+                if (e.type === "right" || e.type === "left") {
+                    isCursorAtEnd = this.inputView.isCursorAtEnd();
+                    ignoreEvent = this.inputView.getLanguageDirection() === "ltr" ? e.type === "left" : e.type === "right";
+                    if (!isCursorAtEnd || ignoreEvent) {
+                        return;
+                    }
+                }
+                query = this.inputView.getQuery();
+                hint = this.inputView.getHintValue();
+                if (hint !== "" && query !== hint) {
+                    this.inputView.setInputValue(hint);
+                }
+            }
+        });
+        return TypeaheadView;
+        function wrapInput(input) {
+            var $input = $(input), $hint = $(html.hint).css({
+                "background-color": $input.css("background-color")
+            });
+            if ($input.length === 0) {
+                return null;
+            }
+            try {
+                !$input.attr("dir") && $input.attr("dir", "auto");
+            } catch (e) {}
+            return $input.attr({
+                autocomplete: false,
+                spellcheck: false
+            }).addClass("tt-query").wrap(html.wrapper).parent().prepend($hint).append(html.dropdown);
+        }
+    }();
+    (function() {
+        var initializedDatasets = {}, transportOptions = {}, transport, methods;
+        jQuery.fn.typeahead = typeahead;
+        typeahead.configureTransport = configureTransport;
+        methods = {
+            initialize: function(datasetDefs) {
+                var datasets = {};
+                datasetDefs = utils.isArray(datasetDefs) ? datasetDefs : [ datasetDefs ];
+                if (datasetDefs.length === 0) {
+                    throw new Error("no datasets provided");
+                }
+                delete typeahead.configureTransport;
+                transport = transport || new Transport(transportOptions);
+                utils.each(datasetDefs, function(i, datasetDef) {
+                    var dataset, name = datasetDef.name = datasetDef.name || utils.getUniqueId();
+                    if (initializedDatasets[name]) {
+                        dataset = initializedDatasets[name];
+                    } else {
+                        datasetDef.limit = datasetDef.limit || 5;
+                        datasetDef.template = datasetDef.template;
+                        datasetDef.engine = datasetDef.engine;
+                        if (datasetDef.template && !datasetDef.engine) {
+                            throw new Error("no template engine specified for " + name);
+                        }
+                        dataset = initializedDatasets[name] = new Dataset({
+                            name: datasetDef.name,
+                            limit: datasetDef.limit,
+                            local: datasetDef.local,
+                            prefetch: datasetDef.prefetch,
+                            remote: datasetDef.remote,
+                            matcher: datasetDef.matcher,
+                            ranker: datasetDef.ranker,
+                            transport: transport
+                        });
+                    }
+                    datasets[name] = {
+                        name: datasetDef.name,
+                        limit: datasetDef.limit,
+                        template: datasetDef.template,
+                        engine: datasetDef.engine,
+                        getSuggestions: dataset.getSuggestions
+                    };
+                });
+                return this.each(function() {
+                    $(this).data({
+                        typeahead: new TypeaheadView({
+                            input: this,
+                            datasets: datasets
+                        })
+                    });
+                });
+            }
+        };
+        function typeahead(method) {
+            if (methods[method]) {
+                methods[method].apply(this, [].slice.call(arguments, 1));
+            } else {
+                methods.initialize.apply(this, arguments);
+            }
+        }
+        function configureTransport(o) {
+            transportOptions = o;
+        }
+    })();
+})();