table_cloth 0.2.3 → 0.3.0.beta1

data/spec/lib/column_jury_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe TableCloth::ColumnJury do
+  let(:dummy_table) { stub(:table, admin?: true, moderator?: false) }
+
+  subject { TableCloth::ColumnJury.new(column, dummy_table) }
+
+  context 'conditions' do
+    context 'if' do
+      let(:column) { FactoryGirl.build(:if_column) }
+
+      specify 'the column is available when condition returns true' do
+        expect(subject).to be_available
+      end
+
+      it 'the column is not available when condition returns false' do
+        dummy_table.stub admin?: false
+        expect(subject).not_to be_available
+      end
+    end
+
+    context 'unless' do
+      let(:column) { FactoryGirl.build(:unless_column) }
+
+      specify 'the column is available when condition returns false' do
+        expect(subject).to be_available
+      end
+
+      specify 'the column is not available when condition returns true' do
+        dummy_table.stub moderator?: true
+        expect(subject).not_to be_available
+      end
+    end
+  end
+end

data/spec/lib/column_spec.rb

@@ -20,22 +20,17 @@ describe TableCloth::Column do
     it 'returns the email from a proc correctly' do
       email_column.value(dummy_model, view_context).should == 'robert at example.com'
     end
+  end
 
-    context '.available?' do
-      it 'returns true on successful constraint' do
-        table  = Class.new(DummyTable).new([dummy_model], view_context)
-        column = TableCloth::Column.new(:name, if: :admin?)
-        column.available?(table).should be_true
-      end
-
-      it 'returns false on failed constraints' do
-        table  = Class.new(DummyTable).new([dummy_model], view_context)
-        table.stub admin?: false
-
+  context "human name" do
+    it "returns the label when set" do
+      column = FactoryGirl.build(:column, options: { label: "Whatever" })
+      expect(column.human_name).to eq("Whatever")
+    end
 
-        column = TableCloth::Column.new(:name, if: :admin?)
-        column.available?(table).should be_false
-      end
+    it "humanizes the symbol if no label is set" do
+      column = FactoryGirl.build(:column, name: :email)
+      expect(column.human_name).to eq("Email")
     end
   end
 end

data/spec/lib/extensions/actions/action_collection_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe TableCloth::Extensions::Actions::ActionCollection do
+  subject { described_class.new }
+
+  context "#action" do
+    it "adds an action" do
+      subject.action { }
+      expect(subject).to have(1).actions
+    end
+
+    it "adds an action with options" do
+      subject.action(option: "something") { }
+      expect(subject.actions.first.options[:option]).to eq("something")
+    end
+  end
+
+  context "#actions" do
+    before(:each) do
+      subject.action { }
+    end
+
+    it "returns a list of actions" do
+      subject.actions.each do |action|
+        expect(action).to be_kind_of TableCloth::Extensions::Actions::Action
+      end
+    end
+  end
+end

data/spec/lib/extensions/actions/action_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe TableCloth::Extensions::Actions::Action do
+  let(:action_hash) { {proc: Proc.new{}} }
+  subject { described_class.new(action_hash) }
+
+  it "initializes with a hash" do
+    expect(subject.options).to eq(action_hash)
+  end
+
+  it "defines a delegator to a jury" do
+    expect(subject.jury).to be_kind_of TableCloth::Extensions::Actions::Jury
+  end
+
+  context "#value" do
+    let(:model) { FactoryGirl.build(:dummy_model) }
+    let(:view_context) { ActionView::Base.new }
+
+    context "string" do
+      let(:action_hash) { {proc: Proc.new{ "something" }} }
+
+      it "returns a string" do
+        expect(subject.value(model, view_context)).to match /something/
+      end
+    end
+
+    context "view helper" do
+      let(:action_hash) do
+        {proc: Proc.new { link_to "blank", "something" }}
+      end
+
+      it "returns a link" do
+        expect(subject.value(model, view_context)).to match /href="something"/
+        expect(subject.value(model, view_context)).to match />blank</
+      end
+    end
+
+    context "conditional" do
+      let(:action_hash) do
+        {
+          proc: Proc.new { "something" },
+          if: Proc.new {|object| object.admin? }
+        }
+      end
+
+      it "returns the link when the model condition succeeds" do
+        model.stub admin?: true
+        expect(subject.value(model, view_context)).to include "something"
+      end
+
+      it "does not return the link when the model condition fails" do
+        model.stub admin?: false
+        expect(subject.value(model, view_context)).not_to include "something"
+      end
+    end
+  end
+end

