hirb 0.2.9 → 0.2.10

data/test/hirb_test.rb

@@ -1,11 +1,13 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 class HirbTest < Test::Unit::TestCase
-  before(:each) {Hirb.instance_eval "@config = nil"}
+  before(:all) { Hirb.config_files = nil }
+  before(:each) { Hirb.config = nil }
 
   test "config converts yaml when config file exists" do
     yaml_data = {:blah=>'blah'}
     File.stubs('exists?').returns(true)
+    Hirb.config_files = ['ok']
     YAML::expects(:load_file).returns(yaml_data)
     Hirb.config.should == yaml_data
   end
@@ -17,14 +19,21 @@ class HirbTest < Test::Unit::TestCase
   
   test "config reloads if given explicit reload" do
     Hirb.config
-    Hirb.expects(:read_config_file)
+    Hirb.expects(:read_config_file).returns({})
     Hirb.config(true)
   end
 
+  test "config reads multiple config files and merges them" do
+    Hirb.config_files = %w{one two}
+    Hirb.expects(:read_config_file).times(2).returns({:output=>{"String"=>:auto_table}}, {:output=>{"Array"=>:auto_table}})
+    Hirb.config.should == {:output=>{"Array"=>:auto_table, "String"=>:auto_table}}
+    Hirb.config_files = nil
+  end
+
   test "config_file sets correctly when no ENV['HOME']" do
-    Hirb.config_file = nil
+    Hirb.config_files = nil
     home = ENV.delete('HOME')
-    Hirb.config_file.class.should == String
+    Hirb.config_files[0].class.should == String
     ENV["HOME"] = home
   end
 end

data/test/menu_test.rb

@@ -1,6 +1,8 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 class Hirb::MenuTest < Test::Unit::TestCase
+  before(:all) { Hirb::View.instance_variable_set("@config", :width=>Hirb::View::DEFAULT_WIDTH) }
+
   def menu(*args, &block)
     # testing via menu's main use case (through console) instead of Hirb::Menu.render
     @console ||= Object.new.extend(Hirb::Console)
@@ -41,11 +43,11 @@ class Hirb::MenuTest < Test::Unit::TestCase
 
     test "with block and no chosen doesn't call block" do
       menu_input ""
-      block = lambda {|e| }
-      block.expects(:call).never
+      block = lambda {|e| @called = true }
       capture_stdout {
         menu([1,2,3], &block).should == []
       }
+      assert !@called
     end
 
     test "with valid helper_class option renders" do
@@ -86,9 +88,136 @@ class Hirb::MenuTest < Test::Unit::TestCase
       menu([1], :ask=>false).should == [1]
     end
 
