rails-autocomplete 1.1.0

data/lib/rails-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 RailsJQueryAutocomplete::FormtasticPlugin
+    end
+  end
+rescue LoadError
+end

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

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

@@ -0,0 +1,6 @@
+module RailsJQueryAutocomplete
+  module Orm
+    autoload :ActiveRecord , 'rails-jquery-autocomplete/orm/active_record'
+  end
+end
+

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

@@ -0,0 +1,83 @@
+module RailsJQueryAutocomplete
+  module Orm
+    module ActiveRecord
+      def active_record_get_autocomplete_order(method, options, model=nil)
+        order = options[:order]
+
+        table_prefix = model ? "#{model.table_name}." : ""
+        if sqlite?
+          order || "LOWER(#{method}) ASC"
+        else
+          order || "LOWER(#{table_prefix}#{method}) ASC"
+        end
+      end
+
+      def active_record_get_autocomplete_items(parameters)
+        model   = parameters[:model]
+        term    = parameters[:term]
+        options = parameters[:options]
+        method  = options[:hstore] ? options[:hstore][:method] : parameters[:method]
+        scopes  = Array(options[:scopes])
+        where   = options[:where]
+        limit   = get_autocomplete_limit(options)
+        order   = active_record_get_autocomplete_order(method, options, model)
+
+        items = (::Rails::VERSION::MAJOR * 10 + ::Rails::VERSION::MINOR) >= 40 ? model.where(nil) : 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)
+        items = items.where(where) unless where.blank?
+
+        items
+      end
+
+      def get_autocomplete_select_clause(model, method, options)
+        if sqlite?
+          table_name = model.quoted_table_name
+          ([
+              "#{table_name}.#{model.connection.quote_column_name(model.primary_key)} as #{model.primary_key}",
+              "#{table_name}.#{model.connection.quote_column_name(method)} as #{method}"
+            ] + (options[:extra_data].blank? ? [] : options[:extra_data]))
+        else
+          table_name = model.table_name
+          (["#{table_name}.#{model.primary_key}", "#{table_name}.#{method}"] + (options[:extra_data].blank? ? [] : options[:extra_data]))
+        end
+      end
+
+      def get_autocomplete_where_clause(model, term, method, options)
+        table_name = model.table_name
+        is_full_search = options[:full]
+        is_case_sensitive_search = options[:case_sensitive]
+        like_clause = (postgres?(model) && !is_case_sensitive_search ? 'ILIKE' : 'LIKE')
+        column_transform = is_case_sensitive_search ? '' : 'LOWER'
+        term = "#{(is_full_search ? '%' : '')}#{term.gsub(/([_%\\])/, '\\\\\1')}%"
+        if options[:hstore]
+          ["#{column_transform}(#{table_name}.#{method} -> '#{options[:hstore][:key]}') LIKE #{column_transform}(?)", term]
+        elsif sqlite?
+          ["#{column_transform}(#{method}) #{like_clause} #{column_transform}(?)", term]
+        else
+          ["#{column_transform}(#{table_name}.#{method}) #{like_clause} #{column_transform}(?)", term]
+        end
+      end
+
+      protected
+
+        def sqlite?
+          begin
+            return ::ActiveRecord::Base.connection.to_s.match(/SQLite/)
+          rescue ::ActiveRecord::ConnectionNotEstablished
+            return false
+          end
+          return false
+        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/rails-jquery-autocomplete/rails/engine.rb

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

data/lib/rails-jquery-autocomplete/simple_form_plugin.rb

