magic_grid 0.11.1 → 0.12.0

data/lib/magic_grid/version.rb

@@ -1,3 +1,3 @@
 module MagicGrid
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/spec/collection_spec.rb

@@ -1,21 +1,20 @@
 require 'spec_helper'
 require 'magic_grid/collection'
+require 'magic_grid/column'
 
 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] }
+      let(:magic_collection) { MagicGrid::Collection.new(actual_collection) }
+      subject { MagicGrid::Collection.create_or_reuse(magic_collection) }
       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] }
+      subject { MagicGrid::Collection.create_or_reuse(actual_collection) }
       its(:collection) { should eq(actual_collection) }
-      its(:grid) { should eq(:original_grid) }
     end
   end
 
@@ -23,7 +22,6 @@ describe MagicGrid::Collection 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
@@ -37,8 +35,141 @@ describe MagicGrid::Collection 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")
+      column = MagicGrid::FilterOnlyColumn.new("col")
+      collection.apply_sort(column, "order")
       collection.collection.should == ordered
     end
   end
-end
+
+  context "when post filter callback is given" do
+    it "should call the given callback when the collection is reduced" do
+      array = [1]
+      callback = double.tap do |cb|
+        cb.should_receive(:call).with(array) { [2] }
+      end
+      collection = MagicGrid::Collection.new(array, nil)
+      collection.add_post_filter_callback(callback)
+      collection.collection.should == [2]
+    end
+  end
+
+  describe "#perform_search" do
+    context "when the collection is searchable" do
+      let(:collection) {
+        fake_active_record_collection('some_table', [:name, :description])
+      }
+      subject {
+        MagicGrid::Collection.new(collection).tap do |c|
+          c.searchable_columns = [MagicGrid::FilterOnlyColumn.new(:name, c)]
+        end
+      }
+      it { subject.should be_filterable }
+      it { subject.should be_searchable }
+      it "should apply a search query when given one" do
+        subject.apply_search("foobar")
+        subject.searches.should_not be_empty
+      end
+      it "should not barf when given a blank search query" do
+        subject.apply_search(nil)
+        subject.apply_search("")
+        subject.searches.should be_empty
+      end
+    end
+
+    context "when the collection is not searchable" do
+      let(:collection) {
+        fake_active_record_collection('some_table', [:name, :description])
+      }
+      subject { MagicGrid::Collection.new(collection) }
+      it { subject.should be_filterable }
+      it { subject.should_not be_searchable }
+      it "should not apply a search query when given one" do
+        subject.apply_search("foobar")
+        subject.searches.should be_empty
+      end
+      it "should not barf when given a blank search query" do
+        subject.apply_search(nil)
+        subject.apply_search("")
+        subject.searches.should be_empty
+      end
+    end
+  end
+
+  #TODO these tests will only really work properly once we have the ability
+  #     to undefine constants, which looks like it should be coming in a future
+  #     version of RSpec (as in post 2.11.1)
+
+  describe "#perform_pagination" do
+
+    context "when #paginate (aka WillPaginate) is available" do
+      it "should call paginate helper when it is detected" do
+        array = [1].tap do |a|
+          a.should_receive(:paginate).with(page: 1, per_page: 1) { a }
+        end
+        collection = MagicGrid::Collection.new(array, nil)
+        collection.per_page = 1
+        collection.apply_pagination 1
+        collection.perform_pagination(array).should == array
+      end
+    end
+
+    unless Module.const_defined? :WillPaginate
+      context "when #page (possibly from Kaminari) is available" do
+        it "should call paginate helper when it is detected" do
+          array = [1].tap do |a|
+            a.should_receive(:per).with(1) { array }
+            a.should_receive(:page).with(1) { array }
+          end
+          collection = MagicGrid::Collection.new(array, nil)
+          collection.per_page = 1
+          collection.apply_pagination 1
+          collection.perform_pagination(array).should == array
+        end
+      end
+
+      context "when given an Array and Kaminari is available" do
+        it "should call paginate helper when it is detected" do
+          array = Array.new(10) { 1 }
+          kaminaried_array = [1,1].tap do |ka|
+            ka.should_receive(:per).with(1) { ka }
+            ka.should_receive(:page).with(1) { ka }
+          end
+          kaminari = double.tap do |k|
+            k.should_receive(:paginate_array).with(array) { kaminaried_array }
+          end
+          stub_const('Kaminari', kaminari)
+          collection = MagicGrid::Collection.new(array, nil)
+          collection.per_page = 1
+          collection.apply_pagination 1
+          collection.perform_pagination(array).should == kaminaried_array
+        end
+      end
+    end
+
+    context "when no pagination is provided" do
+      # TODO replace this when rspec-mocks add 'hide_const'
+      # before :each do
+      #   if Module.const_defined?(:Kaminari)
+      #     @kaminari = Module.const_get(:Kaminari)
+      #     Object.send(:remove_const, :Kaminari)
+      #   end
+      # end
+      # after :each do
+      #   Module.const_set(:Kaminari, @kaminari) if @kaminari
+      # end
+
+      #
+      #  For now, Travis-CI takes care of this, since we have gem profiles defined
+      #  to test all 3 supported pagination scenarios
+      #
+
+      it "should attempt to use Enumerable methods to perform pagination" do
+        array = Array.new(100) { 1 }
+        collection = MagicGrid::Collection.new(array, nil)
+        collection.per_page = 1
+        collection.apply_pagination 1
+        collection.perform_pagination(array).should == [1]
+      end
+    end
+  end
+end