-    test "with validate_one option returns chosen one" do
-      menu_input '2'
-      capture_stdout { menu([1,2,3], :validate_one=> true).should == 2 }
+    test "with no items to choose from always return without asking" do
+      $stdin.expects(:gets).never
+      menu([], :ask=>false).should == []
+      menu([], :ask=>true).should == []
+    end
+
+    test "with directions option turns off directions" do
+      menu_input('blah')
+      capture_stdout { menu([1], :directions=>false) }.should_not =~ /range.*all/
+    end
+  end
+
+  def two_d_menu(options={})
+    if options[:invokes] || options[:invoke]
+      cmd = options[:command] || 'p'
+      (options[:invokes] || [options[:invoke]]).each {|e|
+        Hirb::Menu.any_instance.expects(:invoke).with(cmd, e)
+      }
+    end
+
+    capture_stdout {
+      return menu(options[:output] || [{:a=>1, :bro=>2}, {:a=>3, :bro=>4}],
+       {:two_d=>true}.merge(options))
+    }
+  end
+
+  context "2d menu" do
+    test "with default field from last_table renders" do
+      menu_input "1"
+      two_d_menu.should == [1]
+    end
+
+    test "with default field from fields option renders" do
+      menu_input "1"
+      two_d_menu(:fields=>[:bro, :a]).should == [2]
+    end
+
+    test "with default field option renders" do
+      menu_input "1"
+      two_d_menu(:default_field=>:bro).should == [2]
+    end
+
+    test "with non-table helper class renders" do
+      menu_input "1"
+      two_d_menu(:helper_class=>false, :fields=>[:a,:bro]).should == [1]
+    end
+
+    test "with no default field prints error" do
+      menu_input "1"
+      capture_stderr { two_d_menu(:fields=>[]) }.should =~ /No default.*found/
+    end
+
+    test "with invalid field prints error" do
+      menu_input "1:z"
+      capture_stderr { two_d_menu }.should =~ /Invalid.*'z'/
+    end
+
+    test "with choice from abbreviated field" do
+      menu_input "2:b"
+      two_d_menu.should == [4]
+    end
+
+    test "with choices from multiple fields renders" do
+      menu_input "1 2:bro"
+      two_d_menu.should == [1,4]
+    end
+  end
+
+  context "action menu" do
+    test "invokes" do
+      menu_input "p 1 2:bro"
+      two_d_menu(:action=>true, :invoke=>[[1,4]])
+    end
+
+    test "with 1d invokes" do
+      menu_input "p 1"
+      two_d_menu(:action=>true, :two_d=>nil, :invoke=>[[{:a=>1, :bro=>2}]])
+    end
+
+    test "with non-choice arguments invokes" do
+      menu_input "p arg1 1"
+      two_d_menu :action=>true, :invoke=>['arg1', [1]]
+    end
+
+    test "with multiple choice arguments flattens them into arg" do
+      menu_input "p arg1 1 2:bro arg2"
+      two_d_menu :action=>true, :invoke=>['arg1', [1,4], 'arg2']
+    end
+
+    test "with nothing chosen prints error" do
+      menu_input "cmd"
+      capture_stderr { two_d_menu(:action=>true) }.should =~ /No rows chosen/
+    end
+
+    test "with no command given prints error" do
+      menu_input "1"
+      capture_stderr { two_d_menu(:action=>true) }.should =~ /No command given/
+    end
+
+    test "with multi_action option invokes" do
+      menu_input "p 1 2:bro"
+      two_d_menu(:action=>true, :multi_action=>true, :invokes=>[[1], [4]])
+    end
+
+    test "with command option invokes" do
+      menu_input "1"
+      two_d_menu(:action=>true, :command=>'p', :invoke=>[[1]])
+    end
+
+    test "with command option and empty input doesn't invoke action and exists silently" do
+      Hirb::Menu.any_instance.expects(:invoke).never
+      menu_input ""
+      two_d_menu(:action=>true, :command=>'p').should == nil
+    end
+
+    test "with action_object option invokes" do
+      obj = mock(:blah=>true)
+      menu_input "blah 1"
+      two_d_menu(:action=>true, :action_object=>obj)
+    end
+
+    test "with ask false and defaults invokes" do
+      two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :default_field=>:a,
+        :command=>'p', :invoke=>[[1]])
+    end
+
+    test "with ask false and no defaults prints error" do
+      capture_stderr {
+        two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :command=>'p')
+      }.should =~ /Default.*required/
     end
   end
 end

data/test/object_table_test.rb

@@ -2,6 +2,10 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 
 class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
   context "object table" do
+    def table(*args)
+      Hirb::Helpers::ObjectTable.render(*args)
+    end
+
     before(:all) {
       @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
     }
@@ -15,7 +19,7 @@ class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
       +-------+-----+
       2 rows in set
       TABLE
-      Hirb::Helpers::ObjectTable.render(@pets, :fields=>[:name, :age]).should == expected_table
+      table(@pets, :fields=>[:name, :age]).should == expected_table
     end
     
     test "with no options defaults to to_s field" do
@@ -28,7 +32,7 @@ class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
       +-------+
       2 rows in set
       TABLE
-      Hirb::Helpers::ObjectTable.render(@pets).should == expected_table
+      table(@pets).should == expected_table
     end
 
     test "renders simple arrays" do
@@ -43,14 +47,29 @@ class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
       +-------+
       4 rows in set
       TABLE