data/spec/lib/extensions/actions/column_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TableCloth::Extensions::Actions::Column do
+  let(:view_context) { ActionView::Base.new }
+  let(:dummy_model) { FactoryGirl.build(:dummy_model) }
+  let(:action_collection) { TableCloth::Extensions::Actions::ActionCollection.new }
+
+  subject { described_class.new(:actions, collection: action_collection) }
+
+  context "value" do
+    it "returns action values" do
+      action_collection.action { "something" }
+      expect(subject.value(dummy_model, view_context)).to match /something/
+    end
+
+    it "returns multiple action values" do
+      action_collection.action { "something" }
+      action_collection.action { "else" }
+      expect(subject.value(dummy_model, view_context)).to match /something/
+      expect(subject.value(dummy_model, view_context)).to match /else/
+    end
+  end
+end

data/spec/lib/extensions/actions/jury_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe TableCloth::Extensions::Actions::Jury do
+  let(:action) { FactoryGirl.build(:action, options: action_options) }
+  subject { described_class.new(action) }
+  let(:model) { double("model") }
+
+  context "Proc" do
+    context "if .available?" do
+      let(:action_options) { {if: Proc.new{|o| o.state == "valid" }} }
+
+      it "returns true for valid models" do
+        model.stub state: "valid"
+        expect(subject).to be_available(model)
+      end
+
+      it "returns false for invalid models" do
+        model.stub state: "invalid"
+        expect(subject).not_to be_available(model)
+      end
+    end
+
+    context "unless .available?" do
+      let(:action_options) { {unless: Proc.new{|o| o.state == "invalid" }} }
+      
+      it "returns true for valid models" do
+        model.stub state: "valid"
+        expect(subject).to be_available(model)
+      end
+
+      it "returns false for invalid models" do
+        model.stub state: "invalid"
+        expect(subject).not_to be_available(model)
+      end
+    end
+  end
+
+  context "Symbol" do
+    context "if .available?" do
+      let(:action_options) { {if: :valid?} }
+
+      it "returns true for valid?" do
+        model.stub valid?: true
+        expect(subject).to be_available(model)
+      end
+
+      it "returns true for valid?" do
+        model.stub valid?: false
+        expect(subject).not_to be_available(model)
+      end
+    end
+
+    context "unless .available?" do
+      let(:action_options) { {unless: :valid?} }
+      
+      it "returns true for valid models" do
+        model.stub valid?: false
+        expect(subject).to be_available(model)
+      end
+
+      it "returns false for invalid models" do
+        model.stub valid?: true
+        expect(subject).not_to be_available(model)
+      end
+    end
+  end
+end

data/spec/lib/extensions/actions_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe TableCloth::Extensions::Actions do
+  let(:dummy_table) { FactoryGirl.build(:dummy_table) }
+
+  context "inclusion" do
+    it "gives the table class an actions method" do
+      expect { dummy_table.send(:include, described_class) }.to change { dummy_table.respond_to? :actions }.to true
+    end
+
+    context ".actions" do
+      before(:each) { dummy_table.send(:include, described_class) }
+
+      it "yields an ActionCollection block" do
+        block_type = nil
+        dummy_table.actions { block_type = self }
+        expect(block_type).to be_kind_of TableCloth::Extensions::Actions::ActionCollection
+      end
+
+      it "creates an actions column on the table" do
+        dummy_table.actions { }
+        expect(dummy_table.columns).to have_key :actions
+      end
+
+      it "accepts options" do
+        dummy_table.actions(if: :admin?) { }
+        expect(dummy_table.columns[:actions][:options]).to have_key :if
+      end
+
+      it "sets a collection key for the column pointing to the collection object" do
+        dummy_table.actions { }
+        expect(dummy_table.columns[:actions][:options][:collection]).to be_kind_of TableCloth::Extensions::Actions::ActionCollection
+      end
+
+      it "sets the column class to an action column" do
+        dummy_table.actions { }
+        column = dummy_table.columns[:actions]
+        expect(column[:class]).to eq(TableCloth::Extensions::Actions::Column)
+      end
+    end
+  end
+end