data/spec/column_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'magic_grid/column'
+require 'magic_grid/collection'
+
+describe MagicGrid::Column do
+  describe "Column.columns_for_collection" do
+    context "for setting searchable columns on column filtering collection" do
+      let(:collection_backing) { fake_active_record_collection }
+      let(:collection) { MagicGrid::Collection.new(collection_backing) }
+      it "enables searching on non-displayed columns" do
+        display = [:name]
+        searchable = [:secret]
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should be_searchable
+      end
+      it "enables searching on displayed columns" do
+        display = [:name]
+        searchable = [:name]
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should be_searchable
+      end
+      it "accepts false as a method of disabling search" do
+        display = [:name]
+        searchable = false
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should_not be_searchable
+      end
+      it "doesn't enable searching when not given a column" do
+        display = [:name]
+        searchable = true
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should_not be_searchable
+      end
+    end
+    context "for enabling/disabling search on #search() style collection" do
+      let(:collection) {
+        data = [1,2,3].tap do |c|
+          c.stub(:search) { c }
+        end
+        MagicGrid::Collection.new(data, search_method: :search)
+      }
+      # I actually consider this a bug, since it is totally inconsistent, but
+      # it's how things are currently implemented.
+      it "doesn't disable searching, even when told so" do
+        display = [:name]
+        searchable = false
+        collection.should be_searchable
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should be_searchable
+      end
+      it "enables searching when told so" do
+        collection.should be_searchable
+        display = [:name]
+        searchable = true
+        columns = MagicGrid::Column.columns_for_collection(collection,
+                                                           display,
+                                                           searchable)
+        collection.should be_searchable
+      end
+    end
+  end
+end

data/spec/definition_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'magic_grid/definition'
-require 'active_support/core_ext/hash/indifferent_access'
 
 describe MagicGrid::Definition do
   pending "embarasses me with how tightly it is coupled with.. EVERYTHING"
@@ -45,12 +44,37 @@ describe MagicGrid::Definition do
     expect { MagicGrid::Definition.new() }.to raise_error
   end
 
+  context "options that can't be used" do
+      let(:controller) {
+        double.tap do |c|
+          c.stub(:params) { {} }
+        end
+      }
+    it "doesn't barf when listeners are given for a dumb collection" do
+      expect {
+        MagicGrid::Definition.new([:a], [1], controller, listeners: {a: :a})
+      }.not_to raise_error
+    end
+
+    it "doesn't barf when search columns are given for a dumb collection" do
+      expect {
+        MagicGrid::Definition.new([:a], [1], controller, searchable: [:a])
+      }.not_to raise_error
+    end
+  end
+
   context "when given an empty collection" do
     subject { MagicGrid::Definition.new(column_list, empty_collection) }
     its(:base_params) { should include(:magic_grid_id) }
     its(:collection) { should == empty_collection }
-    its(:columns) { should == column_list }
+    its('columns.length') { should == column_list.length }
     it_behaves_like "a basic grid"
+
+    context "when pagination is disabled" do
+      subject { MagicGrid::Definition.new(column_list, empty_collection, nil, per_page: false) }
+      its(:current_page) { should == 1 }
+      its(:collection) { should be_empty }
+    end
   end
 
   context "when given a large collection and default options" do