-      Hirb::Helpers::ObjectTable.render([1,2,3,4]).should == expected_table
+      table([1,2,3,4]).should == expected_table
+    end
+
+    test "renders simple arrays with custom header" do
+      expected_table = <<-TABLE.unindent
+      +-----+
+      | num |
+      +-----+
+      | 1   |
+      | 2   |
+      | 3   |
+      | 4   |
+      +-----+
+      4 rows in set
+      TABLE
+      table([1,2,3,4], :headers=>{:to_s=>'num'}).should == expected_table
     end
 
     test "with empty fields" do
       expected_table = <<-TABLE.unindent
       0 rows in set
       TABLE
-      Hirb::Helpers::ObjectTable.render(@pets, :fields => []).should == expected_table
+      table(@pets, :fields => []).should == expected_table
     end
   end
 end

data/test/pager_test.rb

@@ -27,7 +27,7 @@ module Hirb
     end
 
     context "default_pager" do
-      before(:all) { reset_config; Hirb.enable {|c| c.pager = true}}
+      before(:all) { reset_config; Hirb.enable :pager=>true }
       before(:each) { View.pager = nil; Pager.stubs(:pager_command).returns(nil) }
       after(:all) { Hirb.disable }
 

data/test/resizer_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::Table
+  class ResizerTest < Test::Unit::TestCase
+    def table(options)
+      @table = Hirb::Helpers::Table.new [options[:field_lengths].keys.inject({}) {|t,e| t[e] = '1'; t}]
+      @table.field_lengths = options[:field_lengths]
+      @table.width = options[:width]
+      @table.max_fields = options[:max_fields] if options[:max_fields]
+      @width, @field_lengths = @table.width, @table.field_lengths
+    end
+
+    test "resize ensures columns total doesn't exceed max width" do
+      table :field_lengths=>{:f1=>135, :f2=>45, :f3=>4, :f4=>55}, :width=>195
+      Resizer.resize!(@table)
+      @field_lengths.values.inject {|a,e| a+=e}.should <= @width
+    end
+
+    test "resize sets columns by relative lengths" do
+      table :field_lengths=>{:a=>30, :b=>30, :c=>40}, :width=>60
+      Resizer.resize!(@table)
+      @field_lengths.values.inject {|a,e| a+=e}.should <= @width
+      @field_lengths.values.uniq.size.should_not == 1
+    end
+
+    test "resize sets all columns roughly equal when adusting long fields don't work" do
+      table :field_lengths=>{:field1=>10, :field2=>15, :field3=>100}, :width=>20
+      Resizer.resize!(@table)
+      @field_lengths.values.inject {|a,e| a+=e}.should <= @width
+      @field_lengths.values.each {|e| e.should <= 4 }
+    end
+
+    context "add_extra_width and max_fields" do
+      def table_and_resize(options={})
+        defaults = {:field_lengths=>{:f1=>135, :f2=>30, :f3=>4, :f4=>100}, :width=>195, :max_fields=>{:f1=>80, :f4=>30} }
+        table defaults.merge(options)
+        Resizer.resize! @table
+      end
+
+      test "doesn't add to already maxed out field" do
+        table_and_resize
+        @field_lengths[:f3].should == 4
+      end
+
+      test "restricted before adding width" do
+        table_and_resize
+        @field_lengths[:f4].should <= 30
+      end
+
+      test "adds to restricted field" do
+        table_and_resize
+        @field_lengths[:f1].should <= 80
+      end
+
+      test "adds to unrestricted field" do
+        table_and_resize :field_lengths=>{:f1=>135, :f2=>70, :f3=>4, :f4=>100}
+        @field_lengths[:f2].should == 70
+      end
+    end
+  end
+end

data/test/table_test.rb

@@ -81,17 +81,45 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([{:name=>"ｱｲｳｴｵｶｷ"}, {:name=>"ｸｹｺｻｼｽｾｿﾀﾁﾂﾃ"}, {:name=>"Tata l'asticote"}, {:name=>"toto létoile PAOLI"}]).should == expected_table
     end
 
-    test "with newlines renders with newlines stringified" do
+    test "stringifies newlines and tabs and renders" do
       expected_table = <<-TABLE.unindent
       +-----+---+
       | a   | b |
       +-----+---+
       | 1#{'\n'} | 2 |
-      | 3   | 4 |
+      | 3#{'\t'} | 4 |
       +-----+---+
       2 rows in set
       TABLE
