rails4-autocomplete 1.0.7

data/lib/rails4-autocomplete/simple_form_plugin.rb

@@ -0,0 +1,84 @@
+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-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
+
+      def input
+        @builder.autocomplete_field(
+          attribute_name,
+          options[:url],
+          rewrite_autocomplete_option
+        )
+      end
+
+      protected
+      def limit
+        column && column.limit
+      end
+
+      def has_placeholder?
+        placeholder_present?
+      end
+    end
+
+    class AutocompleteCollectionInput < CollectionInput
+      include Autocomplete
+
+      def input
+        # 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
+        autocomplete_options = rewrite_autocomplete_option
+        #
+        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/rails4-autocomplete/version.rb

@@ -0,0 +1,3 @@
+module Rails4Autocomplete
+  VERSION = '1.0.7'
+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/rails3-jquery-autocomplete/autocomplete_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Rails4Autocomplete
+  class AutocompleteTest < Test::Unit::TestCase
+    include Rails4Autocomplete::Autocomplete
+
+    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
+
+      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

data/test/lib/rails3-jquery-autocomplete/orm/active_record_test.rb

@@ -0,0 +1,145 @@
+require 'test_helper'
+
+module Rails4Autocomplete
+  module Orm
+    class ActiveRecordTest < Test::Unit::TestCase
+      include Rails4Autocomplete::Orm::ActiveRecord
+
+      context "#get_autocomplete_order" do
+        context 'order is specified' do
+          should 'returns that order option' do
+            assert_equal "field ASC", get_autocomplete_order(:field, {:order => 'field ASC'})
+          end
+        end
+
+        context 'no order is specified' do
+          should 'return the order clause by the field ASC' do
+            assert_equal "field ASC", get_autocomplete_order(:field, {})
+          end
+
+          context 'a different model is specified' do
+            should 'return the order clause by the table_name.field ASC' do
+              model = Object.new
+              mock(model).table_name { 'table_name' }
+              assert_equal "table_name.field ASC", get_autocomplete_order(:field, {}, model)
+            end
+          end
+        end
+      end
+
+      context '#get_autocomplete_items' do
+        should 'retrieve the items from ActiveRecord' do
+          class Dog ; end
+
+          model = Dog
+          scoped = []
+          whered = []
+          term = 'query'
+          method = :field
+
+          options = {
+            :model => model,
+            :term => term,
+            :method => method,
+            :options => {}
+          }
+
+          mock(self).get_autocomplete_limit(anything) { 10 }
+          mock(self).get_autocomplete_order(anything, anything, anything) { "order ASC" }
+          mock(self).get_autocomplete_select_clause(model, method, {}) { ["field"] }
+          mock(self).get_autocomplete_where_clause(model, term, method, {}) { ["WHERE something"] }
+          mock(model).table_name.times(any_times) { 'model_table_name' }
+
+          mock(model).scoped { model }
+          mock(model).select(["field"]) { model }
+          mock(model).where(["WHERE something"]).mock!.limit(10).mock!.
+              order("order ASC") { 1 }
+
+          assert_equal 1, get_autocomplete_items(options)
+        end
+      end
+
+      context '#get_autocomplete_select_clause' do
+        setup do
+          @model = Object.new
+          mock(@model).table_name  { 'table_name' }
+          mock(@model).primary_key { 'id' }
+        end
+
+        should 'create a select clause' do
+          assert_equal ["table_name.id", "table_name.method"],
+              get_autocomplete_select_clause(@model, :method, {})
+        end
+
+        context 'with extra options' do
+          should 'return those extra fields on the clause' do
+            options = {:extra_data => ['table_name.created_at']}
+
+            assert_equal ["table_name.id", "table_name.method", "table_name.created_at"],
+                get_autocomplete_select_clause(@model, :method, options)
+          end
+        end
+      end
+
+      context '#get_autocomplete_where_clause' do
+        setup do
+          @model = Object.new
+          mock(@model).table_name { 'table_name' }
+
+          @term = 'query'
+          @options = {}
+          @method = :method
+        end
+
+        context 'Not Postgres' do
+          should 'return options for where' do
+            mock(self).postgres?(@model) { false }
+            assert_equal ["LOWER(table_name.method) LIKE ?", "query%"], get_autocomplete_where_clause(@model, @term, @method, @options)
+          end
+        end
+
+        context 'Postgres' do
+          should 'return options for where with ILIKE' do
+            mock(self).postgres?(@model) { true }
+            assert_equal ["LOWER(table_name.method) ILIKE ?", "query%"], get_autocomplete_where_clause(@model, @term, @method, @options)
+          end
+        end
+
+        context 'full search' do
+          should 'return options for where with the term sourrounded by %%' do
+            mock(self).postgres?(@model) { false }
+            @options[:full] = true
+            assert_equal ["LOWER(table_name.method) LIKE ?", "%query%"], get_autocomplete_where_clause(@model, @term, @method, @options)
+          end
+        end
+      end
+
+      context '#postgres?' do
+        setup do
+          @model = stub
+        end
+
+        context 'the connection class is not postgres' do
+          setup do
+            mock(@model).connection { stub }
+          end
+
+          should 'return nil if the connection class matches PostgreSQLAdapter' do
+            assert_nil self.postgres?(@model)
+          end
+        end
+
+        context 'the connection class matches PostgreSQLAdapter' do
+          setup do
+            class PostgreSQLAdapter; end
+            mock(@model).connection { PostgreSQLAdapter.new }
+          end
+
+          should 'return true' do
+            assert self.postgres?(@model)
+          end
+        end
+      end
+    end
+  end
+end

data/test/lib/rails3-jquery-autocomplete/orm/mongo_mapper_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Rails4Autocomplete
+	module Orm
+		class MongoMapperTest < Test::Unit::TestCase
+			include Rails4Autocomplete::Orm::MongoMapper
+
+			context "#get_autocomplete_order" do
+				context "order is specified" do
+					should 'returns the parametrized order for Mongoid' do
+						assert_equal [[:field, :asc], [:state, :desc]],
+							get_autocomplete_order(:method, :order => 'field ASC, state DESC')
+					end
+				end
+
+				context 'order is not specified' do
+					should 'return the method ordered ASC by default' do
+						assert_equal [[:method, :asc]],
+							get_autocomplete_order(:method, {})
+					end
+				end
+			end
+
+			context "#get_autocomplete_items" do
+				setup do
+					@model = mock(Object)
+
+					@parameters = {
+						:model => @model,
+						:method => :field,
+						:term => 'query',
+						:options => {:full => false}
+					}
+					mock(self).get_autocomplete_limit(anything) { 10 }
+					mock(self).get_autocomplete_order(anything, anything) { [[:order, :asc]] }
+				end
+
+				context 'not a full search' do
+					should 'do stuff' do
+						mock(@model).where({:field=>/^query.*/i}).mock!.limit(10).
+								mock!.sort([[:order, :asc]])
+
+						get_autocomplete_items(@parameters)	
+					end
+				end
+
+				context 'full search' do
+					should 'return a full search query' do
+						@parameters[:options] = {:full => true}
+
+						mock(@model).where({:field => /.*query.*/i}).mock!.limit(10).
+								mock!.sort([[:order, :asc]])
+						
+						get_autocomplete_items(@parameters)	
+					end
+				end
+			end
+		end
+	end
+end