table_helper 0.1.0 → 0.2.0

data/lib/table_helper/body.rb

@@ -4,34 +4,40 @@ module TableHelper
   # Represents the body of the table.  In HTML, you can think of this as
   # the <tbody> tag of the table.
   class Body < HtmlElement
+    # The css class to apply for all rows in the body
+    cattr_accessor :empty_caption_class
+    @@empty_caption_class = 'ui-collection-empty'
+    
+    # The table this body is a part of
+    attr_reader :table
+    
     # If set to :odd or :even, every odd or even-numbered row will have the
-    # class 'alternate' appended to its html attributes. Default is nil.
-    attr_accessor :alternate_rows
+    # alternate class appended to its html attributes. Default is nil.
+    attr_accessor :alternate
     
     # The caption to display in the collection is empty
     attr_accessor :empty_caption
     
-    def initialize(collection, header) #:nodoc:
+    def initialize(table) #:nodoc:
       super()
       
-      @collection, @header = collection, header
+      @table = table
       @empty_caption = 'No matches found.'
     end
     
-    def alternate_rows=(value) #:nodoc:
-      raise ArgumentError, 'alternate_rows must be set to :odd or :even' if value && ![:odd, :even].include?(value)
-      @alternate_rows = value
+    def alternate=(value) #:nodoc:
+      raise ArgumentError, 'alternate must be set to :odd or :even' if value && ![:odd, :even].include?(value)
+      @alternate = value
     end
     
     # Builds the body of the table.  This includes the actual data that is
     # generated for each object in the collection.
     # 
-    # +build+ expects a block that defines the data in each cell.  Each
-    # iteration of the block will provide the object being rendered, the row
-    # within the table that will be built and the index of the object.  For
-    # example,
+    # +each+ expects a block that defines the data in each cell.  Each
+    # iteration of the block will provide the row within the table, the object
+    # being rendered, and the index of the object.  For example,
     # 
-    #   body.build do |row, post, index|
+    #   t.rows.each do |row, post, index|
     #     row.title     "<div class=\"wrapped\">#{post.title}</div>"
     #     row.category  post.category.name
     #   end
@@ -51,66 +57,57 @@ module TableHelper
     # if a Post consists of the attribute +title+, then the cell for the
     # title will be prepopulated with that attribute's value:
     # 
-    #   body.build do |row, post index|
-    #     row.category post.category.name
+    #   t.rows.each do |row, post index|
+    #     row.title post.title
     #   end
     # 
     # <tt>row.title</tt> is already set to post.category so there's no need to
     # manually set the value of that cell.  However, it is always possible
     # to override the default value like so:
     # 
-    #   body.build do |row, post, index|
+    #   t.rows.each do |row, post, index|
     #     row.title     link_to(post.title, post_url(post))
     #     row.category  post.category.name
     #   end
-    def build(&block)
-      @content = ''
-      
-      # Display nothing if there are no objects to display
-      if @collection.empty? && @empty_caption
-        row = Row.new
-        row[:class] = 'no_content'
-        
-        html_options = {}
-        html_options[:colspan] = @header.column_names.size if @header.column_names.size > 1
-        row.cell nil, @empty_caption, html_options
-        
-        @content << row.html
-      else
-        @collection.each_with_index do |object, i|
-          @content << build_row(object, i, &block)
-        end
-      end
-      
-      @content
+    def each(&block)
+      @builder = block
     end
     
     # Builds a row for an object in the table.
     # 
     # The provided block should set the values for each cell in the row.
-    def build_row(object, index = @collection.index(object), &block)
-      row = BodyRow.new(object, @header)
-      row.alternate = alternate_rows ? index.send("#{@alternate_rows}?") : false
-      
-      yield row.builder, object, index if block_given?
-      
+    def build_row(object, index = table.collection.index(object))
+      row = BodyRow.new(object, self)
+      row.alternate = alternate ? index.send("#{alternate}?") : false
+      @builder.call(row.builder, object, index) if @builder
       row.html
     end
     
-    def html #:nodoc:
-      html_options = @html_options.dup
-      html_options[:class] = (html_options[:class].to_s + ' alternate').strip if alternate_rows 
-      
-      content_tag(tag_name, content, html_options)
-    end
-    
     private
       def tag_name
         'tbody'
       end
       
       def content
-        @content
+        content = ''
+        
+        if table.empty? && @empty_caption
+          # No objects to display
+          row = Row.new(self)
+          row[:class] = empty_caption_class
+          
+          html_options = {}
+          html_options[:colspan] = table.header.columns.size if table.header.columns.size > 1
+          row.cell nil, @empty_caption, html_options
+          
+          content << row.html
+        else
+          table.collection.each_with_index do |object, i|
+            content << build_row(object, i)
+          end
+        end
+        
+        content
       end
   end
 end

data/lib/table_helper/body_row.rb

@@ -9,28 +9,32 @@ module TableHelper
   # Alternating rows can be automated by setting the +alternate+ property.
   # For example,
   # 
-  #   r = BodyRow.new
+  #   r = BodyRow.new(object, parent)
   #   r.alternate = true
   class BodyRow < Row
