rails4-autocomplete 1.0.7

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">
+*/
+(function(e){var t=null;e.fn.railsAutocomplete=function(){var t=function(){this.railsAutoCompleter||(this.railsAutoCompleter=new e.railsAutocomplete(this))};return e.fn.on!==undefined?$(document).on("focus",this.selector,t):this.live("focus",t)},e.railsAutocomplete=function(e){_e=e,this.init(_e)},e.railsAutocomplete.fn=e.railsAutocomplete.prototype={railsAutocomplete:"0.0.1"},e.railsAutocomplete.fn.extend=e.railsAutocomplete.extend=e.extend,e.railsAutocomplete.fn.extend({init:function(t){function n(e){return e.split(t.delimiter)}function r(e){return n(e).pop().replace(/^\s+/,"")}t.delimiter=e(t).attr("data-delimiter")||null,e(t).autocomplete({source:function(n,i){e.getJSON(e(t).attr("data-autocomplete"),{term:r(n.term)},function(){arguments[0].length==0&&(arguments[0]=[],arguments[0][0]={id:"",label:"no existing match"}),e(arguments[0]).each(function(n,r){var i={};i[r.id]=r,e(t).data(i)}),i.apply(null,arguments)})},change:function(t,n){if(e(e(this).attr("data-id-element")).val()=="")return;e(e(this).attr("data-id-element")).val(n.item?n.item.id:"");var r=e.parseJSON(e(this).attr("data-update-elements")),i=n.item?e(this).data(n.item.id.toString()):{};if(r&&e(r["id"]).val()=="")return;for(var s in r)e(r[s]).val(n.item?i[s]:"")},search:function(){var e=r(this.value);if(e.length<2)return!1},focus:function(){return!1},select:function(r,i){var s=n(this.value);s.pop(),s.push(i.item.value);if(t.delimiter!=null)s.push(""),this.value=s.join(t.delimiter);else{this.value=s.join(""),e(this).attr("data-id-element")&&e(e(this).attr("data-id-element")).val(i.item.id);if(e(this).attr("data-update-elements")){var o=e(this).data(i.item.id.toString()),u=e.parseJSON(e(this).attr("data-update-elements"));for(var a in u)e(u[a]).val(o[a])}}var f=this.value;return e(this).bind("keyup.clearId",function(){e(this).val().trim()!=f.trim()&&(e(e(this).attr("data-id-element")).val(""),e(this).unbind("keyup.clearId"))}),e(t).trigger("railsAutocomplete.select",i),!1}})}}),e(document).ready(function(){e("input[data-autocomplete]").railsAutocomplete()})})(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/rails4-autocomplete.rb

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

data/lib/rails4-autocomplete/autocomplete.rb

@@ -0,0 +1,96 @@
+module Rails4Autocomplete
+  module Autocomplete
+    def self.included(target)
+      target.extend Rails4Autocomplete::Autocomplete::ClassMethods
+
+      if defined?(Mongoid::Document)
+        target.send :include, Rails4Autocomplete::Orm::Mongoid
+      elsif defined?(MongoMapper::Document)
+        target.send :include, Rails4Autocomplete::Orm::MongoMapper
+      else
+        target.send :include, Rails4Autocomplete::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/rails4-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/rails4-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 Rails4Autocomplete::FormtasticPlugin
+    end
+  end
+rescue LoadError
+end

data/lib/rails4-autocomplete/formtastic_plugin.rb

@@ -0,0 +1,44 @@
+module Rails4Autocomplete
+  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/rails4-autocomplete/orm.rb

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

data/lib/rails4-autocomplete/orm/active_record.rb

@@ -0,0 +1,52 @@
+module Rails4Autocomplete
+  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])
+        where   = options[:where]
+        limit   = get_autocomplete_limit(options)
+        order   = get_autocomplete_order(method, options, model)
+
+
+        items = model.all
+
+        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)
+        items = items.where(where) unless where.blank?
+
+        items
+      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?(model) ? 'ILIKE' : 'LIKE')
+        ["LOWER(#{table_name}.#{method}) #{like_clause} ?", "#{(is_full_search ? '%' : '')}#{term.downcase}%"]
+      end
+
+      def postgres?(model)
+        # Figure out if this particular model uses the PostgreSQL adapter
+        model.connection.class.to_s.match(/PostgreSQLAdapter/)
+      end
+    end
+  end
+end

data/lib/rails4-autocomplete/orm/mongo_mapper.rb

@@ -0,0 +1,30 @@
+module Rails4Autocomplete
+	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/rails4-autocomplete/orm/mongoid.rb

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

data/lib/rails4-autocomplete/rails/engine.rb

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