cldwalker-hirb 0.1.2 → 0.2.0

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
@@ -89,6 +90,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 +148,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 +170,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 +209,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,11 +222,37 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([[1,2], [3,4]], :headers=>['A', 'B']).should == expected_table
     end
     
+    test "filters option renders" do
+      expected_table = <<-TABLE.unindent
+      +-----------+---+
+      | 0         | 1 |
+      +-----------+---+
+      | s,o,m,e   | 2 |
+      | t,h,i,n,g | 1 |
+      +-----------+---+
+      2 rows in set
+      TABLE
+      table([['some', {:num=>2}], ['thing', {:num=>1}]], :filters=>{0=>lambda {|e| e.split("").join(",")},
+        1=>[:[], :num]}).should == expected_table
+    end
+
+    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 "object table" do
     before(:all) {
-      @pets = [stub(:name=>'rufus', :age=>7), stub(:name=>'alf', :age=>101)]
+      @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
     }
     test "renders" do
       expected_table = <<-TABLE.unindent
@@ -233,14 +267,38 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       Hirb::Helpers::ObjectTable.render(@pets, :fields=>[:name, :age]).should == expected_table
     end
     
-    test "with no options fields raises ArgumentError" do
-      assert_raises(ArgumentError) { Hirb::Helpers::ObjectTable.render(@pets) }
+    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
   
   context "activerecord table" do
     before(:all) {
-      @pets = [stub(:name=>'rufus', :age=>7, :attribute_names=>['age', 'name']), stub(:name=>'alf', :age=>101)]
+      @pets = [stub(:name=>'rufus', :age=>7, :class=>mock(:column_names=>[:age, :name])), stub(:name=>'alf', :age=>101)]
     }
     test "renders" do
       expected_table = <<-TABLE.unindent
@@ -255,9 +313,30 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       Hirb::Helpers::ActiveRecordTable.render(@pets).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

data/test/test_helper.rb

@@ -7,6 +7,26 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'hirb'
 
 class Test::Unit::TestCase
+  # set these to avoid invoking stty multiple times which doubles test suite running time
+  ENV["LINES"] = ENV["COLUMNS"] = "20"
+  def reset_terminal_size
+    ENV["LINES"] = ENV["COLUMNS"] = "20"
+  end
+
+  def capture_stdout(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+
+  def reset_config
+    Hirb::View.instance_eval "@config = nil"
+  end
 end
 
 class String
@@ -14,4 +34,14 @@ class String
     regex = num ? /^\s{#{num}}/ : /^\s*/
     gsub(regex, '').chomp
   end
+end
+
+# mocks IRB for View + Pager
+module ::IRB
+  class Irb
+    def initialize(context)
+      @context = context
+    end
+    def output_value; end
+  end
 end

data/test/util_test.rb

@@ -1,21 +1,56 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::UtilTest < Test::Unit::TestCase
-  test "any_const_get returns nested class" do
-    Hirb::Util.any_const_get("Test::Unit").should == ::Test::Unit
-  end
-  
-  test "any_const_get returns nil for invalid class" do
-    Hirb::Util.any_const_get("Basdfr").should == nil
-  end
-  
-  test "any_const_get returns class when given class" do
-    Hirb::Util.any_const_get(String).should == String
-  end
-  
-  test "recursive_hash_merge merges" do
-    expected_hash = {:output=>{:fields=>["f1", "f2"], :method=>"blah"}, :key1=>"hash1", :key2=>"hash2"}
-    Hirb::Util.recursive_hash_merge({:output=>{:fields=>%w{f1 f2}}, :key1=>'hash1'},
-      {:output=>{:method=>'blah'}, :key2=>'hash2'}).should == expected_hash
+module Hirb
+  class UtilTest < Test::Unit::TestCase
+    test "any_const_get returns nested class" do
+      Util.any_const_get("Test::Unit").should == ::Test::Unit
+    end
+    
+    test "any_const_get returns nil for invalid class" do
+      Util.any_const_get("Basdfr").should == nil
+    end
+    
+    test "any_const_get returns class when given class" do
+      Util.any_const_get(String).should == String
+    end
+    
+    test "recursive_hash_merge merges" do
+      expected_hash = {:output=>{:fields=>["f1", "f2"], :method=>"blah"}, :key1=>"hash1", :key2=>"hash2"}
+      Util.recursive_hash_merge({:output=>{:fields=>%w{f1 f2}}, :key1=>'hash1'},
+        {:output=>{:method=>'blah'}, :key2=>'hash2'}).should == expected_hash
+    end
+
+    test "choose_from_array specifies range with -" do
+      Util.choose_from_array([1,2,3,4], '1-2,4').should == [1,2,4]
+    end
+
+    test "choose_from_array specifies range with .." do
+      Util.choose_from_array([1,2,3,4], '1 .. 2,4').should == [1,2,4]
+    end
+
+    test "choose_from_array chooses all with *" do
+      Util.choose_from_array([1,2,3,4], '*').should == [1,2,3,4]
+    end
+
+    test "choose_from_array ignores non-numerical input" do
+      Util.choose_from_array([1,2,3,4], 'a,2').should == [2]
+    end
+
+    test "choose_from_array ignores 0" do
+      Util.choose_from_array([1,2,3,4], '0,2').should == [2]
+    end
+
+    test "choose_from_array returns empty when empty input" do
+      Util.choose_from_array([1,2,3,4], "\n").should == []
+    end
+
+    test "choose_from_array returns empty with an invalid range" do
+      Util.choose_from_array([1,2,3,4], "5").should == []
+    end
+
+    test "capture_stdout" do
+      string = "sweetness man"
+      Util.capture_stdout { puts string }.should == string + "\n"
+    end
   end
-end
+end