+    # The css class to apply for all rows in the body
+    cattr_accessor :result_class
+    @@result_class = 'ui-collection-result'
+    
+    # The css class to apply for rows that are marked as "alternate"
+    cattr_accessor :alternate_class
+    @@alternate_class = 'ui-state-alternate'
+    
     # True if this is an alternating row, otherwise false.  Default is false.
     attr_accessor :alternate
     
-    def initialize(object, header) #:nodoc:
-      super()
+    def initialize(object, parent) #:nodoc:
+      super(parent)
       
-      @header = header
       @alternate = false
-      @html_options[:class] = ('row ' + @html_options[:class].to_s).strip
+      self[:class] = "#{self[:class]} #{table.object_name} #{result_class}".strip
       
       # For each column defined in the table, see if we can prepopulate the
       # cell based on the data in the object.  If not, we can at least
       # provide shortcut accessors to the cell
-      @header.column_names.each do |column|
-        if object.respond_to?(column)
-          cell(column, object.send(column))
-        else
-          builder.define_cell(column)
-        end
+      table.header.column_names.each do |column|
+        value = object.respond_to?(column) ? object.send(column) : nil
+        cell(column, value)
       end
     end
     
@@ -38,7 +42,7 @@ module TableHelper
     # (if specified)
     def html
       original_options = @html_options.dup
-      @html_options[:class] = (@html_options[:class].to_s + ' alternate').strip if alternate
+      self[:class] = "#{self[:class]} #{alternate_class}".strip if alternate
       html = super
       @html_options = original_options
       html
@@ -52,13 +56,13 @@ module TableHelper
         number_to_skip = 0 # Keeps track of the # of columns to skip
         
         html = ''
-        @header.column_names.each do |column|
+        table.header.column_names.each do |column|
           number_to_skip -= 1 and next if number_to_skip > 0
           
           if cell = @cells[column]
             number_to_skip = (cell[:colspan] || 1) - 1
           else
-            cell = Cell.new(column, '', :class => 'empty')
+            cell = Cell.new(column, nil)
           end
           
           html << cell.html

data/lib/table_helper/cell.rb

@@ -1,31 +1,46 @@
 module TableHelper
   # Represents a single cell within a table.  This can either be a regular
   # data cell (td) or a header cell (th).  By default, all cells will have
-  # their column name appended to the cell's class attribute.
+  # their name appended to the cell's class attribute.
   # 
-  # == Creating data cells
-  # 
-  #   Cell.new(:author, 'John Doe').build
-  # 
-  # ...would generate the following tag:
-  # 
-  #   <td class="author">John Doe</td>
-  # 
-  # == Creating header cells
+  # == Examples
   # 
+  #   # Data cell
+  #   c = Cell.new(:author, 'John Doe')
+  #   c.html    # => <td class="author">John Doe</td>
+  #   
+  #   # Header cell
   #   c = Cell.new(:author, 'Author Name')
   #   c.content_type = :header
-  #   c.build
-  # 
-  # ...would generate the following tag:
-  # 
-  #   <th class="author">Author Name</th>
+  #   c.html
+  #   
+  #   # With namespace
+  #   c = Cell.new(:author, :namespace => 'post')
+  #   c.content_type = :header
+  #   c.html    # => <td class="post-author">Author</td>
   class Cell < HtmlElement
-    def initialize(class_name, content = class_name.to_s.titleize, html_options = {}) #:nodoc
+    # The css class to apply to empty cells
+    cattr_accessor :empty_class
+    @@empty_class = 'ui-state-empty'
+    
+    # The content to display within the cell
+    attr_reader :content
+    
+    # The type of content this cell represents (:data or :header)
+    attr_reader :content_type
+    
+    def initialize(name, content = name.to_s.titleize, html_options = {}) #:nodoc
+      html_options, content = content, name.to_s.titleize if content.is_a?(Hash)
+      namespace = html_options.delete(:namespace)
       super(html_options)
       
-      @content = content
-      @html_options[:class] = ("#{class_name} " + @html_options[:class].to_s).strip if class_name
+      @content = content.to_s
+      
+      if name
+        name = "#{namespace}-#{name}" unless namespace.blank?
+        self[:class] = "#{self[:class]} #{name}".strip
+      end
+      self[:class] = "#{self[:class]} #{empty_class}".strip if content.blank?
       
       self.content_type = :data
     end
@@ -41,9 +56,5 @@ module TableHelper
       def tag_name
         @content_type == :data ? 'td' : 'th'
       end
-      
-      def content
-        @content
-      end
   end
 end

data/lib/table_helper/collection_table.rb

@@ -7,58 +7,132 @@ module TableHelper
   # Represents a table that displays data for multiple objects within a
   # collection.
   class CollectionTable < HtmlElement
