wf-rails3-jquery-autocomplete 1.0.4

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+* 1.0.3 Fixed Formtastic 2.0 + Ruby 1.8.7 compat issue
+* 1.0.2 Fixed issue #93, #94
+* 1.0.1 Formtastic 2.0 compatibility fix
+* 1.0.0 Rails 3.1 asset pipeline support
+* 0.9.1 Fixes issues #96 and #32
+* 0.9.0 Massive rewrite
+* 0.8.0 Compressed JS file
+* 0.7.5 Pull request #46
+* 0.7.4 Allows Rails 3.1
+* 0.7.3 MongoMapper
+* 0.7.2 Steak helper
+* 0.7.1 Fixed joined scopes (Issue #43)
+* 0.7.0 Scopes
+* 0.6.6 ILIKE for postgres
+* 0.6.5 JS select event
+* 0.6.4 Use YAJL instead of JSON
+* 0.6.3 SimpleForm plugin
+* 0.6.2 Fix Issue #8
+* 0.6.1 Allow specifying fully qualified class name for model object as an option to autocomplete
+* 0.6.0 JS Code cleanup
+* 0.5.1 Add STI support
+* 0.5.0 Formtastic support
+* 0.4.0 MongoID support
+* 0.3.6 Using .live() to put autocomplete on dynamic fields
+

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.md

@@ -0,0 +1,345 @@
+# rails3-jquery-autocomplete
+
+An easy way to use jQuery's autocomplete with Rails 3.
+
+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)
+
+## ActiveRecord
+
+You can find a [detailed example](http://github.com/crowdint/rails3-jquery-autocomplete-app)
+on how to use this gem with ActiveRecord [here](http://github.com/crowdint/rails3-jquery-autocomplete-app).
+
+## MongoID
+
+You can find a [detailed example](http://github.com/crowdint/rails3-jquery-autocomplete-app/tree/mongoid)
+on how to use this gem with MongoID [here](http://github.com/crowdint/rails3-jquery-autocomplete-app/tree/mongoid). (Same thing, different branch)
+
+## 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 'rails3-jquery-autocomplete'
+
+Install it
+
+    bundle install
+
+### Rails 3.0.x
+
+Run the generator
+
+    rails generate autocomplete:install
+
+And include autocomplete-rails.js on your layouts
+
+    javascript_include_tag "autocomplete-rails.js"
+
+### Rails 3.1.x
+
+Just add it to your app/assets/javascripts/application.js file
+
+    //= require jquery
+    //= require jquery_ujs
+    //= require autocomplete-rails
+
+## Upgrading from older versions
+
+If you are upgrading from a previous version, run the generator after installing to replace the javascript file.
+
+    rails generate autocomplete:install
+
+I'd recommend you do this every time you update to make sure you have the latest JS file.
+
+## Uncompressed Javascript file
+
+If you want to make changes to the JS file, you can install the
+uncompressed version by running:
+
+    rails generate autocomplete:uncompressed
+
+## Usage
+
+### 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.input :brand_name, :as => :autocomplete, :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
+
+Everyone on [this list](https://github.com/crowdint/rails3-jquery-autocomplete/contributors)
+
+# About the Author
+
+[Crowd Interactive](http://www.crowdint.com) is an American web design and development company that happens to work in Colima, Mexico.
+We specialize in building and growing online retail stores. We don’t work with everyone – just companies we believe in. Call us today to see if there’s a fit.
+Find more info [here](http://www.crowdint.com)!
+

data/Rakefile

@@ -0,0 +1,28 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+require 'rcov/rcovtask'
+
+task :default => [:uglify, :test]
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :uglify do
+  require 'uglifier'
+  file_folder = "lib/assets/javascripts"
+  File.open("#{file_folder}/autocomplete-rails.js", "w") do |f|
+    f << Uglifier.compile(File.read("#{file_folder}/autocomplete-rails-uncompressed.js"))
+  end
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.rcov_opts = %w{--exclude \/gems\/}
+  t.verbose = true
+end

data/lib/assets/javascripts/autocomplete-rails-uncompressed.js

@@ -0,0 +1,113 @@
+/*
+* 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(jQuery)
+{
+  var self = null;
+  jQuery.fn.railsAutocomplete = function() {
+    return this.live('focus',function() {
+      if (!this.railsAutoCompleter) {
+        this.railsAutoCompleter = new jQuery.railsAutocomplete(this);
+      }
+    });
+  };
+
+  jQuery.railsAutocomplete = function (e) {
+    _e = e;
+    this.init(_e);
+  };
+
+  jQuery.railsAutocomplete.fn = jQuery.railsAutocomplete.prototype = {
+    railsAutocomplete: '0.0.1'
+  };
+
+  jQuery.railsAutocomplete.fn.extend = jQuery.railsAutocomplete.extend = jQuery.extend;
+  jQuery.railsAutocomplete.fn.extend({
+    init: function(e) {
+      e.delimiter = $(e).attr('data-delimiter') || null;
+      function split( val ) {
+        return val.split( e.delimiter );
+      }
+      function extractLast( term ) {
+        return split( term ).pop().replace(/^\s+/,"");
+      }
+
+      $(e).autocomplete({
+        source: function( request, response ) {
+          $.getJSON( $(e).attr('data-autocomplete'), {
+            term: extractLast( request.term )
+          }, function() {
+            $(arguments[0]).each(function(i, el) {
+              var obj = {};
+              obj[el.id] = el;
+              $(e).data(obj);
+            });
+            response.apply(null, arguments);
+          });
+        },
+        search: function() {
+          // custom minLength
+          var term = extractLast( this.value );
+          if ( term.length < 2 ) {
+            return false;
+          }
+        },
+        focus: function() {
+          // prevent value inserted on focus
+          return false;
+        },
+        select: function( event, ui ) {
+          var terms = split( this.value );
+          // remove the current input
+          terms.pop();
+          // add the selected item
+          terms.push( ui.item.value );
+          // add placeholder to get the comma-and-space at the end
+          if (e.delimiter != null) {
+            terms.push( "" );
+            this.value = terms.join( e.delimiter );
+          } else {
+            this.value = terms.join("");
+            if ($(this).attr('data-id-element')) {
+              $($(this).attr('data-id-element')).val(ui.item.id);
+            }
+            if ($(this).attr('data-update-elements')) {
+              var data = $(this).data(ui.item.id.toString());
+              var update_elements = $.parseJSON($(this).attr("data-update-elements"));
+              for (var key in update_elements) {
+                $(update_elements[key]).val(data[key]);
+              }
+            }
+          }
+          var remember_string = this.value;
+          $(this).bind('keyup.clearId', function(){
+            if($(this).val().trim() != remember_string.trim()){
+              $($(this).attr('data-id-element')).val("");
+              $(this).unbind('keyup.clearId');
+            }
+          });
+          $(this).trigger('railsAutocomplete.select', ui);
+
+          return false;
+        }
+      });
+    }
+  });
+})(jQuery);

data/lib/assets/javascripts/autocomplete-rails.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 b(b){return b.split(a.delimiter)}function c(a){return b(a).pop().replace(/^\s+/,"")}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;return $(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),!1}})}})}(jQuery)

data/lib/cucumber/autocomplete.rb

@@ -0,0 +1,6 @@
+Given /^I choose "([^"]*)" in the autocomplete list$/ do |text|
+  page.execute_script %Q{ $('input[data-autocomplete]').trigger("focus") }
+  page.execute_script %Q{ $('input[data-autocomplete]').trigger("keydown") }
+  sleep 1
+  page.execute_script %Q{ $('.ui-menu-item a:contains("#{text}")').trigger("mouseenter").trigger("click"); }
+end

data/lib/generators/autocomplete/install_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Autocomplete
+  class InstallGenerator < Rails::Generators::Base
+    def install
+      # Copy the unobtrusive JS file
+      copy_file('autocomplete-rails.js', 'public/javascripts/autocomplete-rails.js')
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..', '..', 'assets', 'javascripts')
+    end
+  end
+end

data/lib/generators/autocomplete/uncompressed_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Autocomplete
+  class UncompressedGenerator < Rails::Generators::Base
+    def install
+      # Copy the unobtrusive JS file
+      copy_file('autocomplete-rails-uncompressed.js', 'public/javascripts/autocomplete-rails.js')
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..', '..', 'assets', 'javascripts')
+    end
+  end
+end

data/lib/rails3-jquery-autocomplete.rb

@@ -0,0 +1,23 @@
+require 'rails3-jquery-autocomplete/form_helper'
+require 'rails3-jquery-autocomplete/autocomplete'
+
+module Rails3JQueryAutocomplete
+  autoload :Orm              , 'rails3-jquery-autocomplete/orm'
+  autoload :FormtasticPlugin , 'rails3-jquery-autocomplete/formtastic_plugin'
+
+  unless ::Rails.version < "3.1"
+    require 'rails3-jquery-autocomplete/rails/engine'
+  end
+end
+
+class ActionController::Base
+  include Rails3JQueryAutocomplete::Autocomplete
+end
+
+require 'rails3-jquery-autocomplete/formtastic'
+
+begin
+  require 'simple_form'
+  require 'rails3-jquery-autocomplete/simple_form_plugin'
+rescue LoadError
+end

data/lib/rails3-jquery-autocomplete/autocomplete.rb

@@ -0,0 +1,110 @@
+module Rails3JQueryAutocomplete
+  module Autocomplete
+    def self.included(target)
+      target.extend Rails3JQueryAutocomplete::Autocomplete::ClassMethods
+
+      target.send :include, Rails3JQueryAutocomplete::Orm::Mongoid if defined?(Mongoid::Document)
+      target.send :include, Rails3JQueryAutocomplete::Orm::MongoMapper if defined?(MongoMapper::Document)
+      target.send :include, Rails3JQueryAutocomplete::Orm::ActiveRecord
+    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("get_prefix") do |model|
+          if model.superclass == ActiveRecord::Base
+            'active_record'
+          elsif model.superclass == Object && model.include?(Mongoid::Document)
+            'mongoid'
+          elsif model.superclass == Object && model.include?(MongoMapper::Document)
+            'mongo_mapper'
+          end
+        end
+
+        define_method("get_autocomplete_order") do |method, options, model=nil|
+          method("#{get_prefix(get_object(options[:class_name] || object))}_get_autocomplete_order").call(method, options, model)
+        end
+        
+        define_method("get_autocomplete_items") do |parameters|
+          method("#{get_prefix(get_object(options[:class_name] || object))}_get_autocomplete_items").call(parameters)
+        end
+        
+        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/rails3-jquery-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/rails3-jquery-autocomplete/formtastic.rb

@@ -0,0 +1,41 @@
+#
+# Load the formtastic plugin if using Formtastic
+#
+begin
+  require 'formtastic'
+  begin
+    require "formtastic/version"
+  rescue LoadError
+  end
+
+  if defined?(Formtastic::VERSION)
+    #
+    # Formtastic 2.x
+    #
+
+    module Formtastic
+      module Inputs
+        class AutocompleteInput
+          include Base
+          include Base::Stringish
+
+          def to_html
+            input_wrapping do
+              label_html <<
+              builder.autocomplete_field(method, options.delete(:url), input_html_options)
+            end
+          end
+        end
+      end
+    end
+  else
+
+    #
+    # Formtastic 1.x
+    #
+    class Formtastic::SemanticFormBuilder < ActionView::Helpers::FormBuilder
+      include Rails3JQueryAutocomplete::FormtasticPlugin
+    end
+  end
+rescue LoadError
+end

data/lib/rails3-jquery-autocomplete/formtastic_plugin.rb

@@ -0,0 +1,44 @@
+module Rails3JQueryAutocomplete
+  module FormtasticPlugin
+    def autocomplete_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[:required] = method_required?(method) unless options.key?(:required)
+      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
+
+    alias_method :autocompleted_input, :autocomplete_input
+
+
+    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/rails3-jquery-autocomplete/orm.rb

@@ -0,0 +1,8 @@
+module Rails3JQueryAutocomplete
+  module Orm
+    autoload :ActiveRecord , 'rails3-jquery-autocomplete/orm/active_record'
+		autoload :Mongoid      , 'rails3-jquery-autocomplete/orm/mongoid'
+		autoload :MongoMapper  , 'rails3-jquery-autocomplete/orm/mongo_mapper'
+  end
+end
+

data/lib/rails3-jquery-autocomplete/orm/active_record.rb

@@ -0,0 +1,47 @@
+module Rails3JQueryAutocomplete
+  module Orm
+    module ActiveRecord
+      def active_record_get_autocomplete_order(method, options, model=nil)
+        order = options[:order]
+
+        table_prefix = model ? "#{model.table_name}." : ""
+        order || "#{table_prefix}#{method} ASC"
+      end
+
+      def active_record_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   = active_record_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/rails3-jquery-autocomplete/orm/mongo_mapper.rb

@@ -0,0 +1,30 @@
+module Rails3JQueryAutocomplete
+	module Orm
+		module MongoMapper
+			def mongo_mapper_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 mongo_mapper_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          = mongo_mapper_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/rails3-jquery-autocomplete/orm/mongoid.rb

@@ -0,0 +1,34 @@
+module Rails3JQueryAutocomplete
+  module Orm
+    module Mongoid
+      def mongoid_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 mongoid_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          = mongoid_get_autocomplete_order(method, options)
+
+        if is_full_search
+          search = '.*' + term + '.*'
+        else
+          search = '^' + term
+        end
+        items  = model.where(method.to_sym => /#{search}/i).limit(limit).order_by(order)
+      end
+    end
+  end
+end

data/lib/rails3-jquery-autocomplete/rails/engine.rb

@@ -0,0 +1,5 @@
+module Rails3JQueryAutocomplete
+  module Rails
+    class Engine < ::Rails::Engine ; end
+  end
+end

data/lib/rails3-jquery-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/rails3-jquery-autocomplete/version.rb

@@ -0,0 +1,3 @@
+module Rails3JQueryAutocomplete
+  VERSION = '1.0.4'
+end

data/lib/steak/autocomplete.rb

@@ -0,0 +1,12 @@
+module Steak
+  module Autocomplete
+    def choose_autocomplete_result(text, input_id="input[data-autocomplete]")
+      page.execute_script %Q{ $('#{input_id}').trigger("focus") }
+      page.execute_script %Q{ $('#{input_id}').trigger("keydown") }
+      sleep 1
+      page.execute_script %Q{ $('.ui-menu-item a:contains("#{text}")').trigger("mouseenter").trigger("click"); }
+    end
+  end
+end
+
+RSpec.configuration.include Steak::Autocomplete, :type => :acceptance

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: wf-rails3-jquery-autocomplete
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+  prerelease: 
+platform: ruby
+authors:
+- David Padilla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: mongo_mapper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use jQuery's autocomplete plugin with Rails 3.
+email: david.padilla@crowdint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/assets/javascripts/autocomplete-rails-uncompressed.js
+- lib/assets/javascripts/autocomplete-rails.js
+- lib/cucumber/autocomplete.rb
+- lib/generators/autocomplete/install_generator.rb
+- lib/generators/autocomplete/uncompressed_generator.rb
+- lib/rails3-jquery-autocomplete/autocomplete.rb
+- lib/rails3-jquery-autocomplete/formtastic.rb
+- lib/rails3-jquery-autocomplete/formtastic_plugin.rb
+- lib/rails3-jquery-autocomplete/form_helper.rb
+- lib/rails3-jquery-autocomplete/orm/active_record.rb
+- lib/rails3-jquery-autocomplete/orm/mongoid.rb
+- lib/rails3-jquery-autocomplete/orm/mongo_mapper.rb
+- lib/rails3-jquery-autocomplete/orm.rb
+- lib/rails3-jquery-autocomplete/rails/engine.rb
+- lib/rails3-jquery-autocomplete/simple_form_plugin.rb
+- lib/rails3-jquery-autocomplete/version.rb
+- lib/rails3-jquery-autocomplete.rb
+- lib/steak/autocomplete.rb
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+homepage: http://github.com/crowdint/rails3-jquery-autocomplete
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Use jQuery's autocomplete plugin with Rails 3.
+test_files: []