-      table([{'a'=>"1\n", 'b'=>2}, {'a'=>3, 'b'=>4}]).should == expected_table
+      value = [{'a'=>"1\n", 'b'=>2}, {'a'=>"3\t", 'b'=>4}]
+      table(value).should == expected_table
+      value.should == [{'a'=>"1\n", 'b'=>2}, {'a'=>"3\t", 'b'=>4}]
+    end
+
+    test "with a field of only array values renders values comma joined" do
+      expected_table = <<-TABLE.unindent
+      +----+------+
+      | a  | b    |
+      +----+------+
+      | 12 | 1, 2 |
+      | ok | 3, 4 |
+      +----+------+
+      2 rows in set
+      TABLE
+      # depends on 1.8 Array#to_s
+      table([{:a=>[1,2], :b=>[1,2]}, {:a=>'ok', :b=>[3,4]}]).should == expected_table
+    end
+
+    test "with filter class default doesn't override explicit filters" do
+      expected_table = <<-TABLE.unindent
+      +------+-------+
+      | name | value |
+      +------+-------+
+      | a    | b1    |
+      +------+-------+
+      1 row in set
+      TABLE
+      table([{:name=>'a', :value=>{:b=>1}}], :filters=>{:value=>:to_s}).should == expected_table
     end
   end
 
@@ -136,11 +164,11 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | 4 |   |
       +---+---+
       2 rows in set
-  TABLE
+      TABLE
       table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:b, :c]).should == expected_table
     end
   
-    test "invalid fields in field_lengths option renders" do
+    test "invalid field in max_fields option renders" do
       expected_table = <<-TABLE.unindent
       +------------+---+
       | a          | b |
@@ -148,11 +176,11 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | AAAAAAA... | 2 |
       +------------+---+
       1 row in set
-  TABLE
-      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10,:c=>10}).should == expected_table
+      TABLE
+      table([{:a=> "A" * 50, :b=>2}], :max_fields=>{:a=>10,:c=>10}).should == expected_table
     end
   
-    test "field_lengths option and field_lengths less than 3 characters renders" do
+    test "max_fields option with fields less than 3 characters renders" do
       expected_table = <<-TABLE.unindent
       +----+---+
       | a  | b |
@@ -160,11 +188,11 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | AA | 2 |
       +----+---+
       1 row in set
-  TABLE
-      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>2}).should == expected_table
+      TABLE
+      table([{:a=> "A" * 50, :b=>2}], :max_fields=>{:a=>2}, :resize=>false).should == expected_table
     end
   
-    test "field_lengths option renders" do
+    test "max_fields option without resize renders" do
       expected_table = <<-TABLE.unindent
       +------------+---+
       | a          | b |
@@ -172,23 +200,35 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | AAAAAAA... | 2 |
       +------------+---+
       1 row in set
-  TABLE
-      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10}).should == expected_table
+      TABLE
+      table([{:a=> "A" * 50, :b=>2}], :max_fields=>{:a=>10}, :resize=>false).should == expected_table
+    end
+
+    test "max_fields option with percentage renders" do
+      expected_table = <<-TABLE.unindent
+      +------------------+---+
+      | a                | b |
+      +------------------+---+
+      | AAAAAAAAAAAAA... | 2 |
+      +------------------+---+
+      1 row in set
+      TABLE
+      table([{:a=> "A" * 50, :b=>2}], :max_fields=>{:a=>'0.15'}).should == expected_table
     end
   
     test "max_width option renders" do
       expected_table = <<-TABLE.unindent
-      +-----------+---+-----------+
-      | a         | b | c         |
-      +-----------+---+-----------+
-      | AAAAAA... | 2 | CCCCCC... |
-      +-----------+---+-----------+
+      +-----------+---+------------+
+      | a         | b | c          |
+      +-----------+---+------------+
+      | AAAAAA... | 2 | CCCCCCCCCC |
+      +-----------+---+------------+
       1 row in set
-  TABLE
+      TABLE
       table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>30).should == expected_table
     end
 
-    test "max_width option nil renders full table" do
+    test "resize option false renders full table" do
       expected_table = <<-TABLE.unindent
       +----------------------------------------------------+---+------------+
       | a                                                  | b | c          |
