magic_grid 0.10.4 → 0.11.0

data/lib/assets/javascripts/magic_grid.js

@@ -95,10 +95,10 @@ $(function () {
                     current = $input.data("current"),
                     value = $input.val(),
                     length = value.length,
-                    base_url = base_url.split("?", 2)[0],
+                    base_url_path = base_url.split("?", 2)[0],
                     relevant = is_manual || (value != current && (length >= minLength || length == 0)),
                     pos = $input.getCursor(),
-                    url = base_url + '?' + $.param($grid.getGridParams());
+                    url = base_url_path + '?' + $.param($grid.getGridParams());
                 clearTimeout(timer);
                 if (relevant) {
                     $grid.trigger("magic_grid:loading");

data/lib/magic_grid.rb

@@ -1,7 +1 @@
-module MagicGrid
-  if ::Rails.version < "3.1"
-    require 'magic_grid/railtie'
-  else
-    require 'magic_grid/engine'
-  end
-end
+require 'magic_grid/engine'

data/lib/magic_grid/collection.rb

@@ -0,0 +1,187 @@
+require 'active_support/core_ext'
+require 'magic_grid/logger'
+
+module MagicGrid
+  class Collection
+
+    def initialize(collection, grid)
+      @collection = collection
+      @grid = grid
+      @current_page = 1
+      @sorts = []
+      @filter_callbacks = []
+      @filters = []
+      @searches = []
+      @post_filters = []
+      @post_filter_callbacks = []
+      @paginations = []
+    end
+
+    delegate :map, :count, :to => :collection
+
+    attr_accessor :grid
+    attr_reader :current_page, :original_count, :total_pages
+
+    def self.[](collection, grid)
+      if collection.is_a?(self)
+        collection.grid = grid
+        collection
+      else
+        Collection.new(collection, grid)
+      end
+    end
+
+    def quote_column_name(col)
+      @collection.connection.quote_column_name(col.to_s)
+    end
+
+    def search_using_builtin(collection, q)
+      collection.__send__(@grid.options[:search_method], q)
+    end
+
+    def search_using_where(collection, q)
+      result = collection
+      search_cols = @grid.options[:searchable].map do |searchable|
+        case searchable
+        when Symbol
+          known = @grid.columns.find {|col| col[:col] == searchable}
+          if known and known.key?(:sql)
+            known[:sql]
+          else
+            "#{@collection.table_name}.#{quote_column_name(searchable)}"
+          end
+        when Integer
+          @grid.columns[searchable][:sql]
+        when String
+          searchable
+        else
+          raise "Searchable must be identifiable"
+        end
+      end
+
+      unless search_cols.empty?
+        begin
+          clauses = search_cols.map {|c| c << " LIKE :search" }.join(" OR ")
+          result = collection.where(clauses, {:search => "%#{q}%"})
+        rescue
+          MagicGrid.logger.debug "Given collection doesn't respond to :where well"
+        end
+      end
+      result
+    end
+
+    def sortable?
+      @collection.respond_to?(:order)
+    end
+
+    def apply_sort(col, dir)
+      @sorts << "#{col} #{dir}"
+      self
+    end
+
+    def searchable?
+      filterable? or @collection.respond_to? @grid.options[:search_method]
+    end
+
+    def apply_search(q)
+      @searches << q
+      self
+    end
+
+    def perform_search(collection, q)
+      search_using_builtin(collection, q)
+    rescue
+      MagicGrid.logger.debug "Given collection doesn't respond to #{@grid.options[:search_method]} well"
+      search_using_where(collection, q)
+    end
+
+    def filterable?
+      @collection.respond_to? :where
+    end
+
+    def apply_filter(filters = {})
+      if @collection.respond_to? :where
+        @filters << filters
+      end
+      self
+    end
+
+    def apply_filter_callback(callback)
+      if callback.respond_to? :call
+        @filter_callbacks << callback
+      end
+      self
+    end
+
+    def has_post_filter?
+      @collection.respond_to? :post_filter
+    end
+
+    def apply_post_filter
+      @post_filters << :post_filter
+      self
+    end
+
+    def apply_pagination(current_page, per_page)
+      if per_page
+        @paginations << {:current_page => current_page, :per_page => per_page}
+      end
+      self
+    end
+
+    def perform_pagination(collection, current_page, per_page)
+      @original_count = @collection.count
+      @total_pages = @original_count / per_page
+      @current_page = current_page
+      if collection.respond_to? :paginate
+        collection = collection.paginate(:page => current_page,
+                                           :per_page => per_page)
+      elsif collection.respond_to? :page
+        collection = collection.page(current_page).per(per_page)
+      elsif collection.is_a?(Array) and Module.const_defined?(:Kaminari)
+        collection = Kaminari.paginate_array(collection).page(current_page).per(per_page)
+      else
+        collection = collection.to_enum
+        collection = collection.each_slice(per_page)
+        collection = collection.drop(current_page - 1)
+        collection = collection.first.to_a
+        class << collection
+          attr_accessor :current_page, :total_pages, :original_count
+        end
+      end
+      collection
+    end
+
+    def apply_all_operations(collection)
+      @sorts.each do |ordering|
+        collection = collection.order(ordering)
+      end
+      @filter_callbacks.each do |callback|
+        collection = callback.call(collection)
+      end
+      @filters.each do |hsh|
+        collection = collection.where(hsh)
+      end
+      @searches.each do |query|
+        collection = perform_search(collection, query)
+      end
+      @post_filters.each do |filter|
+        collection = collection.__send__(filter)
+      end
+      @post_filter_callbacks.each do |callback|
+        collection = callback.call(collection)
+      end
+      @paginations.each do |params|
+        collection = perform_pagination(collection, params[:current_page], params[:per_page])
+      end
+      collection
+    end
+
+    def collection
+      @reduced_collection ||= apply_all_operations(@collection)
+    end
+
+
+
+  end
+end

data/lib/magic_grid/definition.rb

@@ -1,18 +1,22 @@
-#require 'will_paginate/view_helpers/action_view'
+require 'magic_grid/logger'
+require 'magic_grid/collection'
 
 module MagicGrid
   class Definition
-    #include WillPaginate::ActionView
-    attr_accessor :columns, :collection, :magic_id, :options, :params,
+    attr_reader :columns, :magic_id, :options, :params,
       :current_sort_col, :current_order, :default_order, :per_page
 
+    def collection
+      @collection.collection
+    end
+
     DEFAULTS = {
       :class => [],
       :top_pager => false,
       :bottom_pager => true,
       :remote => false,
       :per_page => 30,
-      :searchable => false,
+      :searchable => [],
       :search_method => :search,
       :min_search_length => 3,
       :id => false,
@@ -56,13 +60,13 @@ module MagicGrid
       @default_order = @options[:default_order]
       @params = controller && controller.params || {}
       @per_page = @options[:per_page]
-      @collection = collection
+      @collection = Collection[collection, self]
       begin
         #if @collection.respond_to? :table
         table_name = @collection.quoted_table_name
         table_columns = @collection.table.columns.map {|c| c.name}
       rescue
-        Rails.logger.debug "Given collection doesn't respond to :table well"
+        MagicGrid.logger.debug "Given collection doesn't respond to :table well"
         table_name = nil
         table_columns = @columns.each_index.to_a
       end
@@ -90,107 +94,69 @@ module MagicGrid
         @magic_id << @collection.to_sql.hash.abs.to_s(36) if @collection.respond_to? :to_sql
       end
       @current_sort_col = sort_col_i = param(:col, @options[:default_col]).to_i
-      if @collection.respond_to?(:order) and @columns.count > sort_col_i and @columns[sort_col_i].has_key?(:sql)
+      if @collection.sortable? and @columns.count > sort_col_i and @columns[sort_col_i].has_key?(:sql)
         sort_col = @columns[sort_col_i][:sql]
         @current_order = order(param(:order, @default_order))
         sort_dir = order_sql(@current_order)
-        @collection = @collection.order("#{sort_col} #{sort_dir}")
+        @collection.apply_sort(sort_col, sort_dir)
       else
-        Rails.logger.debug "#{self.class.name}: Ignoring sorting on non-AR collection"
+        MagicGrid.logger.debug "#{self.class.name}: Ignoring sorting on non-AR collection"
       end
 
-      @options[:searchable] = [] if @options[:searchable] and not @options[:searchable].kind_of? Array
-
-      if @collection.respond_to?(:where) or @options[:listener_handler].respond_to?(:call)
+      if @collection.filterable? or @options[:listener_handler].respond_to?(:call)
         if @options[:listener_handler].respond_to? :call
-          @collection = @options[:listener_handler].call(@collection)
+          @collection.apply_filter_callback @options[:listener_handler]
         else
           @options[:listeners].each_pair do |key, value|
             if @params[value] and not @params[value].to_s.empty?
-              @collection = @collection.where(value => @params[value])
+              @collection.apply_filter(value => @params[value])
             end
           end
         end
       else
         unless @options[:listeners].empty?
-          Rails.logger.warn "#{self.class.name}: Ignoring listener on dumb collection"
+          MagicGrid.logger.warn "#{self.class.name}: Ignoring listener on dumb collection"
           @options[:listeners] = {}
         end
       end
+
+      @options[:searchable] = Array(@options[:searchable])
       @options[:current_search] ||= param(:q)
-      if (@collection.respond_to?(:where) or
-          (@options[:search_method] and @collection.respond_to?(@options[:search_method])))
-        if param(:q) and not param(:q).empty? and @options[:searchable]
-          orig_collection = @collection
-          begin
-            @collection = @collection.__send__(@options[:search_method], param(:q))
-          rescue
-            Rails.logger.debug "Given collection doesn't respond to #{@options[:search_method]} well"
-            @collection = orig_collection
-            search_cols = @options[:searchable].map do |searchable|
-              case searchable
-              when Symbol
-                known = @columns.find {|col| col[:col] == searchable}
-                if known and known.key?(:sql)
-                  known[:sql]
-                else
-                  "#{table_name}.#{@collection.connection.quote_column_name(searchable.to_s)}"
-                end
-              when Integer
-                @columns[searchable][:sql]
-              when String
-                searchable
-              else
-                raise "Searchable must be identifiable"
-              end
-            end
-            unless search_cols.empty?
-              begin
-                clauses = search_cols.map {|c| c << " LIKE :search" }.join(" OR ")
-                @collection = @collection.where(clauses, {:search => "%#{param(:q)}%"})
-              rescue
-                Rails.logger.debug "Given collection doesn't respond to :where well"
-                @collection = orig_collection
-              end
-            end
-          end
+      if @collection.searchable?
+        if param(:q) and not param(:q).empty? and not @options[:searchable].empty?
+          @collection.apply_search(param(:q))
         end
       else
-        if @options[:searchable] or param(:q)
-          Rails.logger.warn "#{self.class.name}: Ignoring searchable fields on non-AR collection"
+        if not @options[:searchable].empty? or param(:q)
+          MagicGrid.logger.warn "#{self.class.name}: Ignoring searchable fields on non-AR collection"
         end
-        @options[:searchable] = false
-      end
-      if not @options[:searcher] and @options[:searchable]
-        @options[:needs_searcher] = true
-        @options[:searcher] = param_key(:searcher)
+        @options[:searchable] = []
       end
+
       # Do collection filter first, may convert from AR to Array
-      if @options[:collection_post_filter?] and @collection.respond_to?(:post_filter)
-        @collection = @collection.post_filter(controller)
+      if @options[:collection_post_filter?] and @collection.has_post_filter?
+        @collection.apply_post_filter
       end
       if @options[:post_filter] and @options[:post_filter].respond_to?(:call)
-        @collection = @options[:post_filter].call(@collection)
+        @collection.apply_filter_callback @options[:post_filter]
       end
       # Paginate at the very end, after all sorting, filtering, etc..
-      if @per_page
-        if @collection.respond_to? :paginate
-          @collection = @collection.paginate(:page => current_page,
-                                             :per_page => @per_page)
-        elsif @collection.respond_to? :page
-          @collection = @collection.page(current_page).per(@per_page)
-        elsif @collection.is_a?(Array) and Module.const_defined?(:Kaminari)
-          @collection = Kaminari.paginate_array(@collection).page(current_page).per(@per_page)
-        else
-          original = @collection
-          @collection = @collection.to_enum.each_slice(@per_page).drop(current_page - 1).first.to_a
-          class << @collection
-            attr_accessor :current_page, :total_pages, :original_count
-          end
-          @collection.current_page = current_page
-          @collection.original_count = original.count
-          @collection.total_pages = original.count / @per_page
-        end
+      @collection.apply_pagination(current_page, @per_page)
+    end
+
+    def searchable?
+      @collection.searchable? and not @options[:searchable].empty?
+    end
+
+    def needs_searcher?
+      @options[:needs_searcher] or (searchable? and not @options[:searcher])
+    end
+
+    def searcher
+      if needs_searcher?
+        param_key(:searcher)
+      else
+        @options[:searcher]
       end
     end
 

data/lib/magic_grid/engine.rb

@@ -1,3 +1,5 @@
+require 'magic_grid/logger'
+
 module MagicGrid
   class Engine < ::Rails::Engine
     # Once in production, on every page view in development
@@ -10,5 +12,9 @@ module MagicGrid
       # Provide some fallback translations that users can override
       app.config.i18n.load_path += Dir.glob(File.expand_path('../../locales/*.{rb,yml}', __FILE__))
     end
+
+    initializer "Rails logger" do
+      MagicGrid.logger = Rails.logger
+    end
   end
 end

data/lib/magic_grid/helpers.rb

@@ -4,29 +4,23 @@ if Module.const_defined? :WillPaginate
   require 'will_paginate/array'
 end
 
+def MagicGrid::compact_hash(hash)
+  hash.select {|_,v| v }
+end
+
 module MagicGrid
   module Helpers
     def normalize_magic(collection, columns = [], options = {})
-      if collection.is_a? MagicGrid::Definition
-        collection
-      elsif columns.is_a? MagicGrid::Definition
-        columns
-      elsif options.is_a? MagicGrid::Definition
-        options
-      else
-        MagicGrid::Definition.new(columns, collection, controller, options)
-      end
-    end
-
-    def magic_collection(collection, cols, opts = {})
-      normalize_magic(collection, cols, opts).collection
+      args_enum = [collection, columns, options].to_enum
+      given_grid = args_enum.find {|e| e.is_a? MagicGrid::Definition }
+      given_grid || MagicGrid::Definition.new(columns, collection, controller, options)
     end
 
     def magic_grid(collection = nil, cols = nil, opts = {}, &block)
       grid = normalize_magic(collection, cols, opts)
       base_params = grid.base_params
       data = {
-        :searcher => grid.options[:searcher],
+        :searcher => grid.searcher,
         :current => controller.request.fullpath,
         :live_search => grid.options[:live_search],
         :listeners => (grid.options[:listeners] unless grid.options[:listeners].empty?),
@@ -38,7 +32,7 @@ module MagicGrid
       content_tag('table',
                   :class => classes.join(' '),
                   :id => grid.magic_id,
-                  :data => data.select {|_,v| v }
+                  :data => MagicGrid.compact_hash(data)
                   ) do
         table = content_tag('thead', :data => {:params => base_params}
                            ) do
@@ -48,7 +42,7 @@ module MagicGrid
                         :id => (grid.magic_id.to_s + "_spinner"),
                         :class => "magic_grid_spinner"
                        )
-          if grid.options[:needs_searcher]
+          if grid.needs_searcher?
             thead << content_tag('tr') do
               content_tag('td', :class => 'searcher full-width ui-widget-header',
                           :colspan => grid.columns.count) do
@@ -62,18 +56,10 @@ module MagicGrid
             end
           end
           if grid.options[:per_page] and grid.options[:top_pager]
-            thead << content_tag('tr') do
-              content_tag('td', :class => 'full-width ui-widget-header',
-                          :colspan => grid.columns.count) do
-                pager = magic_paginate(grid.collection,
-                                      :param_name => grid.param_key(:page),
-                                      :params => base_params
-                                     )
-                unless has_spinner
-                  has_spinner = true
-                  pager << spinner
-                end
-                pager
+            thead << magic_pager(grid, base_params) do
+              unless has_spinner
+                has_spinner = true
+                spinner
               end
             end
           end
@@ -96,15 +82,7 @@ module MagicGrid
         table << content_tag('tfoot') do
           tfoot = ''.html_safe
           if grid.options[:per_page] and grid.options[:bottom_pager]
-            tfoot << content_tag('tr') do
-              content_tag('td', :class => 'full-width ui-widget-header',
-                          :colspan => grid.columns.count) do
-                magic_paginate(grid.collection,
-                              :param_name => grid.param_key(:page),
-                              :params => base_params
-                             )
-              end
-            end
+            tfoot << magic_pager(grid, base_params)
           end
           if tfoot.empty? and not grid.options[:empty_footer]
             tfoot = content_tag 'tr' do
@@ -231,9 +209,9 @@ module MagicGrid
         :min_length => grid.options[:min_search_length],
         :current => grid.options[:current_search] || "",
       }
-      searcher = label_tag(grid.options[:searcher].to_sym,
-        grid.options[:searcher_label])
-      searcher << search_field_tag(grid.options[:searcher].to_sym,
+      searcher = label_tag(grid.searcher.to_sym,
+                           grid.options[:searcher_label])
+      searcher << search_field_tag(grid.searcher.to_sym,
         grid.param(:q),
         :placeholder => grid.options[:searcher_tooltip],
         :size => grid.options[:searcher_size],
@@ -261,6 +239,20 @@ module MagicGrid
       end
     end
 
+    def magic_pager(grid, base_params, &block)
+      content_tag('tr') do
+        content_tag('td', :class => 'full-width ui-widget-header magic-pager',
+                    :colspan => grid.columns.count) do
+          pager = magic_paginate(grid.collection,
+                                :param_name => grid.param_key(:page),
+                                :params => base_params
+                               )
+          pager << capture(&block) if block_given?
+          pager
+        end
+      end
+    end
+
     ::ActionView::Base.send :include, self
   end
 end

data/lib/magic_grid/logger.rb

@@ -0,0 +1,8 @@
+module MagicGrid
+  def self.logger=(logger)
+    @logger = logger
+  end
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/magic_grid/version.rb

@@ -1,3 +1,3 @@
 module MagicGrid
-  VERSION = "0.10.4"
+  VERSION = "0.11.0"
 end

data/spec/collection_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'magic_grid/collection'
+
+describe MagicGrid::Collection do
+
+  context "via [] class method" do
+    context "when given a MagicGrid::Collection" do
+      let(:actual_collection) { [1,2,3,4] }
+      let(:magic_collection) { MagicGrid::Collection.new(actual_collection, :original_grid) }
+      subject { MagicGrid::Collection[magic_collection, :new_grid] }
+      its(:collection) { should eq(actual_collection) }
+      its(:grid) { should eq(:new_grid) }
+    end
+    context "when given a basic collection" do
+      let(:actual_collection) { [1,2,3,4] }
+      subject { MagicGrid::Collection[actual_collection, :original_grid] }
+      its(:collection) { should eq(actual_collection) }
+      its(:grid) { should eq(:original_grid) }
+    end
+  end
+
+  context "when based on an array" do
+    let(:collection) { [1,2,3,4] }
+    subject { MagicGrid::Collection.new(collection, nil) }
+    its(:collection) { should eq(collection) }
+    its(:grid) { should be_nil }
+  end
+
+  context "when based on something sortable" do
+    data = [1,5,3,2,56,7]
+    let(:sortable_collection) {
+      data.tap do |d|
+        d.stub(:order) { d }
+      end
+    }
+    it "should send #order when sorted" do
+      ordered = [1,2,3,4,5]
+      collection = MagicGrid::Collection.new(sortable_collection, nil)
+      sortable_collection.should_receive(:order) { ordered }
+      collection.apply_sort("col", "order")
+      collection.collection.should == ordered
+    end
+  end
+end

data/spec/definition_spec.rb

@@ -67,6 +67,13 @@ describe MagicGrid::Definition do
     its(:columns) { should == column_list }
   end
 
+  context "when given a MagicGrid::Collection" do
+    actual_collection = [1,2,3]
+    let(:collection) { MagicGrid::Collection.new(actual_collection, nil) }
+    subject { MagicGrid::Definition.new(column_list, collection, controller) }
+    its(:collection) { should eq(actual_collection) }
+  end
+
   context "when given a large collection and some options" do
     let(:controller) {
       controller = double()
@@ -87,6 +94,110 @@ describe MagicGrid::Definition do
       subject.param_key(:hunkydory).should == :grid_hunkydory
       subject.param(:page).should == 2
     end
+  end
+
+  context "sorting" do
+    data = [1,56,7,21,1]
+    let(:controller) {
+      controller = double()
+      controller.stub(:params) { HashWithIndifferentAccess.new({grid_order: 1}) }
+      controller
+    }
+    let(:collection) { data }
+    it "should sort collection using #order" do
+      collection.should_receive(:order).with("foo DESC") { data.sort.reverse }
+      grid = MagicGrid::Definition.new([{:sql => "foo"}], collection, controller, id: :grid)
+
+      grid.collection.should == data.sort.reverse
+    end
+    pending "test #order_sql directly"
+  end
+
+  context "filtering with #where" do
+    data = [1,56,7,21,1]
+    let(:controller) {
+      controller = double.tap do |c|
+        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+      end
+    }
+    let(:collection) {
+      data.tap do |d|
+        d.stub(:where) do |h|
+          d.select { |d| d < 10 }
+        end
+      end
+    }
+    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+                                        collection,
+                                        controller,
+                                        id: :grid, listeners: {f1: :f1}) }
+    its(:collection) { should == [1, 7, 1] }
+  end
+
+  context "filtering with a callback" do
+    data = [1,56,7,21,1]
+    filter = Proc.new do |c|
+      c.select { |i| i > 10 }
+    end
+    let(:controller) {
+      controller = double.tap do |c|
+        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+      end
+    }
+    let(:collection) {
+      data
+    }
+    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+                                        collection,
+                                        controller,
+                                        id: :grid, listener_handler: filter) }
+    its(:collection) { should == [56, 21] }
+  end
+
+  pending "test listening on a dumb collection"
+
+  context "post_filtering with a callable post_filter" do
+    data = [1,56,7,21,1]
+    filter = Proc.new do |c|
+      c.select { |i| i > 10 }
+    end
+    let(:controller) {
+      controller = double.tap do |c|
+        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+      end
+    }
+    let(:collection) {
+      data
+    }
+    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+                                        collection,
+                                        controller,
+                                        id: :grid, post_filter: filter) }
+    its(:collection) { should == [56, 21] }
+  end
 