@@ -64,7 +88,7 @@ describe MagicGrid::Definition do
     its(:collection) { should_not == empty_collection }
 
     its(:collection) { should have(MagicGrid::Definition.runtime_defaults[:per_page]).items }
-    its(:columns) { should == column_list }
+    its('columns.length') { should == column_list.length }
   end
 
   context "when given a MagicGrid::Collection" do
@@ -83,10 +107,10 @@ describe MagicGrid::Definition do
     subject { MagicGrid::Definition.new(column_list, large_collection, controller, id: :grid, per_page: 17) }
     its(:collection) { should_not == empty_collection }
     it "should give a collection with a page worth of items" do
-      subject.per_page.should < large_collection.count
-      subject.collection.should have(subject.per_page).items
+      subject.magic_collection.per_page.should < large_collection.count
+      subject.collection.should have(subject.magic_collection.per_page).items
     end
-    its(:columns) { should == column_list }
+    its('columns.length') { should == column_list.length }
     its(:current_page) { should == 2 }
 
     it "should know how to extract its params" do
@@ -106,7 +130,7 @@ describe MagicGrid::Definition do
     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 = MagicGrid::Definition.new([{sql: "foo"}], collection, controller, id: :grid)
 
       grid.collection.should == data.sort.reverse
     end
@@ -114,24 +138,17 @@ describe MagicGrid::Definition do
   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] }
+    it "should use listeners with #where when asked to" do
+      filter_param = HashWithIndifferentAccess.new({f1: 1})
+      controller = double(params: filter_param)
+      collection = [1,56,7,21,1]
+      collection.should_receive(:where).with(filter_param).and_return([1, 7, 1])
+      grid = MagicGrid::Definition.new([{sql: "foo"}],
+                                          collection,
+                                          controller,
+                                          id: :grid, listeners: {f1: :f1})
+      grid.collection.should == [1, 7, 1]
+    end
   end
 
   context "filtering with a callback" do
@@ -147,7 +164,7 @@ describe MagicGrid::Definition do
     let(:collection) {
       data
     }
-    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+    subject { MagicGrid::Definition.new([{sql: "foo"}],
                                         collection,
                                         controller,
                                         id: :grid, listener_handler: filter) }
@@ -169,7 +186,7 @@ describe MagicGrid::Definition do
     let(:collection) {
       data
     }
-    subject { MagicGrid::Definition.new([{:sql => "foo"}],
+    subject { MagicGrid::Definition.new([{sql: "foo"}],
                                         collection,
                                         controller,
                                         id: :grid, post_filter: filter) }
@@ -178,9 +195,6 @@ describe MagicGrid::Definition do
 
   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}) }
@@ -193,11 +207,25 @@ describe MagicGrid::Definition do
         end
       end
     }
-    subject { MagicGrid::Definition.new([{:sql => "foo"}],
-                                        collection,
-                                        controller,
-                                        id: :grid, collection_post_filter?: true) }
-    its(:collection) { should == [56, 21] }
+    it "should use the collection's post_filter method" do
+      grid = MagicGrid::Definition.new([{sql: "foo"}],
+                                       collection,
+                                       controller,
+                                       id: :grid, collection_post_filter: true)
+
+      data.should_receive(:post_filter).with().and_return([1,2,3,4])
+      grid.collection.should == [1,2,3,4]
+      grid.collection.should_not be_empty
+    end
+    it "can be disabled via the collection_post_filter option" do
+      grid = MagicGrid::Definition.new([{sql: "foo"}],
+                                       collection,
+                                       controller,
+                                       id: :grid, collection_post_filter: false)
+
+      data.should_not_receive(:post_filter)
+      grid.collection.should == data
+    end
   end
 
 end

data/spec/helpers_spec.rb

@@ -1,45 +1,5 @@
 require 'spec_helper'
 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',
-                                  columns = [:name, :description])
-
-  columns = columns.map { |c|
-    double.tap do |col|
-      col.stub(:name) { c }
-    end
-  }
-  (1..1000).to_a.tap do |c|
-    c.stub(:connection => fake_connection)
-    c.stub(:quoted_table_name => table_name)
-    c.stub(:table_name => table_name)
-    c.stub(:where) { c }
-    c.stub(:table) {
-            double.tap do |t|
-              t.stub(:columns) { columns }
-            end
-          }
-  end
-end
 
 describe MagicGrid::Helpers do
 
