tabloid 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tabloid.gemspec
+gemspec
+
+group :test do
+  gem "ruby-debug"
+  gem "ZenTest"
+end

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2011 Inductive Applications
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.txt

@@ -0,0 +1,137 @@
+Tabloid allows the creation of cacheable report data using a straightforward DSL and output to HTML, CSV, and more to come.
+
+This gem comes out of an Austin.rb meeting about our favorite gems where I sketched out what my ideal reporting DSL would look like.  This gem is inspired by some of the features of Ruport, but I found its API to be a bit top-heavy for rapidly producing reports (though at the time of this writing, Ruport is far more flexible than Tabloid) and its up to you to take care of items like data caching. If your reporting needs are fairly straightforward, Tabloid should work pretty well for your needs.  That said, this gem is early in development and has a lot of rough edges (see TODO list below), but it is being used in production and makes me happy there.
+
+Features:
+  * easy to use DSL for specifying report definitions
+  * built-in caching of compiled data to Memcached and Redis
+  * parameterized reports
+  * can be used with your choice of ORM (used in production with ActiveRecord, should be usable with any other ORM)
+  * grouping of data with group and report summaries (totals only at the moment)
+  * unicorns
+
+How to use it
+  
+Simple report
+  class UnpaidInvoicesReport
+    include Tabloid::Report
+
+    element :invoice_number, "Invoice Number"
+    element :invoice_date, "Invoice Date"
+    element :customer_name, "Name"
+    element :invoice_amount, "Amount"
+    element :balance, "Balance"
+
+    rows do
+      Invoice.select(:invoice_number, :invoice_date, :customer_name, :invoice_amount, :balance).where("balance > 0")
+    end
+  end
+
+  #create the report
+  report = UnpaidInvoicesReport.new
+
+  #collect the data
+  report.prepare
+
+  #output formats supported now
+  csv = report.to_csv
+  html = report.to_html
+
+
+Walking through the above:
+
+  include Tabloid::Report
+
+makes this class into a Tabloid report.
+
+  element :invoice_number, "Invoice Number"
+
+#element creates a report column.  In this case the report data will either use the first element of an array or whatever responds to the symbol :invoice_number on the data coming back from #rows.  More on that in a sec...
+
+    rows do
+      Invoice.select(:invoice_number, :invoice_date, :customer_name, :invoice_amount, :balance).where("balance > 0")
+    end
+  
+#rows is the workhorse of a report.  This is where you collect your data for reporting.  It should return an array of arrays or an array of objects that respond to the keys dictated by your use of #element.  (Support for an array of hashes is on the TODO list.) If you use nested arrays, the elements are order dependent—use the order you specified when adding element columns.
+
+#to_csv and #to_html do pretty much what you'd think; they return a string containing the report in the respective formats.  The HTML returned by #to_html is a table with one column per visible column; each cell will have the element symbol as a class name to allow for styling of columns.
+
+Bells and whistles
+Tabloid also supports groups with summaries and a report summary.  Only totals are supported at the moment, but more flexibility is coming soon.
+
+  class UnpaidInvoicesReport < ActiveRecord::Base
+    include Tabloid::Report
+    handle_asynchronously :prepare
+
+    cache_key { "unpaid_invoices_report-#{id}"}
+
+    #parameterized report, supply parameters to report.prepare(...)
+    parameter :start_date
+    parameter :end_date
+
+    grouping :customer_name, :total => true
+
+    element :invoice_number, "Invoice Number"
+    element :invoice_date, "Invoice Date"
+    element :customer_name, "Name", :hidden => true
+    element :invoice_amount, "Amount", :total => true
+    element :balance, "Balance"
+
+    summary :balance => :sum
+
+    rows do
+      Invoice.select(:invoice_number, :invoice_date, :customer_name, :invoice_amount, :balance).where("balance > 0 AND invoice_date BETWEEN ? AND ?", parameter(:start_date), parameter(:end_date))
+    end
+  end
+
+There's several things different about this one.  We use #grouping to tell Tabloid to group the data by customer name, and indicate that we want totals to be calculated for each group.  We indicate which columns we want totalled by passing :total => true on the elements requiring totals.  We tell Tabloid to hide the :customer_name column because it will show a group header that contains this element for us.  Finally, we tell Tabloid to summarize the report by summing balances. (:sum is the only accepted value for now, but support is coming for arbitrary blocks and a wider range of built-in functions).
+
+Background support
+Notice the parent class on this one? This report is backed by ActiveRecord. The main reason you'd want to do that is to allow for generation of report data in the background.  In the report above, we've enabled that by making #prepare (which invokes the #rows block) run in the background using DelayedJob's #handle_asynchronously method.  To use it under these circumstances, you'll create and save the report, then call prepare explicitly:
+   
+  report = UnpaidInvoicesReport.create
+  report.prepare(:start_date => 30.days.ago, :end_date => Date.today)
+
+Caching support
+Background generation of data wouldn't make sense to do, however, unless you were also caching the data somewhere.  Tabloid has explicit support for caching using Memcached and Redis.  Redis is preferred under most circumstances, as it doesn't have the 1MB record limit of memcached.  To enable caching, you have to provide the #cache_key block above (see TODO for changes that are coming there) and set the caching parameters of Tabloid in an initializer:
+
+  #config/initializers/tabloid.rb
+  config = YAML.load(IO.read(Rails.root.join("config/tabloid.yml")))[Rails.env]
+  if config
+    Tabloid.cache_engine             = config['cache_engine'].to_sym
+    Tabloid.cache_connection_options = {
+        :server => config['server'],
+        :port   => config['port']
+    }
+  end
+
+  #config/tabloid.yml
+  production:
+    cache_engine: redis
+    server: 172.16.0.10
+    port: 6379
+  development:
+    cache_engine: memcached
+    server: localhost
+    port: 11211
+  test:
+    cache_engine: memcached
+    server: localhost
+    port: 11211
+
+
+Caveat Emptor
+This gem is being used in production without any real problems.  There are definitely some rough edges to it; it was born out of the needs of a particular application, so while I've designed it to be something that isn't single purpose, its also geared towards basic reports that have totals in various configurations.  So its a work in progress.  That said, if you need to whip up a report quickly, give it a try.  It has very few dependencies, as its being used with a Rails 2.3 application, so it doesn't pull in anything like ActiveSupport that would make it unsuitable for other environments.
+
+Patches are welcome!
+
+TODO:
+* Add more options for summary rows, like average and arbitrary blocks
+* clean up the test suite a bit
+* documentation!
+* more caching mechanisms
+* better callbacks
+* PDF output format support with PDFkit (optional)
+* extend the summary method to support more complex summary formats
+* Add support for a preamble section (e.g. detailing report parameters)
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/tabloid.rb

