table_helper 0.0.5 → 0.1.0

data/lib/table_helper/collection_table.rb

@@ -3,58 +3,62 @@ require 'table_helper/header'
 require 'table_helper/body'
 require 'table_helper/footer'
 
-module PluginAWeek #:nodoc:
-  module TableHelper
-    # Represents a table that is displaying data for multiple objects within
-    # a collection.
-    class CollectionTable < HtmlElement
-      def initialize(collection, options = {}, html_options = {}) #:nodoc:
-        super(html_options)
-        
-        options.assert_valid_keys(
-          :class,
-          :footer,
-          :header
-        )
-        @options = options.reverse_merge(
-          :header => true,
-          :footer => false
-        )
-        
-        @html_options.reverse_merge!(
-          :cellspacing => '0',
-          :cellpadding => '0'
-        )
-        
-        @header = Header.new(collection, options[:class])
-        @body = Body.new(collection, @header)
-        @footer = Footer.new(collection)
+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.
+    # 
+    # 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:
+      super(html_options)
+      
+      options.assert_valid_keys(
+        :class,
+        :footer,
+        :header
+      )
+      @options = options.reverse_merge(
+        :header => true,
+        :footer => false
+      )
+      
+      @html_options.reverse_merge!(
+        :cellspacing => '0',
+        :cellpadding => '0'
+      )
+      
+      @header = Header.new(collection, options[:class])
+      @body = Body.new(collection, @header)
+      @footer = Footer.new(collection)
+    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
+    end
+    
+    private
+      def tag_name
+        'table'
       end
       
-      # Builds the table by rendering a header, body, and footer.
-      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}
+      def content
         @content
       end
-      
-      private
-        def tag_name
-          'table'
-        end
-        
-        def content
-          @content
-        end
-    end
   end
 end

data/lib/table_helper/footer.rb

@@ -1,47 +1,45 @@
 require 'table_helper/row'
 
-module PluginAWeek #:nodoc:
-  module TableHelper
-    # Represents the header of the table.  In HTML, you can think of this as
-    # the tfoot tag of the table.
-    class Footer < HtmlElement
-      # The actual footer row
-      attr_reader :row
+module TableHelper
+  # Represents the header of the table.  In HTML, you can think of this as
+  # the <tfoot> tag of the table.
+  class Footer < HtmlElement
+    # The actual footer row
+    attr_reader :row
+    
+    delegate  :cell,
+                :to => :row
+    
+    # Whether or not the footer should be hidden when the collection is
+    # empty.  Default is true.
+    attr_accessor :hide_when_empty
+    
+    def initialize(collection) #:nodoc:
+      super()
       
-      delegate  :cell,
-                  :to => :row
-      
-      # Whether or not the footer should be hidden when the collection is
-      # empty.  Default is true.
-      attr_accessor :hide_when_empty
+      @collection = collection
+      @row = Row.new
+      @hide_when_empty = true
+    end
+    
+    def html #:nodoc:
+      html_options = @html_options.dup
+      html_options[:style] = 'display: none;' if @collection.empty? && hide_when_empty
       
-      def initialize(collection) #:nodoc:
-        super()
-        
-        @collection = collection
-        @row = Row.new
-        @hide_when_empty = true
+      content_tag(tag_name, content, html_options)
+    end
+    
+    private
+      def tag_name
+        'tfoot'
       end
       
-      def html #:nodoc:
-        html_options = @html_options.dup
-        html_options[:style] = 'display: none;' if @collection.empty? && hide_when_empty
-        
-        content_tag(tag_name, content, html_options)
+      # Generates the html for the footer.  The footer generally consists of a
+      # summary of the data in the body.  This row will be wrapped inside of
+      # a tfoot tag.  If the collection is empty and hide_when_empty was set
+      # to true, then the footer will be hidden.
+      def content
+        @row.html
       end
-      
-      private
-        def tag_name
-          'tfoot'
-        end
-        
-        # Generates the html for the footer.  The footer generally consists of a
-        # summary of the data in the body.  This row will be wrapped inside of
-        # a tfoot tag.  If the collection is empty and hide_when_empty was set
-        # to true, then the footer will be hidden.
-        def content
-          @row.html
-        end
-    end
   end
 end

data/lib/table_helper/header.rb

@@ -1,163 +1,161 @@
 require 'table_helper/row'
 
