datagrid 0.6.4 → 0.7.0

data/lib/datagrid/helper.rb

@@ -31,8 +31,8 @@ module Datagrid
     end
 
     def datagrid_column_classes(grid, column)
-        order_class = grid.order == column.name ? ["ordered", grid.descending ? "desc" : "asc"] : nil
-      [column.name, order_class].compact.join(" ")
+      order_class = grid.order == column.name ? ["ordered", grid.descending ? "desc" : "asc"] : nil
+      [column.name, order_class, column.options[:class]].compact.join(" ")
     end
   end
 end

data/lib/datagrid/ordering.rb

@@ -50,8 +50,8 @@ module Datagrid
 
       def assets
         result = super
-        if self.order
-          column = column_by_name(self.order)
+        if order
+          column = column_by_name(order)
           result = apply_order(result, column)
         end
         result
@@ -60,19 +60,49 @@ module Datagrid
       private
 
       def apply_order(assets, column)
-
-        order = column.order
-        if self.descending?
+        if descending?
           if column.order_desc
-            driver.asc(assets, column.order_desc) 
+            apply_asc_order(assets, column.order_desc)
           else
-            driver.desc(assets, order)
+            apply_desc_order(assets, column.order)
           end
+        else
+          apply_asc_order(assets, column.order)
+        end
+      end
+
+      def apply_asc_order(assets, order)
+        if order.respond_to?(:call)
+          apply_block_order(assets, order)
         else
           driver.asc(assets, order) 
         end
       end
 
+      def apply_desc_order(assets, order)
+        if order.respond_to?(:call)
+          reverse_order(apply_asc_order(assets, order))
+        else
+          driver.desc(assets, order)
+        end
+      end
+
+      def reverse_order(assets)
+        driver.reverse_order(assets)
+      rescue NotImplementedError
+        self.class.order_unsupported("Your ORM do not support reverse order: please specify :order_desc option manually")
+      end
+
+      def apply_block_order(assets, order)
+        case order.arity 
+        when -1, 0
+          assets.instance_eval(&order)
+        when 1
+          order.call(assets)
+        else
+          self.class.order_unsupported("Order option proc can not handle more than one argument")
+        end
+      end
     end # InstanceMethods
 
   end

data/lib/datagrid/renderer.rb

@@ -12,15 +12,24 @@ module Datagrid
     end
 
     def format_value(grid, column, asset)
+
       value = if column.html?
-        if column.block.arity > 1
-          @template.instance_exec(asset, grid, &column.block)
-        else
-          @template.instance_exec(asset, &column.block)
+        args = []
+        remaining_arity = column.html_block.arity
+
+        if column.data?
+          args << column.value(asset,grid)
+          remaining_arity -= 1
         end
+
+        args << asset if remaining_arity > 0
+        args << grid if remaining_arity > 1
+
+        @template.instance_exec(*args, &column.html_block)
       else
-        column.value(asset, grid)
+        column.value(asset,grid)
       end
+
       url = column.options[:url] && column.options[:url].call(asset)
       if url
         @template.link_to(value, url)

data/lib/datagrid/utils.rb

@@ -2,6 +2,7 @@ module Datagrid
   module Utils
     class << self
 
+
       TRUTH = [true, 1, "1", "true", "yes", "on"]
 
       def booleanize(value)
@@ -17,6 +18,21 @@ module Datagrid
           @warnings[message] = true
         end
       end
+
+      def add_html_classes(options, *classes)
+        options = options.clone
+        options[:class] ||= ""
+        if options[:class].is_a?(Array)
+          options[:class] += classes
+        else
+          # suppose that it is a String
+          options[:class] += " " unless options[:class].blank?
+          options[:class] += classes.join(" ")
+        end
+        options
+      end
+
+
     end
   end
 end

data/spec/datagrid/columns_spec.rb

@@ -11,17 +11,23 @@ describe Datagrid::Columns do
   describe "basic methods" do
 
     let!(:entry) {  Entry.create!(
-      :group => group, :name => "Star", :disabled => false, :confirmed => false, :category => "first"
+      :group => group,
+      :name => "Star",
+      :disabled => false,
+      :confirmed => false,
+      :category => "first",
+      :access_level => 'admin',
+      :pet => 'rottweiler'
     ) }
 
     it "should have data columns without html columns" do
       subject.data_columns.size.should == subject.columns.size - 1
     end
     it "should build rows of data" do
-      subject.rows.should == [["Pop", "Star"]]
+      subject.rows.should == [["Pop", "Star", "admin", "ROTTWEILER"]]
     end
     it  "should generate header" do
-      subject.header.should == ["Group", "Name"]
+      subject.header.should == ["Group", "Name", "Access level", "Pet"]
     end
 
     it "should generate table data" do