@@ -47,31 +7,13 @@ describe MagicGrid::Helpers do
   include MagicGrid::Helpers
 
   let(:empty_collection) { [] }
-
   let(:column_list) { [:name, :description] }
-
   let(:controller) { make_controller }
 
   # Kaminari uses view_renderer instead of controller
   let(:view_renderer) { controller }
 
-  describe "#normalize_magic" do
-
-    it "should turn an array into a MagicGrid::Definition" do
-      expect(normalize_magic([])).to be_a(MagicGrid::Definition)
-    end
-
-    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( nil, definition )).to be(definition)
-      expect(normalize_magic( nil, nil, definition )).to be(definition)
-    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
@@ -90,13 +32,26 @@ describe MagicGrid::Helpers do
       end
     end
 
+    context "when given an empty collection and an if_empty callback" do
+      it "calls the callback" do
+        if_emtpy_string = "ZOMG! NO ROWS!"
+        callback = double.tap do |cb|
+          cb.should_receive(:call).with(instance_of MagicGrid::Definition) {
+            if_emtpy_string
+          }
+        end
+        grid = magic_grid empty_collection, column_list, if_empty: callback
+        grid.should include(if_emtpy_string)
+      end
+    end
+
     context "when given a non-empty collection" do
       subject { magic_grid( [1, 2], [:to_s] ) }
       it "should not indicate there is no data" do
         should_not match(/if-empty/)
       end
-      it { should  =~ /<td>1<\/td>/ }
-      it { should  =~ /<td>2<\/td>/ }
+      it { should  match_select("td", text: "1") }
+      it { should  match_select("td", text: "2") }
     end
 
     context "when given a block" do
@@ -108,6 +63,28 @@ describe MagicGrid::Helpers do
       it { should =~ /HOKY_POKY_ALAMO: 1/ }
     end
 
+    context "when given an array of Symbols as column list" do
+      subject {
+        magic_grid( [1,2], [:col1, :col2]) do |row|
+          "draw a row"
+        end
+      }
+      it { should match(/draw a row/) }
+      it("capitalizes the column name") { should match(/Col1/) }
+      it { should match(/Col2/) }
+    end
+
+    context "when given an array of Strings as column list" do
+      subject {
+        magic_grid( [1,2], ["CamelCase", "lower_case"]) do |row|
+          "draw a row"
+        end
+      }
+      it { should match(/draw a row/) }
+      it("leaves case alone") { should match(/CamelCase/) }
+      it("leaves underscores alone") { should match(/lower_case/) }
+    end
+
     context "renders top and bottom pagers as told" do
       large_collection = (1..1000).to_a
 
@@ -144,6 +121,20 @@ describe MagicGrid::Helpers do
       end
     end
 
+    context "searching and paging" do
+      let(:searchabe_collection) {
+        collection = [].tap do |c|
+          c.stub(:search) { collection }
+        end
+      }
+      it "should only render one spinner" do
+        grid = magic_grid(searchabe_collection, column_list, searchable: [:some_col])
+        grid.should match_select("td.searcher", 1)
+        grid.should match_select("td.magic-pager", 1)
+        grid.should match_select(".magic_grid_spinner", 1)
+      end
+    end
+
     context "searching" do
       let(:searchabe_collection) {
         collection = [].tap do |c|
@@ -151,7 +142,7 @@ describe MagicGrid::Helpers do
         end
       }
       it "should render a search bar when asked" do
-        grid = magic_grid(searchabe_collection, column_list, :searchable => [:some_col])
+        grid = magic_grid(searchabe_collection, column_list, searchable: [:some_col])
         grid.should match_select('input[type=search]')
       end
 
