rails3-jquery-autocomplete 0.8.0 → 0.9.0

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

@@ -0,0 +1,30 @@
+module Rails3JQueryAutocomplete
+  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/rails3-jquery-autocomplete/version.rb

@@ -1,3 +1,3 @@
 module Rails3JQueryAutocomplete
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/rails3-jquery-autocomplete.gemspec

@@ -13,7 +13,6 @@ Gem::Specification.new do |s|
   s.description = %q{Use jQuery's autocomplete plugin with Rails 3.}
 
   s.add_dependency('rails', '~>3.0')
-  s.add_dependency('yajl-ruby')
 
   s.add_development_dependency('sqlite3-ruby')
   s.add_development_dependency('mongoid', '>= 2.0.0')
@@ -21,6 +20,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency('bson_ext', '~>1.3.0')
   s.add_development_dependency('shoulda', '~>2.11.1')
   s.add_development_dependency('uglifier')
+  s.add_development_dependency('rr')
+  s.add_development_dependency('rcov')
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/test/generators/autocomplete/install_generator_test.rb

@@ -10,7 +10,7 @@ module Autocomplete
 
       File.unlink(@filename) if File.exists?(@filename)
 
-      InstallGenerator.start('', :destination_root => @destination)
+      InstallGenerator.start([], :destination_root => @destination)
     end
 
     def test_install

data/test/generators/autocomplete/uncompressed_generator_test.rb

@@ -10,14 +10,14 @@ module Autocomplete
 
       File.unlink(@filename) if File.exists?(@filename)
 
-      InstallGenerator.start('', :destination_root => @destination)
+      UncompressedGenerator.start([], :destination_root => @destination)
     end
 
     def test_install
       assert File.exists?(@filename)
 
       assert_equal(
-          File.read(File.join(@source, 'autocomplete-rails.js')),
+          File.read(File.join(@source, 'autocomplete-rails-uncompressed.js')),
           File.read(@filename)
       )
     end

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

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+  class AutocompleteTest < Test::Unit::TestCase
+    include Rails3JQueryAutocomplete::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,130 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+	module Orm
+		class ActiveRecordTest < Test::Unit::TestCase
+			include Rails3JQueryAutocomplete::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? { 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? { 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? { 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
+				should 'return nil if PGConn is not defined' do
+					assert_nil self.postgres?
+				end
+
+				should 'return true if PGConn is defined' do
+					class ::PGConn ; end
+
+					assert self.postgres?
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+	module Orm
+		class MongoMapperTest < Test::Unit::TestCase
+			include Rails3JQueryAutocomplete::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

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

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+	module Orm
+		class MongoidTest < Test::Unit::TestCase
+			include Rails3JQueryAutocomplete::Orm::Mongoid
+
+			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!.order_by([[: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!.order_by([[:order, :asc]])
+						
+						get_autocomplete_items(@parameters)	
+					end
+				end
+			end
+		end
+	end
+end

data/test/lib/rails3-jquery-autocomplete_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+  class Rails3JQueryAutocompleteTest < ActionController::TestCase
+    ActorsController = Class.new(ActionController::Base)
+    ActorsController.autocomplete(:movie, :name)
+
+    class ::Movie ; end
+
+    context '#autocomplete_object_method' do
+      setup do
+        @controller = ActorsController.new
+        @items = {}
+        @options = { :display_value => :name }
+      end
+
+      should 'respond to the action' do
+        assert_respond_to @controller, :autocomplete_movie_name
+      end
+
+      should 'render the JSON items' do
+        mock(@controller).get_autocomplete_items({
+          :model => Movie, :method => :name, :options => @options, :term => "query"
+        }) { @items }
+
+        mock(@controller).json_for_autocomplete(@items, :name, nil)
+        get :autocomplete_movie_name, :term => 'query'
+      end
+
+      context 'no term is specified' do
+        should "render an empty hash" do
+          mock(@controller).json_for_autocomplete({}, :name, nil)
+          get :autocomplete_movie_name
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -10,6 +10,7 @@ require 'rails/all'
 require 'mongoid'
 require 'mongo_mapper'
 require 'shoulda'
+require 'rr'
 require 'rails/test_help'
 require 'rails3-jquery-autocomplete'
 
@@ -24,5 +25,7 @@ end
 
 ActionController::Base.send :include, Rails3JQueryAutocomplete::Application.routes.url_helpers
 
-ActorsController = Class.new(ActionController::Base)
-ActorsController.autocomplete(:movie, :name)
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+