magic_grid 0.12.3 → 0.12.4

data/spec/column_spec.rb

@@ -45,7 +45,7 @@ describe MagicGrid::Column do
         data = [1,2,3].tap do |c|
           c.stub(:search) { c }
         end
-        MagicGrid::Collection.new(data, search_method: :search)
+        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.

data/spec/definition_spec.rb

@@ -24,7 +24,7 @@ describe MagicGrid::Definition do
   end
 
   let (:empty_collection) { [] }
-  let (:large_collection) { 200.times.map { |i| {id: i, name: "Name", description: "Describe me!"} } }
+  let (:large_collection) { 200.times.map { |i| {:id => i, :name => "Name", :description => "Describe me!"} } }
   let (:column_list) { [:name, :description] }
   let (:column_hash) { {} }
 
@@ -52,13 +52,13 @@ describe MagicGrid::Definition do
       }
     it "doesn't barf when listeners are given for a dumb collection" do
       expect {
-        MagicGrid::Definition.new([:a], [1], controller, listeners: {a: :a})
+        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])
+        MagicGrid::Definition.new([:a], [1], controller, :searchable => [:a])
       }.not_to raise_error
     end
   end
@@ -71,7 +71,7 @@ describe MagicGrid::Definition do
     it_behaves_like "a basic grid"
 
     context "when pagination is disabled" do
-      subject { MagicGrid::Definition.new(column_list, empty_collection, nil, per_page: false) }
+      subject { MagicGrid::Definition.new(column_list, empty_collection, nil, :per_page => false) }
       its(:current_page) { should == 1 }
       its(:collection) { should be_empty }
     end
@@ -80,7 +80,7 @@ describe MagicGrid::Definition do
   context "when given a large collection and default options" do
     let(:controller) {
       controller = double()
-      controller.stub(:params) { {page: 2} }
+      controller.stub(:params) { {:page => 2} }
       controller
     }
     subject { MagicGrid::Definition.new(column_list, large_collection, controller) }
@@ -101,10 +101,10 @@ describe MagicGrid::Definition do
   context "when given a large collection and some options" do
     let(:controller) {
       controller = double()
-      controller.stub(:params) { HashWithIndifferentAccess.new({grid_page: 2}) }
+      controller.stub(:params) { HashWithIndifferentAccess.new({:grid_page => 2}) }
       controller
     }
-    subject { MagicGrid::Definition.new(column_list, large_collection, controller, id: :grid, per_page: 17) }
+    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.magic_collection.per_page.should < large_collection.count
@@ -124,13 +124,13 @@ describe MagicGrid::Definition do
     data = [1,56,7,21,1]
     let(:controller) {
       controller = double()
-      controller.stub(:params) { HashWithIndifferentAccess.new({grid_order: 1}) }
+      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 = MagicGrid::Definition.new([{:sql => "foo"}], collection, controller, :id => :grid)
 
       grid.collection.should == data.sort.reverse
     end
@@ -139,14 +139,14 @@ describe MagicGrid::Definition do
 
   context "filtering with #where" do
     it "should use listeners with #where when asked to" do
-      filter_param = HashWithIndifferentAccess.new({f1: 1})
-      controller = double(params: filter_param)
+      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"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                           collection,
                                           controller,
-                                          id: :grid, listeners: {f1: :f1})
+                                          :id => :grid, :listeners => {:f1 => :f1})
       grid.collection.should == [1, 7, 1]
     end
   end
@@ -158,17 +158,17 @@ describe MagicGrid::Definition do
     end
     let(:controller) {
       controller = double.tap do |c|
-        c.stub(:params) { HashWithIndifferentAccess.new({column_name: 1}) }
+        c.stub(:params) { HashWithIndifferentAccess.new({:column_name => 1}) }
       end
     }
     let(:collection) { data }
 
     it "should use a listener_hanlder callback when given one" do
       options = {
-        id: :grid,
-        listener_handler: filter
+        :id => :grid,
+        :listener_handler => filter
       }
