client_side_autocomplete 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in client_side_autocomplete.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Padilla
+
+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.markdown

@@ -0,0 +1,307 @@
+# client_side_autocomplete
+
+An easy way to use jQuery's autocomplete with Rails 3.1
+
+Supports both ActiveRecord, [mongoid](http://github.com/mongoid/mongoid), and [MongoMapper](https://github.com/jnunemaker/mongomapper).
+
+Works with [Formtastic](http://github.com/justinfrench/formtastic)
+and [SimpleForm](https://github.com/plataformatec/simple_form)
+
+## Before you start
+
+Make sure your project is using jQuery-UI and the autocomplete widget
+before you continue.
+
+You can find more info about that here:
+
+* http://jquery.com/
+* http://jqueryui.com/demos/autocomplete/
+* http://github.com/rails/jquery-ujs
+
+I'd encourage you to understand how to use those 3 amazing tools before attempting to use this gem.
+
+## Installing
+
+Include the gem on your Gemfile
+
+    gem 'client_side_autocomplete'
+
+Install it
+
+    bundle install
+
+## Usage ##
+
+### Rails 3.1 ###
+The javascript file is served up in the asset pipeline. Add the
+following to your `app/assets/javascripts/application.js` file.
+
+```javascript
+//= require jquery
+//= require jquery_ujs
+//= require jquery-ui
+//= require rails.autocomplete
+```
+
+### Model Example
+
+Assuming you have a Brand model:
+
+    class Brand < ActiveRecord::Base
+    end
+
+    create_table :brand do |t|
+      t.column :name, :string
+    end
+
+### Controller
+
+To set up the required action on your controller, all you have to do is call it with the class name and the method
+as in the following example:
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name
+    end
+
+This will create an action _autocomplete_brand_name_ on your controller, don't forget to add it on your routes file
+
+    resources :products do
+      get :autocomplete_brand_name, :on => :collection
+    end
+
+### Options
+
+#### :full => true
+
+By default, the search starts from the beginning of the string you're searching for. If you want to do a full search, set the _full_ parameter to true.
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name, :full => true
+    end
+
+The following terms would match the query 'un':
+
+* Luna
+* Unacceptable
+* Rerun
+
+#### :full => false (default behavior)
+
+Only the following terms mould match the query 'un':
+
+* Unacceptable
+
+#### :extra_data
+
+By default, your search will only return the required columns from the database needed to populate your form, namely id and the column you are searching (name, in the above example).
+
+Passing an array of attributes/column names to this option will fetch and return the specified data.
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name, :extra_data => [:slogan]
+    end
+
+#### :display_value
+
+If you want to display a different version of what you're looking for, you can use the :display_value option.
+
+This options receives a method name as the parameter, and that method will be called on the instance when displaying the results.
+
+    class Brand < ActiveRecord::Base
+      def funky_method
+        "#{self.name}.camelize"
+      end
+    end
+
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name, :display_value => :funky_method
+    end
+
+In the example above, you will search by _name_, but the autocomplete list will display the result of _funky_method_
+
+This wouldn't really make much sense unless you use it with the "id_element" attribute. (See below)
+
+Only the object's id and the column you are searching on will be returned in JSON, so if your display_value method requires another parameter, make sure to fetch it with the :extra_data option
+
+
+#### :scopes
+  Added option to use scopes. Pass scopes in an array.
+  e.g `:scopes => [:scope1, :scope2]`
+
+#### :column_name
+   By default autocomplete uses method name as column name. Now it can be specified using column_name options
+   `:column_name => 'name'`
+
+#### json encoder
+Autocomplete uses Yajl as JSON encoder/decoder, but you can specify your own
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name do |items|
+         CustomJSON::Encoder.encode(items)
+      end
+    end
+
+### View
+
+On your view, all you have to do is include the attribute autocomplete on the text field
+using the url to the autocomplete action as the value.
+
+    form_for @product do |f|
+      f.autocomplete_field :brand_name, autocomplete_brand_name_products_path
+    end
+
+This will generate an HTML tag that looks like:
+
+    <input type="text" data-autocomplete="products/autocomplete_brand_name">
+
+If you are not using a FormBuilder (form_for) or you just want to include an autocomplete field without the form, you can use the
+*autocomplete_field_tag* helper.
+
+    form_tag 'some/path'
+      autocomplete_field_tag 'address', '', address_autocomplete_path, :size => 75
+    end
+
+Now your autocomplete code is unobtrusive, Rails 3 style.
+
+### Getting the object id
+
+If you need to use the id of the selected object, you can use the *id_element* attribute too:
+
+    f.autocomplete_field :brand_name, autocomplete_brand_name_products_path, :id_element => '#some_element'
+
+This will update the field with id *#some_element with the id of the selected object. The value for this option can be any jQuery selector.
+
+### Getting extra object data
+
+If you need to extra data about the selected object, you can use the *:update_elements* HTML attribute.
+
+The :update_elements attribute accepts a hash where the keys represent the object attribute/column data to use to update and the values are jQuery selectors to retrieve the HTML element to update:
+
+    f.autocomplete_field :brand_name, autocomplete_brand_name_products_path, :update_elements => {:id => '#id_element', :slogan => '#some_other_element'}
+
+    class ProductsController < Admin::BaseController
+      autocomplete :brand, :name, :extra_data => [:slogan]
+    end
+
+The previous example would fetch the extra attribute slogan and update jQuery('#some_other_element') with the slogan value.
+
+### Running custom code on selection
+
+A javascript event named *railsAutocomplete.select* is fired on the input field when a value is selected from the autocomplete drop down. If you need to do something more complex than update fields with data, you can hook into this event, like so:
+
+    $('#my_autocomplete_field').bind('railsAutocomplete.select', function(event, data){
+    	/* Do something here */
+    	alert(data.item.id);
+    });
+
+## Formtastic
+
+If you are using [Formtastic](http://github.com/justinfrench/formtastic), you automatically get the *autocompleted_input* helper on *semantic_form_for*:
+
+    semantic_form_for @product do |f|
+      f.autocompleted_input :brand_name, :url => autocomplete_brand_name_products_path
+    end
+
+The only difference with the original helper is that you must specify the autocomplete url using the *:url* option.
+
+## SimpleForm
+
+If you want to use it with simple_form, all you have to do is use the
+:as option on the input and set the autocomplete path with the :url
+option.
+
+
+    simple_form_for @product do |form|
+      form.input :name
+      form.input :brand_name, :url => autocomplete_brand_name_products_path, :as => :autocomplete
+
+# Cucumber
+
+I have created a step to test your autocomplete with Cucumber and Capybara, all you have to do is add the following lines to your *env.rb* file:
+
+    require 'cucumber/autocomplete'
+
+Then you'll have access to the following step:
+
+    I choose "([^"]*)" in the autocomplete list
+
+An example on how to use it:
+
+    @javascript
+    Scenario: Autocomplete
+      Given the following brands exists:
+        | name  |
+        | Alpha |
+        | Beta  |
+        | Gamma |
+      And I go to the home page
+      And I fill in "Brand name" with "al"
+      And I choose "Alpha" in the autocomplete list
+      Then the "Brand name" field should contain "Alpha"
+
+I have only tested this using Capybara, no idea if it works with something else, to see it in action, check the [example app](http://github.com/crowdint/rails3-jquery-autocomplete-app).
+
+# Steak
+
+I have created a helper to test your autocomplete with Steak and Capybara, all you have to do is add the following lines to your *acceptance_helper.rb* file:
+
+    require 'steak/autocomplete'
+
+Then you'll have access to the following helper:
+
+    choose_autocomplete_result
+
+An example on how to use it:
+
+    scenario "Autocomplete" do
+      lambda do 
+        Brand.create! [
+          {:name => "Alpha"}, 
+          {:name => "Beta"},
+          {:name => "Gamma"}
+        ]
+      end.should change(Brand, :count).by(3)
+
+      visit home_page
+      fill_in "Brand name", :with => "al"
+      choose_autocomplete_result "Alpha"
+      find_field("Brand name").value.should include("Alpha")
+    end
+
+I have only tested this using Capybara, no idea if it works with something else.
+
+# Development
+
+If you want to make changes to the gem, first install bundler 1.0.0:
+
+    gem install bundler
+
+And then, install all your dependencies:
+
+    bundle install
+
+## Running the test suite
+
+You need to have an instance of MongoDB running on your computer or all the mongo tests will fail miserably.
+
+    rake test
+
+## Integration tests
+
+If you make changes or add features to the jQuery part, please make sure
+you write a cucumber test for it.
+
+You can find an example Rails app on the *integration* folder.
+
+You can run the integration tests with the cucumber command while on the
+integration folder:
+
+    cd integration
+    rake db:migrate
+    cucumber
+
+# Thanks to
+
+Author of rails3-jquery-autocomplete and [this list](https://github.com/crowdint/rails3-jquery-autocomplete/contributors)
+

data/Rakefile

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

data/client_side_autocomplete.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "client_side_autocomplete/version"
+
+Gem::Specification.new do |s|
+  s.name        = "client_side_autocomplete"
+  s.version     = ClientSideAutocomplete::VERSION
+  s.authors     = ["Shenouda Bertel"]
+  s.email       = ["ShenoudaB@gmail.com"]
+  s.homepage    = "http://mobithought.com"
+  s.summary     = %q{Client Side AutoComplete}
+  s.description = %q{Client Side AutoComplete}
+
+  s.rubyforge_project = "client_side_autocomplete"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('rails', '~>3.1.0')
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/client_side_autocomplete.rb

@@ -0,0 +1,29 @@
+require "client_side_autocomplete/version"
+require 'client_side_autocomplete/form_helper'
+require 'client_side_autocomplete/autocomplete'
+
+module ClientSideAutocomplete
+    autoload :Orm              , 'client_side_autocomplete/orm'
+  autoload :FormtasticPlugin , 'client_side_autocomplete/formtastic_plugin'
+end
+
+class ActionController::Base
+  include ClientSideAutocomplete::Autocomplete
+end
+
+#
+# Load the formtastic plugin if using Formtastic
+# TODO: Better way to load plugins
+begin
+  require 'formtastic'
+  class Formtastic::FormBuilder < ActionView::Helpers::FormBuilder
+    include ClientSideAutocomplete::FormtasticPlugin
+  end
+rescue LoadError
+end
+
+begin
+  require 'simple_form'
+  require 'client_side_autocomplete/simple_form_plugin'
+rescue LoadError
+end

data/lib/client_side_autocomplete/autocomplete.rb

@@ -0,0 +1,96 @@
+module ClientSideAutocomplete
+  module Autocomplete
+    def self.included(target)
+      target.extend ClientSideAutocomplete::Autocomplete::ClassMethods
+
+      if defined?(Mongoid::Document)
+        target.send :include, ClientSideAutocomplete::Orm::Mongoid
+      elsif defined?(MongoMapper::Document)
+        target.send :include, ClientSideAutocomplete::Orm::MongoMapper
+      else
+        target.send :include, ClientSideAutocomplete::Orm::ActiveRecord
+      end
+    end
+
+    #
+    # Usage:
+    #
+    # class ProductsController < Admin::BaseController
+    #   autocomplete :brand, :name
+    # end
+    #
+    # This will magically generate an action autocomplete_brand_name, so,
+    # don't forget to add it on your routes file
+    #
+    #   resources :products do
+    #      get :autocomplete_brand_name, :on => :collection
+    #   end
+    #
+    # Now, on your view, all you have to do is have a text field like:
+    #
+    #   f.text_field :brand_name, :autocomplete => autocomplete_brand_name_products_path
+    #
+    #
+    # Yajl is used by default to encode results, if you want to use a different encoder
+    # you can specify your custom encoder via block
+    #
+    # class ProductsController < Admin::BaseController
+    #   autocomplete :brand, :name do |items|
+    #     CustomJSONEncoder.encode(items)
+    #   end
+    # end
+    #
+    module ClassMethods
+      def autocomplete(object, method, options = {})
+        define_method("autocomplete_#{object}_#{method}") do
+
+          method = options[:column_name] if options.has_key?(:column_name)
+
+          term = params[:term]
+
+          if term && !term.blank?
+            #allow specifying fully qualified class name for model object
+            class_name = options[:class_name] || object
+            items = get_autocomplete_items(:model => get_object(class_name), \
+              :options => options, :term => term, :method => method)
+          else
+            items = {}
+          end
+
+          render :json => json_for_autocomplete(items, options[:display_value] ||= method, options[:extra_data])
+        end
+      end
+    end
+
+    # Returns a limit that will be used on the query
+    def get_autocomplete_limit(options)
+      options[:limit] ||= 10
+    end
+
+    # Returns parameter model_sym as a constant
+    #
+    #   get_object(:actor)
+    #   # returns a Actor constant supposing it is already defined
+    #
+    def get_object(model_sym)
+      object = model_sym.to_s.camelize.constantize
+    end
+
+    #
+    # Returns a hash with three keys actually used by the Autocomplete jQuery-ui
+    # Can be overriden to show whatever you like
+    # Hash also includes a key/value pair for each method in extra_data
+    #
+    def json_for_autocomplete(items, method, extra_data=[])
+      items.collect do |item|
+        hash = {"id" => item.id.to_s, "label" => item.send(method), "value" => item.send(method)}
+        extra_data.each do |datum|
+          hash[datum] = item.send(datum)
+        end if extra_data
+        # TODO: Come back to remove this if clause when test suite is better
+        hash
+      end
+    end
+  end
+end
+

data/lib/client_side_autocomplete/form_helper.rb

@@ -0,0 +1,47 @@
+module ActionView
+  module Helpers
+    module FormHelper
+      # Returns an input tag of the "text" type tailored for accessing a specified attribute (identified by +method+) and
+      # that is populated with jQuery's autocomplete plugin.
+      #
+      # ==== Examples
+      #   autocomplete_field(:post, :title, author_autocomplete_path, :size => 20)
+      #   # => <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}"  data-autocomplete="author/autocomplete"/>
+      #
+      def autocomplete_field(object_name, method, source, options ={})
+        options["data-autocomplete"] = source
+        text_field(object_name, method, rewrite_autocomplete_option(options))
+      end
+    end
+
+    module FormTagHelper
+      # Creates a standard text field that can be populated with jQuery's autocomplete plugin
+      #
+      # ==== Examples
+      #   autocomplete_field_tag 'address', '', address_autocomplete_path, :size => 75
+      #   # => <input id="address" name="address" size="75" type="text" value="" data-autocomplete="address/autocomplete"/>
+      #
+      def autocomplete_field_tag(name, value, source, options ={})
+        options["data-autocomplete"] = source
+        text_field_tag(name, value, rewrite_autocomplete_option(options))
+      end
+    end
+
+    #
+    # Method used to rename the autocomplete key to a more standard
+    # data-autocomplete key
+    #
+    private
+    def rewrite_autocomplete_option(options)
+      options["data-update-elements"] = JSON.generate(options.delete :update_elements) if options[:update_elements]
+      options["data-id-element"] = options.delete :id_element if options[:id_element]
+      options
+    end
+  end
+end
+
+class ActionView::Helpers::FormBuilder #:nodoc:
+  def autocomplete_field(method, source, options = {})
+    @template.autocomplete_field(@object_name, method, source, objectify_options(options))
+  end
+end

data/lib/client_side_autocomplete/formtastic_plugin.rb

@@ -0,0 +1,41 @@
+module ClientSideAutocomplete
+  module FormtasticPlugin
+    def autocompleted_input(method, options = {})
+      if options.key?(:selected) || options.key?(:checked) || options.key?(:default)
+        ::ActiveSupport::Deprecation.warn(
+        "The :selected, :checked (and :default) options are deprecated in Formtastic and will be removed from 1.0. " <<
+        "Please set default values in your models (using an after_initialize callback) or in your controller set-up. " <<
+        "See http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html for more information.", caller)
+      end
+
+      options[:as]     ||= "autocompleted_string"
+
+      html_class = [ options[:as], (options[:required] ? :required : :optional) ]
+      html_class << 'error' if @object && @object.respond_to?(:errors) && !@object.errors[method.to_sym].blank?
+
+      wrapper_html = options.delete(:wrapper_html) || {}
+      # wrapper_html[:id]  ||= generate_html_id(method)
+      wrapper_html[:class] = (html_class << wrapper_html[:class]).flatten.compact.join(' ')
+
+      if options[:input_html] && options[:input_html][:id]
+        options[:label_html] ||= {}
+        options[:label_html][:for] ||= options[:input_html][:id]
+      end
+
+      # input_parts = self.class.inline_order.dup
+      # input_parts = input_parts - [:errors, :hints] if options[:as] == :hidden
+
+      list_item_content = input_parts.map do |type|
+        send(:"inline_#{type}_for", method, options)
+      end.compact.join("\n")
+
+      return template.content_tag(:li, Formtastic::Util.html_safe(list_item_content), wrapper_html)
+    end
+
+
+    protected
+    def autocompleted_string_input(method, options)
+      self.label(method, options_for_label(options)) << autocomplete_field(method, options.delete(:url), options)
+    end
+  end
+end

data/lib/client_side_autocomplete/orm.rb

@@ -0,0 +1,8 @@
+module ClientSideAutocomplete
+  module Orm
+    autoload :ActiveRecord , 'client_side_autocomplete/orm/active_record'
+		autoload :Mongoid      , 'client_side_autocomplete/orm/mongoid'
+		autoload :MongoMapper  , 'client_side_autocomplete/orm/mongo_mapper'
+  end
+end
+

data/lib/client_side_autocomplete/orm/active_record.rb

@@ -0,0 +1,47 @@
+module ClientSideAutocomplete
+  module Orm
+    module ActiveRecord
+      def get_autocomplete_order(method, options, model=nil)
+        order = options[:order]
+
+        table_prefix = model ? "#{model.table_name}." : ""
+        order || "#{table_prefix}#{method} ASC"
+      end
+
+      def get_autocomplete_items(parameters)
+        model   = parameters[:model]
+        term    = parameters[:term]
+        method  = parameters[:method]
+        options = parameters[:options]
+        scopes  = Array(options[:scopes])
+        limit   = get_autocomplete_limit(options)
+        order   = get_autocomplete_order(method, options, model)
+
+
+        items = model.scoped
+
+        scopes.each { |scope| items = items.send(scope) } unless scopes.empty?
+
+        items = items.select(get_autocomplete_select_clause(model, method, options)) unless options[:full_model]
+        items = items.where(get_autocomplete_where_clause(model, term, method, options)).
+            limit(limit).order(order)
+      end
+
+      def get_autocomplete_select_clause(model, method, options)
+        table_name = model.table_name
+        (["#{table_name}.#{model.primary_key}", "#{table_name}.#{method}"] + (options[:extra_data].blank? ? [] : options[:extra_data]))
+      end
+
+      def get_autocomplete_where_clause(model, term, method, options)
+        table_name = model.table_name
+        is_full_search = options[:full]
+        like_clause = (postgres? ? 'ILIKE' : 'LIKE')
+        ["LOWER(#{table_name}.#{method}) #{like_clause} ?", "#{(is_full_search ? '%' : '')}#{term.downcase}%"]
+      end
+
+      def postgres?
+        defined?(PGConn)
+      end
+    end
+  end
+end

data/lib/client_side_autocomplete/orm/mongo_mapper.rb

@@ -0,0 +1,30 @@
+module ClientSideAutocomplete
+	module Orm
+		module MongoMapper
+			def get_autocomplete_order(method, options, model=nil)
+        order = options[:order]
+        if order
+          order.split(',').collect do |fields|
+            sfields = fields.split
+            [sfields[0].downcase.to_sym, sfields[1].downcase.to_sym]
+          end
+        else
+          [[method.to_sym, :asc]]
+        end
+			end
+
+			def get_autocomplete_items(parameters)
+        model          = parameters[:model]
+        method         = parameters[:method]
+        options        = parameters[:options]
+        is_full_search = options[:full]
+        term           = parameters[:term]
+        limit          = get_autocomplete_limit(options)
+        order          = get_autocomplete_order(method, options)
+
+        search = (is_full_search ? '.*' : '^') + term + '.*'
+				items  = model.where(method.to_sym => /#{search}/i).limit(limit).sort(order)
+			end
+		end	
+	end
+end

data/lib/client_side_autocomplete/orm/mongoid.rb

@@ -0,0 +1,30 @@
+module ClientSideAutocomplete
+  module Orm
+    module Mongoid
+      def get_autocomplete_order(method, options, model=nil)
+        order = options[:order]
+        if order
+          order.split(',').collect do |fields|
+            sfields = fields.split
+            [sfields[0].downcase.to_sym, sfields[1].downcase.to_sym]
+          end
+        else
+          [[method.to_sym, :asc]]
+        end
+      end
+
+      def get_autocomplete_items(parameters)
+        model          = parameters[:model]
+        method         = parameters[:method]
+        options        = parameters[:options]
+        is_full_search = options[:full]
+        term           = parameters[:term]
+        limit          = get_autocomplete_limit(options)
+        order          = get_autocomplete_order(method, options)
+
+        search = (is_full_search ? '.*' : '^') + term + '.*'
+        items  = model.where(method.to_sym => /#{search}/i).limit(limit).order_by(order)
+      end
+    end
+  end
+end

data/lib/client_side_autocomplete/simple_form_plugin.rb

@@ -0,0 +1,25 @@
+module SimpleForm
+  module Inputs
+    class AutocompleteInput < Base
+      def input
+        @builder.autocomplete_field(attribute_name, options[:url], input_html_options)
+      end
+
+    protected
+
+      def limit
+        column && column.limit
+      end
+
+      def has_placeholder?
+        placeholder_present?
+      end
+    end
+  end
+end
+
+module SimpleForm
+  class FormBuilder
+    map_type :autocomplete, :to => SimpleForm::Inputs::AutocompleteInput
+  end
+end

data/lib/client_side_autocomplete/version.rb

@@ -0,0 +1,3 @@
+module ClientSideAutocomplete
+  VERSION = "0.0.1"
+end

data/vendor/assets/javascripts/rails.autocomplete.js

@@ -0,0 +1,16 @@
+/*
+* Unobtrusive autocomplete
+*
+* To use it, you just have to include the HTML attribute autocomplete
+* with the autocomplete URL as the value
+*
+*   Example:
+*       <input type="text" data-autocomplete="/url/to/autocomplete">
+*
+* Optionally, you can use a jQuery selector to specify a field that can
+* be updated with the element id whenever you find a matching value
+*
+*   Example:
+*       <input type="text" data-autocomplete="/url/to/autocomplete" data-id-element="#id_field">
+*/
+$(document).ready(function(){$("input[data-autocomplete]").railsAutocomplete()}),function(a){var b=null;a.fn.railsAutocomplete=function(){return this.live("focus",function(){this.railsAutoCompleter||(this.railsAutoCompleter=new a.railsAutocomplete(this))})},a.railsAutocomplete=function(a){_e=a,this.init(_e)},a.railsAutocomplete.fn=a.railsAutocomplete.prototype={railsAutocomplete:"0.0.1"},a.railsAutocomplete.fn.extend=a.railsAutocomplete.extend=a.extend,a.railsAutocomplete.fn.extend({init:function(a){function c(a){return b(a).pop().replace(/^\s+/,"")}function b(b){return b.split(a.delimiter)}a.delimiter=$(a).attr("data-delimiter")||null,$(a).autocomplete({source:function(b,d){$.getJSON($(a).attr("data-autocomplete"),{term:c(b.term)},function(){$(arguments[0]).each(function(b,c){var d={};d[c.id]=c,$(a).data(d)}),d.apply(null,arguments)})},search:function(){var a=c(this.value);if(a.length<2)return!1},focus:function(){return!1},select:function(c,d){var f=b(this.value);f.pop(),f.push(d.item.value);if(a.delimiter!=null)f.push(""),this.value=f.join(a.delimiter);else{this.value=f.join(""),$(this).attr("data-id-element")&&$($(this).attr("data-id-element")).val(d.item.id);if($(this).attr("data-update-elements")){var g=$(this).data(d.item.id.toString()),h=$.parseJSON($(this).attr("data-update-elements"));for(var i in h)$(h[i]).val(g[i])}}var j=this.value;$(this).bind("keyup.clearId",function(){$(this).val().trim()!=j.trim()&&($($(this).attr("data-id-element")).val(""),$(this).unbind("keyup.clearId"))}),$(this).trigger("railsAutocomplete.select",d);return!1}})}})}(jQuery)

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: client_side_autocomplete
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Shenouda Bertel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70263840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70263840
+description: Client Side AutoComplete
+email:
+- ShenoudaB@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- client_side_autocomplete.gemspec
+- lib/client_side_autocomplete.rb
+- lib/client_side_autocomplete/autocomplete.rb
+- lib/client_side_autocomplete/form_helper.rb
+- lib/client_side_autocomplete/formtastic_plugin.rb
+- lib/client_side_autocomplete/orm.rb
+- lib/client_side_autocomplete/orm/active_record.rb
+- lib/client_side_autocomplete/orm/mongo_mapper.rb
+- lib/client_side_autocomplete/orm/mongoid.rb
+- lib/client_side_autocomplete/simple_form_plugin.rb
+- lib/client_side_autocomplete/version.rb
+- vendor/assets/javascripts/rails.autocomplete.js
+homepage: http://mobithought.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: client_side_autocomplete
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Client Side AutoComplete
+test_files: []