+  context "post_filtering with a collection post_filter" do
+    data = [1,56,7,21,1]
+    filter = Proc.new do |c|
+      c.select { |i| i > 10 }
+    end
+    let(:controller) {
+      controller = double.tap do |c|
+        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+      end
+    }
+    let(:collection) {
+      data.tap do |d|
+        d.stub(:post_filter) do |h|
+          d.select { |d| d > 10 }
+        end
+      end
+    }
+    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+                                        collection,
+                                        controller,
+                                        id: :grid, collection_post_filter?: true) }
+    its(:collection) { should == [56, 21] }
   end
+
 end

data/spec/helpers_spec.rb

@@ -3,23 +3,44 @@ require 'magic_grid/helpers'
 require 'action_controller'
 require "active_support/core_ext"
 
+def make_controller
+  request = double.tap { |r|
+    r.stub(:fullpath, "/foo?page=bar")
+  }
+  double.tap { |v|
+    v.stub(:render)
+    v.stub(:params) { {} }
+    v.stub(:request) { request }
+  }
+end
+
+def fake_connection
+  double(:connection).tap do |c|
+    c.stub(:quote_column_name) { |col| col.to_s }
+  end
+end
+
+def fake_active_record_collection(table_name = 'some_table')
+  (1..1000).to_a.tap do |c|
+    c.stub(:connection => fake_connection)
+    c.stub(:table_name => table_name)
+    c.stub(:where) { c }
+  end
+end
+
+
 describe MagicGrid::Helpers do
 
   # Let's use the helpers the way they're meant to be used!
   include MagicGrid::Helpers
 
   let(:empty_collection) { [] }
