datagrid 1.2.0 → 1.2.1

data/spec/datagrid/core_spec.rb

@@ -15,7 +15,7 @@ describe Datagrid::Core do
       context 'in the class' do
         let(:report) { report_class.new }
 
-        it { expect(report.scope.to_a).to have(2).item }
+        it { expect(report.scope.to_a.size).to eq(2) }
       end
 
       context 'changes scope on the fly' do
@@ -25,26 +25,26 @@ describe Datagrid::Core do
           end
         end
 
-        it { expect(report.scope.to_a).to have(1).item }
+        it { expect(report.scope.to_a.size).to eq(1) }
       end
 
       context 'overriding scope by initializer' do
         let(:report) { report_class.new { Entry.limit(1) } }
 
-        it { expect(report.scope.to_a).to have(1).item }
+        it { expect(report.scope.to_a.size).to eq(1) }
 
         context "reset scope to default" do
           before do
             report.reset_scope
           end
-          it { expect(report.scope.to_a).to have(2).item }
+          it { expect(report.scope.to_a.size).to eq(2) }
         end
       end
 
       context "appending scope by initializer " do
         let(:report) { report_class.new {|scope| scope.limit(1)} }
-        it { expect(report.scope.to_a).to have(1).item }
-        it { expect(report.scope.order_values).to have(1).item }
+        it { expect(report.scope.to_a.size).to eq(1) }
+        it { expect(report.scope.order_values.size).to eq(1) }
       end
     end
   end

data/spec/datagrid/drivers/active_record_spec.rb

@@ -11,13 +11,13 @@ describe Datagrid::Drivers::ActiveRecord do
   end
 
   it "should convert any scope to AR::Relation" do
-    subject.to_scope(Entry).should be_a(ActiveRecord::Relation)
-    subject.to_scope(Entry.limit(5)).should be_a(ActiveRecord::Relation)
-    subject.to_scope(Group.create!.entries).should be_a(ActiveRecord::Relation)
+    expect(subject.to_scope(Entry)).to be_a(ActiveRecord::Relation)
+    expect(subject.to_scope(Entry.limit(5))).to be_a(ActiveRecord::Relation)
+    expect(subject.to_scope(Group.create!.entries)).to be_a(ActiveRecord::Relation)
   end
 
   it "should support append_column_queries" do
     scope = subject.append_column_queries(Entry.scoped, [Datagrid::Columns::Column.new(SimpleReport, :sum_group_id, 'sum(entries.group_id)')])
-    scope.to_sql.strip.should == 'SELECT "entries".*, sum(entries.group_id) AS sum_group_id FROM "entries"'
+    expect(scope.to_sql.strip).to eq('SELECT "entries".*, sum(entries.group_id) AS sum_group_id FROM "entries"')
   end
 end

data/spec/datagrid/drivers/array_spec.rb

@@ -38,23 +38,56 @@ describe Datagrid::Drivers::Array do
     end
   
           
