datagrid 1.2.0 → 1.2.1

data/spec/datagrid/filters/string_filter_spec.rb

@@ -8,19 +8,19 @@ describe Datagrid::Filters::StringFilter do
       scope {Entry}
       filter(:name, :string, :multiple => true)
     end
-    report.assets.should include(Entry.create!( :name => "one"))
-    report.assets.should include(Entry.create!( :name => "two"))
-    report.assets.should_not include(Entry.create!( :name => "three"))
+    expect(report.assets).to include(Entry.create!( :name => "one"))
+    expect(report.assets).to include(Entry.create!( :name => "two"))
+    expect(report.assets).not_to include(Entry.create!( :name => "three"))
   end
   it "should support custom separator multiple values" do
     report = test_report(:name => "one,1|two,2") do
       scope {Entry}
       filter(:name, :string, :multiple => '|')
     end
-    report.assets.should include(Entry.create!( :name => "one,1"))
-    report.assets.should include(Entry.create!( :name => "two,2"))
-    report.assets.should_not include(Entry.create!( :name => "one"))
-    report.assets.should_not include(Entry.create!( :name => "two"))
+    expect(report.assets).to include(Entry.create!( :name => "one,1"))
+    expect(report.assets).to include(Entry.create!( :name => "two,2"))
+    expect(report.assets).not_to include(Entry.create!( :name => "one"))
+    expect(report.assets).not_to include(Entry.create!( :name => "two"))
   end
 
 end

data/spec/datagrid/filters_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 describe Datagrid::Filters do
 
   it "should support default option as proc" do
-    test_report do
+    expect(test_report do
       scope {Entry}
       filter(:created_at, :date, :default => proc { Date.today } )
-    end.created_at.should == Date.today
+    end.created_at).to eq(Date.today)
   end
 
   it "should stack with other filters" do
@@ -16,7 +16,7 @@ describe Datagrid::Filters do
       filter(:name)
       filter(:category, :enum, :select => ["first", "second"])
     end
-    report.assets.should be_empty
+    expect(report.assets).to be_empty
   end
 
   it "should not support array argument for not multiple filter" do
@@ -24,9 +24,9 @@ describe Datagrid::Filters do
       scope {Entry}
       filter(:group_id, :integer)
     end
-    lambda {
+    expect {
       report.group_id = [1,2]
-    }.should raise_error(Datagrid::ArgumentError)
+    }.to raise_error(Datagrid::ArgumentError)
   end
 
   it "should filter block with 2 arguments" do
@@ -36,15 +36,15 @@ describe Datagrid::Filters do
         scope.where(:group_id => value)
       end
     end
-    lambda {
+    expect {
       report.group_id = [1,2]
-    }.should raise_error(Datagrid::ArgumentError)
+    }.to raise_error(Datagrid::ArgumentError)
   end
 
 
   it "should initialize when report Scope table not exists" do
     class ModelWithoutTable < ActiveRecord::Base; end
-    ModelWithoutTable.should_not be_table_exists
+    expect(ModelWithoutTable).not_to be_table_exists
     class TheReport
       include Datagrid
 
@@ -53,7 +53,7 @@ describe Datagrid::Filters do
       filter(:name)
       filter(:limit)
     end
-    TheReport.new(:name => 'hello').should_not be_nil
+    expect(TheReport.new(:name => 'hello')).not_to be_nil
   end
 
   it "should support inheritence" do
@@ -65,8 +65,8 @@ describe Datagrid::Filters do
     child = Class.new(parent) do
       filter(:group_id)
     end
-    parent.filters.size.should == 1
-    child.filters.size.should == 2
+    expect(parent.filters.size).to eq(1)
+    expect(child.filters.size).to eq(2)
   end
 
   describe "allow_blank and allow_nil options" do
@@ -80,9 +80,9 @@ describe Datagrid::Filters do
           self
         end
       end
-      report.name.should == value
+      expect(report.name).to eq(value)
       report.assets
-      $FILTER_PERFORMED.should == result
+      expect($FILTER_PERFORMED).to eq(result)
     end
 
     it "should support allow_blank argument" do
@@ -110,7 +110,7 @@ describe Datagrid::Filters do
         scope {Entry}
         filter(:limit)
       end
-      grid.assets.to_a.size.should == 1
+      expect(grid.assets.to_a.size).to eq(1)
     end
     
   end
@@ -125,7 +125,7 @@ describe Datagrid::Filters do
           end
         end
       end
-      grid.assets.should_not be_empty
+      expect(grid.assets).not_to be_empty
     end
 
   end
@@ -137,7 +137,7 @@ describe Datagrid::Filters do
         filter(:limit)
         filter(:name, :before => :limit)
       end