@@ -0,0 +1,18 @@
+require "builder"
+require 'yaml'
+
+module Tabloid
+  # Your code goes here...
+end
+require 'tabloid/configuration'
+require 'tabloid/header_row'
+require 'tabloid/missing_parameter_error'
+require 'tabloid/missing_element_error'
+require 'tabloid/parameter'
+require 'tabloid/report'
+require 'tabloid/column_extensions'
+require 'tabloid/report_column'
+require 'tabloid/row'
+require 'tabloid/group'
+require 'tabloid/data'
+

data/lib/tabloid/column_extensions.rb

@@ -0,0 +1,11 @@
+module Tabloid
+  module ColumnExtensions
+    def [](val)
+      if val.is_a?(String) || val.is_a?(Symbol)
+        self.detect { |c| c.key == val }
+      else
+        super
+      end
+    end
+  end
+end

data/lib/tabloid/configuration.rb

@@ -0,0 +1,20 @@
+module Tabloid
+  def self.cache_engine=(engine)
+    @engine = engine
+  end
+
+  def self.cache_engine
+    @engine
+  end
+
+  def self.cache_enabled?
+    !@engine.nil?
+  end
+
+  def self.cache_connection_options=(options)
+    @cache_connection_options = options
+  end
+  def self.cache_connection_options
+    @cache_connection_options || {}
+  end
+end

data/lib/tabloid/data.rb

