hirb 0.1.2 → 0.2.2

data/test/menu_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::MenuTest < Test::Unit::TestCase
+  def menu(*args, &block)
+    # testing via menu's main use case (through console) instead of Hirb::Menu.render
+    @console ||= Object.new.extend(Hirb::Console)
+    @console.menu(*args, &block)
+  end
+
+  def basic_menu(*args, &block)
+    menu_input('1')
+    capture_stdout { menu(*args, &block).should == [1] }
+  end
+
+  def menu_input(input='')
+    $stdin.expects(:gets).returns(input)
+  end
+
+  context "menu" do
+    test "by default renders table menu" do
+      expected_menu = <<-MENU.unindent
+      +--------+-------+
+      | number | value |
+      +--------+-------+
+      | 1      | 1     |
+      | 2      | 2     |
+      | 3      | 3     |
+      +--------+-------+
+      3 rows in set
+      MENU
+      basic_menu([1,2,3]).include?(expected_menu).should == true
+    end
+
+    test "with block renders" do
+      menu_input "1,2"
+      expected_result = [1,2]
+      capture_stdout { 
+        menu([1,2,3]) {|e| e.should == expected_result }.should == expected_result
+      }
+    end
+
+    test "with block and no chosen doesn't call block" do
+      menu_input ""
+      block = lambda {|e| }
+      block.expects(:call).never
+      capture_stdout {
+        menu([1,2,3], &block).should == []
+      }
+    end
+
+    test "with valid helper_class option renders" do
+      Hirb::Helpers::Table.expects(:render)
+      basic_menu [1,2,3], :helper_class=>"Hirb::Helpers::Table"
+    end
+
+    test "with invalid helper_class option renders default menu" do
+      expected_menu = <<-MENU.unindent
+      1: 1
+      2: 2
+      3: 3
+      MENU
+      basic_menu([1,2,3], :helper_class=>"SomeHelper").include?(expected_menu).should == true
+    end
+
+    test "with false helper_class option renders default menu" do
+      expected_menu = <<-MENU.unindent
+      1: 1
+      2: 2
+      3: 3
+      MENU
+      basic_menu([1,2,3], :helper_class=>false).include?(expected_menu).should == true
+    end
+
+    test "prints prompt option" do
+      prompt = "Input or else ..."
+      basic_menu([1,2,3], :prompt=>prompt).include?(prompt).should == true
+    end
+
+    test "converts non-array inputs to array" do
+      Hirb::Helpers::AutoTable.expects(:render).with([1], anything)
+      basic_menu 1
+    end
+
+    test "with false ask option returns one choice without asking" do
+      $stdin.expects(:gets).never
+      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 }
+    end
+  end
+end

data/test/object_table_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
+  context "object table" do
+    before(:all) {
+      @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
+    }
+    test "renders" do
+      expected_table = <<-TABLE.unindent
+      +-------+-----+
+      | name  | age |
+      +-------+-----+
+      | rufus | 7   |
+      | alf   | 101 |
+      +-------+-----+
+      2 rows in set
+      TABLE
+      Hirb::Helpers::ObjectTable.render(@pets, :fields=>[:name, :age]).should == expected_table
+    end
+    
+    test "with no options defaults to to_s field" do
+      expected_table = <<-TABLE.unindent
+      +-------+
+      | value |
+      +-------+
+      | rufus |
+      | alf   |
+      +-------+
+      2 rows in set
+      TABLE
+      Hirb::Helpers::ObjectTable.render(@pets).should == expected_table
+    end
+
+    test "renders simple arrays" do
+      expected_table = <<-TABLE.unindent
+      +-------+
+      | value |
+      +-------+
+      | 1     |
+      | 2     |
+      | 3     |
+      | 4     |
+      +-------+
+      4 rows in set
+      TABLE
+      Hirb::Helpers::ObjectTable.render([1,2,3,4]).should == expected_table
+    end
+  end  
+end

data/test/pager_test.rb