+
   let(:column_list) { [:name, :description] }
-  let(:controller) {
-    request = double.tap{ |r|
-      r.stub(:fullpath, "/foo?page=bar")
-    }
-    double.tap { |v|
-      v.stub(:render) { nil }
-      v.stub(:params) { {} }
-      v.stub(:request) { request }
-    }
-  }
+
+  let(:controller) { make_controller }
+
+  # Kaminari uses view_renderer instead of controller
   let(:view_renderer) { controller }
 
   describe "#normalize_magic" do
@@ -28,40 +49,32 @@ describe MagicGrid::Helpers do
       expect(normalize_magic([])).to be_a(MagicGrid::Definition)
     end
 
-    it "should give back the MagicGrid::Definition given, if given one" do
+    it "should give back the MagicGrid::Definition given, if given as any argument" do
       definition = normalize_magic([])
-      expect(normalize_magic(definition)).to be(definition)
+      expect(normalize_magic( definition )).to be(definition)
+      expect(normalize_magic( nil, definition )).to be(definition)
+      expect(normalize_magic( nil, nil, definition )).to be(definition)
     end
   end
 
-  describe "#magic_collection" do
-    pending "should probably be removed, it's not really used"
-
-    it "should give back a collection like the one given" do
-      my_empty_collection = empty_collection
-      expect(magic_collection(my_empty_collection, column_list)).to eq(my_empty_collection)
-    end
-
-  end
-
   describe "#magic_grid" do
     pending "DOES WAY TOO MUCH!!"
 
