table_print 0.2.3 → 1.0.0.rc3

data/spec/formatter_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require "formatter"
+
+include TablePrint
+
+describe TablePrint::TimeFormatter do
+  describe "#format" do
+    it "only operates on Time objects" do
+      f = TablePrint::TimeFormatter.new
+      f.format(12).should == 12
+    end
+
+    it "uses the config'd time_format" do
+      f = TablePrint::TimeFormatter.new
+      time = Time.local(2012, 01, 11, 1, 23, 45)
+      f.format(time).should == "2012-01-11 01:23:45" # default time format is set in config.rb
+    end
+
+    it "overrides the config'd time format with one it was passed" do
+      f = TablePrint::TimeFormatter.new("%Y")
+      time = Time.local(2012, 01, 11, 1, 23, 45)
+      f.format(time).should == "2012" # default time format is set in config.rb
+    end
+  end
+end
+
+describe TablePrint::NoNewlineFormatter do
+  before(:each) do
+    @f = TablePrint::NoNewlineFormatter.new
+  end
+
+  describe "#format" do
+    it "replaces carriage returns with spaces" do
+      @f.format("foo\r\nbar").should == "foo bar"
+    end
+
+    it "replaces newlines with spaces" do
+      @f.format("foo\nbar").should == "foo bar"
+    end
+  end
+end
+
+describe TablePrint::FixedWidthFormatter do
+  before(:each) do
+    @f = TablePrint::FixedWidthFormatter.new(10)
+  end
+
+  describe "#format" do
+    it "pads a short field to the specified width" do
+      @f.format("asdf").should == "asdf      "
+    end
+
+    it "truncates long fields with periods" do
+      @f.format("1234567890123456").should == "1234567..."
+    end
+
+    it "uses an empty string in place of nils" do
+      @f.format(nil).should == "          "
+    end
+
+    it "turns objects into strings before trying to format them" do
+      @f.format(123).should == "123       "
+    end
+  end
+
+  describe "#width" do
+    it "returns the width" do
+      @f.width.should == 10
+    end
+
+    it "respects the config'd max_width" do
+      max = TablePrint::Config.max_width
+      TablePrint::Config.max_width = 5
+      @f.width.should == 5
+      TablePrint::Config.max_width = max
+    end
+  end
+end

data/spec/hash_extensions_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'hash_extensions'
+
+describe "#constructive_merge" do
+  it "merges hashes without clobbering" do
+    x = {'reviews' => {'user' => {}}}
+    y = {'reviews' => {'ratings' => {}}}
+    x.extend TablePrint::HashExtensions::ConstructiveMerge
+    x.constructive_merge(y).should == {'reviews' => {'user' => {}, 'ratings' => {}}}
+  end
+end
+
+describe "#constructive_merge!" do
+  it "merges hashes in place without clobbering" do
+    x = {'reviews' => {'user' => {}}}
+    y = {'reviews' => {'ratings' => {}}}
+    x.extend TablePrint::HashExtensions::ConstructiveMerge
+    x.constructive_merge!(y)
+    x.should == {'reviews' => {'user' => {}, 'ratings' => {}}}
+  end
+end

data/spec/printable_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'printable'
+
+describe TablePrint::Printable do
+  before(:each) do
+    Sandbox.cleanup!
+  end
+
+  describe "#default_display_methods" do
+    it "returns attribute getters" do
+      Sandbox.add_class("Hat")
+      Sandbox.add_attributes("Hat", "brand")
+
+      p = Sandbox::Hat.new
+      TablePrint::Printable.default_display_methods(p).should == %W(brand)
+    end
+
+    it "ignores dangerous methods" do
+      Sandbox.add_class("Hat")
+      Sandbox.add_method("Hat", "brand!") {}
+
+      p = Sandbox::Hat.new
+      TablePrint::Printable.default_display_methods(p).should == []
+    end
+
+    it "ignores methods defined in a superclass" do
+      Sandbox.add_class("Hat::Bowler")
+      Sandbox.add_attributes("Hat", "brand")
+      Sandbox.add_attributes("Hat::Bowler", "brim_width")
+
+      p = Sandbox::Hat::Bowler.new
+      TablePrint::Printable.default_display_methods(p).should == %W(brim_width)
+    end
+
+    it "ignores methods that require arguments" do
+      Sandbox.add_class("Hat")
+      Sandbox.add_attributes("Hat", "brand")
+      Sandbox.add_method("Hat", "tip?") { |person| person.rapscallion? }
+
+      p = Sandbox::Hat.new
+      TablePrint::Printable.default_display_methods(p).should == %W(brand)
+    end
+
+    it "ignores methods from an included module" do
+      pending "waiting for Cat to support module manipulation"
+    end
+
+    it "uses column information when available (eg, from ActiveRecord objects)"
+  end
+end
+