@@ -0,0 +1,100 @@
+module SimpleForm
+  module Inputs
+    module Autocomplete
+      #
+      # Method used to rename the autocomplete key to a more standard
+      # data-autocomplete key
+      #
+      def rewrite_autocomplete_option
+        new_options = {}
+        new_options["data-autocomplete-fields"] = JSON.generate(options.delete :fields) if options[:fields]
+        new_options["data-update-elements"] = JSON.generate(options.delete :update_elements) if options[:update_elements]
+        new_options["data-id-element"] = options.delete :id_element if options[:id_element]
+        input_html_options.merge new_options
+      end
+    end
+
+    class AutocompleteInput < Base
+      include Autocomplete
+
+      protected
+      def limit
+        column && column.limit
+      end
+
+      def has_placeholder?
+        placeholder_present?
+      end
+
+      def input(args = nil)
+        # This branching is to deal with a change beginning in simple_form 3.0.2 and above to ensure backwards compatibility
+        if args.nil?
+          @builder.autocomplete_field(
+            attribute_name,
+            options[:url],
+            rewrite_autocomplete_option
+          )
+        else
+          @builder.autocomplete_field(
+            attribute_name,
+            options[:url],
+            merge_wrapper_options(rewrite_autocomplete_option, args)
+          )
+        end
+      end
+    end
+
+    class AutocompleteCollectionInput < CollectionInput
+      include Autocomplete
+
+      def input(opts)
+        # http://www.codeofficer.com/blog/entry/form_builders_in_rails_discovering_field_names_and_ids_for_javascript/
+        hidden_id = "#{object_name}_#{attribute_name}_hidden".gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+        id_element = options[:id_element]
+        if id_element
+          id_element << ", #" << hidden_id
+        else
+          id_element = "#" + hidden_id
+        end
+        options[:id_element] = id_element
+
+        # This branching is to deal with a change beginning in simple_form 3.0.2 and above to ensure backwards compatibility
+        if opts.nil?
+          autocomplete_options = rewrite_autocomplete_option
+        else
+          merge_wrapper_options(rewrite_autocomplete_option, args)
+        end
+
+        label_method, value_method = detect_collection_methods
+        association = object.send(reflection.name)
+        if association && association.respond_to?(label_method)
+          autocomplete_options[:value] = association.send(label_method)
+        end
+        out = @builder.autocomplete_field(
+          attribute_name,
+          options[:url],
+          autocomplete_options
+        )
+        hidden_options = if association && association.respond_to?(value_method)
+          new_options = {}
+          new_options[:value] = association.send(value_method)
+          input_html_options.merge new_options
+        else
+          input_html_options
+        end
+        hidden_options[:id] = hidden_id
+        out << @builder.hidden_field(
+          attribute_name,
+          hidden_options
+        )
+        out.html_safe
+      end
+    end
+  end
+
+  class FormBuilder
+    map_type :autocomplete, :to => SimpleForm::Inputs::AutocompleteInput
+    map_type :autocomplete_collection, :to => SimpleForm::Inputs::AutocompleteCollectionInput
+  end
+
+end

data/lib/rails-jquery-autocomplete/version.rb

@@ -0,0 +1,3 @@
+module RailsJQueryAutocomplete
+  VERSION = '1.1.0'
+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