+    let(:emtpy_grid) { magic_grid empty_collection, column_list }
+
     it "should barf without any arguments" do
       expect { magic_grid }.to raise_error
     end
 
-    let(:emtpy_grid) { magic_grid empty_collection, column_list }
-
     it "should render a table" do
       expect( emtpy_grid ).not_to be_empty
       expect( emtpy_grid ).to match(/<\/table>/)
     end
 
     context "when given an empty collection" do
-      let(:empty_grid) { magic_grid(empty_collection, column_list) }
+      subject { magic_grid empty_collection, column_list }
       it "should indicate there is no data" do
-        expect(empty_grid).to match(/"if-empty"/)
+        subject.should match(/"if-empty"/)
       end
     end
 
@@ -82,6 +95,163 @@ describe MagicGrid::Helpers do
       }
       it { should =~ /HOKY_POKY_ALAMO: 1/ }
     end
+
+    context "renders top and bottom pagers as told" do
+      large_collection = (1..1000).to_a
+
+      if Module.const_defined? :Kaminari
+        def render(*args)
+          "<nav class='pagination'><!-- paginate! --></nav>".html_safe
+        end
+      end
+
+      it "should render an actual pager" do
+        grid = magic_grid(large_collection, [:to_s])
+        if Module.const_defined? :WillPaginate
+          grid.should match_select("tfoot>tr>td.magic-pager>div.pagination", 1)
+        elsif Module.const_defined? :Kaminari
+          grid.should match_select("tfoot>tr>td.magic-pager>nav.pagination", 1)
+        else
+          grid.should match_select("tfoot>tr>td.magic-pager", /INSTALL/)
+        end
+      end
+      it "should render only a bottom pager by default" do
+        grid = magic_grid( large_collection, [:to_s] )
+        grid.should match_select("thead>tr>td.magic-pager", 0)
+        grid.should match_select("tfoot>tr>td.magic-pager", 1)
+      end
+      it "should render a top and bottom pager when told" do
+        grid = magic_grid( large_collection, [:to_s], top_pager: true )
+        grid.should match_select("thead>tr>td.magic-pager", 1)
+        grid.should match_select("tfoot>tr>td.magic-pager", 1)
+      end
+      it "should render only a top pager when told" do
+        grid = magic_grid( large_collection, [:to_s], top_pager: true, bottom_pager: false )
+        grid.should match_select("thead>tr>td.magic-pager", 1)
+        grid.should match_select("tfoot>tr>td.magic-pager", 0)
+      end
+    end
+
+    context "searching" do
+      let(:searchabe_collection) {
+        collection = [].tap do |c|
+          c.stub(:search) { collection }
+        end
+      }
+      it "should render a search bar when asked" do
+        grid = magic_grid(searchabe_collection, column_list, :searchable => [:some_col])
+        grid.should match_select('input[type=search]')
+      end
+
+      context "when a search query is given" do
+        let(:search_param) { 'foobar' }
+        let(:controller) {
+          make_controller.tap { |c|
+            c.stub(:params) { {:grid_id_q => search_param} }
+          }
+        }
+        it "should search a searchable collection when there are search params" do
+          collection = (1..1000).to_a
+          collection.should_receive(:search).with(search_param) { collection }
+          grid = magic_grid(collection, column_list, :id => "grid_id", :searchable => [:some_col])
+          grid.should match_select('input[type=search]')
+        end
+
+        context "when the collection responds to #where" do
+          it "should call where when there are search params" do
+            search_col = :some_col
+            table_name = "tbl"
+            search_sql = "tbl.some_col"
+
+            collection = fake_active_record_collection(table_name)
+            collection.should_receive(:where).
+                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+
+            grid = magic_grid(collection, column_list, :id => "grid_id", :searchable => [search_col])
+          end
+
+          it "should use custom sql from column for call to where when given" do
+            search_col = :some_col
+            search_sql = "sql that doesn't necessarily match column name"
+            table_name = "table name not used in query"
+
+            collection = fake_active_record_collection(table_name)
+            collection.should_receive(:where).
+                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+
+            magic_grid(collection,
+                       [ :name,
+                         :description,
+                         {:col => search_col, :sql => search_sql}
+                         ],
+                       :id => "grid_id", :searchable => [search_col])
+          end
+
+          it "should use column number to look up search column" do
+            search_col = :some_col
+            search_sql = "sql that doesn't necessarily match column name"
+            table_name = "table name not used in query"
+
+            collection = fake_active_record_collection(table_name)
+            collection.should_receive(:where).
+                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+
+            magic_grid(collection,
+                       [ :name,
+                         :description,
+                         {:col => search_col, :sql => search_sql}
+                         ],
+                       :id => "grid_id", :searchable => [2])
+          end
+
+          it "should use custom sql for call to where when given" do
+            search_col = :some_col
+            custom_search_col = "some custom search column"
+            search_sql = custom_search_col
+            table_name = "table name not used in query"
+
+            collection = fake_active_record_collection(table_name)
+            collection.should_receive(:where).
+                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+
+            magic_grid(collection,
+                       [ :name,
+                         :description,
+                         {:col => search_col, :sql => search_sql}
+                         ],
+                       :id => "grid_id", :searchable => [custom_search_col])
+          end
+
+          it "should fail when given bad searchable columns" do
+            collection = fake_active_record_collection()
+            collection.should_not_receive(:where)
+
+            expect {
+              magic_grid(collection,
+                         [ :name, :description],
+                         :id => "grid_id", :searchable => [nil])
+            }.to raise_error
+          end
+
+          it "should not fail if #where fails" do
+            search_col = :some_col
+            table_name = "tbl"
+            search_sql = "tbl.some_col"
+
+            collection = fake_active_record_collection(table_name)
+            magic_collection = MagicGrid::Collection.new(collection, nil)
+            collection.should_receive(:where).and_raise("some failure")
+            MagicGrid.logger = double.tap do |l|
+              l.should_receive(:debug).at_least(:once)
+            end
+
+            expect {
+              magic_grid(collection, column_list, :id => "grid_id", :searchable => [search_col])
+            }.to_not raise_error
+          end
+        end
+      end
+    end
   end
 
 end

