cldwalker-hirb 0.1.1 → 0.1.2

data/CHANGELOG.rdoc

@@ -1,3 +1,7 @@
+== 0.1.2
+* Added tree views.
+* Added output_method option to Hirb::View.render_output.
+
 == 0.1.1
 * Fixed bug when rendering table with many fields.
 

data/README.rdoc

@@ -3,15 +3,15 @@
 Hirb currently provides a mini view framework for console applications, designed with irb in mind.
 Given the output of a console application, it renders a view if there is one configured, based on
 the output's class. The framework encourages reusing views by letting you package them in classes
-and associate them with any number of output classes.  Hirb comes with table views (see
-Hirb::Helpers::Table) which work out of the box with any output class, especially Rails' model
-classes.
+and associate them with any number of output classes.  Hirb comes with tree views (see
+Hirb::Helpers::Tree) and table views (see Hirb::Helpers::Table). By default Hirb displays Rails'
+model classes as tables.
 
 == Install
 
 Install the gem with:
 
-    sudo gem install cldwalker-hirb -s http://gems.github.com
+    sudo gem install cldwalker-hirb --source http://gems.github.com
 
 == Rails Example
 
@@ -214,14 +214,15 @@ and colors to work nicely, please fork. To colorize your Hirb output:
 
 == Motivation
 Table code from http://gist.github.com/72234 and {my console