@@ -0,0 +1,106 @@
+module Tabloid
+  class Data
+    attr_accessor :report_columns
+    attr_reader :rows
+
+    def initialize(options = {})
+      raise ArgumentError.new("Must supply row data") unless options[:rows]
+      raise ArgumentError.new("Must supply column data") unless options[:report_columns]
+
+      @report_columns   = options[:report_columns]
+      @grouping_key     = options[:grouping_key]
+      @grouping_options = options[:grouping_options] || {:total => true}
+      @summary_options  = options[:summary] || {}
+
+      @rows = convert_rows(options[:rows])
+
+    end
+
+    def to_csv
+      header_csv + rows.map(&:to_csv).join + summary_csv
+    end
+
+    def to_html
+      header_html + rows.map(&:to_html).join + summary_html
+    end
+
+    private
+    def convert_rows(rows)
+      rows.map! do |row|
+        Tabloid::Row.new(:columns => @report_columns, :data => row)
+      end
+
+      if @grouping_key
+        rows = rows.group_by { |r| r[@grouping_key] }
+      else
+        rows = {:default => rows}
+      end
+
+      rows.keys.sort.map do |key|
+        data_rows = rows[key]
+
+        label = (key == :default ? false : key)
+        Tabloid::Group.new :columns => @report_columns, :rows => data_rows, :label => label, :total => @grouping_options[:total]
+      end
+    end
+
+    def header_csv
+      FasterCSV.generate do |csv|
+        csv << @report_columns.map(&:to_header)
+      end
+    end
+
+    def header_html
+      headers = Builder::XmlMarkup.new
+      headers.tr do |tr|
+        @report_columns.each do |col|
+          tr.th(col.to_header, "class" => col.key) unless col.hidden?
+        end
+      end
+    end
+
+    def summary_html
+      summary_rows.map { |row| row.to_html(:class => "summary") }.join
+    end
+
+    def summary_csv
+      summary_rows.map(&:to_csv).join
+    end
+
+    #perform the supplied block on all rows in the data structure
+    def summarize(key, block)
+      summaries = rows.map { |r| r.summarize(key, &block) }
+      if summaries.any?
+        summaries[1..-1].inject(summaries[0]) do |summary, val|
+          block.call(summary, val)
+        end
+      else
+        nil
+      end
+    end
+
+    def summary_rows
+      data_summary = report_columns.map do |col|
+        if summarizer = @summary_options[col.key]
+          summarize(col.key, self.send(summarizer)) unless col.hidden?
+        end
+
+      end
+      [
+          Tabloid::HeaderRow.new("Totals", :column_count => visible_column_count),
+          Tabloid::Row.new(:columns => @report_columns,
+                           :data    => data_summary)
+
+      ]
+
+    end
+
+    def visible_column_count
+      @visible_col_count ||= @report_columns.select { |col| !col.hidden? }.count
+    end
+
+    def sum
+      proc(&:+)
+    end
+  end
+end

data/lib/tabloid/group.rb

@@ -0,0 +1,69 @@
+class Tabloid::Group
+
+  attr_reader :rows
+  attr_reader :columns
+  attr_reader :label
+
+  def initialize(options)
+    @rows                 = options[:rows]
+    @columns              = options[:columns]
+    @visible_column_count = @columns.select { |col| !col.hidden? }.count
+    @total_required       = options[:total]
+    @label                = options[:label]
+    raise ArgumentError.new("Must supply row data to a Group") unless @rows
+  end
+
+  def total_required?
+    !(@total_required.nil? || @total_required == false)
+  end
+
+  def rows
+    if total_required?
+      summed_data = columns.map { |col| col.total? ? sum_rows(col.key) : nil }
+      @rows + [Tabloid::Row.new(:data => summed_data, :columns => self.columns)]
+    else
+      @rows
+    end
+  end
+
+  def summarize(key, &block)
+    @rows[1..-1].inject(@rows[0].send(key)){|summary, row| block.call(summary, row.send(key))  }
+  end
+
+  def to_csv
+    header_row_csv + rows.map(&:to_csv).join
+  end
+
+  def to_html
+    header_row_html + rows.map(&:to_html).join
+  end
+
+  private
+  def sum_rows(key)
+    #use the initial value from the same set of addends to prevent type conflict
+    #like 0:Fixnum + 0:Money => Exception
+    return nil unless @rows && @rows.any?
+    @rows[1..-1].inject(@rows[0][key]) { |sum, row| sum + row[key] }
+  end
+
+  def header_row_csv
+    if @label
+      cols = [label]
+      (@visible_column_count-1).times{ cols << nil}
+      FasterCSV.generate{|csv| csv<<cols}
+    else
+      ""
+    end
+  end
+
+  def header_row_html
+    if @label
+      html = Builder::XmlMarkup.new
+      html.tr(:class => "group_header") do |tr|
+        tr.td(label, {"colspan" => @visible_column_count})
+      end
+    else
+      ""
+    end
+  end
+end

data/lib/tabloid/header_row.rb