data/spec/logger_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'magic_grid/logger'
+
+describe MagicGrid do
+  it "should user the specified logger" do
+    logger = double.tap do |l|
+      l.should_receive(:debug)
+      l.should_receive(:warn)
+      l.should_receive(:error)
+    end
+    MagicGrid.logger = logger
+    MagicGrid.logger.warn "Something is afoot"
+    MagicGrid.logger.error "Something is really wrong"
+    MagicGrid.logger.debug "Something is foo"
+  end
+end

data/spec/spec_helper.rb

@@ -9,13 +9,16 @@ unless ENV['TRAVIS']
   end
 end
 
+require 'magic_grid/logger'
 require 'action_view'
 require 'rails'
+require 'test/unit'
+require 'action_controller'
 
 begin
   require 'will_paginate'
   require 'will_paginate/array'
-  require 'will_paginate/view_helpers'
+  require 'will_paginate/view_helpers/action_view'
   puts "Testing with WillPaginate"
 rescue LoadError
   puts "skipping WillPaginate"
@@ -31,28 +34,33 @@ end
 
 Rails.backtrace_cleaner.remove_silencers!
 
-# I has a sad :-(
-module Rails
-  def logger.debug(*ignore) end
+class NullObject
+  def method_missing(*args, &block) self; end
+  def nil?; true; end
 end
 
 module ActionFaker