-      grid.filters.index {|f| f.name == :name}.should == 0
+      expect(grid.filters.index {|f| f.name == :name}).to eq(0)
     end
   end
 
@@ -149,7 +149,7 @@ describe Datagrid::Filters do
         filter(:name)
         filter(:group_id, :after => :limit)
       end
-      grid.filters.index {|f| f.name == :group_id}.should == 1
+      expect(grid.filters.index {|f| f.name == :group_id}).to eq(1)
     end
   end
 
@@ -159,7 +159,7 @@ describe Datagrid::Filters do
       filter(:period, :date, :dummy => true, :default => proc { Date.today })
     end
     Entry.create!(:created_at => 3.days.ago)
-    grid.assets.should_not be_empty
+    expect(grid.assets).not_to be_empty
   end
 
   describe "#filter_by" do
@@ -171,8 +171,8 @@ describe Datagrid::Filters do
       end
       e = Entry.create!(:name => 'hello')
       grid.attributes = {:id => -1, :name => 'hello'}
-      grid.assets.should be_empty
-      grid.filter_by(:name).should_not be_empty
+      expect(grid.assets).to be_empty
+      expect(grid.filter_by(:name)).not_to be_empty
     end
   end
 end

data/spec/datagrid/form_builder_spec.rb

@@ -20,7 +20,7 @@ describe Datagrid::FormBuilder do
 
     it "should work for every filter type" do
       Datagrid::Filters::FILTER_TYPES.each do |type, klass|
-        Datagrid::FormBuilder.instance_methods.map(&:to_sym).should include(klass.form_builder_helper_name)
+        expect(Datagrid::FormBuilder.instance_methods.map(&:to_sym)).to include(klass.form_builder_helper_name)
       end
     end
 
@@ -497,22 +497,22 @@ DOM
       end
     end
     it "should generate label for filter" do