@@ -0,0 +1,31 @@
+class Tabloid::HeaderRow
+  def initialize(text, options={})
+    @text = text
+    @options = options
+  end
+
+  def to_csv
+    FasterCSV.generate{|csv| csv << to_a}
+  end
+
+  def to_html(options={})
+    html = Builder::XmlMarkup.new
+    html.tr("class" => (options[:class] || "header")) do |tr|
+      tr.td(@text, "colspan" => column_count)
+    end
+  end
+
+  def to_a
+    [@text].fill(nil, 1, column_count-1)
+  end
+
+  def summarize
+    nil
+  end
+
+  private
+  def column_count
+    (@options[:column_count] || 1)
+  end
+
+end

data/lib/tabloid/missing_element_error.rb

@@ -0,0 +1,3 @@
+class Tabloid::MissingElementError < Exception
+  # To change this template use File | Settings | File Templates.
+end

data/lib/tabloid/missing_parameter_error.rb

@@ -0,0 +1,5 @@
+module Tabloid
+  class MissingParameterError < Exception
+
+  end
+end

data/lib/tabloid/parameter.rb

@@ -0,0 +1,15 @@
+module Tabloid
+  class Parameter
+    attr_accessor :key, :label
+    def initialize(key, label = nil )
+      self.key = key
+      self.label = label || humanize(key.to_s)
+    end
+
+    private
+    def humanize(string)
+      "#{string.first.upcase}#{string[1..-1]}".gsub("_", " ")
+    end
+
+  end
+end

data/lib/tabloid/report.rb

@@ -0,0 +1,228 @@
+module Tabloid::Report
+
+  def self.included(base)
+    base.class_eval do
+      @report_parameters = []
+      @report_columns    = []
+      @report_columns.extend Tabloid::ColumnExtensions
+      extend Tabloid::Report::ClassMethods
+      include Tabloid::Report::InstanceMethods
+    end
+  end
+
+  module ClassMethods
+    def parameter(*args)
+      @report_parameters << Tabloid::Parameter.new(*args)
+    end
+
+    def store_parameters(attribute)
+
+    end
+
+    def parameters
+      @report_parameters
+    end
+
+    def summary(summary_options = {})
+      @summary_options = summary_options
+    end
+
+    def report_columns
+      @report_columns
+    end
+
+    def cache_key(&block)
+      if block
+        @cache_block = block
+      end
+    end
+
+    def cache_key_block
+      @cache_block
+    end
+
+    def rows_block
+      @rows_block
+    end
+
+    def rows(*args, &block)
+      @rows_block = block
+    end
+
+    def element(key, label = "", options={})
+      @report_columns << Tabloid::ReportColumn.new(key, label, options)
+    end
+
+    def grouping(key, options = {})
+      @grouping_key     = key
+      @grouping_options = options
+    end
+
+    def grouping_key
+      @grouping_key
+    end
+
+    def grouping_options
+      @grouping_options
+    end
+
+    def summary_options
+      @summary_options
+    end
+  end
+
+  module InstanceMethods
+
+    def prepare(options={})
+      before_prepare if self.respond_to?(:before_prepare)
+      @report_parameters = {}
+      parameters.each do |param|
+        value = options.delete param.key
+        raise Tabloid::MissingParameterError.new("Must supply :#{param.key} when creating the report") unless value
+        @report_parameters[param.key] = value
+      end
+      data
+      after_prepare if self.respond_to?(:after_prepare)
+
+      self
+    end
+
+    def report_columns
+      self.class.report_columns
+    end
+
+    def parameters
+      self.class.parameters
+    end
+
+    def parameter(key)
+      load_from_cache if Tabloid.cache_enabled?
+      @report_parameters[key] if @report_parameters
+    end
+
+    def data
+      load_from_cache if Tabloid.cache_enabled?
+      build_and_cache_data
+      @data
+    end
+
+    def to_html
+      "<table>#{data.to_html}</table>"
+    end
+
+    def to_csv
+      data.to_csv
+    end
+
+    def cache_key
+      @key ||= begin
+        if self.class.cache_key_block
+          self.instance_exec &self.class.cache_key_block
+        else
+          nil
+        end
+      end
+    end
+
+
+    private
+    def cache_data(data)
+      if Tabloid.cache_enabled?
+        raise Tabloid::MissingParameterError.new("Must supply a cache_key block when caching is enabled") unless self.class.cache_key_block
+
+        report_data = {
+            :parameters => @report_parameters,
+            :data       => data
+        }
+
+        raise "Unable to cache data" unless cache_client.set(cache_key, YAML.dump(report_data))
+
+      end
+      data
+    end
+
+    def load_from_cache
+      if Tabloid.cache_enabled? && !@cached_data
+        @cached_data = read_from_cache
+        if @cached_data
+          @cached_data        = YAML.load(@cached_data)
+          @data              = @cached_data[:data]
+          @report_parameters = @cached_data[:parameters]
+        end
+      end
+    end
+
+
+    def cache_client
+      if Tabloid.cache_enabled?
+        server = Tabloid.cache_connection_options[:server] || 'localhost'
+        if Tabloid.cache_engine == :memcached
+          port          = Tabloid.cache_connection_options[:port] || '11211'
+          @cache_client ||= Dalli::Client.new("#{server}:#{port}")
+        elsif Tabloid.cache_engine == :redis
+          port          = Tabloid.cache_connection_options[:port] || '6379'
+          @cache_client ||= Redis.new(
+              :host => server,
+              :port => port)
+        end
+      end
+    end
+
+    def build_and_cache_data
+
+      @data ||= begin
+        report_data = Tabloid::Data.new(
+            :report_columns   => self.report_columns,
+            :rows             => prepare_data,
+            :grouping_key     => grouping_key,
+            :grouping_options => grouping_options,
+            :summary          => summary_options
+        )
+        cache_data(report_data)
+        report_data
+      end
+    end
+
+
+    def prepare_data
+      row_data = instance_exec(&self.class.rows_block)
+      #unless row_data.first.is_a? Array
+      #  row_data.map! do |row|
+      #    report_columns.map do |col|
+      #      row.send(col.key).to_s
+      #    end
+      #  end
+      #end
+      row_data
+    end
+
+    def read_from_cache
+      cache_client.get(cache_key) if cache_client && cache_key
+    end
+
+    def grouping_options
+      self.class.grouping_options
+    end
+
+    def grouping_key
+      self.class.grouping_key
+    end
+
+    def summary_options
+      self.class.summary_options
+    end
+
+    def parameter_info_html
+      html = Builder::XmlMarkup.new
+      html = html.p("id" => "parameters") do |p|
+        parameters.each do |param|
+          p.div do |div|
+            div.span(param.label, "class" => "parameter_label")
+            div.span(parameter(param.key), "class" => "parameter_value")
+          end
+        end
+      end
+      html.to_s
+    end
+  end
+end