data/spec/lib/presenter_spec.rb

@@ -10,50 +10,48 @@ describe TableCloth::Presenter do
   let(:view_context) { ActionView::Base.new }
   subject { TableCloth::Presenter.new(objects, dummy_table, view_context) }
 
-
-  context ".column_names" do
-    let(:table_instance) { dummy_table.new(objects, view_context) }
-    before(:each) { table_instance.stub admin?: false, awesome?: true }
-
-    it 'returns all names' do
-      dummy_table.column :name, :email
-      subject.column_names.should =~ ["Id", "Name", "Email"]
+  context ".columns" do
+    it "returns all columns from the table" do
+      expect(subject).to have(3).columns
     end
 
-    it 'includes actions when given' do
-      dummy_table.actions { action { } }
-      subject.column_names.should include 'Actions'
+    it "returns them as columns" do
+      subject.columns.each do |column|
+        expect(column).to be_kind_of TableCloth::Column
+      end
     end
 
-    it 'include actions when only partial are available' do
-      dummy_table.actions do
-        action(if: :admin?) { '/' }
-        action(if: :awesome?) { '/' }
+    context "that are unavaialble" do
+      let(:dummy_table) { FactoryGirl.build(:dummy_table, email: {if: :admin?}) }
+      let(:table_instance) { dummy_table.new(objects, view_context) }
+      before(:each) do 
+        table_instance.stub admin?: false
+        subject.stub table: table_instance
       end
-      subject.column_names.should include 'Actions'  
-    end
 
-    it 'uses a name given to it' do
-      dummy_table.column :email, label: 'Email Address'
-      subject.column_names.should include 'Email Address'
+      specify "are not returned" do
+        expect(subject).to have(0).columns
+      end
+
+      specify "name is not returned" do
+        expect(subject.column_names).not_to include "email"
+      end
     end
   end
 
-  it 'returns all values for a row' do
-    subject.row_values(dummy_model).should == [dummy_model.id, dummy_model.name, dummy_model.email]
-  end
+  context ".column_names" do
+    let(:table_instance) { dummy_table.new(objects, view_context) }
+    before(:each) { table_instance.stub admin?: false, awesome?: true }
 
-  it 'returns an edit link in the actions column' do
-    dummy_table.actions do
-      action {|object, view| link_to 'Edit', '/model/1/edit' }
+    it 'returns all names' do
+      subject.column_names.should == ["Id", "Name", "Email"]
     end
-
-    actions_value = subject.row_values(dummy_model).last
-    column = Nokogiri::HTML(actions_value)
-    column.at_xpath('//a')[:href].should == '/model/1/edit'
-    column.at_xpath('//a').text.should == 'Edit'
   end
 
+  it 'returns all values for a row' do
+    subject.row_values(dummy_model).should == [dummy_model.id, dummy_model.name, dummy_model.email]
+  end
+  
   it 'generates the values for all of the rows' do
     expected = objects.map {|o| [o.id, o.name, o.email] }
     expect(subject.rows).to eq(expected)

data/spec/lib/presenters/default_spec.rb

@@ -2,197 +2,134 @@ require 'spec_helper'
 
 describe TableCloth::Presenters::Default do
   let(:dummy_table) { Class.new(DummyTable) }
-  let(:dummy_model) do
-    DummyModel.new.tap do |d|
-      d.id    = 1
-      d.email = 'robert@example.com'
-      d.name  = 'robert'
-    end
-  end
+  let(:dummy_model) { FactoryGirl.build(:dummy_model) }
 
   let(:objects) do