-module PluginAWeek #:nodoc:
-  module TableHelper
-    # Provides a blank class that can be used to build the columns for a header
-    class HeaderBuilder < BlankSlate
-      reveal :respond_to?
-      
-      attr_reader :header
-      
-      # Creates a builder for the given header
-      def initialize(header)
-        @header = header
-      end
-      
-      # Proxies all missed methods to the header
-      def method_missing(*args)
-        header.send(*args)
-      end
-      
-      # Defines the accessor method for the given column name.  For example, if
-      # a column with the name :title was defined, then the column would be able
-      # to be read and written like so:
-      # 
-      #   header.title               #=> Accesses the title
-      #   header.title "Page Title"  #=> Creates a new column with "Page Title" as the content
-      def define_column(name)
-        method_name = name.to_s.gsub('-', '_')
-        
-        klass = class << self; self; end
-        klass.class_eval do
-          define_method(method_name) do |*args|
-            header.row.builder.__send__(method_name, *args)
-          end
-        end unless klass.method_defined?(method_name)
-      end
+module TableHelper
+  # Provides a blank class that can be used to build the columns for a header
+  class HeaderBuilder < BlankSlate #:nodoc:
+    reveal :respond_to?
+    
+    attr_reader :header
+    
+    # Creates a builder for the given header
+    def initialize(header)
+      @header = header
+    end
+    
+    # Proxies all missed methods to the header
+    def method_missing(*args)
+      header.send(*args)
+    end
+    
+    # Defines the accessor method for the given column name.  For example, if
+    # a column with the name :title was defined, then the column would be able
+    # to be read and written like so:
+    # 
+    #   header.title               #=> Accesses the title
+    #   header.title "Page Title"  #=> Creates a new column with "Page Title" as the content
+    def define_column(name)
+      method_name = name.to_s.gsub('-', '_')
       
-      # Removes the definition for the given cp;i,m
-      def undef_column(name)
-        klass = class << self; self; end
-        klass.class_eval do
-          remove_method(name.gsub('-', '_'))
+      klass = class << self; self; end
+      klass.class_eval do
+        define_method(method_name) do |*args|
+          header.row.builder.__send__(method_name, *args)
         end
+      end unless klass.method_defined?(method_name)
+    end
+    
+    # Removes the definition for the given cp;i,m
+    def undef_column(name)
+      klass = class << self; self; end
+      klass.class_eval do
+        remove_method(name.gsub('-', '_'))
       end
     end
+  end
+  
+  # Represents the header of the table.  In HTML, you can think of this as
+  # the <thead> tag of the table.
+  class Header < HtmlElement
+    # The actual header row
+    attr_reader :row
+    
+    # The proxy class used externally to build the actual columns
+    attr_reader :builder
+    
+    # Whether or not the header should be hidden when the collection is
+    # empty.  Default is true.
+    attr_accessor :hide_when_empty
     
-    # Represents the header of the table.  In HTML, you can think of this as
-    # the <thead> tag of the table.
-    class Header < HtmlElement
-      # The actual header row
-      attr_reader :row
+    # Creates a new header for a collection that contains objects of the
+    # given class.
+    # 
+    # If the class is known, then the header will be pre-filled with
+    # the columns defined in that class (assuming it's an ActiveRecord
+    # class).
+    def initialize(collection, klass = nil)
+      super()
       
-      # The proxy class used externally to build the actual columns
-      attr_reader :builder
+      @collection = collection
+      @row = Row.new
+      @builder = HeaderBuilder.new(self)
       
-      # Whether or not the header should be hidden when the collection is
-      # empty.  Default is true.
-      attr_accessor :hide_when_empty
+      @hide_when_empty = true
+      @customized = true
       