-      view.datagrid_label(:name).should equal_to_dom(
+      expect(view.datagrid_label(:name)).to equal_to_dom(
         '<label for="report_name">Name</label>'
       )
     end
     it "should pass options through to the helper" do
-      view.datagrid_label(:name, :class => 'foo').should equal_to_dom(
+      expect(view.datagrid_label(:name, :class => 'foo')).to equal_to_dom(
         '<label class="foo" for="report_name">Name</label>'
       )
     end
     it "should support block" do
-      view.datagrid_label(:name, :class => 'foo') { 'The Name' }.should equal_to_dom(
+      expect(view.datagrid_label(:name, :class => 'foo') { 'The Name' }).to equal_to_dom(
         '<label class="foo" for="report_name">The Name</label>'
       )
     end
     it "should support explicit label" do
-      view.datagrid_label(:name, "The Name").should equal_to_dom(
+      expect(view.datagrid_label(:name, "The Name")).to equal_to_dom(
         '<label for="report_name">The Name</label>'
       )
     end

data/spec/datagrid/helper_spec.rb

@@ -7,15 +7,15 @@ require 'datagrid/renderer'
 describe Datagrid::Helper do
   subject do
     template = ActionView::Base.new
-    template.stub(:protect_against_forgery?).and_return(false)
+    allow(template).to receive(:protect_against_forgery?).and_return(false)
     template.view_paths << File.expand_path("../../../app/views", __FILE__)
     template.view_paths << File.expand_path("../../support/test_partials", __FILE__)
     template
   end
 
   before(:each) do
-    subject.stub(:params).and_return({})
-    subject.stub(:url_for) do |options|
+    allow(subject).to receive(:params).and_return({})
+    allow(subject).to receive(:url_for) do |options|
       options.to_param
     end
 
@@ -37,16 +37,16 @@ describe Datagrid::Helper do
     it "should show an empty table with dashes" do
       datagrid_table = subject.datagrid_table(grid)
 
-      datagrid_table.should match_css_pattern(
+      expect(datagrid_table).to match_css_pattern(
         "table.datagrid tr td.noresults" => 1
       )
-      datagrid_table.should include("&mdash;&mdash;")
+      expect(datagrid_table).to include("&mdash;&mdash;")
     end
   end
 
   describe ".datagrid_table" do
     it "should have grid class as html class on table" do
-      subject.datagrid_table(grid).should match_css_pattern(
+      expect(subject.datagrid_table(grid)).to match_css_pattern(
         "table.datagrid.simple_report" => 1
       )
     end
@@ -57,14 +57,14 @@ describe Datagrid::Helper do
           scope { Entry }
         end
       end
-      subject.datagrid_table(::Ns23::TestGrid.new).should match_css_pattern(
+      expect(subject.datagrid_table(::Ns23::TestGrid.new)).to match_css_pattern(
         "table.datagrid.ns23_test_grid" => 1
       )
     end
     it "should return data table html" do
       datagrid_table = subject.datagrid_table(grid)
 
-      datagrid_table.should match_css_pattern({
+      expect(datagrid_table).to match_css_pattern({
         "table.datagrid tr th.group div.order" => 1,
         "table.datagrid tr th.group" => /Group.*/,
         "table.datagrid tr th.name div.order" => 1,
@@ -78,7 +78,7 @@ describe Datagrid::Helper do
       other_entry = Entry.create!(entry.attributes)
       datagrid_table = subject.datagrid_table(grid, [entry])
 
-      datagrid_table.should match_css_pattern({
+      expect(datagrid_table).to match_css_pattern({
         "table.datagrid tr th.group div.order" => 1,
         "table.datagrid tr th.group" => /Group.*/,
         "table.datagrid tr th.name div.order" => 1,
@@ -89,7 +89,7 @@ describe Datagrid::Helper do
     end
 
     it "should support cycle option" do
-      subject.datagrid_rows(grid, [entry], :cycle => ["odd", "even"]).should match_css_pattern({
+      expect(subject.datagrid_rows(grid, [entry], :cycle => ["odd", "even"])).to match_css_pattern({
         "tr.odd td.group" => "Pop",
         "tr.odd td.name" => "Star"
       })
@@ -97,11 +97,11 @@ describe Datagrid::Helper do
     end
 
     it "should support no order given" do
-      subject.datagrid_table(grid, [entry], :order => false).should match_css_pattern("table.datagrid th .order" => 0)
+      expect(subject.datagrid_table(grid, [entry], :order => false)).to match_css_pattern("table.datagrid th .order" => 0)
     end
 
     it "should support columns option" do
-      subject.datagrid_table(grid, [entry], :columns => [:name]).should match_css_pattern(
+      expect(subject.datagrid_table(grid, [entry], :columns => [:name])).to match_css_pattern(
         "table.datagrid th.name" => 1,
         "table.datagrid td.name" => 1,
         "table.datagrid th.group" => 0,
@@ -119,7 +119,7 @@ describe Datagrid::Helper do
       end
 
       it "should output only given column names" do
-        subject.datagrid_table(grid, [entry]).should match_css_pattern(
+        expect(subject.datagrid_table(grid, [entry])).to match_css_pattern(
           "table.datagrid th.name" => 1,
           "table.datagrid td.name" => 1,
           "table.datagrid th.category" => 0,
@@ -155,7 +155,7 @@ describe Datagrid::Helper do
           scope { Entry }
           column(:name, :url => lambda {|model| model.name})
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name a[href=Star]" => "Star"
         )
       end
@@ -165,7 +165,7 @@ describe Datagrid::Helper do
           scope { Entry }
           column(:name, :url => lambda {|model| false})
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name" => "Star"
         )
       end
@@ -175,7 +175,7 @@ describe Datagrid::Helper do
           scope { Entry }
           column(:name)
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name.ordered.asc" => "Star"
         )
       end
@@ -185,7 +185,7 @@ describe Datagrid::Helper do
           scope { Entry }
           column(:name)
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name.ordered.desc" => "Star"
         )
       end
@@ -197,7 +197,7 @@ describe Datagrid::Helper do
             content_tag(:span, model.name)
           end
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name span" => "Star"
         )
       end
@@ -207,7 +207,7 @@ describe Datagrid::Helper do
           scope { Entry }
           column(:name, :html => lambda {|data| content_tag :h1, data})
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name h1" => "Star"
         )
       end
@@ -219,7 +219,7 @@ describe Datagrid::Helper do
             self.name.upcase
           end
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name em" => "STAR"
         )
       end
@@ -231,7 +231,7 @@ describe Datagrid::Helper do
             content_tag(:span, "#{model.name}-#{grid.assets.klass}" )
           end
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name span" => "Star-Entry"
         )
       end
@@ -243,7 +243,7 @@ describe Datagrid::Helper do
             content_tag :h1, "#{data}-#{model.name.downcase}"
           })
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name h1" => "Star-star"
         )
       end
@@ -255,7 +255,7 @@ describe Datagrid::Helper do
             content_tag :h1, "#{data}-#{model.name.downcase}-#{grid.assets.klass}"
           })
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name h1" => "Star-star-Entry"
         )
       end
@@ -269,7 +269,7 @@ describe Datagrid::Helper do
             self.name.upcase
           end
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name h1" => "STAR-Star"
         )
       end
@@ -283,7 +283,7 @@ describe Datagrid::Helper do
             self.name.upcase
           end
         end
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name h1" => "STAR-Star-Entry"
         )
       end
@@ -294,10 +294,10 @@ describe Datagrid::Helper do
           column(:name)
           column(:category)
         end
-        subject.datagrid_rows(rp, [entry], :columns => [:name]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry], :columns => [:name])).to match_css_pattern(
           "tr td.name" => "Star"
         )
-        subject.datagrid_rows(rp, [entry], :columns => [:name]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry], :columns => [:name])).to match_css_pattern(
           "tr td.category" => 0
         )
       end
@@ -308,7 +308,7 @@ describe Datagrid::Helper do
           column(:name, :class => 'my_class')
         end
 
-        subject.datagrid_rows(rp, [entry]).should match_css_pattern(
+        expect(subject.datagrid_rows(rp, [entry])).to match_css_pattern(
           "tr td.name.my_class" => "Star"
         )
       end
@@ -324,7 +324,7 @@ describe Datagrid::Helper do
           end
         end
         it "should ignore them" do
-          subject.datagrid_rows(grid, [entry]).should match_css_pattern(
+          expect(subject.datagrid_rows(grid, [entry])).to match_css_pattern(
             "td.name" => 1
           )
         end
@@ -339,7 +339,7 @@ describe Datagrid::Helper do
           column(:category)
         end
         grid = OrderedGrid.new(:descending => true, :order => :category)
-        subject.datagrid_order_for(grid, grid.column_by_name(:category)).should equal_to_dom(<<-HTML)
+        expect(subject.datagrid_order_for(grid, grid.column_by_name(:category))).to equal_to_dom(<<-HTML)
 <div class="order">
   <a href="ordered_grid%5Bdescending%5D=false&amp;ordered_grid%5Border%5D=category" class="asc">&uarr;</a>
   <a href="ordered_grid%5Bdescending%5D=true&amp;ordered_grid%5Border%5D=category" class="desc">&darr;</a>
@@ -362,12 +362,13 @@ describe Datagrid::Helper do
           filter(:category)
         end
         grid = FormForGrid.new(:category => "hello")
-        subject.datagrid_form_for(grid, :url => "/grid").should match_css_pattern(
+        expect(subject.datagrid_form_for(grid, :url => "/grid")).to match_css_pattern(
           "form.datagrid-form.form_for_grid[action='/grid']" => 1,
           "form input[name=utf8]" => 1,
           "form .filter label" => "Category",
           "form .filter input.category.default_filter[name='form_for_grid[category]'][value=hello]" => 1,
-          "form input[name=commit][value=Search]" => 1
+          "form input[name=commit][value=Search]" => 1,
+          "form a.datagrid-reset[href='']" => 1
         )
       end
       it "should support html classes for grid class with namespace" do
@@ -377,7 +378,7 @@ describe Datagrid::Helper do
             scope { Entry }
           end
         end
-        subject.datagrid_form_for(::Ns22::TestGrid.new, :url => "grid").should match_css_pattern(
+        expect(subject.datagrid_form_for(::Ns22::TestGrid.new, :url => "grid")).to match_css_pattern(
           "form.datagrid-form.ns22_test_grid" => 1,
         )
       end
@@ -399,13 +400,13 @@ describe Datagrid::Helper do
 
       it "should provide access to row data" do
         r = subject.datagrid_row(grid, entry)
-        r.name.should == "Hello"
-        r.category.should == "greetings"
+        expect(r.name).to eq("Hello")
+        expect(r.category).to eq("greetings")
       end
       it "should yield block" do
         subject.datagrid_row(grid, entry) do |row|
-          row.name.should == "Hello"
-          row.category.should == "greetings"
+          expect(row.name).to eq("Hello")
+          expect(row.category).to eq("greetings")
         end
       end
 
@@ -415,7 +416,7 @@ describe Datagrid::Helper do
           subject.concat(",")
           subject.concat(row.category)
         end
-        name.should == "Hello,greetings"
+        expect(name).to eq("Hello,greetings")
       end
     end
   end
@@ -428,7 +429,7 @@ describe Datagrid::Helper do
           "<b>#{e.name}</b>"
         end
       end
-      subject.datagrid_value(report, :name, entry).should == "<b>Star</b>"
+      expect(subject.datagrid_value(report, :name, entry)).to eq("<b>Star</b>")
     end
     it "should support format in column" do
       report = test_report do
@@ -439,7 +440,7 @@ describe Datagrid::Helper do
           end
         end
       end
-      subject.datagrid_value(report, :name, entry).should == "<a href=\"/profile\">Star</a>"
+      expect(subject.datagrid_value(report, :name, entry)).to eq("<a href=\"/profile\">Star</a>")
     end
   end
 end