data-table 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in data-table.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/data-table.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "data-table/version"
+
+Gem::Specification.new do |s|
+  s.name        = "data-table"
+  s.version     = DataTable::VERSION
+  s.authors     = ["Steve Erickson", "Jeff Fraser"]
+  s.email       = ["sixfeetover@gmail.com"]
+  s.homepage    = "https://github.com/sixfeetover/data-table"
+  s.summary     = %q{Turn arrays of hashes or models in to an HTML table.}
+  s.description = %q{data-table is a simple gem that provides a DSL for allowing you do turn an array of hashes or ActiveRecord objects into an HTML table.}
+
+  s.rubyforge_project = "data-table"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/data-table.rb

@@ -0,0 +1,3 @@
+require "data-table/version"
+require "data-table/data_table"
+require "data-table/data_table_column"

data/lib/data-table/data_table.rb

@@ -0,0 +1,385 @@
+## 
+# Config Options
+# 
+# id: the html id 
+# title: the title of the data table
+# subtitle: the subtitle of the data table
+# css_class: an extra css class to get applied to the table
+# empty_text: the text to display of the collection is empty
+# display_header => false: hide the column headers for the data table
+# alternate_rows => false: turn off alternating of row css classes
+# alternate_cols => true: turn on alternating of column classes, defaults to false
+#
+# columns: an array of hashes of the column specs for this table
+#
+# group_by: an array of columns to group on
+# pivot_on: an array of columns to pivot on
+#
+# subtotals: an array of hashes that contain the subtotal information for each column that should be subtotaled
+# totals: an array of hashes that contain the total information for each column that should be totaled
+#
+##
+
+class DataTable
+  
+  #############
+  # CONFIG 
+  #############
+  attr_reader :grouped_data, :pivoted_data, :subtotals, :totals, :subtotal_calculations, :total_calculations
+  attr_accessor :id, :title, :css_class, :empty_text, :alternate_rows, :alternate_cols, :display_header, :hide_if_empty, :repeat_headers_for_groups, :custom_headers
+  
+  def initialize(collection)
+    @collection = collection
+    default_options!
+    
+    @columns = []
+    
+    @groupings, @pivot_columns = [], []
+    @pivoted_data, @grouped_data = false, false
+    @subtotals, @totals = {}, {}
+  end
+  
+  def default_options!
+    @id = ''
+    @title = ''
+    @subtitle = ''
+    @css_class = ''
+    @empty_text = 'No records found'
+    @hide_if_empty = false
+    @display_header = true
+    @alternate_rows = true
+    @alternate_cols = false
+    @subtotal_title = "Subtotal:"
+    @total_title = "Total:"
+    @repeat_headers_for_groups = false
+    @custom_headers = []
+    @row_attributes = nil
+  end
+  
+  def self.default_css_styles
+    <<-CSS_STYLE
+      .data_table {width: 100%; empty-cells: show}
+      .data_table td, .data_table th {padding: 3px}
+      
+      .data_table caption {font-size: 2em; font-weight: bold}
+      
+      .data_table thead {}
+      .data_table thead th {background-color: #ddd; border-bottom: 1px solid #bbb;}
+      
+      .data_table tbody {}
+      .data_table tbody tr.alt {background-color: #eee;}
+      
+      .data_table .group_header th {text-align: left;}
+      
+      .data_table .subtotal {}
+      .data_table .subtotal td {border-top: 1px solid #000;}
+      
+      .data_table tfoot {}
+      .data_table tfoot td {border-top: 1px solid #000;}
+      
+      .empty_data_table {text-align: center; background-color: #ffc;}
+      
+      /* Data Types */
+      .data_table .number, .data_table .money {text-align: right}
+      .data_table .text {text-align: left}
+    CSS_STYLE
+  end
+  
+  # Define a new column for the table
+  def column(id, title="", opts={}, &b)
+    @columns << DataTableColumn.new(id, title, opts, &b)
+  end
+  
+  def prepare_data
+    self.pivot_data! if @pivoted_data
+    self.group_data! if @grouped_data
+    
+    self.calculate_subtotals! if has_subtotals?
+    self.calculate_totals! if has_totals?
+  end
+  
+  #############
+  # GENERAL RENDERING 
+  #############
+
+  def self.render(collection, &blk)
+    # make a new table
+    t = self.new(collection)
+    
+    # yield it to the block for configuration
+    yield t
+    
+    # modify the data structure if necessary and do calculations
+    t.prepare_data
+    
+    # render the table
+    t.render.html_safe
+  end
+  
+  def render
+    render_data_table
+  end
+  
+  def render_data_table
+    html = "<table id='#{@id}' class='data_table #{@css_class}' cellspacing='0' cellpadding='0'>"
+      html << "<caption>#{@title}</caption>" if @title
+      html << render_data_table_header if @display_header
+      if @collection.any?
+        html << render_data_table_body(@collection)
+        html << render_totals if has_totals?
+      else
+        html << "<tr><td class='empty_data_table' colspan='#{@columns.size}'>#{@empty_text}</td></tr>"
+      end
+    html << "</table>"
+  end
+
+  def render_data_table_header
+    html = "<thead>"
+    
+    html << render_custom_table_header unless @custom_headers.empty?
+    
+    html << "<tr>"
+      @columns.each do |col|
+        html << col.render_column_header
+      end
+    html << "</tr></thead>"
+  end
+  
+  def render_custom_table_header
+    html = "<tr>"
+      @custom_headers.each do |h|
+        html << "<th class=\"#{h[:css]}\" colspan=\"#{h[:colspan]}\">#{h[:text]}</th>"
+      end
+    html << "</tr>"
+  end
+
+  def render_data_table_body(collection)
+    if @grouped_data
+      render_grouped_data_table_body(collection)
+    else
+      "<tbody>#{render_rows(collection)}</tbody>"
+    end
+  end
+  
+  def render_rows(collection)
+    html = ""
+    collection.each_with_index do |row, row_index|
+      css_class = @alternate_rows && row_index % 2 == 1 ? 'alt ' : ''
+      if @row_style && style = @row_style.call(row, row_index)
+        css_class << style
+      end
+
+      attributes = @row_attributes.nil? ? {} : @row_attributes.call(row)
+      html << render_row(row, row_index, css_class, attributes)
+    end
+    html
+  end
+  
+  def render_row(row, row_index, css_class='', row_attributes={})
+    if row_attributes.nil?
+      attributes = ''
+    else
+      attributes = row_attributes.map {|attr, val| "#{attr}='#{val}'"}.join " "
+    end
+    
+    html = "<tr class='row_#{row_index} #{css_class}' #{attributes}>"
+      @columns.each_with_index do |col, col_index|
+        cell = row[col.name] rescue nil
+        html << col.render_cell(cell, row, row_index, col_index)
+      end
+    html << "</tr>"
+  end
+  
+  # define a custom block to be used to determine the css class for a row.
+  def row_style(&b)
+    @row_style = b
+  end
+  
+  def custom_header(&blk)
+    instance_eval(&blk)
+  end
+  
+  def th(header_text, options)
+    @custom_headers << options.merge(:text => header_text)
+  end
+  
+  def row_attributes(&b)
+    @row_attributes = b
+  end
+  
+  #############
+  # GROUPING 
+  #############
+  
+  # TODO: allow for group column only, block only and group column and block
+  def group_by(group_column, &blk)
+    @grouped_data = true
+    @groupings = group_column
+    @columns.reject!{|c| c.name == group_column}
+  end
+  
+  def group_data!
+    @collection = @collection.group_by {|row| row[@groupings] }
+  end
+  
+  def render_grouped_data_table_body(collection)
+    html = ""
+    collection.keys.each do |group_name|
+      html << render_group(group_name, collection[group_name])
+    end
+    html
+  end
+  
+  def render_group_header(group_header)
+    html = "<tr class='group_header'>"
+    if @repeat_headers_for_groups 
+      @columns.each_with_index do |col, i|
+        html << (i == 0 ? "<th>#{group_header}</th>" : col.render_column_header)
+      end
+    else
+      html << "<th colspan='#{@columns.size}'>#{group_header}</th>"
+    end
+    html << "</tr>"
+    html
+  end
+  
+  def render_group(group_header, group_data)
+    html = "<tbody class='#{group_header.to_s.downcase.gsub(/[^A-Za-z0-9]+/, '_')}'>" #replace non-letters and numbers with '_'
+      html << render_group_header(group_header)
+      html << render_rows(group_data)
+      html << render_subtotals(group_header, group_data) if has_subtotals?
+    html << "</tbody>"
+  end
+  
+  
+  #############
+  # PIVOTING 
+  #############
+  
+  def pivot_on(pivot_column)
+    @pivoted_data = true
+    @pivot_column = pivot_column
+  end
+  
+  def pivot_data!
+    @collection.pivot_on
+  end
+
+  #############
+  # TOTALS AND SUBTOTALS 
+  #############
+  def render_totals
+    html = "<tfoot><tr>"
+      @columns.each do |col|
+        html << col.render_cell(@total_calculations[col.name])
+      end
+    html << "</tr></tfoot>"
+  end
+  
+  def render_subtotals(group_header, group_data)
+    html = "<tr class='subtotal'>"
+      @columns.each do |col|
+        html << col.render_cell(@subtotal_calculations[group_header][col.name])
+      end
+    html << "</tr>"
+  end
+  
+  # define a new total column definition.
+  # total columns take the name of the column that should be totaled
+  # they also take a default aggregate function name and/or a block
+  # if only a default function is given, then it is used to calculate the total
+  # if only a block is given then only it is used to calculated the total
+  # if both a block and a function are given then the default aggregate function is called first
+  # then its result is passed into the block for further processing.
+  def subtotal(column_name, function=nil, &b)
+    function_or_block = function || b
+    f = function && block_given? ? [function, b] : function_or_block
+    @subtotals << {column_name => f}
+  end
+  
+  def has_subtotals?
+    !@subtotals.empty?
+  end
+  
+  # define a new total column definition.
+  # total columns take the name of the column that should be totaled
+  # they also take a default aggregate function name and/or a block
+  # if only a default function is given, then it is used to calculate the total
+  # if only a block is given then only it is used to calculated the total
+  # if both a block and a function are given then the default aggregate function is called first
+  # then its result is passed into the block for further processing.
+  def total(column_name, function=nil, &b)
+    function_or_block = function || b
+    f = function && block_given? ? [function, b] : function_or_block
+    @totals << {column_name => f}
+  end
+  
+  def has_totals?
+    !@totals.empty?
+  end
+  
+  def calculate_totals!
+    @total_calculations = {}
+    
+    @totals.each do |column_name, function|
+      collection = @collection.is_a?(Hash) ? @collection.values.flatten : @collection
+      result = calculate(collection, column_name, function)
+      @total_calculations[column_name] = result
+    end
+  end
+  
+  def calculate_subtotals!
+    @subtotal_calculations = Hash.new { |h,k| h[k] = {} }
+    
+    #ensure that we are dealing with a grouped results set.
+    unless @grouped_data
+      raise 'Subtotals only work with grouped results sets'
+    end
+    
+    @collection.each do |group_name, group_data|
+      @subtotals.each do |column_name, function|
+        result = calculate(group_data, column_name, function)
+        @subtotal_calculations[group_name][column_name] = result
+      end
+    end
+    
+  end
+  
+  def calculate(data, column_name, function)
+    
+    col = @columns.select { |column| column.name == column_name }
+    
+    if function.is_a?(Proc)
+      case function.arity
+        when 1; function.call(data)
+        when 2; function.call(data, col.first)
+      end
+    elsif function.is_a?(Array)
+      result = self.send("calculate_#{function[0].to_s}", data, column_name)
+      case function[1].arity
+        when 1; function[1].call(result)
+        when 2; function[1].call(result, col.first)
+      end
+    else
+      self.send("calculate_#{function.to_s}", data, column_name)
+    end
+  end
+  
+  def calculate_sum(collection, column_name)
+    collection.inject(0) {|sum, row| sum += row[column_name].to_f }
+  end
+  
+  def calculate_avg(collection, column_name)
+    sum = calculate_sum(collection, column_name)
+    sum / collection.size
+  end
+  
+  def calculate_max(collection, column_name)
+    collection.collect{|r| r[column_name].to_f }.max
+  end
+  
+  def calculate_min(collection, column_name)
+    collection.collect{|r| r[column_name].to_f }.min
+  end
+
+end

data/lib/data-table/data_table_column.rb

@@ -0,0 +1,60 @@
+class DataTableColumn
+ 
+  attr_reader :name
+  attr_accessor :display, :index, :options, :css_class, :attributes
+  
+  def initialize(name, description="", opts={}, &renderer)
+    @name, @description, = name, description
+    @data_type = opts[:data_type] || :text
+    @help_text = opts[:help_text] || ""
+    @css_class = opts[:css_class]
+    @attributes = opts[:attributes] || {}
+    @width = opts[:width]
+    @options = opts
+    
+    @display = true
+    @index = 0
+    @renderer = renderer
+  end
+  
+  def render_cell(cell_data, row=nil, row_index=0, col_index=0)
+    html = ""
+    if @renderer && row
+      cell_data = cell_data.to_s
+      html << case @renderer.arity
+            when 1; @renderer.call(cell_data).to_s
+            when 2; @renderer.call(cell_data, row).to_s
+            when 3; @renderer.call(cell_data, row, row_index).to_s
+            when 4; @renderer.call(cell_data, row, row_index, self).to_s
+            when 5; @renderer.call(cell_data, row, row_index, self, col_index).to_s
+          end
+    else
+      html << cell_data.to_s
+    end
+    
+    html << "</td>"
+    # Doing this here b/c you can't change @css_class if this is done before the renderer is called
+    html = "<td class='#{css_class_names}' #{custom_attributes}>" + html
+  end
+  
+  def render_column_header
+    header = "<th class='#{css_class_names}' #{custom_attributes}" 
+    header << "title='#{@help_text}' " if @help_text
+    header << "style='width: #{@width}'" if @width
+    header << ">#{@description}</th>"
+    header
+  end
+  
+  def custom_attributes
+    @attributes.map{|k, v| "#{k}='#{v}'"}.join ' '
+  end
+  
+  def css_class_names
+    class_names = []
+    class_names << @name.to_s
+    class_names << @data_type.to_s
+    class_names << @css_class
+    class_names.compact.join(' ')
+  end
+  
+end

data/lib/data-table/version.rb

@@ -0,0 +1,3 @@
+class DataTable
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: data-table
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Steve Erickson
+- Jeff Fraser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-09 00:00:00.000000000Z
+dependencies: []
+description: data-table is a simple gem that provides a DSL for allowing you do turn
+  an array of hashes or ActiveRecord objects into an HTML table.
+email:
+- sixfeetover@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- data-table.gemspec
+- lib/data-table.rb
+- lib/data-table/data_table.rb
+- lib/data-table/data_table_column.rb
+- lib/data-table/version.rb
+homepage: https://github.com/sixfeetover/data-table
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: data-table
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Turn arrays of hashes or models in to an HTML table.
+test_files: []