data/lib/tabloid/report_column.rb

@@ -0,0 +1,31 @@
+module Tabloid
+  class ReportColumn
+    attr_accessor :key
+    attr_accessor :label
+    attr_accessor :hidden
+
+    def initialize(key, label = "", options={})
+      self.key = key
+      self.label = label
+      @hidden =  options[:hidden]
+      @total = options[:total]
+    end
+
+    def to_s
+      @key.to_s
+    end
+
+    def total?
+      @total
+    end
+
+    def hidden?
+      hidden
+    end
+
+    def to_header
+      return self.label if label
+      return self.key
+    end
+  end
+end

data/lib/tabloid/row.rb

@@ -0,0 +1,65 @@
+class Tabloid::Row
+  def initialize(*args)
+    options = args.pop
+    if args.first
+      @data = args.first
+    else
+      @data = options[:data]
+    end
+    raise "Must supply data to .new when creating a new Row" unless @data
+
+    @columns = options[:columns]
+    raise "Must supply column information when creating a new Row" unless @columns
+  end
+
+
+  def to_csv
+    FasterCSV.generate do |csv|
+      csv_array = []
+      @columns.each_with_index do |col, index|
+        next if col.hidden?
+        val = self[col.key]
+        csv_array << val
+      end
+      csv << csv_array
+    end
+  end
+
+  def to_html(options = {})
+    html = Builder::XmlMarkup.new
+    html.tr("class" => (options[:class] || "data")) do |tr|
+      @columns.each_with_index do |col, index|
+        tr.td(self[col.key], "class" => col.key) unless col.hidden?
+      end
+    end
+  end
+
+  def summarize(key, &block)
+    self[key]
+  end
+
+  def [](key)
+    if @data.is_a? Array
+      if key.is_a? Numeric
+        @data[key]
+      else
+        index = @columns.index{|col| col.key == key}
+        @data[index]
+      end
+    else
+      if key.is_a? Numeric
+        key = @columns[key].key
+      end
+      @data.send(key)
+    end
+  end
+
+  def method_missing(method, *args)
+    if @columns.detect{|col| col.key == method}
+      self[method]
+    else
+      super
+    end
+  end
+
+end