-  def output_buffer=(o)
-    @output_buffer = o
+  attr_accessor :output_buffer
+  def url_for(*args)
+    "fake_url(#{args.inspect})"
   end
-  def output_buffer()
-    @output_buffer
-  end
-  def url_for
-    "fake_url"
+end
+
+class TextSelector
+  include ActionDispatch::Assertions::SelectorAssertions
+  include Test::Unit::Assertions
+  def initialize(text)
+    @selected = HTML::Document.new(text).root.children
   end
-  def controller
-    stub_controller = ActionController::Base.new
-    def stub_controller.params(*ignored) {} end
-    stub_controller
+end
+
+RSpec::Matchers.define :match_select do |*expected|
+  match do |actual|
+    TextSelector.new(actual).assert_select(*expected)
   end
 end
 
+
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -60,10 +68,14 @@ RSpec.configure do |config|
   config.filter_run :focus
 
   config.include ActionView::Helpers
-  config.include WillPaginate::ViewHelpers if Module.const_defined? :WillPaginate
+  config.include WillPaginate::ActionView if Module.const_defined? :WillPaginate
   config.include Kaminari::ActionViewExtension if Module.const_defined? :Kaminari
   config.include ActionFaker
 
+  config.before do
+    MagicGrid.logger = NullObject.new
+  end
+
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.