-      # Creates a new header for a collection that contains objects of the
-      # given class.
-      # 
-      # If the class is known, then the header will be pre-filled with
-      # the columns defined in that class (assuming it's an ActiveRecord
-      # class).
-      def initialize(collection, klass = nil)
-        super()
-        
-        @collection = collection
-        @row = Row.new
-        @builder = HeaderBuilder.new(self)
-        
-        @hide_when_empty = true
+      # If we know what class the objects in the collection are and we can
+      # figure out what columns are defined in that class, then we can
+      # pre-fill the header with those columns so that the user doesn't
+      # have to
+      klass ||= class_for_collection(collection)
+      if klass && klass.respond_to?(:column_names)
+        klass.column_names.each {|name| column(name)}
+        @customized = false
+      end
+    end
+    
+    # The current columns in this header, in the order in which they will be built
+    def columns
+      row.cells
+    end
+    
+    # Gets the names of all of the columns being displayed in the table
+    def column_names
+      row.cell_names
+    end
+    
+    # Clears all of the current columns from the header
+    def clear
+      # Remove all of the shortcut methods
+      column_names.each {|name| builder.undef_column(name)}
+      row.clear
+    end
+    
+    # Creates a new column with the specified caption.  Columns must be
+    # defined in the order in which they will be rendered.
+    # 
+    # The caption determines what will be displayed in each cell of the
+    # header (if the header is rendered).  For example,
+    # 
+    #   header.column :title, 'The Title'
+    # 
+    # ...will create a column the displays "The Title" in the cell.
+    # 
+    # = Setting html options
+    # 
+    # In addition to customizing the content of the column, you can also
+    # specify html options like so:
+    # 
+    #   header.column :title, 'The Title', :class => 'pretty'
+    def column(name, *args)
+      # Clear the header row if this is being customized by the user
+      unless @customized
         @customized = true
-        
-        # If we know what class the objects in the collection are and we can
-        # figure out what columns are defined in that class, then we can
-        # pre-fill the header with those columns so that the user doesn't
-        # have to
-        klass ||= class_for_collection(collection)
-        if klass && klass.respond_to?(:column_names)
-          klass.column_names.each {|name| column(name)}
-          @customized = false
-        end
+        clear
       end
       
-      # The current columns in this header, in the order in which they will be built
-      def columns
-        row.cells
-      end
+      column = row.cell(name, *args)
+      column.content_type = :header
+      column[:scope] ||= 'col'
       
-      # Gets the names of all of the columns being displayed in the table
-      def column_names
-        row.cell_names
-      end
+      builder.define_column(name)
       
-      # Clears all of the current columns from the header
-      def clear
-        # Remove all of the shortcut methods
-        column_names.each {|name| builder.undef_column(name)}
-        row.clear
-      end
+      column
+    end
+    
+    # Creates and returns the generated html for the header
+    def html
+      html_options = @html_options.dup
+      html_options[:style] = 'display: none;' if @collection.empty? && hide_when_empty
       
-      # Creates a new column with the specified caption.  Columns must be
-      # defined in the order in which they will be rendered.
-      # 
-      # The caption determines what will be displayed in each cell of the
-      # header (if the header is rendered).  For example,
-      # 
-      #   header.column :title, 'The Title'
-      # 
-      # ...will create a column the displays "The Title" in the cell.
-      # 
-      # = Setting html options
-      # 
-      # In addition to customizing the content of the column, you can also
-      # specify html options like so:
-      # 
-      #   header.column :title, 'The Title', :class => 'pretty'
-      def column(name, *args)
-        # Clear the header row if this is being customized by the user
-        unless @customized
-          @customized = true
-          clear
+      content_tag(tag_name, content, html_options)
+    end
+    
+    private
+      # Finds the class representing the objects within the collection
+      def class_for_collection(collection)
+        if collection.respond_to?(:proxy_reflection)
+          collection.proxy_reflection.klass
+        elsif !collection.empty?
+          collection.first.class
         end
-        
-        column = row.cell(name, *args)
-        column.content_type = :header
-        column[:scope] ||= 'col'
-        
-        builder.define_column(name)
-        
-        column
       end
       
-      # Creates and returns the generated html for the header
-      def html
-        html_options = @html_options.dup
-        html_options[:style] = 'display: none;' if @collection.empty? && hide_when_empty
-        
-        content_tag(tag_name, content, html_options)
+      def tag_name
+        'thead'
       end
       
-      private
-        # Finds the class representing the objects within the collection
-        def class_for_collection(collection)
-          if collection.respond_to?(:proxy_reflection)
-            collection.proxy_reflection.klass
-          elsif !collection.empty?
-            collection.first.class
-          end
-        end
-        
-        def tag_name
-          'thead'
-        end
-        
-        def content
-          @row.html
-        end
-    end
+      def content
+        @row.html
+      end
   end
 end