data/lib/tabloid/version.rb

@@ -0,0 +1,3 @@
+module Tabloid
+  VERSION = "0.0.1"
+end

data/spec/lib/tabloid/data_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Tabloid::Data do
+  let(:columns) do
+    [
+        Tabloid::ReportColumn.new(:col1, "Column 1"),
+        Tabloid::ReportColumn.new(:col2, "Column 2")
+    ]
+  end
+  let(:rows) { [[1, 2], [3, 4]] }
+  describe "creation" do
+    it "works when rows and columns are provided" do
+      lambda { Tabloid::Data.new(:report_columns => columns, :rows => rows) }.should_not raise_error(ArgumentError)
+
+    end
+    it "requires row data" do
+      lambda { Tabloid::Data.new(:report_columns => columns) }.should raise_error(ArgumentError, "Must supply row data")
+    end
+    it "requires column data" do
+      lambda { Tabloid::Data.new(:rows => rows) }.should raise_error(ArgumentError, "Must supply column data")
+    end
+
+    it "puts rows into groups" do
+      data = Tabloid::Data.new(:report_columns => columns, :rows => rows, :grouping_key => :col1)
+      data.rows.first.should be_a(Tabloid::Group)
+    end
+
+    describe "summary" do
+      let(:data){ Tabloid::Data.new(:report_columns => columns, :rows => rows, :summary => { :col2 => :sum } )}
+      it "adds a totals row to the csv output" do
+        csv_rows = FasterCSV.parse(data.to_csv)
+        csv_rows.should include(["Totals", nil])
+        csv_rows.should include([nil, "6"])
+      end
+      it "adds a totals row to the html output" do
+        doc = Nokogiri::HTML(data.to_html)
+        (doc/"tr.summary").should_not be_nil
+        (doc/"tr.summary td.col2").text.should == "6"
+      end
+    end
+  end
+end

data/spec/lib/tabloid/group_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+describe Tabloid::Group do
+  let(:columns) do
+    [
+        Tabloid::ReportColumn.new(:col1, "Column 1"),
+        Tabloid::ReportColumn.new(:col2, "Column 2")
+    ]
+  end
+  let(:row1) { Tabloid::Row.new(:columns => columns, :data => [1, 2]) }
+  let(:row2) { Tabloid::Row.new(:columns => columns, :data => [3, 4]) }
+  let(:group) { Tabloid::Group.new(:rows =>[row1, row2], :columns => columns, :label => "foobar") }
+  let(:anon_group) { Tabloid::Group.new(:rows =>[row1, row2], :columns => columns, :label => false) }
+
+  it "has a label" do
+    group.label.should == "foobar"
+  end
+
+  describe "producing output" do
+    describe "as CSV" do
+      let(:rows) { FasterCSV.parse(group.to_csv) }
+      it "includes all rows for the group" do
+        rows.should include(["1", "2"])
+        rows.should include(["3", "4"])
+      end
+      it "includes a group label row" do
+        rows.should include(["foobar", nil])
+      end
+      it "doesn't include a label row when label is falsey" do
+        rows = FasterCSV.parse(anon_group.to_csv)
+        rows.should_not include(["foobar", nil])
+      end
+    end
+    describe "as html" do
+      let(:doc) { doc = Nokogiri::HTML(group.to_html)
+      }
+      it "creates a table row for each data row" do
+        (doc/"tr[class='data']").count.should == 2
+      end
+
+      it "includes a group label row" do
+        (doc/"tr[class = 'group_header']")[0].text.should == "foobar"
+      end
+      it "doesn't include a label row when label is false" do
+        doc = Nokogiri::HTML(anon_group.to_html)
+        (doc/"tr[class='group_header']").count.should == 0
+      end
+    end
+
+    describe "#summarize" do
+      it "performs the supplied operation on the indicated column" do
+        group.summarize(:col1, &:+).should == 4
+        group.summarize(:col2, &:+).should == 6
+      end
+    end
+    context "with totals enabled" do
+      describe "#rows" do
+        it "includes a total row" do
+          columns     = [
+              Tabloid::ReportColumn.new(:col1, "Column 1", :total => true),
+              Tabloid::ReportColumn.new(:col2, "Column 2", :total => true)
+          ]
+          total_group = Tabloid::Group.new(:rows =>[row1, row2], :columns => columns, :total => true)
+          rows        = total_group.rows
+          rows.count.should == 3
+          rows.last[:col1].should == 4
+          rows.last[:col2].should == 6
+        end
+      end
+    end
+  end
+end