@@ -34,12 +40,18 @@ describe Datagrid::Columns do
     it "should generate hash for given asset" do
       subject.hash_for(entry).should == {
         :group => "Pop",
-        :name => "Star"
+        :name => "Star",
+        :access_level => 'admin',
+        :pet => 'ROTTWEILER'
       }
     end
 
     it "should support csv export" do
-      subject.to_csv.should == "Group,Name\nPop,Star\n"
+      subject.to_csv.should == "Group,Name,Access level,Pet\nPop,Star,admin,ROTTWEILER\n"
+    end
+
+    it "should support csv export of particular columns" do
+      subject.to_csv(:name).should == "Name\nStar\n"
     end
   end
 
@@ -50,8 +62,8 @@ describe Datagrid::Columns do
         where("category LIKE '%#{value}%'")
       end
 
-      column(:exact_category) do |entry, report|
-        entry.category == report.category
+      column(:exact_category) do |entry, grid|
+        entry.category == grid.category
       end
     end
     Entry.create!(:category => "foo")

data/spec/datagrid/filters/date_filter_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Datagrid::Filters::DateFilter do
+
+  it "should support date range argument" do
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => 5.day.ago..3.days.ago) 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)
+  end
+
+  it "should support date range given as array argument" do
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => [5.day.ago.to_date.to_s, 3.days.ago.to_date.to_s]) 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)
+  end
+
+  it "should support minimum date argument" do
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => [5.day.ago.to_date.to_s, nil]) 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)
+  end
+
+  it "should support maximum date argument" do
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => [nil, 3.days.ago.to_date.to_s]) 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)
+  end
+
+  it "should find something in one day interval" do
+
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => (4.days.ago.to_date..4.days.ago.to_date)) 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)
+  end
+  it "should support invalid range" do
+
+    e1 = Entry.create!(:created_at => 7.days.ago)
+    e2 = Entry.create!(:created_at => 4.days.ago)
+    e3 = Entry.create!(:created_at => 1.day.ago)
+    report = test_report(:created_at => (1.days.ago.to_date..7.days.ago.to_date)) 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)
+  end
+
+
+  it "should support block" do
+    report = test_report(:created_at => Date.today) do
+      scope { Entry } 
+      filter(:created_at, :date, :range => true) do |value|
+        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))
+  end
+  
+end

data/spec/datagrid/filters/integer_filter_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Datagrid::Filters::IntegerFilter do
+
+  it "should support integer range argument" do
+    e1 = Entry.create!(:group_id => 1)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 7)
+    report = test_report(:group_id => 3..5) do
+      scope { Entry } 
+      filter(:group_id, :integer)
+    end
+    report.assets.should_not include(e1)
+    report.assets.should include(e2)
+    report.assets.should_not include(e3)
+  end
+
+  it "should support integer range given as array argument" do
+    e1 = Entry.create!(:group_id => 7)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 1)
+    report = test_report(:group_id => [3.to_s, 5.to_s]) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true)
+    end
+    report.assets.should_not include(e1)
+    report.assets.should include(e2)
+    report.assets.should_not include(e3)
+  end
+
+  it "should support minimum integer argument" do
+    e1 = Entry.create!(:group_id => 1)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 7)
+    report = test_report(:group_id => [5.to_s, nil]) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true)
+    end
+    report.assets.should_not include(e1)
+    report.assets.should_not include(e2)
+    report.assets.should include(e3)
+  end
+
+  it "should support maximum integer argument" do
+    e1 = Entry.create!(:group_id => 1)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 7)
+    report = test_report(:group_id => [nil, 5.to_s]) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true)
+    end
+    report.assets.should include(e1)
+    report.assets.should include(e2)
+    report.assets.should_not include(e3)
+  end
+
+  it "should find something in one integer interval" do
+
+    e1 = Entry.create!(:group_id => 7)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 1)
+    report = test_report(:group_id => (4..4)) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true)
+    end
+    report.assets.should_not include(e1)
+    report.assets.should include(e2)
+    report.assets.should_not include(e3)
+  end
+  it "should support invalid range" do
+
+    e1 = Entry.create!(:group_id => 7)
+    e2 = Entry.create!(:group_id => 4)
+    e3 = Entry.create!(:group_id => 1)
+    report = test_report(:group_id => (7..1)) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true)
+    end
+    report.assets.should_not include(e1)
+    report.assets.should_not include(e2)
+    report.assets.should_not include(e3)
+  end
+
+
+  it "should support block" do
+    report = test_report(:group_id => 5) do
+      scope { Entry } 
+      filter(:group_id, :integer, :range => true) do |value|
+        where("group_id >= ?", value)
+      end
+    end
+    report.assets.should_not include(Entry.create!(:group_id => 1))
+    report.assets.should include(Entry.create!(:group_id => 5))
+  end
+  
+end