-    3.times.map {|n| dummy_model.dup.tap {|dm| dm.id = n+1 } }
+    FactoryGirl.build_list(:dummy_model, 3)
   end
 
   let(:view_context) { ActionView::Base.new }
   subject { TableCloth::Presenters::Default.new(objects, dummy_table, view_context) }
 
-  it 'creates a table head' do
-    header = subject.render_header
-    doc = Nokogiri::HTML(header)
+  context "header" do
+    let(:column_names) { ["Col1", "Col2"] }
 
-    thead = doc.xpath('.//thead')
-    thead.should be_present
+    before(:each) do
+      subject.stub column_names: column_names
+    end
 
-    tr = thead.xpath('.//tr')
-    tr.should be_present
+    it "creates a thead" do
+      expect(subject.render_header).to have_tag "thead"
+    end
 
-    th = tr.xpath('.//th')
-    th.should be_present
+    it "creates th's" do
+      header = Nokogiri::HTML(subject.render_header)
+      expect(header.css("th").size).to be 2
+    end
 
-    th.length.should == 3
+    it "creates th's with the correct text" do
+      header = Nokogiri::HTML(subject.render_header)
+      header.css("th").each_with_index {|th, i| expect(th.text).to eq(column_names[i]) }
+    end
   end
 
-  it 'creates rows' do
-    rows = subject.render_rows
-    doc = Nokogiri::HTML(rows)
-
-    tbody = doc.xpath('//tbody')
-    tbody.should be_present
-
-    tbody.xpath('.//tr').each_with_index do |row, row_index|
-      row.xpath('.//td').each_with_index do |td, td_index|
-        object = objects[row_index]
-        case td_index
-        when 0
-          object.id.to_s      == td.text
-        when 1
-          object.name.should  == td.text
-        when 2
-          object.email.should == td.text
-        end
-      end
+  context "rows" do
+    it 'creates a tbody' do
+      expect(subject.render_rows).to have_tag "tbody"
+    end
+
+    it "creates a row in the tbody" do
+      tbody = Nokogiri::HTML(subject.render_rows)
+      expect(tbody.css('tr').size).to be 3
     end
   end
 
   context 'escaped values' do
     let(:objects) do
-      model = DummyModel.new.tap do |d|
-        d.id = 1
-        d.email = 'robert@creativequeries.com'
-        d.name = '<script>alert("Im in your columns, snatching your main thread.")</script>'
-      end
-
-      [model]
+      FactoryGirl.build_list(:dummy_model, 1, 
+        name: "<script>alert(\"Im in your columns, snatching your main thread.\")</script>"
+      )
     end
 
     it 'does not allow unescaped values in columns' do
-      rows = subject.render_rows
-      doc = Nokogiri::HTML(rows)
+      tbody = Nokogiri::HTML(subject.render_rows).at_xpath('//tbody')
 
-      tbody = doc.xpath('//tbody')
       tbody.xpath('//td').each do |td|
         td.at_xpath('.//script').should_not be_present
       end
     end
   end
 
-  it 'creates an entire table' do
-    doc = Nokogiri::HTML(subject.render_table)
-    table = doc.xpath('//table')
-    table.should be_present
-
-    thead = table.xpath('.//thead')
-    thead.should be_present
-
-    tbody = table.at_xpath('.//tbody')
-    tbody.should be_present
-
-    tbody.xpath('.//tr').length.should == 3
-  end
-
   context 'configuration' do
-    before(:all) do
-      TableCloth::Configuration.configure do |config|
-        config.table.class = 'table'
-        config.thead.class = 'thead'
-        config.th.class    = 'th'
-        config.tbody.class = 'tbody'
-        config.tr.class    = 'tr'
-        config.td.class    = 'td'
-      end
-    end
-
     let(:doc) { Nokogiri::HTML(subject.render_table) }
 
     it 'tables have a class attached' do
+      TableCloth.stub config_for: {class: "table"}
       doc.at_xpath('//table')[:class].should include 'table'
     end
 
     it 'thead has a class attached' do
+      TableCloth.stub config_for: {class: "thead"}
       doc.at_xpath('//thead')[:class].should include 'thead'
     end
 
     it 'th has a class attached' do
