table_builder 0.1.0 → 0.2.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.1

data/lib/table_builder/calendar_helper.rb

@@ -1,139 +1,79 @@
 module CalendarHelper
 
-  def calendar_for(objects, *args)
-    raise ArgumentError, "Missing block" unless block_given?
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    html_options = options[:html]
-    builder = options[:builder] || CalendarBuilder
-    calendar = options[:calendar] || Calendar
-    concat(tag(:table, html_options, true))
-    yield builder.new(objects || [], self, calendar, options)
-    concat('</table>')
+  def calendar_for objects, options = {}
+    html_options = options.delete(:html)
+    builder      = options.delete(:builder)  || CalendarBuilder
+    calendar     = options.delete(:calendar) || Calendar
+    concat content_tag(:table, html_options){ yield builder.new(objects || [], self, calendar, options) }
   end
 
   class CalendarBuilder < TableHelper::TableBuilder
-    def initialize(objects, template, calendar, options)
-      super(objects, template, options)
+    def initialize objects, template, calendar, options
       @calendar = calendar.new(options)
-      @today = options[:today] || Time.now
-    end    
-    
-    def day(*args)
+      @today    = options[:today] || Time.now
+      super objects, template, options
+    end
+
+    def day options = {}
       raise ArgumentError, "Missing block" unless block_given?
-      options = options_from_hash(args)
       day_method = options.delete(:day_method) || :date
       id_pattern = options.delete(:id)
-      tbody do
-        @calendar.objects_for_days(@objects, day_method).to_a.sort{|a1, a2| a1.first <=> a2.first }.each do |o|
-          key, array = o
-          day, objects = array
-          concat(tag(:tr, options, true)) if(day.wday ==  @calendar.first_weekday)
-          concat(tag(:td, td_options(day, id_pattern), true))
-          yield(day, objects)
-          concat('</td>')
-          concat('</tr>') if(day.wday ==  @calendar.last_weekday)
+      
+      tag(:tbody) do
+        output = ''
+        @calendar.objects_for_days(@objects, &day_method).each_slice(7) do |week|
+          output = r do
+            week.map do |day, objects|
+              d capture{yield day, objects}, td_options(day, objects, id_pattern)
+            end
+          end
         end
+        output
       end
+      
     end
-
-    private
-
-    def objects_for_days
-      @calendar.objects_for_days(@objects)
-    end
-    
-    def td_options(day, id_pattern)
+  
+    def td_options day, objects, id_pattern
       options = {}
-      if(day.strftime("%Y-%m-%d") ==  @today.strftime("%Y-%m-%d"))
-        options[:class] = 'today'
-      elsif(day.month != @calendar.month)
-        options[:class] = 'notmonth'
-      elsif(day.wday == 0 or day.wday == 6)
-        options[:class] = 'weekend'
-      end
-      if id_pattern
-        options[:id] = day.strftime(id_pattern)
-      end
+      css     = []
+      css << 'notmonth' if day.month != @calendar.month
+      css << 'today'    if @today == day
+      css << 'weekend'  if day.wday == 0 or day.wday == 6
+      # css << 'empty'    if objects.empty?
+
+      options[:class] = css.join(' ')
+      options[:id]    = day.strftime(id_pattern) if id_pattern
+      
+      options.delete_if{ |k,v| v.blank?  }
       options
     end
-
+    
   end
 
   class Calendar
-    attr_accessor :first_weekday, :last_weekday, :month
-    def initialize(options={})
-      @year = options[:year] || Time.now.year
-      @month = options[:month] || Time.now.month
-      @first_day_of_week = options[:first_day_of_week] || 0
-      @first_weekday = first_day_of_week(@first_day_of_week)
-      @last_weekday = last_day_of_week(@first_day_of_week)
-      @first = Date.civil(@year, @month, 1)
-      @last = Date.civil(@year, @month, -1)           
+    attr_reader :month, :first_weekday, :last_weekday, :first_day, :last_day
+    def initialize options = {}
+      @year          = options[:year]  || Time.now.year
+      @month         = options[:month] || Time.now.month
+      @first_weekday = (options[:first_weekday] || 0) % 7
+      @last_weekday  = (@first_weekday + 6) % 7
+      @first         = Date.civil @year, @month, 1
+      @last          = Date.civil @year, @month, -1
+      @first_day     = @first - (@first.wday - @first_weekday + 7) % 7
+      @last_day      = @last + (@last_weekday - @last.wday + 7) % 7
     end
     
-    def each_day
-      first_day.upto(last_day) do |day|
-        yield(day)
-      end
+    def each_day &block
+      (first_day..last_day).map(&block)
     end
 