data/spec/datagrid/filters_spec.rb

@@ -51,8 +51,9 @@ describe Datagrid::Filters do
       scope {ModelWithoutTable}
 
       filter(:name)
+      filter(:limit)
     end
-    TheReport.new(:name => 'hello')
+    TheReport.new(:name => 'hello').should_not be_nil
   end
 
   it "should support inheritence" do

data/spec/datagrid/form_builder_spec.rb

@@ -50,6 +50,98 @@ describe Datagrid::FormBuilder do
         '<input class="group_id integer_filter" id="report_group_id" name="report[group_id]" size="30" type="text"/>'
       )}
     end
+
+    context "with date filter type" do
+      let(:_filter) { :created_at }
+      let(:_grid) {
+        test_report do
+          scope {Entry}
+          filter(:created_at, :date)
+        end
+      }
+      it { should equal_to_dom(
+        '<input class="created_at date_filter" id="report_created_at" name="report[created_at]" size="30" type="text"/>'
+      )}
+    end
+
+    context "with integer filter type and range option" do
+      let(:_filter) { :group_id }
+      let(:_grid) {
+        test_report(:group_id => _range) do
+          scope {Entry}
+          filter(:group_id, :integer, :range => true)
+        end
+      }
+      context "with only left bound" do
+        
+        let(:_range) { [10, nil]}
+        it { should equal_to_dom(
+          '<input class="group_id integer_filter from" id="report_group_id" multiple name="report[group_id][]" size="30" type="text" value="10"/>' +
+          '<span class="separator integer"> - </span>' +
+          '<input class="group_id integer_filter to" id="report_group_id" multiple name="report[group_id][]" size="30" type="text"/>'
+        )}
+        it { should be_html_safe }
+      end
+      context "with only right bound" do
+        
+        let(:_range) { [nil, 10]}
+        it { should equal_to_dom(
+          '<input class="group_id integer_filter from" id="report_group_id" multiple name="report[group_id][]" size="30" type="text"/>' +
+          '<span class="separator integer"> - </span>' +
+          '<input class="group_id integer_filter to" id="report_group_id" multiple name="report[group_id][]" size="30" type="text" value="10"/>'
+        )}
+        it { should be_html_safe }
+      end
+
+      context "with invalid range value" do
+        let(:_range) { 2..1 }
+        it { should equal_to_dom(
+          '<input class="group_id integer_filter from" id="report_group_id" multiple name="report[group_id][]" size="30" type="text" value="2"/>' +
+          '<span class="separator integer"> - </span>' +
+          '<input class="group_id integer_filter to" id="report_group_id" multiple name="report[group_id][]" size="30" type="text" value="1"/>'
+        )}
+      end
+    end
+
+
+    context "with date filter type and range option" do
+      let(:_filter) { :created_at }
+      let(:_grid) {
+        test_report(:created_at => _range) do
+          scope {Entry}
+          filter(:created_at, :date, :range => true)
+        end
+      }
+      context "with only left bound" do
+        
+        let(:_range) { ["2012-01-03", nil]}
+        it { should equal_to_dom(
+          '<input class="created_at date_filter from" id="report_created_at" multiple name="report[created_at][]" size="30" type="text" value="2012-01-03"/>' +
+          '<span class="separator date"> - </span>' +
+          '<input class="created_at date_filter to" id="report_created_at" multiple name="report[created_at][]" size="30" type="text"/>'
+        )}
+        it { should be_html_safe }
+      end
+      context "with only right bound" do
+        
+        let(:_range) { [nil, "2012-01-03"]}
+        it { should equal_to_dom(
+          '<input class="created_at date_filter from" id="report_created_at" multiple name="report[created_at][]" size="30" type="text"/>' +
+          '<span class="separator date"> - </span>' +
+          '<input class="created_at date_filter to" id="report_created_at" multiple name="report[created_at][]" size="30" type="text" value="2012-01-03"/>'
+        )}
+        it { should be_html_safe }
+      end
+
+      context "with invalid range value" do
+        let(:_range) { Date.parse('2012-01-02')..Date.parse('2012-01-01') }
+        it { should equal_to_dom(
+          '<input class="created_at date_filter from" id="report_created_at" multiple name="report[created_at][]" size="30" type="text" value="2012-01-02"/>' +
+          '<span class="separator date"> - </span>' +
+          '<input class="created_at date_filter to" id="report_created_at" multiple name="report[created_at][]" size="30" type="text" value="2012-01-01"/>'
+        )}
+      end
+    end
     context "with enum filter type" do
       let(:_filter) { :category }
       let(:_grid) {