data/spec/returnable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'returnable'
+require 'config'
+
+describe TablePrint::Returnable do
+  it "returns its initialized value from its to_s method" do
+    r = TablePrint::Returnable.new("foobar")
+    r.to_s.should == "foobar"
+  end
+
+  it "passes #set through to TablePrint::Config" do
+    TablePrint::Config.should_receive(:set).with(Object, [:foo])
+    r = TablePrint::Returnable.new
+    r.set(Object, :foo)
+  end
+
+  it "passes #clear through to TablePrint::Config" do
+    TablePrint::Config.should_receive(:clear).with(Object)
+    r = TablePrint::Returnable.new
+    r.clear(Object)
+  end
+end
+

data/spec/row_group_spec.rb

@@ -0,0 +1,466 @@
+require 'spec_helper'
+require 'ostruct'
+require 'cat'
+require "row_group"
+
+include TablePrint
+
+describe RowRecursion do
+  let(:parent) { RowGroup.new }
+  let(:child) { Row.new }
+
+  describe "#set_column" do
+    it "assigns the column object to the column name" do
+      column = Column.new
+      parent.set_column(:foobar, column)
+      parent.column_for(:foobar).should == column
+    end
+  end
+
+  describe "#add_child" do
+    it "adds the child to my children" do
+      parent.add_child(child)
+      parent.child_count.should == 1
+    end
+
+    it "sets me as my child's parent" do
+      parent.add_child(child)
+      child.parent.should == parent
+    end
+  end
+
+  describe "#add_children" do
+    let (:child2) {Row.new}
+
+    it "adds all the children to myself" do
+      parent.add_children([child, child2])
+      parent.child_count.should == 2
+    end
+
+    it "sets me as their parent" do
+      parent.add_children([child, child2])
+      child.parent.should == parent
+      child2.parent.should == parent
+    end
+  end
+
+  describe "#columns" do
+    it "returns columns populated with names and data" do
+      child.set_cell_values(:title => 'foobar')
+      parent.add_child(child)
+
+      parent.columns.length.should == 1
+      parent.columns.first.name.should == 'title'
+      parent.columns.first.data.should == ['foobar']
+    end
+
+    it "gets the columns from the root node" do
+      parent.add_child(child)
+      child.set_cell_values(:title => 'foobar')
+
+      parent.columns.length.should == 1
+      child.columns.should == parent.columns
+    end
+  end
+
+  describe "#column_for" do
+    it "returns the column object for a given column name" do
+      parent.add_child(child)
+      child.set_cell_values(:title => 'foobar')
+      column = parent.columns.first
+      parent.column_for(:title).should == column
+    end
+  end
+
+  describe "#add_formatter" do
+    it "adds the formatter to the column object" do
+      parent.add_child(child)
+      child.set_cell_values(:title => 'foobar')
+      column = parent.columns.first
+      parent.add_formatter(:title, {})
+
+      column.formatters.should == [{}]
+    end
+  end
+
+  describe "#width" do
+    it "returns the total width of the columns" do
+      parent.add_child(r1 = Row.new)
+      parent.add_child(r2 = Row.new)
+
+      r1.set_cell_values(:title => 'foobar')
+      r2.set_cell_values(:subtitle => 'elemental')
+
+      parent.width.should == 18
+    end
+  end
+
+  describe "#horizontal_separator" do
+    it "returns hyphens equal to the table width" do
+      child.set_cell_values(:title => 'foobar')
+      child.horizontal_separator.should == '------'
+    end
+
+    it "matches the header width" do
+      child.set_cell_values(:title => 'foobarfoobarfoobarfoobarfoobarfoobarfoobarfoobarfoobarfoobar')
+      child.horizontal_separator.should == '------------------------------' # 30 hyphens
+    end
+  end
+
+  describe "#header" do
+    it "returns the column names, padded to the proper width, separated by the | character" do
+      child.set_cell_values(:title => 'first post', :author => 'chris', :subtitle => 'first is the worst')
+      compare_rows(child.header, "AUTHOR | SUBTITLE           | TITLE     ")
+    end
+  end
+end
+
+describe TablePrint::RowGroup do
+  describe "#raw_column_data" do
+    it "returns the column data from its child rows" do
+      group = RowGroup.new
+      group.add_child(Row.new.set_cell_values(:title => 'foo'))
+      group.add_child(Row.new.set_cell_values(:title => 'bar'))
+      group.raw_column_data(:title).should == ['foo', 'bar']
+    end
+  end
+end
+
+def compare_rows(actual_rows, expected_rows)
+  actual_rows.split("\n").length.should == expected_rows.split("\n").length
+  actual_rows.split("\n").zip(expected_rows.split("\n")).each do |actual, expected|
+    actual.split(//).sort.join.should == expected.split(//).sort.join
+  end
+end
+
+describe TablePrint::Row do
+  let(:row) { Row.new.set_cell_values({'title' => "wonky", 'author' => "bob jones", 'pub_date' => "2012"}) }
+
+  describe "#format" do
+    it "formats the row with padding" do
+      compare_rows(row.format, "wonky | bob jones | 2012    ")
+    end
+
+    it "also formats the children" do
+      row.add_child(RowGroup.new.add_child(Row.new.set_cell_values(:title => "wonky2", :author => "bob jones2", :pub_date => "20122")))
+      compare_rows(row.format, "wonky  | bob jones  | 2012    \nwonky2 | bob jones2 | 20122   ")
+    end
+  end
+
+  describe "#apply_formatters" do
+    it "calls the format method on each formatter for that column" do
+      Sandbox.add_class("DoubleFormatter")
+      Sandbox.add_method("DoubleFormatter", :format) { |value| value * 2 }
+
+      Sandbox.add_class("ChopFormatter")
+      Sandbox.add_method("ChopFormatter", :format) { |value| value[0..-2] }
+
+      f1 = Sandbox::DoubleFormatter.new
+      f2 = Sandbox::ChopFormatter.new
+
+      row.stub(:column_for) {OpenStruct.new(:width => 11, :formatters => [f1, f2])}
+
+      row.apply_formatters(:title, "foobar").should == "foobarfooba"
+    end
+
+    it "uses the config'd time_format to format times" do
+      row.stub(:column_for) {OpenStruct.new(:width => 20, :formatters => [], :time_format => "%Y %m %d")}
+
+      time_formatter = TablePrint::TimeFormatter.new
+      TablePrint::TimeFormatter.should_receive(:new).with("%Y %m %d") {time_formatter}
+      row.apply_formatters(:title, Time.local(2012, 6, 1, 14, 20, 20))
+    end
+  end
+
+  describe "#raw_column_data" do
+    it "returns all the values for a given column" do
+      row = Row.new.set_cell_values(:title => 'one', :author => 'two')
+
+      group = RowGroup.new
+      ['two', 'three', 'four', 'five', 'six', 'seven'].each do |title|
+        group.add_child(Row.new.set_cell_values(:title => title))
+      end
+      row.add_child(group)
+
+      row.raw_column_data('title').should == ['one', 'two', 'three', 'four', 'five', 'six', 'seven']
+    end
+  end
+
+  describe "#collapse" do
+
+    # row: foo
+    #   group
+    #     row: bar
+    # => foo | bar
+    context "for a single row in a single child group" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_child(
+            RowGroup.new.add_child(
+                Row.new.set_cell_values(:bar => "bar")
+            )
+        )
+        @row.collapse!
+      end
+
+      it "pulls the cells up into the parent" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar"}
+      end
+
+      it "dereferences the now-defunct group" do
+        @row.children.length.should == 0
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #     row: baz
+    # => foo | bar
+    #        | baz
+    context "for two rows in a single child group" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_child(
+            RowGroup.new.add_children([
+                                          Row.new.set_cell_values(:bar => "bar"),
+                                          Row.new.set_cell_values(:bar => "baz")
+                                      ])
+        )
+        @row.collapse!
+      end
+
+      it "pulls the cells from the first row up into the parent" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar"}
+      end
+
+      it "deletes the absorbed row but leaves the second row in the group" do
+        @row.children.length.should == 1
+        @row.children.first.children.length.should == 1
+        @row.children.first.children.first.cells.should == {"bar" => "baz"}
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #   group
+    #     row: baz
+    # => foo | bar | baz
+    context "for two groups with a single row each" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_children([
+                                                             RowGroup.new.add_child(
+                                                                 Row.new.set_cell_values(:bar => "bar")
+                                                             ),
+                                                             RowGroup.new.add_child(
+                                                                 Row.new.set_cell_values(:baz => "baz")
+                                                             )
+                                                         ])
+        @row.collapse!
+      end
+
+      it "pulls the cells from both groups into the parent" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar", "baz" => "baz"}
+      end
+
+      it "dereferences both now-defunct groups" do
+        @row.children.length.should == 0
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #   group
+    #     row: baz
+    #     row: bazaar
+    # => foo | bar | baz
+    #              | bazaar
+    context "for two groups, one with a single row and one with two rows" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_children([
+                                                             RowGroup.new.add_child(
+                                                                 Row.new.set_cell_values(:bar => "bar")
+                                                             ),
+                                                             RowGroup.new.add_children([
+                                                                                           Row.new.set_cell_values(:baz => "baz"),
+                                                                                           Row.new.set_cell_values(:baz => "bazaar"),
+                                                                                       ]),
+                                                         ])
+        @row.collapse!
+      end
+
+      it "pulls the single row and the first row from the double into itself" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar", "baz" => "baz"}
+      end
+
+      it "keeps the second row from the second group in its own group" do
+        @row.children.length.should == 1
+        @row.children.first.children.length.should == 1
+        @row.children.first.children.first.cells.should == {"baz" => "bazaar"}
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #       group
+    #         row: baz
+    # => foo | bar | baz
+    context "for two nested groups, each with one row" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_child(
+            RowGroup.new.add_child(
+                Row.new.set_cell_values(:bar => "bar").add_child(
+                    RowGroup.new.add_child(
+                        Row.new.set_cell_values(:baz => "baz")
+                    )
+                )
+            )
+        )
+        @row.collapse!
+      end
+
+      it "pulls the cells from both groups into the parent" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar", "baz" => "baz"}
+      end
+
+      it "dereferences both now-defunct groups" do
+        @row.children.length.should == 0
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #       group
+    #         row: baz
+    #         row: bazaar
+    # => foo | bar | baz
+    #              | bazaar
+    context "for a child with one row, which itself has multiple rows" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_child(
+            RowGroup.new.add_child(
+                Row.new.set_cell_values(:bar => "bar").add_child(
+                    RowGroup.new.add_children([
+                                                  Row.new.set_cell_values(:baz => "baz"),
+                                                  Row.new.set_cell_values(:baz => "bazaar")
+                                              ])
+                )
+            )
+        )
+        @row.collapse!
+      end
+
+      it "pulls the first row from each group up into itself" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar", "baz" => "baz"}
+      end
+
+      it "deletes only the intermediary group" do
+        @row.children.length.should == 1
+        @row.children.first.children.length.should == 1
+        @row.children.first.children.first.cells.should == {"baz" => "bazaar"}
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #     row: bar2
+    #   group
+    #     row: bazaar
+    #     row: bazaar2
+    # => foo | bar  |
+    #        | bar2 |
+    #        |      | bazaar
+    #        |      | bazaar2
+    context "for multiple children with multiple rows" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_children([
+                                                             RowGroup.new.add_children([
+                                                                                           Row.new.set_cell_values(:bar => "bar"),
+                                                                                           Row.new.set_cell_values(:bar => "bar2"),
+                                                                                       ]),
+                                                             RowGroup.new.add_children([
+                                                                                           Row.new.set_cell_values(:baz => "bazaar"),
+                                                                                           Row.new.set_cell_values(:baz => "bazaar2"),
+                                                                                       ])
+                                                         ])
+        @row.collapse!
+      end
+
+      it "pulls the first row from the first group into the parent" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar"}
+      end
+
+      it "leaves the second row in the first group" do
+        @row.children.length.should == 2
+        @row.children.first.children.length.should == 1
+        @row.children.first.children.first.cells.should == {"bar" => "bar2"}
+      end
+
+      it "leaves the second group alone" do
+        @row.children.last.children.length.should == 2
+        @row.children.last.children.first.cells.should == {"baz" => "bazaar"}
+        @row.children.last.children.last.cells.should == {"baz" => "bazaar2"}
+      end
+    end
+
+    # row: foo
+    #   group
+    #     row: bar
+    #       group
+    #         row: bare
+    #         row: bart
+    #     row: baz
+    #       group
+    #         row: bazaar
+    #         row: bizarre
+    # => foo | bar  | bare
+    #        |      | bart
+    #        | baz  | bazaar
+    #        |      | bizarre
+    context "for multiple children with multiple children" do
+      before(:each) do
+        @row = Row.new
+        @row.set_cell_values(:foo => "foo").add_child(
+            RowGroup.new.add_children([
+                                          Row.new.set_cell_values(:bar => "bar").add_child(
+                                              RowGroup.new.add_children([
+                                                                            Row.new.set_cell_values(:barry => "bare"),
+                                                                            Row.new.set_cell_values(:barry => "bart")
+                                                                        ])
+                                          ),
+                                          Row.new.set_cell_values(:bar => "baz").add_child(
+                                              RowGroup.new.add_children([
+                                                                            Row.new.set_cell_values(:barry => "bazaar"),
+                                                                            Row.new.set_cell_values(:barry => "bizarre")
+                                                                        ])
+                                          )
+                                      ])
+        )
+        @row.collapse!
+      end
+
+      it "pulls the first row from the first child into itself" do
+        @row.cells.should == {"foo" => "foo", "bar" => "bar", "barry" => "bare"}
+      end
+
+      it "leaves the second row from the first child in the first group" do
+        @row.children.first.children.first.cells.should == {"barry" => "bart"}
+      end
+
+      it "collapses the second group" do
+        @row.children.last.children.first.cells.should == {"bar" => "baz", "barry" => "bazaar"}
+        @row.children.last.children.first.children.first.children.first.cells.should == {"barry" => "bizarre"}
+      end
+    end
+  end
+end