-    def last_day
-      last = @last
-      while(last.wday % 7 != @last_weekday % 7)
-        last = last.next
-      end   
-      last
-    end
-    
-    def first_day
-      first = @first - 6
-      while(first.wday % 7 != (@first_weekday) % 7)
-        first = first.next
-      end
-      first
-    end      
-    
-    def objects_for_days(objects, day_method)
-      unless @objects_for_days
-        @objects_for_days = {}
-        days.each{|day| @objects_for_days[day.strftime("%Y-%m-%d")] = [day, []]}
-        objects.each do |o|
-          date = o.send(day_method.to_sym).strftime("%Y-%m-%d")
-          if @objects_for_days[date]
-            @objects_for_days[date][1] << o
-          end
-        end
-      end
-      @objects_for_days
+    def objects_for_days objects, &day_method
+      objects = objects.group_by(&day_method)
+      each_day { |day| [day, objects[day] || []] }
     end
     
     def days
-      unless @days
-        @days = []
-        each_day{|day| @days << day} 
-      end
-      @days     
-    end    
-    
-    def mjdays
-      unless @mjdays
-        @mdays = []
-        each_day{|day| @days << day} 
-      end
-      @days     
-    end    
-    
-    def first_day_of_week(day)
-      day
+      @days ||= each_day
     end
-    
-    def last_day_of_week(day)
-      if day > 0
-        day - 1
-      else
-        6
-      end
-    end    
   end
-
-end
+end

data/lib/table_builder/table_builder.rb

@@ -1,125 +1,65 @@
 module TableHelper
 
-  def table_for(objects, *args)
-    raise ArgumentError, "Missing block" unless block_given?
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    html_options = options[:html]
-    builder = options[:builder] || TableBuilder
-    
-    concat(tag(:table, html_options, true))
-    yield builder.new(objects || [], self, options)
-    concat('</table>')
+  def table_for objects = [], options = {}
+    html_options = options.delete(:html)
+    builder      = options.delete(:builder) || TableBuilder
+    concat content_tag(:table, html_options) { yield builder.new(objects, self, options) }
   end
 
   class TableBuilder
-    include ::ActionView::Helpers::TagHelper
-
-    def initialize(objects, template, options)
-      raise ArgumentError, "TableBuilder expects an Array but found a #{objects.inspect}" unless objects.is_a? Array
+    def initialize objects, template, options
+      raise ArgumentError, "TableBuilder expects an Array or ActiveRecord::NamedScope::Scope but found a #{objects.class}" unless Array === objects or ActiveRecord::NamedScope::Scope === objects
       @objects, @template, @options = objects, template, options
     end
-
-    def head(*args)
-      if block_given?
-        concat(tag(:thead, options_from_hash(args), true))
-        yield
-        concat('</thead>')
-      else        
-        @num_of_columns = args.size
-        content_tag(:thead,
-          content_tag(:tr,
-            args.collect { |c| content_tag(:th, c)}.join('')
-          )
-        )
-      end
+    
+    def body options = {}
+      concat content_tag(:tbody, @objects.map{ |o| capture {yield o} }, options)
     end
-
-    def head_r(*args)
-      raise ArgumentError, "Missing block" unless block_given?
-      options = options_from_hash(args)
-      head do
-        concat(tag(:tr, options, true))
-        yield
-        concat('</tr>')
-      end
+    
+    def body_r options = {}
+      concat content_tag(:tbody, @objects.map{ |o| r capture {yield o}, options })
+    end
+    
+    def head *args, &block
+      return tag(:thead, *args, &block) if block_given?
+      options = args.extract_options!
+      content = (args.size == 1 ? args.first : args).map{|c|"<th>#{c}</th>"}
+      content_tag :thead, r(content), options
     end
 
-    def body(*args)
-      raise ArgumentError, "Missing block" unless block_given?
-      options = options_from_hash(args)
-      tbody do
-        @objects.each { |c| yield(c) }
-      end
+    def head_r *args, &block
+      head { tag :tr, *args, &block }
     end
     
-    def body_r(*args)
-      raise ArgumentError, "Missing block" unless block_given?
-      options = options_from_hash(args)
-      tbody do
-        @objects.each { |c|
-          concat(tag(:tr, options, true))
-          yield(c)
-          concat('</tr>')
-        }
-      end
-    end    
-
-    def r(*args)
-      raise ArgumentError, "Missing block" unless block_given?
-      options = options_from_hash(args)
-      tr(options) do
-        yield
-      end
+    def r *args, &block
+      tag :tr, *args, &block
     end
 
-    def h(*args)
-      if block_given?
-        concat(tag(:th, options_from_hash(args), true))
-        yield
-        concat('</th>')
-      else
-        content = args.shift
-        content_tag(:th, content, options_from_hash(args))
-      end        
+    def h *args, &block
+      tag :th, *args, &block
     end
 
