hirb 0.1.2 → 0.2.2

data/lib/hirb/view.rb

@@ -1,195 +1,171 @@
 module Hirb
-  # This class contains one method, render_output, which formats and renders the output its given from a console application.
-  # However, this only happens for output classes that are configured to do so or if render_output is explicitly given
-  # a view formatter. The hash with the following keys are valid for Hirb::View.config as well as the :view key mentioned in Hirb:
-  # [:output] This hash is saved to output_config. It maps output classes to hashes that are passed to render_output. Thus these hashes
-  #           take the same options as render_output. In addition it takes the following keys:
-  #           * :ancestor- Boolean which if true allows all subclasses of the configured output class to inherit this config.
-  # 
-  #           Example: {'String'=>{:class=>'Hirb::Helpers::Table', :ancestor=>true, :options=>{:max_width=>180}}}
+  # This class is responsible for managing all view-related functionality. Its functionality is determined by setting up a configuration file
+  # as explained in Hirb and/or passed configuration directly to Hirb.enable. Most of the functionality in this class is dormant until enabled.
   module View
+    DEFAULT_WIDTH = 120
+    DEFAULT_HEIGHT = 40
     class<<self
-      attr_accessor :config, :render_method
+      attr_accessor :render_method
+      attr_reader :config
 
-      # Overrides irb's output method with Hirb::View.render_output. Takes an optional
-      # block which sets the view config.
+      # This activates view functionality i.e. the formatter, pager and size detection. If irb exists, it overrides irb's output
+      # method with Hirb::View.view_output. If using Wirble, you should call this after it. The view configuration
+      # can be specified in a hash via a config file, as options to this method, as this method's block or any combination of these three.
+      # In addition to the config keys mentioned in Hirb, the options also take the following keys:
+      # Options:
+      # * config_file: Name of config file to read.
       # Examples:
-      #   Hirb.enable
-      #   Hirb.enable {|c| c.output = {'String'=>{:class=>'Hirb::Helpers::Table'}} }
-      def enable(&block)
+      #   Hirb::View.enable
+      #   Hirb::View.enable :formatter=>false
+      #   Hirb::View.enable {|c| c.output = {'String'=>{:class=>'Hirb::Helpers::Table'}} }
+      def enable(options={}, &block)
         return puts("Already enabled.") if @enabled
         @enabled = true
-        load_config(Hirb::HashStruct.block_to_hash(block))
-        ::IRB::Irb.class_eval do
-          alias :non_hirb_render_output  :output_value
-          def output_value #:nodoc:
-            Hirb::View.render_output(@context.last_value) || non_hirb_render_output
+        Hirb.config_file = options.delete(:config_file) if options[:config_file]
+        load_config(Util.recursive_hash_merge(options, HashStruct.block_to_hash(block)))
+        resize(config[:width], config[:height])
+        if Object.const_defined?(:IRB)
+          ::IRB::Irb.class_eval do
+            alias :non_hirb_view_output  :output_value
+            def output_value #:nodoc:
+              Hirb::View.view_output(@context.last_value) || Hirb::View.page_output(@context.last_value.inspect, true) ||
+                non_hirb_view_output
+            end
           end
         end
       end
-      
-      # Disable's Hirb's output by reverting back to irb's.
+
+      # Indicates if Hirb::View is enabled.
+      def enabled?
+        @enabled || false
+      end
+
+      # Disable's Hirb's output and revert's irb's output method if irb exists.
       def disable
         @enabled = false
-        ::IRB::Irb.class_eval do
-          alias :output_value :non_hirb_render_output
+        if Object.const_defined?(:IRB)
+          ::IRB::Irb.class_eval do
+            alias :output_value :non_hirb_view_output
+          end
         end
       end
+
+      # Toggles pager on or off. The pager only works while Hirb::View is enabled.
+      def toggle_pager
+        config[:pager] = !config[:pager]
+      end
+
+      # Toggles formatter on or off.
+      def toggle_formatter
+        config[:formatter] = !config[:formatter]
+      end
+
+      # Resizes the console width and height for use with the table and pager i.e. after having resized the console window. *nix users
+      # should only have to call this method. Non-*nix users should call this method with explicit width and height. If you don't know
+      # your width and height, in irb play with "a"* width to find width and puts "a\n" * height to find height.
+      def resize(width=nil, height=nil)
+        config[:width], config[:height] = determine_terminal_size(width, height)
+        pager.resize(config[:width], config[:height])
+      end
       