@@ -0,0 +1,164 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Hirb
+  class PagerTest < Test::Unit::TestCase
+    def pager; View.pager; end
+
+    def create_pageable_string(inspect_mode=false, size={})
+      size = {:width=>pager.width, :height=>pager.height}.merge(size)
+      seed = inspect_mode ? "a" : "a\n"
+      if inspect_mode
+        seed * (size[:width] * size[:height] + 1)
+      else
+        seed * (size[:height] + 1)
+      end
+    end
+
+    test "command_pager sets pager_command when command exists" do
+      Util.expects(:command_exists?).returns(true)
+      Pager.expects(:basic_pager)
+      Pager.command_pager 'blah', :pager_command=>'less'
+    end
+
+    test "command_pager doesn't set pager_command when command doesn't exist" do
+      Util.expects(:command_exists?).returns(false)
+      Pager.expects(:basic_pager).never
+      Pager.command_pager 'blah', :pager_command=>'moreless'
+    end
+
+    context "default_pager" do
+      before(:all) { reset_config; Hirb.enable {|c| c.pager = true}}
+      before(:each) { View.pager = nil; Pager.stubs(:pager_command).returns(nil) }
+      after(:all) { Hirb.disable }
+
+      test "pages once in normal mode" do
+        $stdin.expects(:gets).returns("\n")
+        output = capture_stdout { pager.page(create_pageable_string, false) }
+        output.include?('quit').should be(true)
+        output.include?('finished').should be(true)
+      end
+
+      test "doesn't page in normal mode" do
+        $stdin.expects(:gets).never
+        output = capture_stdout { pager.page("a\n", false) }
+        output.include?("a\n=== Pager finished. ===\n").should be(true)
+      end
+
+      test "pages once in inspect mode" do
+        $stdin.expects(:gets).returns("\n")
+        output = capture_stdout { pager.page(create_pageable_string(true), true) }
+        output.include?('quit').should be(true)
+        output.include?('finished').should be(true)
+      end
+
+      test "doesn't page in inspect mode" do
+        $stdin.expects(:gets).never
+        output = capture_stdout { pager.page("a", true) }
+        output.include?("a\n=== Pager finished. ===\n").should be(true)
+      end
+    end
+
+    context "pager" do
+      before(:all) { reset_config; Hirb.enable }
+      before(:each) { View.pager = nil; View.formatter = nil }
+      after(:all) { Hirb.disable }
+
+      def irb_eval(string)
+        context_stub = stub(:last_value=>string)
+        ::IRB::Irb.new(context_stub).output_value
+      end
+
+      # this mode is called within @irb.output_value
+      context "in inspect_mode" do
+        test "activates when output is wide enough" do
+          output = create_pageable_string(true)
+          pager.expects(:page).with(output.inspect, true)
+          View.expects(:render_output).returns(false)
+          irb_eval output
+        end
+
+        test "doesn't activate when output isn't wide enough" do
+          pager.expects(:page).never
+          View.expects(:render_output).returns(false)
+          irb_eval("a")
+        end
+
+        test "activates with an explicit width" do
+          View.config[:width] = 10
+          output = create_pageable_string true, :width=>10
+          pager.expects(:page).with(output.inspect, true)
+          View.expects(:render_output).returns(false)
+          irb_eval output
+        end
+
+        test "activates default_pager when pager command is invalid" do
+          Pager.expects(:pager_command).returns(nil)
+          output = create_pageable_string(true)
+          Pager.expects(:default_pager).with(output.inspect, anything)
+          View.expects(:render_output).returns(false)
+          capture_stdout { irb_eval output }
+        end
+      end
+
+      # this mode is called within Hirb::View.render_output
+      context "in normal mode" do
+        test "activates when output is long enough" do
+          output = create_pageable_string
+          View.formatter.expects(:format_output).returns(output)
+          pager.expects(:page).with(output, false)
+          irb_eval(output)
+        end
+
+        test "doesn't activate when output isn't long enough" do
+          output = "a\n"
+          View.formatter.expects(:format_output).returns(output)
+          pager.expects(:page).never
+          capture_stdout { irb_eval(output) }
+        end
+
+        test "activates with an explicit height" do
+          View.config[:height] = 100
+          output = create_pageable_string false, :height=>100
+          View.formatter.expects(:format_output).returns(output)
+          pager.expects(:page).with(output, false)
+          irb_eval(output)
+        end
+
+        test "activates default_pager when pager_command is invalid" do
+          Pager.expects(:pager_command).returns(nil)
+          output = create_pageable_string
+          Pager.expects(:default_pager).with(output, anything)
+          View.formatter.expects(:format_output).returns(output)
+          capture_stdout { irb_eval output }
+        end
+      end
+
+      test "activates pager_command with valid pager_command option" do
+        View.config[:pager_command] = "less"
+        View.expects(:render_output).returns(false)
+        Util.expects(:command_exists?).returns(true)
+        Pager.expects(:command_pager)
+        irb_eval create_pageable_string(true)
+        View.config[:pager_command] = nil
+      end
+
+      test "activates pager_command with pager_command option that has command options" do
+        View.config[:pager_command] = "less -r"
+        View.expects(:render_output).returns(false)
+        Util.expects(:command_exists?).with('less').returns(true)
+        Pager.expects(:command_pager)
+        irb_eval create_pageable_string(true)
+        View.config[:pager_command] = nil
+      end
+
+      test "doesn't activate pager_command with invalid pager_command option" do
+        View.config[:pager_command] = "moreless"
+        View.expects(:render_output).returns(false)
+        Util.expects(:command_exists?).returns(false)
+        Pager.expects(:default_pager)
+        irb_eval create_pageable_string(true)
+        View.config[:pager_command] = nil
+      end
+    end
+  end
+end