+      TableCloth.stub config_for: {class: "th"}
       doc.at_xpath('//th')[:class].should include 'th'
     end
 
     it 'tbody has a class attached' do
+      TableCloth.stub config_for: {class: "tbody"}
       doc.at_xpath('//tbody')[:class].should include 'tbody'
     end
 
     it 'tr has a class attached' do
+      TableCloth.stub config_for: {class: "tr"}
       doc.at_xpath('//tr')[:class].should include 'tr'
     end
 
     it 'td has a class attached' do
+      TableCloth.stub config_for: {class: "td"}
       doc.at_xpath('//td')[:class].should include 'td'
     end
 
   end
 
-  context 'specific configuration' do
-    let(:dummy_table) do
-      Class.new(TableCloth::Base) do
-        column :email, td_options: { class: 'email_column' }
-      end
-    end
+  context "column configuration" do
+    let(:column) { FactoryGirl.build(:column, options: {td_options: {class: "email_column"}}) }
+    let(:model) { FactoryGirl.build(:dummy_model) }
 
-    it 'td has a class set' do
-      doc = Nokogiri::HTML(subject.render_table)
-      doc.at_xpath('//td')[:class].should include 'email_column'
+    it "td has a class set" do
+      td = Nokogiri::HTML(subject.render_td(column, model)).at_css("td")
+      expect(td[:class]).to eq "email_column"
     end
 
-    context 'actions column' do
-      let(:dummy_table) { Class.new(DummyTableWithActions) }
-
-      specify 'actions column has a class set' do
-        doc = Nokogiri::HTML(subject.render_table)
-        td = doc.at_css('td:last')
-        td[:class].should include "actions"
+    context "by value of row column" do
+      before(:each) do
+        column.stub value: ["robert@example.com", {class: "special-class"}]
       end
 
-      context "empty actions" do
-        let(:dummy_table) do
-          Class.new(TableCloth::Base) do
-            actions do
-              action { nil }
-            end
-          end
-        end
-
-        it "changes nil to empty string" do
-          doc = Nokogiri::HTML(subject.render_table)
-          td = doc.at_css('td:last')
-          expect(td.text).to eq "\n"
-        end
-      end
-    end
-
-    context 'by value of row column' do
-      let(:dummy_table) { Class.new(DummyTableWithValueOptions) }
+      specify "column has options because of value" do
+        td = Nokogiri::HTML(subject.render_td(column, model)).at_css("td")
 
-      specify 'column has options because of value' do
-        doc = Nokogiri::HTML(subject.render_table)
-        td = doc.at_xpath('//td')
-        expect(td.text).to include "robert@creativequeries.com"
+        expect(td.text).to include "robert@example.com"
         expect(td[:class]).to eq("special-class")
       end
     end
   end
 
-  context 'table configuration' do
+  context "table configuration" do
     let(:doc) { Nokogiri::HTML(subject.render_table) }
     let(:dummy_table) do
       Class.new(TableCloth::Base) do
         column :email
 
-        config.table.class = 'table2'
-        config.thead.class = 'thead2'
-        config.th.class    = 'th2'
-        config.tbody.class = 'tbody2'
-        config.tr.class    = 'tr2'
-        config.td.class    = 'td2'
+        config.table.class = "table2"
+        config.thead.class = "thead2"
+        config.th.class    = "th2"
+        config.tbody.class = "tbody2"
+        config.tr.class    = "tr2"
+        config.td.class    = "td2"
       end
     end
 
@@ -203,12 +140,12 @@ describe TableCloth::Presenters::Default do
         Class.new(TableCloth::Base) do
           column :email
 
-          config.table.class = 'table2'
-          config.thead.class = 'thead2'
-          config.th.class    = 'th2'
-          config.tbody.class = 'tbody2'
-          config.tr.class    = 'tr2'
-          config.td.class    = 'td2'
+          config.table.class = "table2"
+          config.thead.class = "thead2"
+          config.th.class    = "th2"
+          config.tbody.class = "tbody2"
+          config.tr.class    = "tr2"
+          config.td.class    = "td2"
         end
       end