Chrononaut-hirb 0.2.1

data/test/hirb_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class HirbTest < Test::Unit::TestCase
+  before(:each) {Hirb.instance_eval "@config = nil"}
+  
+  test "config converts yaml when config file exists" do
+    yaml_data = {:blah=>'blah'}
+    File.stubs('exists?').returns(true)
+    YAML::expects(:load_file).returns(yaml_data)
+    Hirb.config.should == yaml_data
+  end
+  
+  test "config defaults to hash when no config file" do
+    File.stubs('exists?').returns(false)
+    Hirb.config.should == {}
+  end
+  
+  test "config reloads if given explicit reload" do
+    Hirb.config
+    Hirb.expects(:read_config_file)
+    Hirb.config(true)
+  end
+end

data/test/import_test.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::ImportTest < Test::Unit::TestCase
+  test "require import_object extends Object" do
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(false)
+    require 'hirb/import_object'
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(true)
+  end
+end

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/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

@@ -0,0 +1,374 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+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
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}]).should == expected_table
+    end
+
+    test "with no headers renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 1 | 2 |
+      +---+---+
+      1 row in set
+      TABLE
+      table([{:a=>1, :b=>2}], :headers=>nil).should == expected_table
+    end
+
+    test "with string keys renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      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
+      +---+---+
+      | 0 | 1 |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      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')]) }
+    end
+
+    test "with no rows renders" do
+      table([]).should == "0 rows in set"
+    end
+  end
+
+  context "table with" do
+    test "fields option renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | b | a |
+      +---+---+
+      | 2 | 1 |
+      | 4 | 3 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:b, :a]).should == expected_table
+    end
+
+    test "fields option and array only rows" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 0 | 2 |
+      +---+---+
+      | 1 | 3 |
+      +---+---+
+      1 row in set
+      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
+      +---+---+
+      | b | c |
+      +---+---+
+      | 2 |   |
+      | 4 |   |
+      +---+---+
+      2 rows in set
+  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
+      expected_table = <<-TABLE.unindent
+      +------------+---+
+      | a          | b |
+      +------------+---+
+      | AAAAAAA... | 2 |
+      +------------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10,:c=>10}).should == expected_table
+    end
+
+    test "field_lengths option and field_lengths less than 3 characters renders" do
+      expected_table = <<-TABLE.unindent
+      +----+---+
+      | a  | b |
+      +----+---+
+      | AA | 2 |
+      +----+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>2}).should == expected_table
+    end
+
+    test "field_lengths option renders" do
+      expected_table = <<-TABLE.unindent
+      +------------+---+
+      | a          | b |
+      +------------+---+
+      | AAAAAAA... | 2 |
+      +------------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10}).should == expected_table
+    end
+
+    test "max_width option renders" do
+      expected_table = <<-TABLE.unindent
+      +-----------+---+-----------+
+      | 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
+    end
+
+    test "max_width option nil renders full table" do
+      expected_table = <<-TABLE.unindent
+      +----------------------------------------------------+---+------------+
+      | a                                                  | b | c          |
+      +----------------------------------------------------+---+------------+
+      | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | 2 | CCCCCCCCCC |
+      +----------------------------------------------------+---+------------+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>nil).should == expected_table
+    end
+
+    test "global width renders" do
+      expected_table = <<-TABLE.unindent
+      +-----------+---+-----------+
+      | a         | b | c         |
+      +-----------+---+-----------+
+      | AAAAAA... | 2 | CCCCCC... |
+      +-----------+---+-----------+
+      1 row in set
+  TABLE
+      Hirb::View.load_config
+      Hirb::View.resize(30)
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}]).should == expected_table
+      reset_config
+    end
+
+    test "headers option and headers longer than fields renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---------+---------+
+      | a | field B | field C |
+      +---+---------+---------+
+      | A | 2       | C       |
+      +---+---------+---------+
+      1 row in set
+  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
+      expected_table = <<-TABLE.unindent
+      +-------+---+
+      | fi... | b |
+      +-------+---+
+      | A     | 2 |
+      +-------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A", :b=>2}], :headers=>{:a=>"field A"}, :field_lengths=>{:a=>5}).should == expected_table
+    end
+
+    test "headers option as an array renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | A | B |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      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, :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
+
+  context "activerecord table" do
+    before(:all) {
+      @pets = [stub(:name=>'rufus', :age=>7, :class=>mock(:column_names=>[:age, :name])), stub(:name=>'alf', :age=>101)]
+    }
+    test "renders" do
+      expected_table = <<-TABLE.unindent
+      +-----+-------+
+      | age | name  |
+      +-----+-------+
+      | 7   | rufus |
+      | 101 | alf   |
+      +-----+-------+
+      2 rows in set
+      TABLE
+      Hirb::Helpers::ActiveRecordTable.render(@pets).should == expected_table
+    end
+  end
+
+  context "auto table" do
+    test "converts nonarrays to arrays and renders" do
+      require 'set'
+      expected_table = <<-TABLE.unindent
+      +-------+
+      | value |
+      +-------+
+      | 1     |
+      | 2     |
+      | 3     |
+      +-------+
+      3 rows in set
+      TABLE
+      Hirb::Helpers::AutoTable.render(::Set.new([1,2,3])).should == expected_table
+    end
+  end
+
+  context "vertical table" do
+    test "should display vertically" do
+      require "set"
+      expected_table = <<-TABLE.unindent
+      *** 1. row ***
+      a: A
+      b: B
+      c: C
+      1 row in set
+      TABLE
+
+      table([{:a => "A", :b => "B", :c => "C"}], :vertical => true).should == expected_table
+    end
+  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 "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'}])
+    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