tinytable 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rspec
+.rvmrc
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Leo Cassarani
+
+MIT License
+
+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.md

@@ -0,0 +1,129 @@
+# TinyTable
+
+TinyTable is a Ruby gem that lets you create and output simple ASCII tables with minimal effort. It draws heavy inspiration from [Ruport](https://github.com/ruport/ruport) but, unlike Ruport, it has a very simple and focused API, and no external dependencies.
+
+TinyTable is particularly well-suited to formatting the results of a Rake task or test suite. The output of `rake stats` is a perfect example of the kind of thing you might choose to use TinyTable for.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tinytable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tinytable
+
+## Usage
+
+Create a `TinyTable::Table` and start adding rows to it:
+
+    table = TinyTable::Table.new
+    table << ["Controllers", 169, 140]
+    table << ["Helpers", 48, 43]
+    table << ["Models", 149, 120]
+    puts table.to_text
+
+This will output:
+
+    +-------------+-----+-----+
+    | Controllers | 169 | 140 |
+    | Helpers     | 48  |  43 |
+	| Models      | 149 | 120 |
+	+-------------+-----+-----+
+
+By default, columns are left-aligned. However, you can specify the text alignment of each column by using its index (starting from 0):
+
+	table.align(0, TinyTable::CENTER)
+	table.align(1, TinyTable::RIGHT)
+	table.align(2, TinyTable::LEFT)
+
+Output:
+
+	+-------------+-----+-----+
+	| Controllers | 169 | 140 |
+	|   Helpers   |  48 | 43  |
+	|   Models    | 149 | 120 |
+	+-------------+-----+-----+
+
+### Headers and Footers
+
+Tables can have headers and footers:
+
+	table = TinyTable::Table.new
+
+	table.header = %w[Name Lines LOC]
+	table << ["Controllers", 169, 140]
+	table << ["Helpers", 48, 43]
+	table.footer = ["Total", 217, 183]
+
+	table.align(1, TinyTable::RIGHT)
+	table.align(2, TinyTable::RIGHT)
+
+	puts table.to_text
+
+Output:
+
+	+-------------+-------+-----+
+	| Name        | Lines | LOC |
+	+-------------+-------+-----+
+	| Controllers |   169 | 140 |
+	| Helpers     |    48 |  43 |
+	+-------------+-------+-----+
+	| Total       |   217 | 183 |
+	+-------------+-------+-----+
+
+Header titles can also be passed into the constructor for the table.
+
+When a table has a header, new rows can be added as hashes, and columns can be referred to by their header title when specifying text alignment:
+
+	table = TinyTable::Table.new("City", "County")
+	table.add "City" => "London", "County" => "Greater London"
+	table.add "County" => "Yorkshire", "City" => "Sheffield"
+	table.align("County", TinyTable::RIGHT)
+	puts table.to_text
+
+Output:
+
+	+-----------+----------------+
+	| City      |         County |
+	+-----------+----------------+
+	| London    | Greater London |
+	| Sheffield |      Yorkshire |
+	+-----------+----------------+
+
+### Partial Rows
+
+Rows can contain empty cells. When supplying an array, you can use `nil` to skip a column, or you can simply supply a smaller array if you want to skip the columns at the end. When using the hash syntax with header titles, just omit the value for the keys you wish to skip.
+
+	table = TinyTable::Table.new("City", "County")
+	table.add [nil, "Shropshire"]
+	table.add ["Sheffield"]
+	table.add "City" => "Bristol"
+	puts table.to_text
+
+Output:
+
+	+-----------+------------+
+	| City      | County     |
+	+-----------+------------+
+	|           | Shropshire |
+	| Sheffield |            |
+	| Bristol   |            |
+	+-----------+------------+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+Copyright (c) 2012 Leo Cassarani. See [LICENSE](https://github.com/leocassarani/tinytable/blob/master/LICENSE) for details.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/tinytable.rb

@@ -0,0 +1,10 @@
+require 'tinytable/version'
+require 'tinytable/constants'
+require 'tinytable/table'
+require 'tinytable/text_formatter'
+require 'tinytable/layout'
+require 'tinytable/row'
+require 'tinytable/cell'
+
+module TinyTable
+end

data/lib/tinytable/cell.rb

@@ -0,0 +1,24 @@
+module TinyTable
+  class Cell
+    attr_reader :alignment
+
+    def initialize(text, alignment)
+      @text = text || ''
+      @alignment = alignment
+    end
+
+    def ==(obj)
+      return false unless obj.is_a? Cell
+      text == obj.text &&
+        alignment == obj.alignment
+    end
+
+    def text
+      @text.to_s
+    end
+
+    def width
+      text.length
+    end
+  end
+end

data/lib/tinytable/constants.rb

@@ -0,0 +1,5 @@
+module TinyTable
+  LEFT = :left
+  CENTER = :center
+  RIGHT = :right
+end

data/lib/tinytable/layout.rb

@@ -0,0 +1,61 @@
+module TinyTable
+  class Layout
+    attr_reader :column_count, :max_column_widths
+
+    def initialize(table)
+      @table = table
+    end
+
+    def analyze
+      @column_count = 0
+      @max_column_widths = []
+
+      analyze_header
+      analyze_rows
+      analyze_footer
+
+      self
+    end
+
+    private
+
+    def analyze_header
+      if @table.has_header?
+        analyze_row(@table.header)
+      end
+    end
+
+    def analyze_rows
+      if @table.has_rows?
+        @table.each_row do |row|
+          analyze_row(row)
+        end
+      end
+    end
+
+    def analyze_footer
+      if @table.has_footer?
+        analyze_row(@table.footer)
+      end
+    end
+
+    def analyze_row(row)
+      if row.cell_count > @column_count
+        @column_count = row.cell_count
+      end
+
+      row.each_cell_with_index do |cell, i|
+        analyze_cell(cell, i)
+      end
+    end
+
+    def analyze_cell(cell, i)
+      @max_column_widths[i] ||= 0
+      max_width = @max_column_widths[i]
+
+      if cell.width > max_width
+        @max_column_widths[i] = cell.width
+      end
+    end
+  end
+end

data/lib/tinytable/row.rb

@@ -0,0 +1,37 @@
+require 'forwardable'
+require 'tinytable/constants'
+
+module TinyTable
+  class Row
+    extend Forwardable
+    def_delegators :@cells, :empty?, :map
+
+    attr_reader :cells
+
+    def initialize(cells, alignments = [])
+      @cells = cells || []
+      @alignments = alignments
+    end
+
+    def ==(obj)
+      return false unless obj.is_a? Row
+      @cells == obj.cells
+    end
+
+    def cell_count
+      @cells.count
+    end
+
+    def each_cell_with_index(&block)
+      @cells.length.times do |idx|
+        block.call(cell_at(idx), idx)
+      end
+    end
+
+    def cell_at(idx)
+      text = @cells.fetch(idx, '')
+      alignment = @alignments[idx] || LEFT
+      Cell.new(text, alignment)
+    end
+  end
+end

data/lib/tinytable/table.rb

@@ -0,0 +1,79 @@
+module TinyTable
+  class Table
+    attr_writer :header, :footer
+    attr_reader :rows
+
+    def initialize(*args)
+      header = args.first.is_a?(Array) ? args.first : args
+      @header = header
+      @rows = []
+      @alignments = []
+    end
+
+    def add(*args)
+      row = extract_row_args(args)
+      rows << row
+    end
+    alias_method :<<, :add
+
+    def align(column, alignment)
+      idx = case column
+      when String
+        @header.index(column)
+      when Fixnum
+        column
+      else
+        raise ArgumentError.new("Received a #{column.class} but expecting a Fixnum or String")
+      end
+      @alignments[idx] = alignment unless idx.nil?
+    end
+
+    def has_header?
+      !(header.nil? || header.empty?)
+    end
+
+    def has_rows?
+      !rows.empty?
+    end
+
+    def has_footer?
+      !(footer.nil? || footer.empty?)
+    end
+
+    def header
+      Row.new(@header, @alignments)
+    end
+
+    def each_row(&block)
+      rows.each do |cells|
+        row = Row.new(cells, @alignments)
+        block.call(row)
+      end
+    end
+
+    def footer
+      Row.new(@footer, @alignments)
+    end
+
+    def to_text
+      TinyTable::TextFormatter.new(self).render
+    end
+
+    private
+
+    def extract_row_args(args)
+      case args.first
+      when Array
+        args.first
+      when Hash
+        if has_header?
+          header.map { |key| args.first[key] }
+        else
+          raise ArgumentError.new("Received a Hash but no header row was given")
+        end
+      else
+        args
+      end
+    end
+  end
+end

data/lib/tinytable/text_formatter.rb

@@ -0,0 +1,109 @@
+require File.expand_path('../constants', __FILE__)
+
+module TinyTable
+  class TextFormatter
+    CORNER = '+'
+    VERTICAL = '|'
+    HORIZONTAL = '-'
+    PADDING = ' '
+
+    STRING_ALIGN = {
+      LEFT => :ljust,
+      CENTER => :center,
+      RIGHT => :rjust
+    }
+
+    def initialize(table)
+      @table = table
+      @output = ''
+    end
+
+    def render
+      clear_output
+      precompute_table_layout
+
+      render_header
+      render_rows
+      render_footer
+
+      @output
+    end
+
+    private
+
+    def render_header
+      if @table.has_header?
+        hr
+        render_row(@table.header)
+      end
+    end
+
+    def render_rows
+      if @table.has_rows?
+        hr
+        @table.each_row { |row| render_row(row) }
+        hr
+      end
+    end
+
+    def render_footer
+      if @table.has_footer?
+        render_row(@table.footer)
+        hr
+      end
+    end
+
+    def hr
+      append CORNER
+      @column_widths.each do |w|
+        append HORIZONTAL * (w + 2)
+        append CORNER
+      end
+      new_line
+    end
+
+    def render_row(row)
+      append VERTICAL
+
+      @column_count.times do |i|
+        cell = row.cell_at(i)
+        render_cell(cell, i)
+      end
+
+      new_line
+    end
+
+    def render_cell(cell, i)
+      append PADDING
+
+      method = STRING_ALIGN[cell.alignment]
+      text = cell.text.__send__(method, @column_widths[i], PADDING)
+      append text
+
+      append PADDING
+      append VERTICAL
+    end
+
+    def append(text)
+      @output << text.to_s
+    end
+
+    def new_line
+      append "\n"
+    end
+
+    def clear_output
+      if RUBY_VERSION < "1.9"
+        @output = ''
+      else
+        @output.clear
+      end
+    end
+
+    def precompute_table_layout
+      layout = Layout.new(@table).analyze
+      @column_count = layout.column_count
+      @column_widths = layout.max_column_widths
+    end
+  end
+end

data/lib/tinytable/version.rb

@@ -0,0 +1,3 @@
+module TinyTable
+  VERSION = "0.1.0"
+end

data/spec/integration/integration_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path('../../../lib/tinytable', __FILE__)
+
+describe "a tiny table" do
+  it "supports tables with no header or footer" do
+    table = TinyTable::Table.new
+    table << ["London", "Greater London"]
+    table << ["Birmingham", "West Midlands"]
+    table << ["Manchester", "Greater Manchester"]
+    table.to_text.should == <<-EOF
++------------+--------------------+
+| London     | Greater London     |
+| Birmingham | West Midlands      |
+| Manchester | Greater Manchester |
++------------+--------------------+
+    EOF
+  end
+
+  it "supports a header" do
+    table = TinyTable::Table.new(%w[City County])
+    table << ["Liverpool", "Merseyside"]
+    table << ["Newcastle", "Tyne & Wear"]
+    table << ["Nottingham", "Nottinghamshire"]
+    table.to_text.should == <<-EOF
++------------+-----------------+
+| City       | County          |
++------------+-----------------+
+| Liverpool  | Merseyside      |
+| Newcastle  | Tyne & Wear     |
+| Nottingham | Nottinghamshire |
++------------+-----------------+
+    EOF
+  end
+
+  it "supports a footer" do
+    table = TinyTable::Table.new
+    table << ["Londoners", 8_294_058]
+    table << ["Brummies", 2_293_099]
+    table << ["Mancunians", 1_741_961]
+    table.footer = ["Total", 12_329_118]
+    table.to_text.should == <<-EOF
++------------+----------+
+| Londoners  | 8294058  |
+| Brummies   | 2293099  |
+| Mancunians | 1741961  |
++------------+----------+
+| Total      | 12329118 |
++------------+----------+
+    EOF
+  end
+
+  it "supports both a header and a footer" do
+    table = TinyTable::Table.new
+    table.header = %w[City County Population]
+    table << ["London", "Greater London", 8_294_058]
+    table << ["Birmingham", "West Midlands", 2_293_099]
+    table << ["Manchester", "Greater Manchester", 1_741_961]
+    table.footer = ["Total", nil, 12_329_118]
+    table.to_text.should == <<-EOF
++------------+--------------------+------------+
+| City       | County             | Population |
++------------+--------------------+------------+
+| London     | Greater London     | 8294058    |
+| Birmingham | West Midlands      | 2293099    |
+| Manchester | Greater Manchester | 1741961    |
++------------+--------------------+------------+
+| Total      |                    | 12329118   |
++------------+--------------------+------------+
+    EOF
+  end
+
+  it "returns an empty string if the table is completely empty" do
+    TinyTable::Table.new.to_text.should == ''
+  end
+
+  it "correctly handles rows with fewer cells than the rest" do
+    table = TinyTable::Table.new("City", "County", "Mayor")
+    table.add "London", "Greater London", "Boris Johnson"
+    table.add "Sheffield", "Yorkshire"
+    table.add "Bristol"
+    table.to_text.should == <<-EOF
++-----------+----------------+---------------+
+| City      | County         | Mayor         |
++-----------+----------------+---------------+
+| London    | Greater London | Boris Johnson |
+| Sheffield | Yorkshire      |               |
+| Bristol   |                |               |
++-----------+----------------+---------------+
+    EOF
+  end
+
+  it "supports an alternative syntax based on argument lists" do
+    table = TinyTable::Table.new("City", "County", "Population")
+    table.add "London", "Greater London", 8_294_058
+    table.add "Birmingham", "West Midlands", 2_293_099
+    table.add "Manchester", "Greater Manchester", 1_741_961
+    table.footer = "Total", nil, 12_329_118
+    table.to_text.should == <<-EOF
++------------+--------------------+------------+
+| City       | County             | Population |
++------------+--------------------+------------+
+| London     | Greater London     | 8294058    |
+| Birmingham | West Midlands      | 2293099    |
+| Manchester | Greater Manchester | 1741961    |
++------------+--------------------+------------+
+| Total      |                    | 12329118   |
++------------+--------------------+------------+
+    EOF
+  end
+
+  it "supports an alternative syntax based on hashes" do
+    table = TinyTable::Table.new("City", "County", "Mayor")
+    table.add "City" => "London", "Mayor" => "Boris Johnson", "County" => "Greater London"
+    table.add "City" => "Sheffield", "County" => "Yorkshire"
+    table.add "Mayor" => "Peter Soulsby", "City" => "Leicester"
+    table.to_text.should == <<-EOF
++-----------+----------------+---------------+
+| City      | County         | Mayor         |
++-----------+----------------+---------------+
+| London    | Greater London | Boris Johnson |
+| Sheffield | Yorkshire      |               |
+| Leicester |                | Peter Soulsby |
++-----------+----------------+---------------+
+    EOF
+  end
+
+  it "allows the user to specify the alignment of column text" do
+    table = TinyTable::Table.new("City", "County", "Population")
+    table.align("City", TinyTable::CENTER)
+    table.align("Population", TinyTable::RIGHT)
+    table.add "London", "Greater London", 8_294_058
+    table.add "Sheffield", "Yorkshire", 2_293_099
+    table.to_text.should == <<-EOF
++-----------+----------------+------------+
+|   City    | County         | Population |
++-----------+----------------+------------+
+|  London   | Greater London |    8294058 |
+| Sheffield | Yorkshire      |    2293099 |
++-----------+----------------+------------+
+    EOF
+  end
+end

data/spec/tinytable/cell_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../../lib/tinytable/cell', __FILE__)
+require File.expand_path('../../../lib/tinytable/constants', __FILE__)
+
+describe TinyTable::Cell do
+  it "converts numbers to strings" do
+    TinyTable::Cell.new(123, TinyTable::LEFT).text.should == "123"
+  end
+
+  it "returns an empty string if its text was initialized as nil" do
+    TinyTable::Cell.new(nil, TinyTable::LEFT).text.should == ''
+  end
+
+  it "is equal to another cell with same (string) text and alignment" do
+    a1 = TinyTable::Cell.new(:a, TinyTable::LEFT)
+    a2 = TinyTable::Cell.new('a', TinyTable::LEFT)
+    a1.should == a2
+  end
+
+  it "is different from another cell with different text or alignment" do
+    a = TinyTable::Cell.new('a', TinyTable::LEFT)
+    b = TinyTable::Cell.new('b', TinyTable::LEFT)
+    a.should_not == b
+  end
+end

data/spec/tinytable/layout_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../../lib/tinytable/layout', __FILE__)
+require File.expand_path('../../../lib/tinytable/row', __FILE__)
+require File.expand_path('../../../lib/tinytable/cell', __FILE__)
+
+describe TinyTable::Layout do
+  let(:table) { mock(:table, :has_header? => false, :has_rows? => true, :has_footer? => false) }
+  let(:layout) { TinyTable::Layout.new(table).analyze }
+
+  it "knows how many columns a table has" do
+    row1 = TinyTable::Row.new(["One"])
+    row2 = TinyTable::Row.new(["One", "Two"])
+    row3 = TinyTable::Row.new(["One", "Two", "Three"])
+    table.stub(:each_row).and_yield(row1).and_yield(row2).and_yield(row3)
+    layout.column_count.should == 3
+  end
+
+  it "knows the maximum width for each column in the table" do
+    row1 = TinyTable::Row.new(["123", "1", "12"])
+    row2 = TinyTable::Row.new(["12345", "123", "1"])
+    row3 = TinyTable::Row.new(["1234567", "12", "1"])
+    table.stub(:each_row).and_yield(row1).and_yield(row2).and_yield(row3)
+    layout.max_column_widths.should == [7, 3, 2]
+  end
+
+  it "includes the header row when calculating maximum column widths" do
+    table.stub(:has_header?) { true }
+    table.stub(:header) { TinyTable::Row.new(["12345", "1"]) }
+    table.stub(:each_row).and_yield(TinyTable::Row.new(["123", "12"]))
+    layout.max_column_widths.should == [5, 2]
+  end
+
+  it "includes the footer row when calculating maximum column widths" do
+    table.stub(:has_footer?) { true }
+    table.stub(:footer) { TinyTable::Row.new(["123", "12345"]) }
+    table.stub(:each_row).and_yield(TinyTable::Row.new(["1234", "12"]))
+    layout.max_column_widths.should == [4, 5]
+  end
+
+  it "correctly calculates the width of cells containing an integer" do
+    row1 = TinyTable::Row.new(["London", 8_294_058])
+    row2 = TinyTable::Row.new(["Liverpool", 830_112])
+    table.stub(:each_row).and_yield(row1).and_yield(row2)
+    layout.max_column_widths.should == [9, 7]
+  end
+
+  it "correctly deals with completely empty tables" do
+    table.stub(:has_rows?) { false }
+    layout.max_column_widths.should == []
+    layout.column_count.should be_zero
+  end
+end

data/spec/tinytable/row_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../../lib/tinytable/row', __FILE__)
+require File.expand_path('../../../lib/tinytable/cell', __FILE__)
+
+describe TinyTable::Row do
+  it "returns cells with the correct alignment" do
+    row = TinyTable::Row.new(['a', 'b'], [TinyTable::RIGHT, TinyTable::LEFT])
+    row.cell_at(0).should == TinyTable::Cell.new('a', TinyTable::RIGHT)
+    row.cell_at(1).should == TinyTable::Cell.new('b', TinyTable::LEFT)
+  end
+
+  it "defaults to left alignment unless otherwise specified" do
+    row = TinyTable::Row.new(['a'])
+    row.cell_at(0).should == TinyTable::Cell.new('a', TinyTable::LEFT)
+  end
+
+  it "knows if it's empty" do
+    TinyTable::Row.new([]).should be_empty
+    TinyTable::Row.new(['a']).should_not be_empty
+  end
+
+  it "is equal to another row with the same cells" do
+    TinyTable::Row.new(['a']).should == TinyTable::Row.new(['a'])
+  end
+end

data/spec/tinytable/table_spec.rb

@@ -0,0 +1,129 @@
+require File.expand_path('../../../lib/tinytable/table', __FILE__)
+require File.expand_path('../../../lib/tinytable/row', __FILE__)
+require File.expand_path('../../../lib/tinytable/cell', __FILE__)
+
+module TinyTable
+  class TextFormatter ; end
+end
+
+describe TinyTable::Table do
+  let(:table) { TinyTable::Table.new }
+  let(:row) { %w[Liverpool Merseyside] }
+
+  it "stores and recalls rows" do
+    table << row
+    table.rows.should == [row]
+  end
+
+  it "exposes an iterator over the rows" do
+    row_obj = mock(:row_obj)
+    TinyTable::Row.stub(:new).with(row, anything) { row_obj }
+    table << row
+    table.each_row do |r|
+      r.should == row_obj
+    end
+  end
+
+  it "knows whether it contains any rows" do
+    table.should_not have_rows
+    table << row
+    table.should have_rows
+  end
+
+  it "uses a TextFormatter to render an ASCII representation of the table" do
+    formatter = mock(:formatter, :render => "ASCII table")
+    TinyTable::TextFormatter.stub(:new).with(table) { formatter }
+    table.to_text.should == "ASCII table"
+  end
+
+  it "stores and recalls a header row" do
+    table.header = ["City", "County"]
+    table.header.should == TinyTable::Row.new(["City", "County"])
+  end
+
+  it "doesn't return the header along with regular rows" do
+    table.header = ["City", "County"]
+    table << row
+    table.rows.should == [row]
+  end
+
+  it "stores and recalls a footer row" do
+    table.footer = ["Total", "123.45"]
+    table.footer.should == TinyTable::Row.new(["Total", "123.45"])
+  end
+
+  it "doesn't return the footer along with regular rows" do
+    table << row
+    table.footer = ["Total", "123.45"]
+    table.rows.should == [row]
+  end
+
+  it "supports a number of different ways to add new rows" do
+    table.add "London", "Greater London"
+    table.add ["Birmingham", "West Midlands"]
+    table << ["Manchester", "Greater Manchester"]
+    table.rows.should == [
+      ["London", "Greater London"],
+      ["Birmingham", "West Midlands"],
+      ["Manchester", "Greater Manchester"]
+    ]
+  end
+
+  it "supports a number of different ways to set the header" do
+    table.header = ["City", "County"]
+    table.header.should == TinyTable::Row.new(["City", "County"])
+
+    table.header = "City", "County"
+    table.header.should == TinyTable::Row.new(["City", "County"])
+
+    table = TinyTable::Table.new("City", "County")
+    table.header.should == TinyTable::Row.new(["City", "County"])
+
+    table = TinyTable::Table.new ["City", "County"]
+    table.header.should == TinyTable::Row.new(["City", "County"])
+  end
+
+  it "supports a number of different ways to set the footer" do
+    table.footer = ["Total", "300"]
+    table.footer.should == TinyTable::Row.new(["Total", "300"])
+
+    table.footer = "Total", "300"
+    table.footer.should == TinyTable::Row.new(["Total", "300"])
+  end
+
+  it "allows a row to be entered as a hash with header titles as its keys" do
+    table.header = "City", "County", "Population"
+    table.add 'City' => "Reading", 'Population' => 373_836, 'County' => "Berkshire"
+    table << { 'County' => "Hampshire", 'City' => "Winchester" }
+    table.rows.should == [
+      ["Reading", "Berkshire", 373_836],
+      ["Winchester", "Hampshire", nil]
+    ]
+  end
+
+  it "raises an ArgumentError if a hash is given without a header row" do
+    lambda {
+      table.add 'City' => "Reading", 'County' => "Berkshire"
+    }.should raise_error(ArgumentError)
+  end
+
+  it "allows the user to specify the alignment for a column" do
+    table.header = "City"
+    table.align("City", TinyTable::RIGHT)
+    table << ["London"]
+    table.each_row do |row|
+      row.cell_at(0).alignment.should == TinyTable::RIGHT
+    end
+  end
+
+  it "can use integers to specify the column to align" do
+    table.header = "City", "County"
+    table.align(0, TinyTable::CENTER)
+    table.align(1, TinyTable::RIGHT)
+    table << ["London", "Greater London"]
+    table.each_row do |row|
+      row.cell_at(0).alignment.should == TinyTable::CENTER
+      row.cell_at(1).alignment.should == TinyTable::RIGHT
+    end
+  end
+end

data/spec/tinytable/text_formatter_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path('../../../lib/tinytable/text_formatter', __FILE__)
+require File.expand_path('../../../lib/tinytable/row', __FILE__)
+require File.expand_path('../../../lib/tinytable/cell', __FILE__)
+
+module TinyTable
+  class Layout ; end
+end
+
+describe TinyTable::TextFormatter do
+  def make_row(row)
+    TinyTable::Row.new(row)
+  end
+
+  let(:table) { mock(:table, :has_header? => false,
+                             :has_rows? => true,
+                             :has_footer? => false) }
+  let(:layout) { mock(:layout, :column_count => 2) }
+  let(:formatter) { TinyTable::TextFormatter.new(table) }
+  before do
+    layout.stub(:analyze) { layout }
+    TinyTable::Layout.stub(:new).with(table) { layout }
+  end
+
+  it "formats a TinyTable as an ASCII table" do
+    table.stub(:each_row).and_yield(make_row %w[Liverpool Merseyside])
+    layout.stub(:max_column_widths) { ["Liverpool".length, "Merseyside".length] }
+    formatter.render.should == <<-EOF
++-----------+------------+
+| Liverpool | Merseyside |
++-----------+------------+
+    EOF
+  end
+
+  it "adjusts the width of the table to fit the largest row" do
+    row1 = make_row %w[Liverpool Merseyside]
+    row2 = make_row %w[Nottingham Nottinghamshire]
+    table.stub(:each_row).and_yield(row1).and_yield(row2)
+    layout.stub(:max_column_widths) { ["Nottingham".length, "Nottinghamshire".length] }
+    formatter.render.should == <<-EOF
++------------+-----------------+
+| Liverpool  | Merseyside      |
+| Nottingham | Nottinghamshire |
++------------+-----------------+
+    EOF
+  end
+
+  it "renders the header row if the table has one" do
+    table.stub(:has_header?) { true }
+    table.stub(:header) { make_row %w[City County] }
+    table.stub(:each_row).and_yield(make_row %w[Southampton Hampshire])
+    layout.stub(:max_column_widths) { ["Southampton".length, "Hampshire".length] }
+
+    formatter.render.should == <<-EOF
++-------------+-----------+
+| City        | County    |
++-------------+-----------+
+| Southampton | Hampshire |
++-------------+-----------+
+    EOF
+  end
+
+  it "renders the footer row if the table has one" do
+    row1 = make_row %w[Londoners 8294058]
+    row2 = make_row %w[Brummies 2293099]
+
+    table.stub(:has_footer?) { true }
+    table.stub(:footer) { make_row %w[Total 10587157] }
+    table.stub(:each_row).and_yield(row1).and_yield(row2)
+
+    layout.stub(:max_column_widths) { ["Londoners".length, "10587157".length] }
+    formatter.render.should == <<-EOF
++-----------+----------+
+| Londoners | 8294058  |
+| Brummies  | 2293099  |
++-----------+----------+
+| Total     | 10587157 |
++-----------+----------+
+    EOF
+  end
+
+  it "renders empty cells if a row has fewer columns than the rest" do
+    row1 = make_row ["London", "Greater London", "Boris Johnson"]
+    row2 = make_row ["Sheffield", "Yorkshire"]
+    table.stub(:each_row).and_yield(row1).and_yield(row2)
+
+    layout.stub(:max_column_widths) { ["Sheffield".length, "Greater London".length, "Boris Johnson".length] }
+    layout.stub(:column_count) { 3 }
+
+    formatter.render.should == <<-EOF
++-----------+----------------+---------------+
+| London    | Greater London | Boris Johnson |
+| Sheffield | Yorkshire      |               |
++-----------+----------------+---------------+
+    EOF
+  end
+
+  it "returns an empty string if the table is completely empty" do
+    table.stub(:has_rows?) { false }
+    layout.stub(:max_column_widths) { [] }
+    layout.stub(:column_count) { 0 }
+    formatter.render.should == ''
+  end
+end

data/tinytable.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/tinytable/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Leo Cassarani"]
+  gem.email         = ["leo.cassarani@me.com"]
+  gem.description   = %q{Simple ASCII table generation in Ruby.}
+  gem.summary       = %q{TinyTable lets you create and output simple ASCII tables with minimal effort.}
+  gem.homepage      = "https://github.com/leocassarani/tinytable"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "tinytable"
+  gem.require_paths = ["lib"]
+  gem.version       = TinyTable::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: tinytable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Leo Cassarani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70326742572440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70326742572440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70326742571820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70326742571820
+description: Simple ASCII table generation in Ruby.
+email:
+- leo.cassarani@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/tinytable.rb
+- lib/tinytable/cell.rb
+- lib/tinytable/constants.rb
+- lib/tinytable/layout.rb
+- lib/tinytable/row.rb
+- lib/tinytable/table.rb
+- lib/tinytable/text_formatter.rb
+- lib/tinytable/version.rb
+- spec/integration/integration_spec.rb
+- spec/tinytable/cell_spec.rb
+- spec/tinytable/layout_spec.rb
+- spec/tinytable/row_spec.rb
+- spec/tinytable/table_spec.rb
+- spec/tinytable/text_formatter_spec.rb
+- tinytable.gemspec
+homepage: https://github.com/leocassarani/tinytable
+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: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: TinyTable lets you create and output simple ASCII tables with minimal effort.
+test_files:
+- spec/integration/integration_spec.rb
+- spec/tinytable/cell_spec.rb
+- spec/tinytable/layout_spec.rb
+- spec/tinytable/row_spec.rb
+- spec/tinytable/table_spec.rb
+- spec/tinytable/text_formatter_spec.rb