data/test/dummy/test/integration/spider_test.rb

@@ -11,7 +11,7 @@ class SpiderTest < ActionDispatch::IntegrationTest
   def test_users
     t = tarantula_crawler(self)
     #t.handlers << Relevance::Tarantula::TidyHandler.new
-    t.crawl_timeout = 15.seconds
+    t.crawl_timeout = 5.seconds
     t.skip_uri_patterns += @@to_skip 
     t.crawl '/users'
   end
@@ -19,7 +19,7 @@ class SpiderTest < ActionDispatch::IntegrationTest
   def test_posts
     t = tarantula_crawler(self)
     #t.handlers << Relevance::Tarantula::TidyHandler.new
-    t.crawl_timeout = 15.seconds
+    t.crawl_timeout = 5.seconds
     t.skip_uri_patterns += @@to_skip 
     t.crawl '/posts'
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magic_grid
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-12 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -106,14 +106,17 @@ files:
 - lib/assets/javascripts/magic_grid.js
 - lib/tasks/magic_grid_tasks.rake
 - lib/magic_grid/version.rb
-- lib/magic_grid/railtie.rb
 - lib/magic_grid/helpers.rb
+- lib/magic_grid/collection.rb
 - lib/magic_grid/engine.rb
+- lib/magic_grid/logger.rb
 - lib/magic_grid/definition.rb
 - lib/locales/en.yml
 - MIT-LICENSE
 - Rakefile
 - README.md
+- spec/collection_spec.rb
+- spec/logger_spec.rb
 - spec/spec_helper.rb
 - spec/helpers_spec.rb
 - spec/definition_spec.rb
@@ -208,7 +211,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 591195015863992118
+      hash: 3180457643805959296
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -217,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 591195015863992118
+      hash: 3180457643805959296
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -225,6 +228,8 @@ signing_key:
 specification_version: 3
 summary: Easy collection display grid with column sorting and pagination
 test_files:
+- spec/collection_spec.rb
+- spec/logger_spec.rb
 - spec/spec_helper.rb
 - spec/helpers_spec.rb
 - spec/definition_spec.rb

data/lib/magic_grid/railtie.rb

@@ -1,9 +0,0 @@
-module MagicGrid
-  class Railtie < Rails::Railtie
-    # Once in production, on every page view in development
-    config.to_prepare do
-      # no caching based on path like require does
-      load 'magic_grid/helpers.rb'
-    end
-  end
-end