-    # Creates a new table based on the objects within the given collection.
+    # The css class to apply for all menu bars
+    cattr_accessor :collection_class
+    @@collection_class = 'ui-collection'
+    
+    # The class of objects that will be rendered in the table
+    attr_reader :klass
+    
+    # The name of the objects in the collection.  By default, this is the
+    # underscored name of the class of objects being rendered.  This value is
+    # used for generates parts of the css classes in the table, such as rows
+    # and cells.
+    # 
+    # For example, if the class is Post, then the object name will be "post".
+    attr_accessor :object_name
+    
+    # The actual collection of objects being rendered in the table's body.
+    # This collection will also be used to help automatically determine what
+    # the class is.
+    attr_reader :collection
+    
+    # The body of rows that will be generated for each object in the
+    # collection.  The actual content for each row and the html options can
+    # be configured as well.
+    # 
+    # See TableHelper::Body for more information.
     # 
-    # Configuration options:
-    # * +class+ - The actual class of the objects contained within the collection. This is used to help build the header columns.
-    # * +header+ - Whether or not to display a header. Default is true.
-    # * +footer+ - Whether or not to display a footer. Default is false.
-    def initialize(collection, options = {}, html_options = {}) #:nodoc:
+    # == Examples
+    # 
+    #   # Defining rows
+    #   t.rows.each do |row, post, index|
+    #     row.category post.category.name
+    #     row.author   post.author.name
+    #     ...
+    #     row[:style] = 'margin-top: 5px;'
+    #   end
+    #   
+    #   # Customizing html options
+    #   t.rows[:class] = 'pretty'
+    attr_reader :rows
+    
+    # Creates a new table based on the objects within the given collection
+    def initialize(collection, klass = nil, html_options = {}) #:nodoc:
+      html_options, klass = klass, nil if klass.is_a?(Hash)
       super(html_options)
       
-      options.assert_valid_keys(
-        :class,
-        :footer,
-        :header
-      )
-      @options = options.reverse_merge(
-        :header => true,
-        :footer => false
-      )
+      @collection = collection
+      @klass = klass || default_class
+      @object_name = @klass ? @klass.name.split('::').last.underscore : nil
+      @html_options.reverse_merge!(:cellspacing => '0', :cellpadding => '0')
+      
+      self[:class] = "#{self[:class]} #{@object_name.pluralize}".strip if @object_name
+      self[:class] = "#{self[:class]} #{collection_class}".strip
       
-      @html_options.reverse_merge!(
-        :cellspacing => '0',
-        :cellpadding => '0'
-      )
+      # Build actual content
+      @header = Header.new(self)
+      @rows = Body.new(self)
+      @footer = Footer.new(self)
       
-      @header = Header.new(collection, options[:class])
-      @body = Body.new(collection, @header)
-      @footer = Footer.new(collection)
+      yield self if block_given?
     end
     
-    # Builds the table by rendering a header (if enabled), body, and footer (if enabled).
-    def build(&block)
-      @body.build # Build with the defaults
-      
-      elements = []
-      elements << @header.builder if @options[:header]
-      elements << @body
-      elements << @footer if @options[:footer]
-      
-      yield *elements if block_given?
-      
-      @content = ''
-      elements.each {|element| @content << element.html}
-      @content
+    # Will any rows be generated in the table's body?
+    def empty?
+      collection.empty?
+    end
+    
+    # Creates a new header cell with the given name.  Headers must be defined
+    # in the order in which they will be rendered.
+    # 
+    # The actual caption and html options for the header can be configured
+    # as well.  The caption determines what will be displayed in each cell.
+    # 
+    # == Examples
+    # 
+    #   # Adding headers
+    #   t.header :title                                   # => <th class="post-title">Title</th>
+    #   t.header :title, 'The Title'                      # => <th class="post-title">The Title</th>
+    #   t.header :title, :class => 'pretty'               # => <th class="post-title pretty">Title</th>
+    #   t.header :title, 'The Title', :class => 'pretty'  # => <th class="post-title pretty">The Title</th>
+    #   
+    #   # Customizing html options
+    #   t.header[:class] = 'pretty'
+    def header(*args)
+      args.empty? ? @header : @header.column(*args)
+    end
+    
+    # Creates a new footer cell with the given name.  Footers must be defined
+    # in the order in which they will be rendered.
+    # 
+    # The actual caption and html options for the footer can be configured
+    # as well.  The caption determines what will be displayed in each cell.
+    # 
+    # == Examples
+    # 
+    #   # Adding footers
+    #   t.footer :total                         # => <td class="post-total"></th>
+    #   t.footer :total, 5                      # => <td class="post-total">5</th>
+    #   t.footer :total, :class => 'pretty'     # => <td class="post-total pretty"></th>
+    #   t.footer :total, 5, :class => 'pretty'  # => <td class="post-total pretty">5</th>
+    #   
+    #   # Customizing html options
+    #   t.footer[:class] = 'pretty'
+    def footer(*args)
+      args.empty? ? @footer : @footer.cell(*args)
     end
     
     private
+      # Finds the class representing the objects within the collection
+      def default_class
+        if collection.respond_to?(:proxy_reflection)
+          collection.proxy_reflection.klass
+        elsif !collection.empty?
+          collection.first.class
+        end
+      end
+      
       def tag_name
         'table'
       end
       
       def content
-        @content
+        content = ''
+        content << @header.html unless @header.empty?
+        content << @rows.html
+        content << @footer.html unless @footer.empty?
+        content
       end
   end
 end