hirb 0.1.2

data/lib/hirb/views/activerecord_base.rb

@@ -0,0 +1,9 @@
+class Hirb::Views::ActiveRecord_Base #:nodoc:
+  def self.default_options
+    {:ancestor=>true}
+  end
+  
+  def self.render(*args)
+    Hirb::Helpers::ActiveRecordTable.render(*args)
+  end
+end

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/table_test.rb

@@ -0,0 +1,263 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::TableTest < Test::Unit::TestCase
+  def table(*args)
+    Hirb::Helpers::Table.render(*args)
+  end
+  
+  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 "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          |
+      +--------------------------+---+------------+
+      | AAAAAAAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
+      +--------------------------+---+------------+
+      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 max_width renders" do
+      expected_table = <<-TABLE.unindent
+      +--------------------------+---+------------+
+      | a                        | b | c          |
+      +--------------------------+---+------------+
+      | AAAAAAAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
+      +--------------------------+---+------------+
+      1 row in set
+  TABLE
+      Hirb::Helpers::Table.max_width = 30
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}]).should == expected_table
+      Hirb::Helpers::Table.max_width = Hirb::Helpers::Table::DEFAULT_MAX_WIDTH
+    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 "with 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
+    
+  end
+  
+  context "object table" do
+    before(:all) {
+      @pets = [stub(:name=>'rufus', :age=>7), stub(:name=>'alf', :age=>101)]
+    }
+    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 fields raises ArgumentError" do
+      assert_raises(ArgumentError) { Hirb::Helpers::ObjectTable.render(@pets) }
+    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
+      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
+  
+  test "restrict_field_lengths handles many fields" do
+    @table = Hirb::Helpers::Table.new([{:field1=>'f1', :field2=>'f2', :field3=>'f3'}])
+    @table.restrict_field_lengths({:field1=>10, :field2=>15, :field3=>100}, 10)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'test/unit'
+require 'context' #gem install jeremymcanally-context -s http://gems.github.com
+require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
+require 'mocha'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'hirb'
+
+class Test::Unit::TestCase
+end
+
+class String
+  def unindent(num=nil)
+    regex = num ? /^\s{#{num}}/ : /^\s*/
+    gsub(regex, '').chomp
+  end
+end

data/test/tree_test.rb

@@ -0,0 +1,167 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::TreeTest < Test::Unit::TestCase
+  def tree(*args)
+    Hirb::Helpers::Tree.render(*args)
+  end
+  
+  context "basic tree" do
+    test "with hash nodes renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+          1.1
+              2.2
+              3.2
+          4.1
+      TREE
+      tree([{:level=>0, :value=>'0.0'}, {:level=>1, :value=>'1.1'}, {:level=>2, :value=>'2.2'},{:level=>2, :value=>'3.2'},
+         {:level=>1, :value=>'4.1'}]).should == expected_tree
+    end
+  
+    test "with array nodes renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+          1.1
+              2.2
+              3.2
+          4.1
+      TREE
+      tree([[0, "0.0"], [1, "1.1"], [2, "2.2"], [2, "3.2"], [1, "4.1"]]).should == expected_tree
+    end
+    
+    test "with non-string values renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+          1.1
+              2.2
+              3.2
+          4.1
+      TREE
+      tree([[0,0.0],[1,1.1],[2,2.2],[2,3.2],[1,4.1]]).should == expected_tree
+    end
+
+    test "with indent option renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+        1.1
+          2.2
+          3.2
+        4.1
+      TREE
+      tree([[0, "0.0"], [1, "1.1"], [2, "2.2"], [2, "3.2"], [1, "4.1"]], :indent=>2).should == expected_tree
+    end
+
+    test "with limit option renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+          1.1
+          4.1
+      TREE
+      tree([[0, "0.0"], [1, "1.1"], [2, "2.2"], [2, "3.2"], [1, "4.1"]], :limit=>1).should == expected_tree
+    end
+
+    test "with description option renders" do
+      expected_tree = <<-TREE.unindent(6)
+      0.0
+          1.1
+              2.2
+              3.2
+          4.1
+      
+      5 nodes in tree
+      TREE
+      tree([[0, "0.0"], [1, "1.1"], [2, "2.2"], [2, "3.2"], [1, "4.1"]], :description=>true).should == expected_tree
+    end
+
+    test "with type directory renders" do
+      expected_tree = <<-TREE.unindent
+      0.0
+      |-- 1.1
+      |   |-- 2.2
+      |   `-- 3.2
+      `-- 4.1
+      TREE
+      tree([[0, "0.0"], [1, "1.1"], [2, "2.2"], [2, "3.2"], [1, "4.1"]], :type=>:directory).should == expected_tree
+    end
+
+    test "with type directory and multiple children per level renders" do
+      expected_tree = <<-TREE.unindent
+      0.0
+      |-- 1.1
+      |   |-- 2.2
+      |   |   `-- 3.3
+      |   `-- 4.2
+      |       `-- 5.3
+      `-- 6.1
+      TREE
+      tree([[0,'0.0'], [1,'1.1'], [2,'2.2'],[3,'3.3'],[2,'4.2'],[3,'5.3'],[1,'6.1']], :type=>:directory).should == expected_tree
+    end
+
+    test "with type number renders" do
+      expected_tree = <<-TREE.unindent(6)
+      1. 0
+          1. 1
+              1. 2
+              2. 3
+          2. 4 
+      TREE
+      tree([[0,'0'],[1,'1'],[2,'2'],[2,'3'],[1,'4']], :type=>:number)
+    end
+  end
+
+  def mock_node(value, value_method)
+    children = []
+    value,children = *value if value.is_a?(Array)
+    mock(value_method=>value, :children=>children.map {|e| mock_node(e, value_method)})
+  end
+
+  context "parent_child_tree" do
+    test "with name value renders" do
+      expected_tree = <<-TREE.unindent
+      0.0
+      |-- 1.1
+      |-- 2.1
+      |   `-- 3.2
+      `-- 4.1
+      TREE
+      root = mock_node(['0.0', ['1.1', ['2.1', '3.2'], '4.1']], :name)
+      Hirb::Helpers::ParentChildTree.render(root, :type=>:directory).should == expected_tree
+    end
+    
+    test "with object_id value renders" do
+      expected_tree = <<-TREE.unindent
+      0.0
+      |-- 1.1
+      |-- 2.1
+      |   `-- 3.2
+      `-- 4.1
+      TREE
+      root = mock_node(['0.0', ['1.1', ['2.1', '3.2'], '4.1']], :object_id)
+      Hirb::Helpers::ParentChildTree.render(root, :type=>:directory).should == expected_tree
+    end
+
+    test "with value_method option renders" do
+      expected_tree = <<-TREE.unindent
+      0.0
+      |-- 1.1
+      |-- 2.1
+      |   `-- 3.2
+      `-- 4.1
+      TREE
+      root = mock_node(['0.0', ['1.1', ['2.1', '3.2'], '4.1']], :blah)
+      Hirb::Helpers::ParentChildTree.render(root, :type=>:directory, :value_method=>:blah).should == expected_tree
+    end
+  end
+
+  test "tree with parentless nodes renders ParentlessNodeError" do
+    assert_raises(Hirb::Helpers::Tree::ParentlessNodeError) { tree([[0, "0.0"], [2, '1.2']], :validate=>true) }
+  end
+  
+  test "tree with hash nodes missing level raises MissingLevelError" do
+    assert_raises(Hirb::Helpers::Tree::Node::MissingLevelError) { tree([{:value=>'ok'}]) }
+  end
+
+  test "tree with hash nodes missing level raises MissingValueError" do
+    assert_raises(Hirb::Helpers::Tree::Node::MissingValueError) { tree([{:level=>0}]) }
+  end
+end