-      # This is the main method of this class. This method searches for the first formatter it can apply
-      # to the object in this order: local block, method option, class option. If a formatter is found it applies it to the object
-      # and returns true. Returns false if no formatter found.
-      # ==== Options:
-      # [: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
-          formatted_output = block.call(output)
-          render_method.call(formatted_output)
-          true
-        elsif (formatted_output = format_output(output, options))
-          render_method.call(formatted_output)
-          true
-        else
-          false
-        end
+      # This is the main method of this class. When view is enabled, this method searches for a formatter it can use for the output and if
+      # successful renders it using render_method(). The options this method takes are helper config hashes as described in 
+      # Hirb::Formatter.format_output(). Returns true if successful and false if no formatting is done or if not enabled.
+      def view_output(output, options={})
+        enabled? && config[:formatter] && render_output(output, options)
+      end
+
+      # Captures STDOUT and renders it using render_method(). The main use case is to conditionally page captured stdout.
+      def capture_and_render(&block)
+        render_method.call Util.capture_stdout(&block)
       end
 
       # A lambda or proc which handles the final formatted object.
-      # Although this puts the object by default, it could be set to do other things
-      # ie write the formatted object to a file.
+      # Although this pages/puts the object by default, it could be set to do other things
+      # i.e. write the formatted object to a file.
       def render_method
         @render_method ||= default_render_method
       end
 
+      # Resets render_method back to its default.
       def reset_render_method
         @render_method = default_render_method
       end
-
-      # 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]
+      
+      # Current console width
+      def width
+        config ? config[:width] : DEFAULT_WIDTH
       end
 
-      def output_config=(value)
-        @config[:output] = value
+      # Current console height
+      def height
+        config ? config[:height] : DEFAULT_HEIGHT
       end
-      
-      # Needs to be called for config changes to take effect. Reloads Hirb::Views classes and registers
-      # most recent config changes.
-      def reload_config
-        current_config = self.config.dup.merge(:output=>output_config)
-        load_config(current_config)
+
+      # Current formatter config
+      def formatter_config
+        formatter.config
       end
-      
-      # 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, :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)
+
+      # Sets the helper config for the given output class.
+      def format_class(klass, helper_config)
+        formatter.format_class(klass, helper_config)
       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}"}
+      def render_output(output, options={})
+        if (formatted_output = formatter.format_output(output, options))
+          render_method.call(formatted_output)
+          true
         else
-          {}
+          false
         end
       end
 
-      def format_output(output, options={})
-        output_class = determine_output_class(output)
-        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]
-          new_output = send(options[:method],*args)
-        elsif options[:class] && (view_class = Util.any_const_get(options[:class]))
-          new_output = view_class.render(*args)
-        end
-        new_output
+      def determine_terminal_size(width, height)
+        detected  = (width.nil? || height.nil?) ? Util.detect_terminal_size || [] : []
+        [width || detected[0] || DEFAULT_WIDTH , height || detected[1] || DEFAULT_HEIGHT]
       end
 
-      def determine_output_class(output)
-        if output.is_a?(Array)
-          output[0].class
+      def page_output(output, inspect_mode=false)
+        if enabled? && config[:pager] && pager.activated_by?(output, inspect_mode)
+          pager.page(output, inspect_mode)
+          true
         else
-          output.class
+          false
         end
       end
 
-      def load_config(additional_config={})
-        self.config = Util.recursive_hash_merge default_config, additional_config
-        true
+      def pager
+        @pager ||= Pager.new(config[:width], config[:height], :pager_command=>config[:pager_command])
       end
 
-      # Stores all view config. Current valid keys:
-      #   :output- contains value of output_config
-      def config=(value)
-        reset_cached_output_config
-        @config = value
+      def pager=(value); @pager = value; end
+
+      def formatter(reload=false)
+        @formatter = reload || @formatter.nil? ? Formatter.new(config[:output]) : @formatter
       end
-      
-      def reset_cached_output_config
-        @cached_output_config = nil
+
+      def formatter=(value); @formatter = value; end
+
+      def load_config(additional_config={})
+        @config = Util.recursive_hash_merge default_config, additional_config
+        formatter(true)
+        true
       end
-      
-      # Internal view options built from user-defined ones. Options are built by recursively merging options from oldest
-      # ancestors to the most recent ones.
-      def output_class_options(output_class)
-        @cached_output_config ||= {}
-        @cached_output_config[output_class] ||= 
-          begin
-            output_ancestors_with_config = output_class.ancestors.map {|e| e.to_s}.select {|e| output_config.has_key?(e)}
-            @cached_output_config[output_class] = output_ancestors_with_config.reverse.inject({}) {|h, klass|
-              (klass == output_class.to_s || output_config[klass][:ancestor]) ? h.update(output_config[klass]) : h
-            }
-          end
-        @cached_output_config[output_class]
+
+      def config_loaded?; !!@config; end
+
+      def config
+        @config
       end
       