data/test/form_helper_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class Post
+  attr_accessor :author
+end
+
+class FormHelperTest < ActionView::TestCase
+  def test_text_field_tag
+    assert_match(/autocomplete=\"some\/path\"/, text_field_tag('field_name', '', :autocomplete => 'some/path'))
+  end
+
+  def test_text_field
+    post = Post.new
+    assert_match(/autocomplete=\"some\/path\"/, text_field(:post, :author, :autocomplete => 'some/path'))
+  end
+
+  def test_autocomplete_field_tag
+    assert_match(/data-autocomplete=\"some\/path\"/, autocomplete_field_tag('field_name', '', 'some/path'))
+  end
+
+  def test_autocomplete_field
+    post= Post.new
+    assert_match(/data-autocomplete=\"some\/path\"/, autocomplete_field(:post, :author, 'some/path'))
+  end
+end

data/test/generators/autocomplete/install_generator_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'generators/autocomplete/install_generator'
+
+module Autocomplete
+  class InstallGeneratorTest < Test::Unit::TestCase
+    def setup
+      @destination = File.join('tmp', 'test_app')
+      @source      = InstallGenerator.source_root
+      @filename    = File.join(@destination, 'public', 'javascripts', 'autocomplete-rails.js')
+
+      File.unlink(@filename) if File.exists?(@filename)
+
+      InstallGenerator.start([], :destination_root => @destination)
+    end
+
+    def test_install
+      assert File.exists?(@filename)
+
+      assert_equal(
+          File.read(File.join(@source, 'autocomplete-rails.js')),
+          File.read(@filename)
+      )
+    end
+  end
+end

data/test/generators/autocomplete/uncompressed_generator_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'generators/autocomplete/uncompressed_generator'
+
+module Autocomplete
+  class UncompressedGeneratorTest < Test::Unit::TestCase
+    def setup
+      @destination = File.join('tmp', 'test_app')
+      @source      = UncompressedGenerator.source_root
+      @filename    = File.join(@destination, 'public', 'javascripts', 'autocomplete-rails.js')
+
+      File.unlink(@filename) if File.exists?(@filename)
+
+      UncompressedGenerator.start([], :destination_root => @destination)
+    end
+
+    def test_install
+      assert File.exists?(@filename)
+
+      assert_equal(
+          File.read(File.join(@source, 'autocomplete-rails-uncompressed.js')),
+          File.read(@filename)
+      )
+    end
+  end
+end

data/test/lib/rails-jquery-autocomplete/autocomplete_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+module RailsJQueryAutocomplete
+  class AutocompleteTest < Test::Unit::TestCase
+    include RailsJQueryAutocomplete::Autocomplete
+
+    context 'ClassMethods' do
+      context '#autocomplete' do
+        context '#get_prefix' do
+          context 'Mongoid and MongoMapper is not defined' do
+            setup do
+              ActorsController = Class.new(ActionController::Base)
+              ActorsController.autocomplete(:movie, :name)
+              @controller = ActorsController.new
+
+              @model = Class.new(ActiveRecord::Base)
+
+              Object.send(:remove_const, :Mongoid)
+              Object.send(:remove_const, :MongoMapper)
+            end
+
+            should 'not raise exception' do
+              @controller.get_prefix(@model)
+            end
+          end
+        end
+      end
+    end
+
+    context '#get_autocomplete_limit' do
+      context 'the limit option was specified' do
+        should "return the limit option" do
+          assert_equal 99, get_autocomplete_limit({:limit => 99})
+        end
+      end
+
+      context 'the limit option is not specified' do
+        should 'return 10' do
+          assert_equal 10, get_autocomplete_limit({})
+        end
+      end
+    end
+
+    context '#get_object' do
+      should 'return the specified sym as a class name' do
+        symbol = Object.new
+        class_object = Class.new
+        mock(symbol).to_s.mock!.camelize.mock!.constantize { class_object }
+        assert_equal class_object, get_object(symbol)
+      end
+    end
+
+    context '#json_for_autocomplete' do
+      should 'parse items to JSON' do
+        item = mock(Object)
+        mock(item).send(:name).times(2) { 'Object Name' }
+        mock(item).id { 1 }
+        items    = [item]
+        response = self.json_for_autocomplete(items, :name).first
+        assert_equal response["id"], "1"
+        assert_equal response["value"], "Object Name"
+        assert_equal response["label"], "Object Name"
+      end
+
+      should 'return an instance of HashWithIndifferentAccess' do
+        item = mock(Object)
+        mock(item).send(:name).times(2) { 'Object Name' }
+        mock(item).id { 1 }
+        items    = [item]
+        response = self.json_for_autocomplete(items, :name).first
+        assert_equal response.is_a?(HashWithIndifferentAccess), true
+        assert_equal response["id"], "1"
+        assert_equal response[:id], "1"
+      end
+
+      context 'with extra data' do
+        should 'add that extra data to result' do
+          item = mock(Object)
+          mock(item).send(:name).times(2) { 'Object Name' }
+          mock(item).id { 1 }
+          mock(item).send("extra") { 'Object Extra ' }
+
+          items    = [item]
+          response = self.json_for_autocomplete(items, :name, ["extra"]).first
+
+          assert_equal "1"           , response["id"]
+          assert_equal "Object Name" , response["value"]
+          assert_equal "Object Name" , response["label"]
+        end
+      end
+    end
+  end
+end