-    its(:"assets.size") {should == 3}
-    its(:rows) {should == [["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
-    its(:header) {should ==[ "Name", "Age"]}
+    describe '#assets' do
+      subject { super().assets }
+      describe '#size' do
+        subject { super().size }
+        it {should == 3}
+      end
+    end
+
+    describe '#rows' do
+      subject { super().rows }
+      it {should == [["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
+    end
+
+    describe '#header' do
+      subject { super().header }
+      it {should ==[ "Name", "Age"]}
+    end
       
-    its(:data) {should == [[ "Name", "Age"], ["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
+    describe '#data' do
+      subject { super().data }
+      it {should == [[ "Name", "Age"], ["Vasya", 15], ["Petya", 12], ["Vova", 13]]}
+    end
       
       
     describe "when some filters specified" do
       let(:_attributes) { {:age => [12,14]} }
-      its(:assets) {should_not include(first)}
-      its(:assets) {should include(second)}
-      its(:assets) {should include(third)}
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should_not include(first)}
+      end
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should include(second)}
+      end
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should include(third)}
+      end
     end
       
     describe "when reverse ordering is specified" do
       let(:_attributes) { {:order => :name, :descending => true} }
-      its(:assets) {should == [third, first, second]}
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should == [third, first, second]}
+      end
     end
   end
 end

data/spec/datagrid/drivers/mongo_mapper_spec.rb

@@ -34,32 +34,64 @@ describe Datagrid::Drivers::MongoMapper, :mongomapper do
     end
   
   
-    its(:assets) {should include(first, second)}
+    describe '#assets' do
+      subject { super().assets }
+      it {should include(first, second)}
+    end
       
-    its(:"assets.size") {should == 2}
-    its(:rows) {should == [["Main First", 2, false], ["Main Second", 3, true]]}
-    its(:header) {should ==[ "Name", "Group", "Disabled"]}
+    describe '#assets' do
+      subject { super().assets }
+      describe '#size' do
+        subject { super().size }
+        it {should == 2}
+      end
+    end
+
+    describe '#rows' do
+      subject { super().rows }
+      it {should == [["Main First", 2, false], ["Main Second", 3, true]]}
+    end
+
+    describe '#header' do
+      subject { super().header }
+      it {should ==[ "Name", "Group", "Disabled"]}
+    end
       
-    its(:data) {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
+    describe '#data' do
+      subject { super().data }
+      it {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
+    end
       
       
     describe "when some filters specified" do
       let(:_attributes) { {:from_group_id => 3} }
-      its(:assets) {should_not include(first)}
-      its(:assets) {should include(second)}
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should_not include(first)}
+      end
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should include(second)}
+      end
     end
       
     describe "when reverse ordering is specified" do
       let(:_attributes) { {:order => :name, :descending => true} }
-      its(:rows) {should == [["Main Second", 3, true], ["Main First", 2, false]]}
+
+      describe '#rows' do
+        subject { super().rows }
+        it {should == [["Main Second", 3, true], ["Main First", 2, false]]}
+      end
     end
     it "should not provide default order for non declared fields" do
-      proc {
+      expect {
         test_report(:order => :test) do
           scope { MongoMapperEntry }
           column(:test)
         end
-      }.should raise_error(Datagrid::OrderUnsupported)
+      }.to raise_error(Datagrid::OrderUnsupported)
     end
   end
 end

data/spec/datagrid/drivers/mongoid_spec.rb

@@ -33,33 +33,65 @@ describe Datagrid::Drivers::Mongoid, :mongoid do
     end
 
 
-    its(:assets) {should include(first, second)}
+    describe '#assets' do
+      subject { super().assets }
+      it {should include(first, second)}
+    end
+
+    describe '#assets' do
+      subject { super().assets }
+      describe '#size' do
+        subject { super().size }
+        it {should == 2}
+      end
+    end
 
-    its(:"assets.size") {should == 2}
-    its(:rows) {should == [["Main First", 2, false], ["Main Second", 3, true]]}
-    its(:header) {should ==[ "Name", "Group", "Disabled"]}
+    describe '#rows' do
+      subject { super().rows }
+      it {should == [["Main First", 2, false], ["Main Second", 3, true]]}
+    end
+
+    describe '#header' do
+      subject { super().header }
+      it {should ==[ "Name", "Group", "Disabled"]}
+    end
 
-    its(:data) {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
+    describe '#data' do
+      subject { super().data }
+      it {should == [[ "Name", "Group", "Disabled"], ["Main First", 2, false], ["Main Second", 3, true]]}
+    end
 
 
     describe "when some filters specified" do
       let(:_attributes) { {:from_group_id => 3} }
-      its(:assets) {should_not include(first)}
-      its(:assets) {should include(second)}
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should_not include(first)}
+      end
+
+      describe '#assets' do
+        subject { super().assets }
+        it {should include(second)}
+      end
     end
 
     describe "when reverse ordering is specified" do
       let(:_attributes) { {:order => :name, :descending => true} }
-      its(:rows) {should == [["Main Second", 3, true], ["Main First", 2, false]]}
+
+      describe '#rows' do
+        subject { super().rows }
+        it {should == [["Main Second", 3, true], ["Main First", 2, false]]}
+      end
     end
 
     it "should not provide default order for non declared fields" do
-      proc {
+      expect {
         test_report(:order => :test) do
           scope { MongoidEntry }
           column(:test)
         end
-      }.should raise_error(Datagrid::OrderUnsupported)
+      }.to raise_error(Datagrid::OrderUnsupported)
     end
 
     it "should support batch_size" do
@@ -69,7 +101,7 @@ describe Datagrid::Drivers::Mongoid, :mongoid do
         column(:name)
       end
 
-      report.data.should == [["Name"], ["Main First"], ["Main Second"]]
+      expect(report.data).to eq([["Name"], ["Main First"], ["Main Second"]])
     end
   end
 end

data/spec/datagrid/filters/composite_filters_spec.rb

@@ -13,23 +13,23 @@ describe Datagrid::Filters::CompositeFilters do
         date_range_filters(:shipping_date)
       end.assets
 
-      assets.should include(e2)
-      assets.should_not include(e1, e3)
+      expect(assets).to include(e2)
+      expect(assets).not_to include(e1, e3)
     end
 
     it "should support options" do
       report = test_report do
         report = date_range_filters(:shipping_date, {:default => 10.days.ago.to_date}, {:default => Date.today})
       end
-      report.from_shipping_date.should == 10.days.ago.to_date
-      report.to_shipping_date.should == Date.today
+      expect(report.from_shipping_date).to eq(10.days.ago.to_date)
+      expect(report.to_shipping_date).to eq(Date.today)
     end
     it "should support table name in field" do
       report = test_report do
         report = date_range_filters("entries.shipping_date", {:default => 10.days.ago.to_date}, {:default => Date.today})
       end
-      report.from_entries_shipping_date.should == 10.days.ago.to_date
-      report.to_entries_shipping_date.should == Date.today
+      expect(report.from_entries_shipping_date).to eq(10.days.ago.to_date)
+      expect(report.to_entries_shipping_date).to eq(Date.today)
     end
   end
   
@@ -44,22 +44,22 @@ describe Datagrid::Filters::CompositeFilters do
         integer_range_filters(:group_id)
       end.assets
 
-      assets.should include(e2)
-      assets.should_not include(e1, e3)
+      expect(assets).to include(e2)
+      expect(assets).not_to include(e1, e3)
     end
     it "should support options" do
       report = test_report do
         report = integer_range_filters(:group_id, {:default => 0}, {:default => 100})
       end
-      report.from_group_id.should == 0
-      report.to_group_id.should == 100
+      expect(report.from_group_id).to eq(0)
+      expect(report.to_group_id).to eq(100)
     end
     it "should table name in field name" do
       report = test_report do
         report = integer_range_filters("entries.group_id", {:default => 0}, {:default => 100})
       end
-      report.from_entries_group_id.should == 0
-      report.to_entries_group_id.should == 100
+      expect(report.from_entries_group_id).to eq(0)
+      expect(report.to_entries_group_id).to eq(100)
     end
   end
 end

data/spec/datagrid/filters/date_filter_spec.rb

@@ -10,9 +10,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
   {:active_record => Entry, :mongoid => MongoidEntry}.each do |orm, klass|
@@ -60,9 +60,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
   it "should support minimum date argument" do
@@ -73,9 +73,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).to include(e3)
   end
 
   it "should support maximum date argument" do
@@ -86,9 +86,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date, :range => true)
     end
-    report.assets.should include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
   it "should find something in one day interval" do
@@ -100,9 +100,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).to include(e2)
+    expect(report.assets).not_to include(e3)
   end
   it "should support invalid range" do
 
@@ -113,9 +113,9 @@ describe Datagrid::Filters::DateFilter do
       scope { Entry }
       filter(:created_at, :date, :range => true)
     end
-    report.assets.should_not include(e1)
-    report.assets.should_not include(e2)
-    report.assets.should_not include(e3)
+    expect(report.assets).not_to include(e1)
+    expect(report.assets).not_to include(e2)
+    expect(report.assets).not_to include(e3)
   end
 
 
@@ -126,8 +126,8 @@ describe Datagrid::Filters::DateFilter do
         where("created_at >= ?", value)
       end
     end
-    report.assets.should_not include(Entry.create!(:created_at => 1.day.ago))
-    report.assets.should include(Entry.create!(:created_at => DateTime.now))
+    expect(report.assets).not_to include(Entry.create!(:created_at => 1.day.ago))
+    expect(report.assets).to include(Entry.create!(:created_at => DateTime.now))
   end
 
 
@@ -143,7 +143,7 @@ describe Datagrid::Filters::DateFilter do
         scope  {Entry}
         filter(:created_at, :date)
       end
-      report.created_at.should == Date.new(2013,10,01)
+      expect(report.created_at).to eq(Date.new(2013,10,01))
     end
 
     it "should support default explicit date" do
@@ -151,7 +151,7 @@ describe Datagrid::Filters::DateFilter do
         scope  {Entry}
         filter(:created_at, :date)
       end
-      report.created_at.should == Date.new(2013,10,01)
+      expect(report.created_at).to eq(Date.new(2013,10,01))
     end
   end
 
@@ -161,14 +161,14 @@ describe Datagrid::Filters::DateFilter do
       scope  {Entry}
       filter(:created_at, :date, :range => true)
     end
-    report.created_at.should == [Date.new(2012, 01, 01), Date.new(2013, 01, 01)]
+    expect(report.created_at).to eq([Date.new(2012, 01, 01), Date.new(2013, 01, 01)])
   end
   it "should automatically reverse Array if first more than last" do
     report = test_report(:created_at => ["2013-01-01", "2012-01-01"]) do
       scope  {Entry}
       filter(:created_at, :date, :range => true)
     end
-    report.created_at.should == [Date.new(2012, 01, 01), Date.new(2013, 01, 01)]
+    expect(report.created_at).to eq([Date.new(2012, 01, 01), Date.new(2013, 01, 01)])
   end
 
   it "should properly format date in filter_value_as_string" do
@@ -177,7 +177,7 @@ describe Datagrid::Filters::DateFilter do
         scope  {Entry}
         filter(:created_at, :date)
       end
-      report.filter_value_as_string(:created_at).should == "01/02/2012"
+      expect(report.filter_value_as_string(:created_at)).to eq("01/02/2012")
     end
   end