data/test/table_test.rb

@@ -4,6 +4,7 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
   def table(*args)
     Hirb::Helpers::Table.render(*args)
   end
+  before(:all) { reset_config }
   
   context "basic table" do
     test "renders" do
@@ -41,7 +42,7 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       TABLE
       table([{'a'=>1, 'b'=>2}, {'a'=>3, 'b'=>4}]).should == expected_table
     end
-    
+
     test "with array only rows renders" do
       expected_table = <<-TABLE.unindent
       +---+---+
@@ -54,11 +55,13 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       TABLE
       table([[1,2], [3,4]]).should == expected_table
     end
-    
-    test "with too many fields raises error" do
-      assert_raises(Hirb::Helpers::Table::TooManyFieldsForWidthError) { table([Array.new(70, 'AAA')]) }
+
+    test "with too many fields defaults to vertical table" do
+      rows = [Array.new(25, "A"* 10)]
+      Hirb::Helpers::VerticalTable.expects(:render).with(rows, anything)
+      capture_stderr { table(rows)}.should =~ /Error/
     end
-    
+
     test "with no rows renders" do
       table([]).should == "0 rows in set"
     end
@@ -89,6 +92,12 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       TABLE
       table([[1,2,3]], :fields=>[0,2]).should == expected_table
     end
+
+    test "fields and number options copies fields option and does not modify it" do
+      options = {:fields=>[:f1], :number=>true}
+      table({:f1=>1, :f2=>2}, options)
+      options[:fields].should == [:f1]
+    end
   
     test "invalid fields option renders empty columns" do
       expected_table = <<-TABLE.unindent
@@ -141,11 +150,11 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
   
     test "max_width option renders" do
       expected_table = <<-TABLE.unindent
-      +--------------------------+---+------------+
-      | a                        | b | c          |
-      +--------------------------+---+------------+
-      | AAAAAAAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
-      +--------------------------+---+------------+
+      +-----------+---+-----------+
+      | a         | b | c         |
+      +-----------+---+-----------+
+      | AAAAAA... | 2 | CCCCCC... |
+      +-----------+---+-----------+
       1 row in set
   TABLE
       table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>30).should == expected_table