@@ -159,13 +150,13 @@ describe MagicGrid::Helpers do
         let(:search_param) { 'foobar' }
         let(:controller) {
           make_controller.tap { |c|
-            c.stub(:params) { {:grid_id_q => search_param} }
+            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 = magic_grid(collection, column_list, id: "grid_id", searchable: [:some_col])
           grid.should match_select('input[type=search]')
         end
 
@@ -177,9 +168,9 @@ describe MagicGrid::Helpers do
 
             collection = fake_active_record_collection(table_name)
             collection.should_receive(:where).
-                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+                       with("#{search_sql} LIKE :search", {search: "%#{search_param}%"})
 
-            grid = magic_grid(collection, column_list, :id => "grid_id", :searchable => [search_col])
+            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
@@ -189,14 +180,14 @@ describe MagicGrid::Helpers do
 
             collection = fake_active_record_collection(table_name)
             collection.should_receive(:where).
-                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+                       with("#{search_sql} LIKE :search", {search: "%#{search_param}%"})
 
             magic_grid(collection,
                        [ :name,
                          :description,
-                         {:col => search_col, :sql => search_sql}
+                         {col: search_col, sql: search_sql}
                          ],
-                       :id => "grid_id", :searchable => [search_col])
+                       id: "grid_id", searchable: [search_col])
           end
 
           it "should use column number to look up search column" do
@@ -206,14 +197,14 @@ describe MagicGrid::Helpers do
 
             collection = fake_active_record_collection(table_name)
             collection.should_receive(:where).
-                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+                       with("#{search_sql} LIKE :search", {search: "%#{search_param}%"})
 
             magic_grid(collection,
                        [ :name,
                          :description,
-                         {:col => search_col, :sql => search_sql}
+                         {col: search_col, sql: search_sql}
                          ],
-                       :id => "grid_id", :searchable => [2])
+                       id: "grid_id", searchable: [2])
           end
 
           it "should use custom sql for call to where when given" do
@@ -224,14 +215,14 @@ describe MagicGrid::Helpers do
 
             collection = fake_active_record_collection(table_name)
             collection.should_receive(:where).
-                       with("#{search_sql} LIKE :search", {:search=>"%#{search_param}%"})
+                       with("#{search_sql} LIKE :search", {search: "%#{search_param}%"})
 
             magic_grid(collection,
                        [ :name,
                          :description,
-                         {:col => search_col, :sql => search_sql}
+                         {col: search_col, sql: search_sql}
                          ],
-                       :id => "grid_id", :searchable => [custom_search_col])
+                       id: "grid_id", searchable: [custom_search_col])
           end
 
           it "should fail when given bad searchable columns" do
@@ -241,7 +232,7 @@ describe MagicGrid::Helpers do
             expect {
               magic_grid(collection,
                          [ :name, :description],
-                         :id => "grid_id", :searchable => [nil])
+                         id: "grid_id", searchable: [nil])
             }.to raise_error
           end
 
@@ -258,7 +249,7 @@ describe MagicGrid::Helpers do
             end
 
             expect {
-              magic_grid(collection, column_list, :id => "grid_id", :searchable => [search_col])
+              magic_grid(collection, column_list, id: "grid_id", searchable: [search_col])
             }.to_not raise_error
           end
         end
@@ -266,20 +257,7 @@ describe MagicGrid::Helpers do
     end
 
     context "sorting" do
-      let(:sortable_collection) {
-        columns = column_list.map { |c|
-          double.tap do |col|
-            col.stub(:name) { c }
-          end
-        }
-        collection = fake_active_record_collection.tap do |c|
-          c.stub(:table) {
-            double.tap do |t|
-              t.stub(:columns) { columns }
-            end
-          }
-        end
-      }
+      let(:sortable_collection) { fake_active_record_collection }
       it "should render sortable column headers when a collection is sortable" do
         grid = magic_grid(sortable_collection, column_list)
         grid.should match_select("thead>tr>th.sorter>a>span.ui-icon", column_list.count)
@@ -289,14 +267,14 @@ describe MagicGrid::Helpers do
       #   let(:search_param) { 'foobar' }
       #   let(:controller) {
       #     make_controller.tap { |c|
-      #       c.stub(:params) { {:grid_id_col => 1} }
+      #       c.stub(:params) { {grid_id_col: 1} }
       #     }
       #   }
       # end
       # context "when a sort order is given" do
       #   let(:controller) {
       #     make_controller.tap { |c|
-      #       c.stub(:params) { {:grid_id_order => 1} }
+      #       c.stub(:params) { {grid_id_order: 1} }
       #     }
       #   }
       # end
@@ -304,7 +282,7 @@ describe MagicGrid::Helpers do
       #   let(:search_param) { 'foobar' }
       #   let(:controller) {
       #     make_controller.tap { |c|
-      #       c.stub(:params) { {:grid_id_q => 1} }
+      #       c.stub(:params) { {grid_id_q: 1} }
       #     }
       #   }
       # end