-      def cached_output_config; @cached_output_config; end
-
       def default_render_method
-        lambda {|output| puts output}
+        lambda {|output| page_output(output) || puts(output) }
       end
 
       def default_config
-        Hirb::Util.recursive_hash_merge({:output=>default_output_config}, Hirb.config[:view] || {} )
-      end
-
-      def default_output_config
-        Hirb::Views.constants.inject({}) {|h,e|
-          output_class = e.to_s.gsub("_", "::")
-          if (views_class = Hirb::Views.const_get(e)) && views_class.respond_to?(:render)
-            default_options = views_class.respond_to?(:default_options) ? views_class.default_options : {}
-            h[output_class] = default_options.merge({:class=>"Hirb::Views::#{e}"})
-          end
-          h
-        }
+        Util.recursive_hash_merge({:pager=>true, :formatter=>true}, Hirb.config || {})
       end
       #:startdoc:
     end

data/test/active_record_table_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::ActiveRecordTableTest < Test::Unit::TestCase
+  context "activerecord table" do
+    test "with no select renders" do
+      expected_table = <<-TABLE.unindent
+      +-----+-------+
+      | age | name  |
+      +-----+-------+
+      | 7   | rufus |
+      | 101 | alf   |
+      +-----+-------+
+      2 rows in set
+      TABLE
+      @pets = [stub(:name=>'rufus', :age=>7, :attributes=>{"name"=>'rufus', 'age'=>7}, :class=>stub(:column_names=>%w{age name})),
+        stub(:name=>'alf', :age=>101)]
+      Hirb::Helpers::ActiveRecordTable.render(@pets).should == expected_table
+    end
+
+    test "with select renders" do
+      expected_table = <<-TABLE.unindent
+      +-------+
+      | name  |
+      +-------+
+      | rufus |
+      | alf   |
+      +-------+
+      2 rows in set
+      TABLE
+      @pets = [stub(:name=>'rufus', :age=>7, :attributes=>{'name'=>'rufus'}, :class=>stub(:column_names=>%w{age name})),
+        stub(:name=>'alf', :age=>101)]
+      Hirb::Helpers::ActiveRecordTable.render(@pets).should == expected_table
+    end
+  end
+end

data/test/auto_table_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::AutoTableTest < Test::Unit::TestCase
+  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
+end

data/test/console_test.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::ConsoleTest < Test::Unit::TestCase
+  context "parse_input" do
+    test "config is set if it wasn't before" do
+      reset_config
+      Hirb::View.expects(:render_output)
+      Hirb::Console.render_output('blah')
+      Hirb::View.config.is_a?(Hash).should == true
+    end
+  end
+end

data/test/formatter_test.rb