@@ -196,19 +236,19 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | 2 | CCCCCCCCCC |
       +----------------------------------------------------+---+------------+
       1 row in set
-  TABLE
-      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>nil).should == expected_table
+      TABLE
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :resize=>false).should == expected_table
     end
     
     test "global width renders" do
       expected_table = <<-TABLE.unindent
-      +-----------+---+-----------+
-      | a         | b | c         |
-      +-----------+---+-----------+
-      | AAAAAA... | 2 | CCCCCC... |
-      +-----------+---+-----------+
+      +-----------+---+------------+
+      | a         | b | c          |
+      +-----------+---+------------+
+      | AAAAAA... | 2 | CCCCCCCCCC |
+      +-----------+---+------------+
       1 row in set
-  TABLE
+      TABLE
       Hirb::View.load_config
       Hirb::View.resize(30)
       table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}]).should == expected_table
@@ -223,11 +263,11 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | A | 2       | C       |
       +---+---------+---------+
       1 row in set
-  TABLE
+      TABLE
       table([{:a=> "A", :b=>2, :c=>"C"}], :headers=>{:b=>"field B", :c=>"field C"}).should == expected_table
     end
   
-    test "headers option and headers shortened by field_lengths renders" do
+    test "headers option and headers shortened by max_fields renders" do
       expected_table = <<-TABLE.unindent
       +-------+---+
       | fi... | b |
@@ -235,8 +275,8 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       | A     | 2 |
       +-------+---+
       1 row in set
-  TABLE
-      table([{:a=> "A", :b=>2}], :headers=>{:a=>"field A"}, :field_lengths=>{:a=>5}).should == expected_table
+      TABLE
+      table([{:a=> "A", :b=>2}], :headers=>{:a=>"field A"}, :max_fields=>{:a=>5}, :resize=>false).should == expected_table
     end
     
     test "headers option as an array renders" do
@@ -251,7 +291,19 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       TABLE
       table([[1,2], [3,4]], :headers=>['A', 'B']).should == expected_table
     end
-    
+
+    test "header_filter option renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | A | B |
+      +---+---+
+      | 2 | 3 |
+      +---+---+
+      1 row in set
+      TABLE
+      table([{:a=> 2, :b=>3}], :header_filter=>:capitalize).should == expected_table
+    end
+
     test "filters option renders" do
       expected_table = <<-TABLE.unindent
       +-----------+---+
@@ -266,6 +318,22 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
         1=>[:[], :num]}).should == expected_table
     end
 
+    test "filters option calls Filters method and renders" do
+      module ::Hirb::Helpers::Table::Filters
+        def semicolon_join(arr); arr.join('; '); end
+      end
+
+      expected_table = <<-TABLE.unindent
+      +------+------------------------------+
+      | 0    | 1                            |
+      +------+------------------------------+
+      | some | unsightly; unreadable; array |
+      +------+------------------------------+
+      1 row in set
+      TABLE
+      table([[['some'], %w{unsightly unreadable array}]], :filters=>{1=>:semicolon_join}).should == expected_table
+    end
+
     test "number option renders" do
       expected_table = <<-TABLE.unindent
       +--------+---+---+
@@ -333,6 +401,17 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], options).should == expected_table
     end
 
+    test "hide_empty and vertical options renders" do
+      expected_table = <<-TABLE.unindent
+      *** 1. row ***
+      b: 2
+      *** 2. row ***
+      a: 3
+      2 rows in set
+      TABLE
+      table([{:a=>'', :b=>2}, {:a=>3, :b=>nil}], :hide_empty=>true, :vertical=>true).should == expected_table
+    end
+
     test "all_fields option renders all fields" do
       expected_table = <<-TABLE.unindent
       +---+---+---+
@@ -357,51 +436,79 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       2 rows in set
       TABLE
       table([[1,2],[2,3]], :change_fields=>{0=>'name', 1=>'value'}).should == expected_table
+      table([[1,2],[2,3]], :change_fields=>['name', 'value']).should == expected_table
     end