data/spec/lib/tabloid/header_row_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Tabloid::Row do
+  let(:header){Tabloid::HeaderRow.new("testtext", :column_count => 3)}
+  it "has the correct number of columns" do
+    header.to_a.should == ["testtext", nil, nil]
+  end
+end

data/spec/lib/tabloid/report_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+
+describe Tabloid::Report do
+
+  context "producing output" do
+    class CsvReport
+      DATA=[
+            [1, 2],
+            [3, 4]
+        ]
+      include Tabloid::Report
+
+      parameter :param1, "TestParameter"
+
+      element :col1, 'Col1'
+      element :col2, 'Col2'
+
+      cache_key{'report'}
+
+      rows do
+        CsvReport::DATA
+      end
+    end
+
+    before do
+      @report = CsvReport.new
+      @report.prepare(:param1 => "foobar")
+    end
+
+    context "with memcached caching" do
+      before do
+        Tabloid.cache_engine = :memcached
+        Tabloid.cache_connection_options = {
+            :server => "localhost",
+            :port => "11211"
+        }
+      end
+      after do
+        dc = Dalli::Client.new
+        dc.set("report", nil)
+        Tabloid.cache_engine = nil
+      end
+
+      describe "#data" do
+        it "should cache after collecting the data" do
+          Dalli::Client.any_instance.stub(:get).and_return(nil)
+          Dalli::Client.any_instance.should_receive(:set).with('report', anything).and_return(true)
+          @report.data
+        end
+
+        it "should return the cached data if it exists" do
+          Dalli::Client.any_instance.stub(:get).with('report').and_return(YAML.dump(@report.data))
+          Dalli::Client.any_instance.stub(:set).and_return(true)
+
+          @report.data.rows.should_not be_nil
+        end
+      end
+    end
+
+    describe "#to_csv" do
+      it "includes headers by default" do
+        csv_output = FasterCSV.parse(@report.to_csv)
+        headers    = csv_output.first
+        headers.first.should match(/Col1/)
+        headers.last.should match(/Col2/)
+      end
+
+      it "includes the data from the report" do
+        csv_output = FasterCSV.parse(@report.to_csv)
+        csv_output.should include( ['1', '2'])
+        csv_output.should include( ['3', '4'])
+      end
+    end
+
+    describe "#to_html" do
+      let(:doc){Nokogiri::HTML(@report.to_html)}
+      it "creates a table" do
+        (doc/"table").count.should == 1
+      end
+
+      it "includes parameter information" do
+        pending("Need to put parameter block in the report")
+        (doc/".parameter_label").text.should include("TestParameter")
+        (doc/".parameter_value").text.should include("foobar")
+      end
+    end
+  end
+
+
+  describe "#element" do
+    class ElementTestReport
+      include Tabloid::Report
+      element :col1
+      rows do
+        [[1,2]]
+      end
+    end
+
+    before do
+      @report = ElementTestReport.new
+    end
+
+    it "adds a column to the report data" do
+      @report.data.report_columns[:col1].should_not be_nil
+      @report.data.report_columns[0].key.to_s.should == "col1"
+    end
+
+  end
+
+  describe "grouping" do
+    class GroupingTest
+      include Tabloid::Report
+      element :col1, "Col 1"
+      element :col2, "Col 2"
+      grouping :col1
+
+      rows do
+        [
+            [1,2,3],
+            [1,4,5]
+        ]
+      end
+    end
+
+    it "groups data by column specified" do
+      report = GroupingTest.new
+      data = FasterCSV.parse(report.to_csv)
+      data.should include(['1',nil])
+    end
+  end
+
+  describe "#parameter" do
+    class ParameterTestReport
+      attr_accessor :parameter_stash
+
+      include Tabloid::Report
+      parameter :test_param
+      cache_key {"key"}
+
+      element :col1, "Column 1"
+      rows do
+        [[parameter(:test_param)]]
+      end
+    end
+
+    it "requires a parameter in the initializer" do
+      expect{ ParameterTestReport.new.prepare}.should raise_error(Tabloid::MissingParameterError, "Must supply :test_param when creating the report")
+    end
+
+    it "makes the parameter available in the report" do
+      report = ParameterTestReport.new.prepare(:test_param => "supercalifragilisticexpialidocious")
+      report.to_html.should match(/supercalifragilisticexpialidocious/)
+    end
+  end
+
+end
+