@@ -0,0 +1,172 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Hirb
+class FormatterTest < Test::Unit::TestCase
+  context "formatter" do
+    def set_formatter(hash={})
+      @formatter = Formatter.new(hash)
+    end
+
+    before(:all) { eval "module ::Dooda; end" }
+
+    test "klass_config merges ancestor options" do
+      set_formatter "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output, :ancestor=>true}, "Kernel"=>{:method=>:default_output}
+      expected_result = {:method=>:object_output, :args=>[1, 2], :ancestor=>true}
+      @formatter.klass_config(String).should == expected_result
+    end
+
+    test "klass_config doesn't merge ancestor options" do
+      set_formatter "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output}, "Kernel"=>{:method=>:default_output}
+      expected_result = {:args=>[1, 2]}
+      @formatter.klass_config(String).should == expected_result
+    end
+
+    test "klass_config returns hash when nothing found" do
+      set_formatter.klass_config(String).should == {}
+    end
+
+    test "reload detects new Hirb::Views" do
+      set_formatter
+      @formatter.config.keys.include?('Zzz').should be(false)
+      eval "module ::Hirb::Views::Zzz; def self.render; end; end"
+      @formatter.reload
+      @formatter.config.keys.include?('Zzz').should be(true)
+    end
+
+    test "format_class sets formatter config" do
+      set_formatter
+      @formatter.format_class ::Dooda, :class=>"DoodaView"
+      @formatter.klass_config(::Dooda).should == {:class=>"DoodaView"}
+    end
+
+    test "format_class overwrites existing formatter config" do
+      set_formatter "Dooda"=>{:class=>"DoodaView"}
+      @formatter.format_class ::Dooda, :class=>"DoodaView2"
+      @formatter.klass_config(::Dooda).should == {:class=>"DoodaView2"}
+    end
+
+    test "parse_console_options passes all options except for formatter options into :options" do
+      set_formatter
+      options = {:class=>'blah', :method=>'blah', :output_method=>'blah', :blah=>'blah'}
+      expected_options = {:class=>'blah', :method=>'blah', :output_method=>'blah', :options=>{:blah=>'blah'}}
+      @formatter.parse_console_options(options).should == expected_options
+    end
+  end
+
+  context "enable" do
+    before(:each) { View.formatter = nil; reset_config }
+    after(:each) { Hirb.disable }
+
+    def formatter_config
+      View.formatter.config
+    end
+    
+    test "sets default formatter config" do
+      eval "module ::Hirb::Views::Something_Base; def self.render; end; end"
+      Hirb.enable
+      formatter_config["Something::Base"].should == {:class=>"Hirb::Views::Something_Base"}
+    end
+  
+    test "sets default formatter config with default_options" do
+      eval "module ::Hirb::Views::Blah; def self.render; end; def self.default_options; {:ancestor=>true}; end; end"
+      Hirb.enable
+      formatter_config["Blah"].should == {:class=>"Hirb::Views::Blah", :ancestor=>true}
+    end
+  
+    test "with block sets formatter config" do
+      class_hash = {"Something::Base"=>{:class=>"BlahBlah"}}
+      Hirb.enable {|c| c.output = class_hash }
+      formatter_config['Something::Base'].should == class_hash['Something::Base']
+    end
+  end
+
+  context "format_output" do
+    def view_output(*args, &block); View.view_output(*args, &block); end
+    def render_method(*args); View.render_method(*args); end
+
+    def enable_with_output(value)
+      Hirb.enable :output=>value
+    end
+
+    before(:all) { 
+      eval %[module ::Commify
+        def self.render(strings)
+          strings = [strings] unless strings.is_a?(Array)
+          strings.map {|e| e.split('').join(',')}.join("\n")
+        end
+      end]
+      reset_config
+    }
+    before(:each) { View.formatter = nil; reset_config }
+    after(:each) { Hirb.disable }
+    
+    test "formats with method option" do
+      eval "module ::Kernel; def commify(string); string.split('').join(','); end; end"
+      enable_with_output "String"=>{:method=>:commify}
+      render_method.expects(:call).with('d,u,d,e')
+      view_output('dude')
+    end
+    
+    test "formats with class option" do
+      enable_with_output "String"=>{:class=>"Commify"}
+      render_method.expects(:call).with('d,u,d,e')
+      view_output('dude')
+    end
+    
+    test "formats with class option as symbol" do
+      enable_with_output "String"=>{:class=>:auto_table}
+      Helpers::AutoTable.expects(:render)
+      view_output('dude')
+    end
+
+    test "formats output array" do
+      enable_with_output "String"=>{:class=>"Commify"}
+      render_method.expects(:call).with('d,u,d,e')
+      view_output(['dude'])
+    end
+    
+    test "formats with options option" do
+      eval "module ::Blahify; def self.render(*args); end; end"
+      enable_with_output "String"=>{:class=>"Blahify", :options=>{:fields=>%w{a b}}}
+      Blahify.expects(:render).with('dude', :fields=>%w{a b})
+      view_output('dude')
+    end
+    
+    test "doesn't format and returns false when no format method found" do
+      Hirb.enable
+      render_method.expects(:call).never
+      view_output(Date.today).should == false
+    end
+    
+    test "formats with output_method option as method" do
+      enable_with_output 'String'=>{:class=>"Commify", :output_method=>:chop}
+      render_method.expects(:call).with('d,u,d')
+      view_output('dude')
+    end
+
+    test "formats with output_method option as proc" do
+      enable_with_output 'String'=>{:class=>"Commify", :output_method=>lambda {|e| e.chop}}
+      render_method.expects(:call).with('d,u,d')
+      view_output('dude')
+    end
+
+    test "formats output array with output_method option" do
+      enable_with_output 'String'=>{:class=>"Commify", :output_method=>:chop}
+      render_method.expects(:call).with("d,u,d\nm,a")
+      view_output(['dude', 'man'])
+    end
+
+    test "formats with explicit class option" do
+      enable_with_output 'String'=>{:class=>"Blahify"}
+      render_method.expects(:call).with('d,u,d,e')
+      view_output('dude', :class=>"Commify")
+    end
+    
+    test "formats with explicit options option merges with existing options" do
+      enable_with_output "String"=>{:class=>"Commify", :options=>{:fields=>%w{f1 f2}}}
+      Commify.expects(:render).with('dude', :max_width=>10, :fields=>%w{f1 f2})
+      view_output('dude', :options=>{:max_width=>10})
+    end
+  end
+end
+end