@@ -163,18 +172,19 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>nil).should == expected_table
     end
     
-    test "global max_width renders" do
+    test "global width renders" do
       expected_table = <<-TABLE.unindent
-      +--------------------------+---+------------+
-      | a                        | b | c          |
-      +--------------------------+---+------------+
-      | AAAAAAAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
-      +--------------------------+---+------------+
+      +-----------+---+-----------+
+      | a         | b | c         |
+      +-----------+---+-----------+
+      | AAAAAA... | 2 | CCCCCC... |
+      +-----------+---+-----------+
       1 row in set
   TABLE
-      Hirb::Helpers::Table.max_width = 30
+      Hirb::View.load_config
+      Hirb::View.resize(30)
       table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}]).should == expected_table
-      Hirb::Helpers::Table.max_width = Hirb::Helpers::Table::DEFAULT_MAX_WIDTH
+      reset_config
     end
 
     test "headers option and headers longer than fields renders" do
@@ -201,7 +211,7 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([{:a=> "A", :b=>2}], :headers=>{:a=>"field A"}, :field_lengths=>{:a=>5}).should == expected_table
     end
     
-    test "with headers option as an array renders" do
+    test "headers option as an array renders" do
       expected_table = <<-TABLE.unindent
       +---+---+
       | A | B |
@@ -214,50 +224,70 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([[1,2], [3,4]], :headers=>['A', 'B']).should == expected_table
     end
     
-  end
-  
-  context "object table" do
-    before(:all) {
-      @pets = [stub(:name=>'rufus', :age=>7), stub(:name=>'alf', :age=>101)]
-    }
-    test "renders" do
+    test "filters option renders" do
       expected_table = <<-TABLE.unindent
-      +-------+-----+
-      | name  | age |
-      +-------+-----+
-      | rufus | 7   |
-      | alf   | 101 |
-      +-------+-----+
+      +-----------+---+
+      | 0         | 1 |
+      +-----------+---+
+      | s,o,m,e   | 2 |
+      | t,h,i,n,g | 1 |
+      +-----------+---+
       2 rows in set
       TABLE
-      Hirb::Helpers::ObjectTable.render(@pets, :fields=>[:name, :age]).should == expected_table
+      table([['some', {:num=>2}], ['thing', {:num=>1}]], :filters=>{0=>lambda {|e| e.split("").join(",")},
+        1=>[:[], :num]}).should == expected_table
     end
-    
-    test "with no options fields raises ArgumentError" do
-      assert_raises(ArgumentError) { Hirb::Helpers::ObjectTable.render(@pets) }
+
+    test "number option renders" do
+      expected_table = <<-TABLE.unindent
+      +--------+---+---+
+      | number | 0 | 1 |
+      +--------+---+---+
+      | 1      | a | b |
+      | 2      | c | d |
+      +--------+---+---+
+      2 rows in set
+      TABLE
+      table([['a','b'], ['c', 'd']], :number=>true).should == expected_table
     end
-  end
-  
-  context "activerecord table" do
-    before(:all) {
-      @pets = [stub(:name=>'rufus', :age=>7, :attribute_names=>['age', 'name']), stub(:name=>'alf', :age=>101)]
-    }
-    test "renders" do
+
+    test "vertical option renders vertical table" do
       expected_table = <<-TABLE.unindent
-      +-----+-------+
-      | age | name  |
-      +-----+-------+
-      | 7   | rufus |
-      | 101 | alf   |
-      +-----+-------+
+      *** 1. row ***
+      a: 1
+      b: 2
+      *** 2. row ***
+      a: 3
+      b: 4
       2 rows in set
       TABLE
-      Hirb::Helpers::ActiveRecordTable.render(@pets).should == expected_table
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], :vertical=>true).should == expected_table
     end
   end
   
-  test "restrict_field_lengths handles many fields" do
+  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 "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
+  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'}])
-    @table.restrict_field_lengths({:field1=>10, :field2=>15, :field3=>100}, 10)
+    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
   end
 end