-  end
-  
-  test "table can detect and run callbacks" do
-    Hirb::Helpers::Table.send(:define_method, :and_one_callback) do |obj, opt|
-      obj.each {|row| row.each {|k,v| row[k] += opt[:add] } }
-      obj
-    end
-
-    expected_table = <<-TABLE.unindent
-    +---+---+
-    | a | b |
-    +---+---+
-    | 2 | 3 |
-    | 4 | 5 |
-    +---+---+
-    2 rows in set
-    TABLE
-    table([{'a'=>1, 'b'=>2}, {'a'=>3, 'b'=>4}], :add=>1).should == expected_table
-    Hirb::Helpers::Table.send(:remove_method, :and_one_callback)
-  end
 
-  test "restrict_field_lengths ensures columns total doesn't exceed max width" do
-    @table = Hirb::Helpers::Table.new([{:f1=>'f1', :f2=>'2', :f3=>'3', :f4=>'4'}])
-    field_lengths = {:f1=>135, :f2=>45, :f3=>4, :f4=>55}
-    width = 195
-    @table.restrict_field_lengths(field_lengths, width)
-    field_lengths.values.inject {|a,e| a+=e}.should <= width
-  end
+    test "return_rows option returns rows" do
+      table([[1,2],[2,3]], :return_rows=>true).should == [{0=>"1", 1=>"2"}, {0=>"2", 1=>"3"}]
+    end
 
-  test "restrict_field_lengths sets columns by relative lengths" do
-    @table = Hirb::Helpers::Table.new([{:a=>'a', :b=>'b', :c=>'c'}])
-    field_lengths = {:a=>30, :b=>30, :c=>40}
-    width = 60
-    @table.restrict_field_lengths(field_lengths, width)
-    field_lengths.values.inject {|a,e| a+=e}.should <= width
-    field_lengths.values.uniq.size.should_not == 1
+    test "filter_any option filters any value" do
+      expected_table = <<-TABLE.unindent
+      +---------+
+      | a       |
+      +---------+
+      | {:b=>1} |
+      | 2       |
+      +---------+
+      2 rows in set
+      TABLE
+      table([{:a=>{:b=>1}}, {:a=>2}], :filter_any=>true).should == expected_table
+    end
+
+    test "filter_classes option overrides class-wide filter_classes" do
+      expected_table = <<-TABLE.unindent
+      +----+
+      | a  |
+      +----+
+      | b1 |
+      +----+
+      1 row in set
+      TABLE
+      table([{:a=>{:b=>1}}], :filter_classes=>{Hash=>:to_s}).should == expected_table
+    end
   end
 
-  test "restrict_field_lengths sets all columns equal when no long_field and relative methods don't work" do
-    @table = Hirb::Helpers::Table.new([{:field1=>'f1', :field2=>'f2', :field3=>'f3'}])
-    field_lengths = {:field1=>10, :field2=>15, :field3=>100}
-    width = 20
-    @table.restrict_field_lengths(field_lengths, width)
-    field_lengths.values.inject {|a,e| a+=e}.should <= width
-    field_lengths.values.uniq.size.should == 1
+  context "table with callbacks" do
+    before(:all) {
+      Hirb::Helpers::Table.send(:define_method, :and_one_callback) do |obj, opt|
+        obj.each {|row| row.each {|k,v| row[k] += opt[:add] } }
+        obj
+      end
+    }
+    after(:all) { Hirb::Helpers::Table.send(:remove_method, :and_one_callback) }
+
+    test "detects and runs them" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 2 | 3 |
+      | 4 | 5 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{'a'=>1, 'b'=>2}, {'a'=>3, 'b'=>4}], :add=>1).should == expected_table
+    end
+
+    test "doesn't run callbacks in delete_callbacks option" do
+      Hirb::Helpers::Table.send(:define_method, :and_two_callback) do |obj, opt|
+        obj.each {|row| row.each {|k,v| row[k] = row[k] * 2 } }
+        obj
+      end
+
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 2 | 3 |
+      | 4 | 5 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{'a'=>1, 'b'=>2}, {'a'=>3, 'b'=>4}], :add=>1, :delete_callbacks=>[:and_two]).should == expected_table
+
+      Hirb::Helpers::Table.send(:remove_method, :and_two_callback)
+    end
   end
-end
+end