-    def d(*args)
-      if block_given?
-        concat(tag(:td, options_from_hash(args), true))
-        yield
-        concat('</td>')
-      else
-        content = args.shift
-        content_tag(:td, content, options_from_hash(args))
-      end        
+    def d *args, &block
+      tag :td, *args, &block
     end
-    
 
     private
+    def tag tag, *args, &block
+      options = args.extract_options!
+      return concat content_tag(tag, capture(&block), options) if block_given?
+      content_tag tag, args, options
+    end
     
-    def options_from_hash(args)
-      args.last.is_a?(Hash) ? args.pop : {}
+    def concat str
+      @template.concat str
     end
     
-    def concat(tag)
-       @template.concat(tag)
+    def capture &block
+      @template.capture &block
     end
 
-    def content_tag(tag, content, *args)
-      options = options_from_hash(args)
+    def content_tag tag, content, options = {}
       @template.content_tag(tag, content, options)
     end
-    
-    def tbody
-      concat('<tbody>')
-      yield
-      concat('</tbody>')
-    end
-    
-    def tr options
-      concat(tag(:tr, options, true))
-      yield
-      concat('</tr>')      
-    end
   end
 end

data/table_builder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{table_builder}
-  s.version = "0.1.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Petrik de Heus"]
-  s.date = %q{2010-06-29}
+  s.date = %q{2010-07-05}
   s.description = %q{Rails builder for creating tables and calendars inspired by ActionView's FormBuilder.}
   s.email = %q{}
   s.extra_rdoc_files = [

data/test/calendar_helper_test.rb

@@ -1,162 +1,163 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require 'test_helper'
 
-class CalendarHelperTest < Test::Unit::TestCase
-  include ActionView::Helpers::TextHelper
-  include ActionView::Helpers::TagHelper
-  include ActionController::TestCase::Assertions
+class CalendarHelperTest < ActionView::TestCase
   include CalendarHelper
-  attr_accessor :output_buffer
 
   def setup
-    @events = [Event.new(3, 'Jimmy Page', Date.civil(2008, 12, 26)),
-              Event.new(4, 'Robert Plant', Date.civil(2008, 12, 26))]
-  end
-  
-  def test_calendar_for
-    self.output_buffer = ''
-    calendar_for(@events, :html => { :id => 'id', :style => 'style', :class => 'class'}) do |t|
-    end
-    expected = %(<table id="id" style="style" class="class">) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
+    @events = [
+      Event.new(3, 'Jimmy Page', Date.civil(2008, 12, 26)),
+      Event.new(4, 'Robert Plant', Date.civil(2008, 12, 26))
+    ]
   end
 
-  def test_calendar_for_without_an_array
-    self.output_buffer = ''
-    assert_raises(ArgumentError) do
-      calendar_for('a') {|t| }
-    end
+  should 'raise error if called without array' do
+    assert_raises(ArgumentError) { calendar_for('a') {|t|} }
   end
   
-  def test_calendar_for_with_empty_array
-    self.output_buffer = ''
-    calendar_for([], :year=> 2008, :month => 12) do |c|
-      c.day do |day, events|
-        output_buffer.concat(events.collect{|e| e.id}.join)
-      end
-    end
-    expected = %(<table>) <<
-      %(<tbody>) <<
-        %(<tr><td class="notmonth"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td class="notmonth"></td><td class="notmonth"></td><td class="notmonth"></td></tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, self.output_buffer
-  end
-  
-  def test_calendar_for_with_events
-    self.output_buffer = ''
-    calendar_for(@events, :year=> 2008, :month => 12) do |c|
-      c.day do |day, events|
-        content = events.collect{|e| e.id}.join
-        output_buffer.concat("(#{day.day})#{content}")
-      end
+  context 'Calendar days' do
+    should 'return objects_for_days with day and empty array' do
+      calendar = CalendarHelper::Calendar.new :year=> 2008, :month => 12
+      objects_for_days = (Date.civil(2008, 11, 30)..Date.civil(2009, 1, 3)).map { |day| [day, []] }
+      assert_equal objects_for_days, calendar.objects_for_days([], &:date)
     end
-    expected = %(<table>) <<
-      %(<tbody>) <<
-        %(<tr><td class="notmonth">(30)</td><td>(1)</td><td>(2)</td><td>(3)</td><td>(4)</td><td>(5)</td><td class="weekend">(6)</td></tr>) <<
-        %(<tr><td class="weekend">(7)</td><td>(8)</td><td>(9)</td><td>(10)</td><td>(11)</td><td>(12)</td><td class="weekend">(13)</td></tr>) <<
-        %(<tr><td class="weekend">(14)</td><td>(15)</td><td>(16)</td><td>(17)</td><td>(18)</td><td>(19)</td><td class="weekend">(20)</td></tr>) <<
-        %(<tr><td class="weekend">(21)</td><td>(22)</td><td>(23)</td><td>(24)</td><td>(25)</td><td>(26)34</td><td class="weekend">(27)</td></tr>) <<
-        %(<tr><td class="weekend">(28)</td><td>(29)</td><td>(30)</td><td>(31)</td><td class="notmonth">(1)</td><td class="notmonth">(2)</td><td class="notmonth">(3)</td></tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
-  
-  def test_calendar_for_sets_css_classes
-    self.output_buffer = ''
-    calendar_for([], :year=> 2008, :month => 12, :today => Date.civil(2008, 12, 15)) do |c|
-      c.day do |day, events|
-        output_buffer.concat(events.collect{|e| e.id}.join)
+    
+    should 'return objects_for_days with days and events' do
+      calendar         = CalendarHelper::Calendar.new :year=> 2008, :month => 12
+      objects_for_days = (Date.civil(2008, 11, 30)..Date.civil(2009, 1, 3)).map do |day|
+        [day, Date.civil(2008, 12, 26) == day ? @events : []]
       end
+      assert_equal objects_for_days, calendar.objects_for_days(@events, &:date)
     end
-    expected = %(<table>) <<
-      %(<tbody>) <<
-        %(<tr><td class="notmonth"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td class="today"></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>) <<
-        %(<tr><td class="weekend"></td><td></td><td></td><td></td><td class="notmonth"></td><td class="notmonth"></td><td class="notmonth"></td></tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, self.output_buffer
-  end  
-  
-  def test_calendar_for_sets_css_ids
-    self.output_buffer = ''
-    calendar_for([], :year=> 2008, :month => 12, :today => Date.civil(2008, 12, 15)) do |c|
-      c.day(:id => 'day_%d') do |day, events|
-        output_buffer.concat(events.collect{|e| e.id}.join)
-      end
+
+    should 'map day range for calendar' do
+      calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
+      assert_equal (Date.civil(2008, 11, 30)..Date.civil(2009, 1, 3)).map, calendar.days
     end
-    expected = %(<table>) <<
-      %(<tbody>) <<
-        %(<tr><td class="notmonth" id="day_30"></td><td id="day_01"></td><td id="day_02"></td><td id="day_03"></td><td id="day_04"></td><td id="day_05"></td><td class="weekend" id="day_06"></td></tr>) <<
-        %(<tr><td class="weekend" id="day_07"></td><td id="day_08"></td><td id="day_09"></td><td id="day_10"></td><td id="day_11"></td><td id="day_12"></td><td class="weekend" id="day_13"></td></tr>) <<
-        %(<tr><td class="weekend" id="day_14"></td><td class="today"id="day_15"></td><td id="day_16"></td><td id="day_17"></td><td id="day_18"></td><td id="day_19"></td><td class="weekend" id="day_20"></td></tr>) <<
-        %(<tr><td class="weekend" id="day_21"></td><td id="day_22"></td><td id="day_23"></td><td id="day_24"></td><td id="day_25"></td><td id="day_26"></td><td class="weekend" id="day_27"></td></tr>) <<
-        %(<tr><td class="weekend" id="day_28"></td><td id="day_29"></td><td id="day_30"></td><td id="day_31"></td><td class="notmonth" id="day_01"></td><td class="notmonth" id="day_02"></td><td class="notmonth" id="day_03"></td></tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, self.output_buffer
-  end  
-  
-end
 
-class CalendarHelperTest < Test::Unit::TestCase
+    should 'map day range starting from monday when passed first_weekday' do
+      calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12, :first_weekday => 1)
+      assert_equal (Date.civil(2008, 12, 1)..Date.civil(2009, 1, 4)).map, calendar.days
+    end
 
-  def setup
-    @events = [Event.new(3, 'Jimmy Page', Date.civil(2008, 12, 26)),
-              Event.new(4, 'Robert Plant', Date.civil(2008, 12, 26))]
-  end
+    should 'set first day to previous sunday' do
+      calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
+      assert_equal Date.civil(2008, 11, 30), calendar.first_day
+    end
 
-  def test_objects_for_days_with_events
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
-    objects_for_days = {}
-    Date.civil(2008, 11, 30).upto(Date.civil(2009, 1, 3)){|day| objects_for_days[day.strftime("%Y-%m-%d")] = [day, []]}
-    objects_for_days['2008-12-26'][1] = @events    
-    assert_equal objects_for_days, calendar.objects_for_days(@events, :date)
+    should 'set last day to following sunday' do
+      calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
+      assert_equal Date.civil(2009, 1, 3), calendar.last_day
+    end
+    
+    should 'start range from previous monday when first_weekday is one' do
+      calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12, :first_weekday => 1)
+      assert_equal Date.civil(2009, 1, 4), calendar.last_day
+    end
+    
   end
+  
+  context 'ERB Rendering' do
+    should 'render table for calendar' do
+      erb = <<-ERB
+         <% calendar_for @events, :html => { :id => 'id', :style => 'style', :class => 'class'} do |t| %>
+         <% end %>
+       ERB
+       assert_dom_equal %(<table id="id" style="style" class="class"></table>), render(:inline => erb)
+    end
+    
+    should 'render trs and tds with empty array' do
+      erb = <<-ERB
+        <% calendar_for [], :year=> 2008, :month => 12 do |c| %>
+          <% c.day do |day, events| %>
+          <% end %>
+        <% end %>
+      ERB
+    
+      html = <<-HTML 
+      <table>
+        <tbody>
+          <tr><td class="notmonth weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td class="notmonth"></td><td class="notmonth"></td><td class="notmonth weekend"></td></tr>
+        </tbody>
+      </table>
+      HTML
+      assert_dom_equal html, render(:inline => erb)
+    end
+   
+    should 'output day numbers' do
+      erb = <<-ERB
+        <% calendar_for @events, :year=> 2008, :month => 12 do |c| %>
+          <% c.day do |day, events| %>
+            <%= day.day %>
+          <% end %>
+        <% end %>
+      ERB
+  
+      html = <<-HTML
+      <table>
+        <tbody>
+          <tr><td class="notmonth weekend">30</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td class="weekend">6</td></tr>
+          <tr><td class="weekend">7</td><td>8</td><td>9</td><td>10</td><td>11</td><td>12</td><td class="weekend">13</td></tr>
+          <tr><td class="weekend">14</td><td>15</td><td>16</td><td>17</td><td>18</td><td>19</td><td class="weekend">20</td></tr>
+          <tr><td class="weekend">21</td><td>22</td><td>23</td><td>24</td><td>25</td><td>26</td><td class="weekend">27</td></tr>
+          <tr><td class="weekend">28</td><td>29</td><td>30</td><td>31</td><td class="notmonth">1</td><td class="notmonth">2</td><td class="notmonth weekend">3</td></tr>
+        </tbody>
+      </table>
+      HTML
 
-  def test_objects_for_days
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
-    objects_for_days = {}
-    Date.civil(2008, 11, 30).upto(Date.civil(2009, 1, 3)){|day| objects_for_days[day.strftime("%Y-%m-%d")] = [day, []]}
-    assert_equal objects_for_days, calendar.objects_for_days([], :date)
-  end
+      assert_dom_equal html, render(:inline => erb)
+    end
+  
+    should 'render events' do
+      erb = <<-ERB
+        <% calendar_for @events, :year=> 2008, :month => 12 do |c| %>
+          <% c.day do |day, events| %>
+            <%= events.map(&:id).join(',') %>
+          <% end %>
+        <% end %>
+      ERB
 
-  def test_days
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
-    days = []
-    Date.civil(2008, 11, 30).upto(Date.civil(2009, 1, 3)){|day| days << day}
-    assert_equal days, calendar.days
-  end
+      html = <<-HTML 
+      <table>
+        <tbody>
+          <tr><td class="notmonth weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td></td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td></td><td>3,4</td><td class="weekend"></td></tr>
+          <tr><td class="weekend"></td><td></td><td></td><td></td><td class="notmonth"></td><td class="notmonth"></td><td class="notmonth weekend"></td></tr>
+        </tbody>
+      </table>
+      HTML
+      assert_dom_equal html, render(:inline => erb)
+    end
 
-  def test_days_with_first_day_of_week_set
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12, :first_day_of_week => 1)
-    days = []
-    Date.civil(2008, 12, 1).upto(Date.civil(2009, 1, 4)){|day| days << day}
-    assert_equal days, calendar.days
-  end
+    should 'render id attribute for using pattern' do
+      erb = <<-ERB
+        <% calendar_for @events, :year=> 2008, :month => 12, :today => Date.civil(2008, 12, 15) do |c| %>
+          <% c.day :id => 'day_%d' do |day, events| %>
+            <%= events.map(&:id).join(',') %>
+          <% end %>
+        <% end %>
+      ERB
 
-  def test_first_day
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
-    assert_equal Date.civil(2008, 11, 30), calendar.first_day
-  end
+      html = <<-HTML
+        <table>
+          <tbody>
+            <tr><td class="notmonth weekend" id="day_30"></td><td id="day_01"></td><td id="day_02"></td><td id="day_03"></td><td id="day_04"></td><td id="day_05"></td><td class="weekend" id="day_06"></td></tr>
+            <tr><td class="weekend" id="day_07"></td><td id="day_08"></td><td id="day_09"></td><td id="day_10"></td><td id="day_11"></td><td id="day_12"></td><td class="weekend" id="day_13"></td></tr>
+            <tr><td class="weekend" id="day_14"></td><td class="today"id="day_15"></td><td id="day_16"></td><td id="day_17"></td><td id="day_18"></td><td id="day_19"></td><td class="weekend" id="day_20"></td></tr>
+            <tr><td class="weekend" id="day_21"></td><td id="day_22"></td><td id="day_23"></td><td id="day_24"></td><td id="day_25"></td><td id="day_26">3,4</td><td class="weekend" id="day_27"></td></tr>
+            <tr><td class="weekend" id="day_28"></td><td id="day_29"></td><td id="day_30"></td><td id="day_31"></td><td class="notmonth" id="day_01"></td><td class="notmonth" id="day_02"></td><td class="notmonth weekend" id="day_03"></td></tr>
+          </tbody>
+        </table>
+      HTML
+      assert_dom_equal html, render(:inline => erb)
+    end
   
-  def test_last_day
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12)
-    assert_equal Date.civil(2009, 1, 3), calendar.last_day
   end
-  
-  def test_last_day_with_first_day_of_week_set
-    calendar = CalendarHelper::Calendar.new(:year=> 2008, :month => 12, :first_day_of_week => 1)
-    assert_equal Date.civil(2009, 1, 4), calendar.last_day
-  end  
 end
 
-class Event < Struct.new(:id, :name, :date); end
+

data/test/table_builder_test.rb

@@ -1,185 +1,226 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require 'test_helper'
 
-class TableBuilderTest < Test::Unit::TestCase
-  include ActionView::Helpers::TextHelper
-  include ActionView::Helpers::TagHelper
-  include ActionController::TestCase::Assertions
+class TableBuilderTest < ActionView::TestCase
   include TableHelper
   attr_accessor :output_buffer  
   
   def setup
-    @drummer1 = Drummer.new(1, 'John "Stumpy" Pepys')
-    @drummer2 = Drummer.new(2, 'Eric "Stumpy Joe" Childs')
-    @drummer3 = Drummer.new(3, 'Peter "James" Bond')
-    @drummer4 = Drummer.new(4, 'Mick Shrimpton (R. J. "Ric" Parnell)')
-    self.output_buffer = ''    
+    @drummers = [
+      Drummer.new(1, 'John "Stumpy" Pepys'),
+      Drummer.new(2, 'Eric "Stumpy Joe" Childs'),
+    ]
   end
   
-  def test_table_for
-    table_for([], :html => { :id => 'id', :style => 'style', :class => 'class'}) do |t|
-    end
-    expected = %(<table id="id" style="style" class="class">) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
+  should 'raise argument error with out array' do
+    assert_raises(ArgumentError) { table_for('a') {|t|} }
   end
-
-  def test_table_for_without_an_array_raises_error
-    assert_raises(ArgumentError) do
-      table_for('a') {|t| }
+  
+  context 'ERB rendering' do
+    should 'output table tag' do
+      erb = <<-ERB
+        <% table_for [], :html => { :id => 'id', :style => 'style', :class => 'class'} do |t| %>
+        <% end %>
+      ERB
+      assert_dom_equal  %(<table id="id" style="style" class="class"></table>), render(:inline => erb)
     end
-  end
-
-  def test_head
-    table_for([]) do |t|
-      t.head do
-        t.r do
-          output_buffer.concat t.h('Id')
-          output_buffer.concat t.h('Name')
-        end
-      end
+        
+    should 'output table tag with content' do
+      erb = <<-ERB
+        <% table_for [] do |t| %>
+          <tr></tr>
+          <tr></tr>
+        <% end %>
+      ERB
+      assert_dom_equal  %(<table><tr></tr><tr></tr></table>), render(:inline => erb)
     end
-    expected = %(<table>) <<
-        %(<thead>) <<
-          %(<tr>) <<
-            %(<th>Id</th>) <<
-            %(<th>Name</th>) <<
-          %(</tr>) <<
-        %(</thead>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_head_r
-    table_for([]) do |t|
-      t.head_r do
-        output_buffer.concat t.h('Id')
-        output_buffer.concat t.h('Name')
-      end
+    
+    should 'output table tag with content and erb tags' do
+      erb = <<-ERB
+        <% table_for [] do |t| %>
+          <%= '<tr></tr>' %>
+          <tr></tr>
+          <%= '<tr></tr>' %>
+        <% end %>
+      ERB
+      assert_dom_equal  %(<table><tr></tr><tr></tr><tr></tr></table>), render(:inline => erb)
     end
-    expected = %(<table>) <<
-        %(<thead>) <<
-          %(<tr>) <<
-            %(<th>Id</th>) <<
-            %(<th>Name</th>) <<
-          %(</tr>) <<
-        %(</thead>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_head_with_array
-    table_for([@drummer1, @drummer2]) do |t|
-      output_buffer.concat t.head('Id', 'Name')
+    
+    should 'output table head passing an array' do
+      erb = <<-ERB
+      <% table_for [] do |t| %>
+        <%= t.head %w(a b c), :class => 'head' %>
+      <% end %>
+      ERB
+      assert_dom_equal %(<table><thead class="head"><tr><th>a</th><th>b</th><th>c</th></tr></thead></table>), render(:inline => erb)
+    end
+      
+    should 'output table head' do
+      erb = <<-ERB
+      <% table_for [] do |t| %>
+        <% t.head(:class => 'head') do %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal %(<table><thead class="head"></thead></table>), render(:inline => erb)
+    end
+        
+    should 'output table head with content' do
+      erb = <<-ERB
+      <% table_for [] do |t| %>
+        <% t.head do %>
+            <%= '<th></th>' %>
+            <th></th>
+            <%= '<th></th>' %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal %(<table><thead><th></th><th></th><th></th></thead></table>), render(:inline => erb)
     end
-    expected = %(<table>) <<
-        %(<thead>) <<
-          %(<tr>) <<
-            %(<th>Id</th>) <<
-            %(<th>Name</th>) <<
-          %(</tr>) <<
-        %(</thead>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
 
-  def test_body
-    table_for([@drummer3, @drummer4]) do |t|
-      t.body do |e|
-        t.r do
-          output_buffer.concat t.d(e.id)
-          output_buffer.concat t.d(e.name)
-        end
-      end
+    should 'output table header inside head' do
+      erb = <<-ERB
+      <% table_for [] do |t| %>
+        <% t.head do %>
+            <%= t.h 'Id' %>
+            <th></th>
+            <%= t.h 'Name' %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal %(<table><thead><th>Id</th><th></th><th>Name</th></thead></table>), render(:inline => erb)
     end
-    expected = %(<table>) <<
-        %(<tbody>) <<
-          %(<tr>) <<
-            %(<td>3</td>) <<
-            %(<td>Peter "James" Bond</td>) <<
-          %(</tr>) <<
-          %(<tr>) <<
-            %(<td>4</td>) <<
-            %(<td>Mick Shrimpton (R. J. "Ric" Parnell)</td>) <<
-          %(</tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
 
-  def test_body_r
-    table_for([@drummer3, @drummer4]) do |t|
-      t.body_r do |e|
-        output_buffer.concat t.d(e.id)
-        output_buffer.concat t.d(e.name)
-      end
+    should 'output table header with block inside head' do
+      erb = <<-ERB
+      <% table_for [] do |t| %>
+        <% t.head do %>
+            <%- t.h do -%>
+              <%= 'I' %>d
+            <%- end -%>
+            <th></th>
+            <%= t.h 'Name' %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal %(<table><thead><th>Id</th><th></th><th>Name</th></thead></table>), render(:inline => erb)
     end
-    expected = %(<table>) <<
-        %(<tbody>) <<
-          %(<tr>) <<
-            %(<td>3</td>) <<
-            %(<td>Peter "James" Bond</td>) <<
-          %(</tr>) <<
-          %(<tr>) <<
-            %(<td>4</td>) <<
-            %(<td>Mick Shrimpton (R. J. "Ric" Parnell)</td>) <<
-          %(</tr>) <<
-        %(</tbody>) <<
-      %(</table>)
-    assert_dom_equal expected, output_buffer
-  end
-  
-  def test_td_with_options
-     table_for([@drummer1]) do |t|
-       t.body_r do |e|
-         output_buffer.concat t.d(e.name, :class => 'class')
-       end
-     end
-     expected = %(<table>) <<
-         %(<tbody>) <<
-           %(<tr>) <<
-             %(<td class="class">John "Stumpy" Pepys</td>) <<
-           %(</tr>) <<
-         %(</tbody>) <<
-       %(</table>)
-     assert_dom_equal expected, output_buffer
-   end  
 
-   def test_td_with_block
-      table_for([@drummer1]) do |t|
-        t.body_r do |e|
-          t.d do
-            output_buffer.concat 'content'
-          end
-        end
-      end
-      expected = %(<table>) <<
-          %(<tbody>) <<
-            %(<tr>) <<
-              %(<td>content</td>) <<
-            %(</tr>) <<
-          %(</tbody>) <<
-        %(</table>)
-      assert_dom_equal expected, output_buffer
+    should 'output head row with block' do
+      erb = <<-ERB 
+      <% table_for [] do |t| %>
+        <% t.head_r :class => 'head' do %>
+          <%= t.h('a') %>
+          <th>b</th>
+          <% t.h do %>
+            c
+          <% end %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal "<table><thead><tr class='head'><th>a</th><th>b</th><th>c</th></tr></thead></table>", render(:inline => erb)
+    end
+    
+    should 'output tbody' do
+      erb = <<-ERB 
+      <% table_for @drummers do |t| %>
+        <% t.head_r do %>
+          <th>a</th><th>b</th><th>c</th>
+        <% end %>
+        <% t.body :class => 'body' do %>
+        <% end %>
+      <% end %>
+      ERB
+      assert_dom_equal "<table><thead><tr><th>a</th><th>b</th><th>c</th></tr></thead><tbody class='body'></tbody></table>", render(:inline => erb)
     end
 
-   def test_td_with_block_and_options
-      table_for([@drummer1]) do |t|
-        t.body_r do |e|
-          t.d(:class => 'class') do
-            output_buffer.concat 'content'
-          end
-        end
-      end
-      expected = %(<table>) <<
-          %(<tbody>) <<
-            %(<tr>) <<
-              %(<td class="class">content</td>) <<
-            %(</tr>) <<
-          %(</tbody>) <<
-        %(</table>)
-      assert_dom_equal expected, output_buffer
+    should 'output tbody with row and content' do
+      erb = <<-ERB 
+      <% table_for @drummers do |t| %>
+        <% t.head_r do %>
+          <th>id</th><th>name</th>
+        <% end %>
+        <% t.body do |d| %>
+          <% t.r do %>
+            <%= t.d d.id %>
+            <%= t.d d.name %>
+          <% end %>
+        <% end %>
+      <% end %>
+      ERB
+  
+      html = <<-HTML
+      <table>
+        <thead>
+          <tr><th>id</th><th>name</th></tr>
+        </thead>
+        <tbody>
+          <tr><td>#{ @drummers.first.id }</td><td>#{ @drummers.first.name }</td></tr>
+          <tr><td>#{ @drummers.last.id }</td><td>#{ @drummers.last.name }</td></tr>
+        </tbody>
+      </table>
+      HTML
+  
+      assert_dom_equal html, render(:inline => erb)
+    end    
+    
+    should 'output body rows' do
+      erb = <<-ERB 
+      <% table_for @drummers do |t| %>
+        <% t.head_r do %>
+          <th>id</th><th>name</th>
+        <% end %>
+        <% t.body_r do |e| %>
+          <%= t.d e.id %>
+          <%= t.d e.name %>
+        <% end %>
+      <% end %>
+      ERB
+      
+      html = <<-HTML
+      <table>
+        <thead>
+          <tr><th>id</th><th>name</th></tr>
+        </thead>
+        <tbody>
+          <tr><td>#{ @drummers.first.id }</td><td>#{ @drummers.first.name }</td></tr>
+          <tr><td>#{ @drummers.last.id }</td><td>#{ @drummers.last.name }</td></tr>
+        </tbody>
+      </table>
+      HTML
+      
+      assert_dom_equal html, render(:inline => erb)
     end
+    
+    should 'output td with block and options' do
+      erb = <<-ERB 
+      <% table_for @drummers do |t| %>
+        <% t.head_r do %>
+          <th>id</th><th>name</th>
+        <% end %>
+        <% t.body_r do |e| %>
+          <% t.d :class => 'id' do %>
+            <%= e.id %>
+          <% end %>
+          <%= t.d e.name %>
+        <% end %>
+      <% end %>
+      ERB
+      
+      html = <<-HTML
+      <table>
+        <thead>
+          <tr><th>id</th><th>name</th></tr>
+        </thead>
+        <tbody>
+          <tr><td class="id">#{ @drummers.first.id }</td><td>#{ @drummers.first.name }</td></tr>
+          <tr><td class="id">#{ @drummers.last.id }</td><td>#{ @drummers.last.name }</td></tr>
+        </tbody>
+      </table>
+      HTML
+      
+      assert_dom_equal html, render(:inline => erb)
+    end
+  end
 
 end
 
-class Drummer < Struct.new(:id, :name); end

data/test/test_helper.rb

@@ -1,10 +1,16 @@
 require 'test/unit'
 
-require "rubygems"
+require 'rubygems'
+require 'shoulda'
+
 require 'active_support'
 require 'action_pack'
 require 'action_controller'
 require 'action_view'
+require 'action_view/test_case'
 require 'action_controller/test_process'
 
-require(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'table_builder')))
+require "#{ File.dirname(__FILE__) }/../lib/table_builder"
+
+class Drummer < Struct.new(:id, :name); end
+class Event < Struct.new(:id, :name, :date); end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 0
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Petrik de Heus
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 -05:00
+date: 2010-07-05 00:00:00 -05:00
 default_executable: 
 dependencies: []