data/spec/lib/tabloid/row_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Tabloid::Row do
+  let(:columns) { [
+      Tabloid::ReportColumn.new(:col1, "Column 1", :hidden => true),
+      Tabloid::ReportColumn.new(:col2, "Column 2")
+  ] }
+  let(:data) { [1, 2] }
+  before do
+    @row = Tabloid::Row.new(
+        :columns => columns,
+        :data    => [1, 2]
+    )
+  end
+  context "producing output" do
+    describe "#to_csv" do
+      it "includes visible columns" do
+        rows = FasterCSV.parse(@row.to_csv)
+        rows.first.should include("2")
+      end
+      it "does not include hidden columns" do
+        rows = FasterCSV.parse(@row.to_csv)
+        rows.first.should_not include("1")
+      end
+    end
+
+    describe "#to_html" do
+      before do
+        @doc = Nokogiri::HTML(@row.to_html)
+      end
+      it "should have a single row" do
+        (@doc / "tr").count.should == 1
+      end
+      it "should have classes on the columns" do
+        (@doc / "td[class='col2']").count.should == 1
+      end
+      it "should not include hidden columns" do
+        (@doc / "td[class='col1']").count.should == 0
+
+      end
+    end
+
+
+  end
+  context "with array data" do
+    describe "accessing contents with []" do
+      it "allows numeric access" do
+        @row[0].should == 1
+      end
+      it "allows access by element key" do
+        @row[:col1].should == 1
+      end
+    end
+  end
+  context "with object data" do
+    let(:data){OpenStruct.new({:col1 => 1, :col2 => 2})}
+    let(:row) { Tabloid::Row.new(:columns => columns, :data => data) }
+    describe "accessing contents with []" do
+      it "allows numeric access" do
+        row[0].should == 1
+      end
+      it "allows access by element key" do
+        row[:col1].should == 1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'tabloid'
+require 'dalli'
+
+require 'ostruct'
+require 'nokogiri'
+require 'fastercsv'

data/tabloid.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tabloid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tabloid"
+  s.version     = Tabloid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Keith Gaddis"]
+  s.email       = ["keith.gaddis@gmail.com"]
+  s.homepage    = "http://github.com/Inductive/tabloid"
+  s.summary     = %q{ Tabloid allows the creation of cacheable report data using a straightforward DSL and output to HTML, CSV, and more to come.}
+  s.description = %q{ Tabloid allows the creation of cacheable report data using a straightforward DSL and output to HTML, CSV, and more to come.}
+
+  s.rubyforge_project = "tabloid"
+
+  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"]
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "nokogiri"
+  s.add_development_dependency "dalli"
+  s.add_runtime_dependency "fastercsv"
+  s.add_runtime_dependency "builder"
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification 
+name: tabloid
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Keith Gaddis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dalli
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fastercsv
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+description: " Tabloid allows the creation of cacheable report data using a straightforward DSL and output to HTML, CSV, and more to come."
+email: 
+- keith.gaddis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.txt
+- Rakefile
+- lib/tabloid.rb
+- lib/tabloid/column_extensions.rb
+- lib/tabloid/configuration.rb
+- lib/tabloid/data.rb
+- lib/tabloid/group.rb
+- lib/tabloid/header_row.rb
+- lib/tabloid/missing_element_error.rb
+- lib/tabloid/missing_parameter_error.rb
+- lib/tabloid/parameter.rb
+- lib/tabloid/report.rb
+- lib/tabloid/report_column.rb
+- lib/tabloid/row.rb
+- lib/tabloid/version.rb
+- spec/lib/tabloid/data_spec.rb
+- spec/lib/tabloid/group_spec.rb
+- spec/lib/tabloid/header_row_spec.rb
+- spec/lib/tabloid/report_spec.rb
+- spec/lib/tabloid/row_spec.rb
+- spec/spec_helper.rb
+- tabloid.gemspec
+homepage: http://github.com/Inductive/tabloid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: tabloid
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Tabloid allows the creation of cacheable report data using a straightforward DSL and output to HTML, CSV, and more to come.
+test_files: 
+- spec/lib/tabloid/data_spec.rb
+- spec/lib/tabloid/group_spec.rb
+- spec/lib/tabloid/header_row_spec.rb
+- spec/lib/tabloid/report_spec.rb
+- spec/lib/tabloid/row_spec.rb
+- spec/spec_helper.rb