-      grid = MagicGrid::Definition.new([{sql: "foo"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                         collection,
                                         controller,
                                         options)
@@ -177,11 +177,11 @@ describe MagicGrid::Definition do
 
     it "should use listeners as where filters when given and set" do
       options = {
-        id: :grid,
-        listeners: { input_id: :column_name }
+        :id => :grid,
+        :listeners => { :input_id => :column_name }
       }
       collection.should_receive(:where).with("column_name" => 1).and_return([1,2,3])
-      grid = MagicGrid::Definition.new([{sql: "foo"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                         collection,
                                         controller,
                                         options)
@@ -190,12 +190,12 @@ describe MagicGrid::Definition do
 
     it "should ignore listener params when a listener_hanlder callback is given" do
       options = {
-        id: :grid,
-        listener_handler: filter,
-        listeners: { input_id: :column_name }
+        :id => :grid,
+        :listener_handler => filter,
+        :listeners => { :input_id => :column_name }
       }
       collection.should_not_receive(:where)
-      grid = MagicGrid::Definition.new([{sql: "foo"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                         collection,
                                         controller,
                                         options)
@@ -213,16 +213,16 @@ describe MagicGrid::Definition do
     end
     let(:controller) {
       controller = double.tap do |c|
-        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+        c.stub(:params) { HashWithIndifferentAccess.new({:f1 => 1}) }
       end
     }
     let(:collection) {
       data
     }
-    subject { MagicGrid::Definition.new([{sql: "foo"}],
+    subject { MagicGrid::Definition.new([{:sql => "foo"}],
                                         collection,
                                         controller,
-                                        id: :grid, post_filter: filter) }
+                                        :id => :grid, :post_filter => filter) }
     its(:collection) { should == [56, 21] }
   end
 
@@ -230,7 +230,7 @@ describe MagicGrid::Definition do
     data = [1,56,7,21,1]
     let(:controller) {
       controller = double.tap do |c|
-        c.stub(:params) { HashWithIndifferentAccess.new({f1: 1}) }
+        c.stub(:params) { HashWithIndifferentAccess.new({:f1 => 1}) }
       end
     }
     let(:collection) {
@@ -241,20 +241,20 @@ describe MagicGrid::Definition do
       end
     }
     it "should use the collection's post_filter method" do
-      grid = MagicGrid::Definition.new([{sql: "foo"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                        collection,
                                        controller,
-                                       id: :grid, collection_post_filter: true)
+                                       :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"}],
+      grid = MagicGrid::Definition.new([{:sql => "foo"}],
                                        collection,
                                        controller,
-                                       id: :grid, collection_post_filter: false)
+                                       :id => :grid, :collection_post_filter => false)
 
       data.should_not_receive(:post_filter)
       grid.collection.should == data

data/spec/helpers_spec.rb

@@ -44,7 +44,7 @@ describe MagicGrid::Helpers do
             if_emtpy_string
           }
         end
-        grid = magic_grid empty_collection, column_list, if_empty: callback
+        grid = magic_grid empty_collection, column_list, :if_empty => callback
         grid.should include(if_emtpy_string)
       end
     end
@@ -54,8 +54,8 @@ describe MagicGrid::Helpers do
       it "should not indicate there is no data" do
         should_not match(/if-empty/)
       end
-      it { should  match_select("td", text: "1") }
-      it { should  match_select("td", text: "2") }
+      it { should  match_select("td", :text => "1") }
+      it { should  match_select("td", :text => "2") }
     end
 
     context "when given a block" do
@@ -92,7 +92,7 @@ describe MagicGrid::Helpers do
     context "renders top and bottom pagers as told" do
       large_collection = (1..1000).to_a
 
-      if Module.const_defined? :Kaminari
+      if defined? Kaminari
         def render(*args)
           "<nav class='pagination'><!-- paginate! --></nav>".html_safe
         end
@@ -100,9 +100,9 @@ describe MagicGrid::Helpers do
 
       it "should render an actual pager" do
         grid = magic_grid(large_collection, [:to_s])
-        if Module.const_defined? :WillPaginate
+        if $will_paginate
           grid.should match_select("tfoot>tr>td.magic-pager>div.pagination", 1)
-        elsif Module.const_defined? :Kaminari
+        elsif $kaminari
           grid.should match_select("tfoot>tr>td.magic-pager>nav.pagination", 1)
         else
           grid.should match_select("tfoot>tr>td.magic-pager", /INSTALL/)
@@ -114,12 +114,12 @@ describe MagicGrid::Helpers do
         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 = 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 = 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
@@ -132,7 +132,7 @@ describe MagicGrid::Helpers do
         end
       }
       it "should only render one spinner" 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("td.searcher", 1)
         grid.should match_select("td.magic-pager", 1)
         grid.should match_select(".magic_grid_spinner", 1)
@@ -146,7 +146,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
 
@@ -154,13 +154,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
 
@@ -172,9 +172,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
@@ -184,14 +184,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
@@ -201,14 +201,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
@@ -219,14 +219,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
@@ -236,7 +236,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
 
@@ -253,7 +253,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

data/spec/html_grid_spec.rb

@@ -20,7 +20,7 @@ describe MagicGrid::HtmlGrid do
         callable = double.tap do |c|
           c.should_receive(:call).with( record ) { tracer }
         end
-        cols = [ {col: 'Col', to_s: callable} ]
+        cols = [ {:col => 'Col', :to_s => callable} ]
         grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
         grid.grid_row( record ).should include(tracer)
       end
@@ -29,7 +29,7 @@ describe MagicGrid::HtmlGrid do
         callable = double.tap do |c|
           c.should_receive(:call).with( record ) { tracer }
         end
-        cols = [ {col: callable, label: "Column"} ]
+        cols = [ {:col => callable, :label => "Column"} ]
         grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
         grid.grid_row( record ).should include(tracer)
       end
@@ -40,14 +40,14 @@ describe MagicGrid::HtmlGrid do
 
       it "should use :to_s as a method on record if it responds to it" do
         record.should_receive(:some_inconceivable_method_name) { tracer }
-        cols = [ {col: :some_col, to_s: :some_inconceivable_method_name} ]
+        cols = [ {:col => :some_col, :to_s => :some_inconceivable_method_name} ]
         grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
         grid.grid_row( record ).should include(tracer)
       end
 
       it "should use :col as a method on record if it responds to it" do
         record.should_receive(:some_inconceivable_method_name) { tracer }
-        cols = [ {col: :some_inconceivable_method_name} ]
+        cols = [ {:col => :some_inconceivable_method_name} ]
         grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
         grid.grid_row( record ).should include(tracer)
       end
@@ -63,13 +63,13 @@ describe MagicGrid::HtmlGrid do
     end
     it "should use :label if no :sql is given" do
       title = "A String"
-      cols = [{label: title}]
+      cols = [{:label => title}]
       grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
       grid.magic_column_headers.should include(title)
     end
     it "should make a sortable header if :sql is specified" do
       tracer = "A MAGIC BULL??"
-      col = {sql: 'some_col'}
+      col = {:sql => 'some_col'}
       cols = [col]
       grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols), self
       # TODO: check parameters to sortable_header
@@ -80,7 +80,7 @@ describe MagicGrid::HtmlGrid do
   end
 
   describe "#searcher_input" do
-    searchable_opts = { needs_searcher: true }
+    searchable_opts = { :needs_searcher => true }
     it "renders a search field" do
       cols = [:some_col]
       grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols, nil, nil, searchable_opts), self
@@ -89,10 +89,10 @@ describe MagicGrid::HtmlGrid do
     it "renders a search button if told to" do
       tracer = "ZOMG! A BUTTON!"
       cols = [:some_col]
-      opts = searchable_opts.merge(search_button: true,
-                                   searcher_button: tracer)
+      opts = searchable_opts.merge(:search_button => true,
+                                   :searcher_button => tracer)
       grid = MagicGrid::HtmlGrid.new MagicGrid::Definition.new(cols, nil, nil, opts), self
-      grid.searcher_input.should match_select("button", text: tracer)
+      grid.searcher_input.should match_select("button", :text => tracer)
     end
   end
 
@@ -114,4 +114,31 @@ describe MagicGrid::HtmlGrid do
       subject.order_class(2).should == 'sort-none'
     end
   end
+
+  describe "#magic_pager" do
+    let(:definition) { MagicGrid::Definition.new(column_list) }
+    let(:collection) { definition.magic_collection }
+    it "should use will_paginate if available" do
+      view = double.tap { |v|
+        v.should_receive(:will_paginate).
+          with(collection.collection, {}).
+          and_return("WillPaginate was used!")
+      }
+      grid = MagicGrid::HtmlGrid.new(definition, view)
+      grid.magic_pager(collection).should == "WillPaginate was used!"
+    end
+    it "should use paginate if available and will_paginate is not" do
+      view = double.tap { |v|
+        v.should_receive(:paginate).
+          with(collection.collection, {}).
+          and_return("#paginate was used!")
+      }
+      grid = MagicGrid::HtmlGrid.new(definition, view)
+      grid.magic_pager(collection).should == "#paginate was used!"
+    end
+    it "should leave a comment for the dev if paginate and will_paginate are both missing" do
+      grid = MagicGrid::HtmlGrid.new(definition, double)
+      grid.magic_pager(collection).should =~ /INSTALL WillPaginate or Kaminari/
+    end
+  end
 end