-app}[http://github.com/cldwalker/tag-tree].
+app's needs}[http://github.com/cldwalker/tag-tree].
 
 == Links
 * http://tagaholic.me/2009/03/13/hirb-irb-on-the-good-stuff.html
+* http://tagaholic.me/2009/03/18/ruby-class-trees-rails-plugin-trees-with-hirb.html
 
 == Todo
-* Create tree views.
-* Possibly add non-view irb goodies ie command manager.
 * Configurable max height, which if exceeded activates a pager.
+* Possibly add non-view irb goodies ie command manager.
+* Consider applying multiple views/filters to output.
 * Provides helper methods to all view classes.
 * Consider adding a template system as needed.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 1
+:patch: 2

data/lib/hirb/console.rb

@@ -9,7 +9,7 @@ module Hirb
     def table(output, options={})
       Hirb::View.console_render_output(output, options.merge(:class=>"Hirb::Helpers::AutoTable"))
     end
-    # Renders any specified view for the given object. Takes same options as Hirb::View.render_output.
+    # Renders any specified view for the given object. Takes same options as Hirb::View.console_render_output.
     def view(*args)
       Hirb::View.console_render_output(*args)
     end

data/lib/hirb/helpers/parent_child_tree.rb

@@ -0,0 +1,22 @@
+class Hirb::Helpers::ParentChildTree < Hirb::Helpers::Tree
+  class <<self
+    # Starting with the given node, this builds a tree by recursively calling a children method.
+    # Takes same options as Hirb::Helper::Table.render with some additional ones below.
+    # ==== Options:
+    # [:value_method] Method to call to display as a node's value. If not given, uses :name if node
+    #                 responds to :name or defaults to :object_id.
+    # [:children_method] Method to call to obtain a node's children. Default is :children.
+    def render(root_node, options={})
+      @value_method = options[:value_method] || (root_node.respond_to?(:name) ? :name : :object_id)
+      @children_method = options[:children_method] || :children
+      @nodes = []
+      build_node(root_node, 0)
+      super(@nodes, options)
+    end
+
+    def build_node(node, level) #:nodoc:
+      @nodes << {:value=>node.send(@value_method), :level=>level}
+      node.send(@children_method).each {|e| build_node(e, level + 1)}
+    end
+  end
+end

data/lib/hirb/helpers/tree.rb

@@ -0,0 +1,177 @@
+# Base tree class which given an array of nodes produces different types of trees.
+# The types of trees currently are:
+# * basic:
+#    0
+#      1
+#        2
+#        3
+#      4
+# 
+# * directory:
+#    0
+#    |-- 1
+#    |   |-- 2
+#    |   `-- 3
+#    `-- 4
+# 
+# * number:
+#    1. 0
+#      1. 1
+#        1. 2
+#        2. 3
+#      2. 4 
+# 
+# Tree nodes can be given as an array of arrays or an array of hashes.
+# To render the above basic tree with an array of hashes:
+#   Hirb::Helpers::Tree.render([{:value=>0, :level=>0}, {:value=>1, :level=>1}, {:value=>2, :level=>2}, 
+#     {:value=>3, :level=>2}, {:value=>4, :level=>1}])
+# Note from the hash keys that :level refers to the depth of the tree while :value refers to the text displayed
+# for a node.
+#
+# To render the above basic tree with an array of arrays:
+#   Hirb::Helpers::Tree.render([[0,0], [1,1], [2,2], [2,3], [1,4]])
+# Note that the each array pair consists of the level and the value for the node.
+class Hirb::Helpers::Tree
+  class ParentlessNodeError < StandardError; end
+
+  class <<self
+    # Main method which renders a tree.
+    # ==== Options:
+    # [:type] Type of tree. Either :basic, :directory or :number. Default is :basic.
+    # [:validate] Boolean to validate tree. Checks to see if all nodes have parents. Raises ParentlessNodeError if
+    #             an invalid node is found. Default is false.
+    # [:indent] Number of spaces to indent between levels for basic + number trees. Default is 4.
+    # [:limit] Limits the level or depth of a tree that is displayed. Root node is level 0.
+    # [:description] Displays brief description about tree ie how many nodes it has.
+    #  Examples:
+    #     Hirb::Helpers::Tree.render([[0, 'root'], [1, 'child']], :type=>:directory)
+    def render(nodes, options={})
+      new(nodes, options).render
+    end
+  end
+
+  # :stopdoc:
+  attr_accessor :nodes
+  
+  def initialize(input_nodes, options={})
+    @options = options
+    @type = options[:type] || :basic
+    if input_nodes[0].is_a?(Array)
+      @nodes = input_nodes.map {|e| Node.new(:level=>e[0], :value=>e[1]) }
+    else
+      @nodes = input_nodes.map {|e| Node.new(e)}
+    end
+    @nodes.each_with_index {|e,i| e.merge!(:tree=>self, :index=>i)}
+    @nodes.each {|e| e[:value] = e[:value].to_s }
+    validate_nodes if options[:validate]
+    self
+  end
+
+  def render
+    body = render_tree
+    body += render_description if @options[:description]
+    body
+  end
+  
+  def render_description
+    "\n\n#{@nodes.length} #{@nodes.length == 1 ? 'node' : 'nodes'} in tree"
+  end
+
+  def render_tree
+    @indent = ' ' * (@options[:indent] || 4 )
+    @nodes = @nodes.select {|e| e[:level] <= @options[:limit] } if @options[:limit]
+    case @type.to_s
+    when 'directory'
+      render_directory
+    when 'number'
+      render_number
+    else
+      render_basic
+    end
+  end
+
+  def render_directory
+    mark_last_nodes_per_level
+    new_nodes = []
+    @nodes.each_with_index {|e, i|
+      value = ''
+      unless e.root?
+        value << e.render_parent_characters
+        value << (e[:last_node] ? "`-- " : "|-- ")
+      end
+      value << e[:value]
+      new_nodes << value
+    }
+    new_nodes.join("\n")
+  end
+  
+  def render_number
+    counter = {}
+    @nodes.each {|e|
+      parent_level_key = "#{(e.parent ||{})[:index]}.#{e[:level]}"
+      counter[parent_level_key] ||= 0
+      counter[parent_level_key] += 1
+      e[:pre_value] = "#{counter[parent_level_key]}. "
+    }
+    @nodes.map {|e| @indent * e[:level] + e[:pre_value] + e[:value]}.join("\n")
+  end
+  
+  def render_basic
+    @nodes.map {|e| @indent * e[:level] + e[:value]}.join("\n")
+  end
+  
+  def validate_nodes
+    @nodes.each do |e|
+      raise ParentlessNodeError if (e[:level] > e.previous[:level]) && (e[:level] - e.previous[:level]) > 1
+    end
+  end
+  
+  # walks tree accumulating last nodes per unique parent+level
+  def mark_last_nodes_per_level
+    @nodes.each {|e| e.delete(:last_node)}
+    last_node_hash = @nodes.inject({}) {|h,e|
+      h["#{(e.parent ||{})[:index]}.#{e[:level]}"] = e; h
+    }
+    last_node_hash.values.uniq.each {|e| e[:last_node] = true}
+  end
+  #:startdoc:
+  class Node < ::Hash #:nodoc:
+    class MissingLevelError < StandardError; end
+    class MissingValueError < StandardError; end
+    
+    def initialize(hash)
+      super
+      raise MissingLevelError unless hash.has_key?(:level)
+      raise MissingValueError unless hash.has_key?(:value)
+      replace(hash)
+    end
+
+    def parent
+      self[:tree].nodes.slice(0 .. self[:index]).reverse.detect {|e| e[:level] < self[:level]}
+    end
+
+    def next
+      self[:tree].nodes[self[:index] + 1]
+    end
+
+    def previous
+      self[:tree].nodes[self[:index] - 1]
+    end
+
+    def root?; self[:level] == 0; end
+
+    # refers to characters which connect parent nodes 
+    def render_parent_characters
+      parent_chars = []
+      get_parents_character(parent_chars)
+      parent_chars.reverse.map {|level| level + ' ' * 3 }.to_s
+    end
+
+    def get_parents_character(parent_chars)
+      if self.parent
+        parent_chars << (self.parent[:last_node] ? ' ' : '|') unless self.parent.root?
+        self.parent.get_parents_character(parent_chars)
+      end
+    end
+  end
+end

data/lib/hirb/helpers.rb

@@ -2,6 +2,6 @@ module Hirb
   module Helpers #:nodoc:
   end
 end
-%w{table object_table active_record_table auto_table}.each do |e|
+%w{table object_table active_record_table auto_table tree parent_child_tree}.each do |e|
   require "hirb/helpers/#{e}"
 end

data/lib/hirb/util.rb

@@ -15,5 +15,15 @@ module Hirb
          nil
       end
     end
+    
+    # Recursively merge hash1 with hash2.
+    def recursive_hash_merge(hash1, hash2)
+      hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
+    end
+
+    # from Rails ActiveSupport
+    def camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
   end
 end

data/lib/hirb/view.rb

@@ -43,6 +43,7 @@ module Hirb
       # [:method] Specifies a global (Kernel) method to do the formatting.
       # [:class] Specifies a class to do the formatting, using its render() class method. The render() method's arguments are the output and 
       #          an options hash.
+      # [:output_method] Specifies a method to call on output before passing it to a formatter.
       # [:options] Options to pass the formatter method or class.
       def render_output(output, options={}, &block)
         if block && block.arity > 0
@@ -70,7 +71,7 @@ module Hirb
 
       # Config hash which maps classes to view hashes. View hashes are the same as the options hash of render_output().
       def output_config
-        @config[:output]
+        config[:output]
       end
 
       def output_config=(value)
@@ -83,20 +84,45 @@ module Hirb
         current_config = self.config.dup.merge(:output=>output_config)
         load_config(current_config)
       end
-
-      #:stopdoc:
-      def console_render_output(output, options={}, &block)
+      
+      # A console version of render_output which takes its same options but allows for some shortcuts.
+      # Examples:
+      #   console_render_output output, :tree, :type=>:directory
+      #   # is the same as:
+      #   render_output output, :class=>"Hirb::Helpers::Tree", :options=> {:type=>:directory}
+      #
+      def console_render_output(*args, &block)
+        load_config unless @config
+        output = args.shift
+        if args[0].is_a?(Symbol) && (view = args.shift)
+          symbol_options = find_view(view)
+        end
+        options = args[-1].is_a?(Hash) ? args[-1] : {}
+        options.merge!(symbol_options) if symbol_options
         # iterates over format_output options that aren't :options
-        real_options = [:method, :class].inject({}) do |h, e|
-          h[e] = options.delete(e) if options[e]
-          h
+        real_options = [:method, :class, :output_method].inject({}) do |h, e|
+          h[e] = options.delete(e) if options[e]; h
         end
         render_output(output, real_options.merge(:options=>options), &block)
       end
 
+      #:stopdoc:
+      def find_view(name)
+        name = name.to_s
+        if (view_method = output_config.values.find {|e| e[:method] == name })
+          {:method=>view_method[:method]}
+        elsif (view_class = Hirb::Helpers.constants.find {|e| e == Util.camelize(name)})
+          {:class=>"Hirb::Helpers::#{view_class}"}
+        else
+          {}
+        end
+      end
+
       def format_output(output, options={})
         output_class = determine_output_class(output)
-        options = output_class_options(output_class).merge(options)
+        options = Util.recursive_hash_merge(output_class_options(output_class), options)
+        output = options[:output_method] ? (output.is_a?(Array) ? output.map {|e| e.send(options[:output_method])} : 
+          output.send(options[:output_method]) ) : output
         args = [output]
         args << options[:options] if options[:options] && !options[:options].empty?
         if options[:method]
@@ -115,11 +141,8 @@ module Hirb
         end
       end
 
-      # Loads config
       def load_config(additional_config={})
-        new_config = default_config
-        new_config[:output].merge!(additional_config.delete(:output) || {})
-        self.config = new_config.merge(additional_config)
+        self.config = Util.recursive_hash_merge default_config, additional_config
         true
       end
 
@@ -155,9 +178,7 @@ module Hirb
       end
 
       def default_config
-        conf = Hirb.config[:view] || {}
-        conf[:output] = default_output_config.merge(conf[:output] || {})
-        conf
+        Hirb::Util.recursive_hash_merge({:output=>default_output_config}, Hirb.config[:view] || {} )
       end
 
       def default_output_config

data/test/test_helper.rb

@@ -10,7 +10,8 @@ class Test::Unit::TestCase
 end
 
 class String
-  def unindent
-    gsub(/^\s*/, '').chomp
+  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

data/test/util_test.rb

@@ -12,4 +12,10 @@ class Hirb::UtilTest < Test::Unit::TestCase
   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
+  end
 end

data/test/view_test.rb

@@ -140,6 +140,18 @@ class Hirb::ViewTest < Test::Unit::TestCase
       Hirb::View.render_output('dude', :class=>"Commify")
     end
     
+    test "formats with output_method option" do
+      set_config 'String'=>{:class=>"Blahify"}
+      Hirb::View.render_method.expects(:call).with('d,u,d')
+      Hirb::View.render_output('dude', :class=>"Commify", :output_method=>:chop)
+    end
+
+    test "formats output array with output_method option" do
+      set_config 'String'=>{:class=>"Blahify"}
+      Hirb::View.render_method.expects(:call).with("d,u,d\nm,a")
+      Hirb::View.render_output(['dude', 'man'], :class=>"Commify", :output_method=>:chop)
+    end
+
     test "formats with block" do
       Hirb::View.load_config
       Hirb::View.render_method.expects(:call).with('=dude=')
@@ -147,5 +159,11 @@ class Hirb::ViewTest < Test::Unit::TestCase
         "=#{output}="
       }
     end
+    
+    test "console_render_output merge options option" do
+      set_config "String"=>{:class=>"Commify", :options=>{:fields=>%w{f1 f2}}}
+      Commify.expects(:render).with('dude', :max_width=>10, :fields=>%w{f1 f2})
+      Hirb::View.render_output('dude', :options=>{:max_width=>10})
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-hirb
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-15 00:00:00 -07:00
+date: 2009-03-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -35,7 +35,9 @@ files:
 - lib/hirb/helpers/active_record_table.rb
 - lib/hirb/helpers/auto_table.rb
 - lib/hirb/helpers/object_table.rb
+- lib/hirb/helpers/parent_child_tree.rb
 - lib/hirb/helpers/table.rb
+- lib/hirb/helpers/tree.rb
 - lib/hirb/helpers.rb
 - lib/hirb/import_object.rb
 - lib/hirb/util.rb
@@ -47,6 +49,7 @@ files:
 - test/import_test.rb
 - test/table_test.rb
 - test/test_helper.rb
+- test/tree_test.rb
 - test/util_test.rb
 - test/view_test.rb
 has_rdoc: true