Chrononaut-hirb 0.2.1

data/lib/hirb/import_object.rb

@@ -0,0 +1,10 @@
+module Hirb
+  module ObjectMethods
+    # Takes same options as Hirb::View.render_output.
+    def view(*args)
+      Hirb::View.console_render_output(*(args.unshift(self)))
+    end
+  end
+end
+
+Object.send :include, Hirb::ObjectMethods

data/lib/hirb/menu.rb

@@ -0,0 +1,47 @@
+module Hirb
+  # This class provides a selection menu using Hirb's table helpers by default to display choices.
+  class Menu
+    # Menu which asks to select from the given array and returns the selected menu items as an array. See Hirb::Util.choose_from_array
+    # for the syntax for specifying selections. All options except for the ones below are passed to render the menu.
+    #
+    # ==== Options:
+    # [:helper_class]  Helper class to render menu. Helper class is expected to implement numbering given a :number option.
+    #                  To use a very basic menu, set this to false. Defaults to Hirb::Helpers::AutoTable.
+    # [:prompt]  String for menu prompt. Defaults to "Choose: ".
+    # [:validate_one] Validates that only one item in array is chosen and returns just that item. Default is false.
+    # [:ask] Always ask for input, even if there is only one choice. Default is true.
+    # Examples:
+    #     extend Hirb::Console
+    #     menu([1,2,3], :fields=>[:field1, :field2], :validate_one=>true)
+    #     menu([1,2,3], :helper_class=>Hirb::Helpers::Table)
+    def self.render(output, options={})
+      default_options = {:helper_class=>Hirb::Helpers::AutoTable, :prompt=>"Choose #{options[:validate_one] ? 'one' : ''}: ", :ask=>true}
+      options = default_options.merge(options)
+      output = [output] unless output.is_a?(Array)
+      chosen = choose_from_menu(output, options)
+      yield(chosen) if block_given? && chosen.is_a?(Array) && chosen.size > 0
+      chosen
+    end
+
+    def self.choose_from_menu(output, options) #:nodoc:
+      return output if output.size == 1 && !options[:ask]
+      if (helper_class = Util.any_const_get(options[:helper_class]))
+        View.render_output(output, :class=>options[:helper_class], :options=>options.merge(:number=>true))
+      else
+        output.each_with_index {|e,i| puts "#{i+1}: #{e}" }
+      end
+      print options[:prompt]
+      input = $stdin.gets.chomp.strip
+      chosen = Util.choose_from_array(output, input)
+      if options[:validate_one]
+        if chosen.size != 1
+          $stderr.puts "Choose one. You chose #{chosen.size} items."
+          return nil
+        else
+          return chosen[0]
+        end
+      end
+      chosen
+    end
+  end
+end

data/lib/hirb/pager.rb

@@ -0,0 +1,94 @@
+module Hirb
+  # This class provides class methods for paging and an object which can conditionally page given a terminal size that is exceeded.
+  class Pager
+    class<<self
+      # Pages using a configured or detected shell command.
+      def command_pager(output, options={})
+        basic_pager(output) if valid_pager_command?(options[:pager_command])
+      end
+
+      def pager_command(*commands) #:nodoc:
+        @pager_command = (!@pager_command.nil? && commands.empty?) ? @pager_command : 
+          begin
+            commands = [ENV['PAGER'], 'less', 'more', 'pager'] if commands.empty?
+            commands.compact.uniq.find {|e| Util.command_exists?(e[/\w+/]) }
+          end
+      end
+
+      # Pages with a ruby-only pager which either pages or quits.
+      def default_pager(output, options={})
+        pager = new(options[:width], options[:height])
+        while pager.activated_by?(output, options[:inspect])
+          puts pager.slice!(output, options[:inspect])
+          return unless continue_paging?
+        end
+        puts output
+        puts "=== Pager finished. ==="
+      end
+
+      #:stopdoc:
+      def valid_pager_command?(cmd)
+        cmd ? pager_command(cmd) : pager_command
+      end
+
+      private
+      def basic_pager(output)
+        pager = IO.popen(pager_command, "w")
+        begin
+          save_stdout = STDOUT.clone
+          STDOUT.reopen(pager)
+          STDOUT.puts output
+        ensure
+         STDOUT.reopen(save_stdout)
+         save_stdout.close
+         pager.close
+        end
+      end
+
+      def continue_paging?
+        puts "=== Press enter/return to continue or q to quit: ==="
+        !$stdin.gets.chomp[/q/i]
+      end
+      #:startdoc:
+    end
+
+    attr_reader :width, :height
+
+    def initialize(width, height, options={})
+      resize(width, height)
+      @pager_command = options[:pager_command] if options[:pager_command]
+    end
+
+    # Pages given string using configured pager.
+    def page(string, inspect_mode)
+      if self.class.valid_pager_command?(@pager_command)
+        self.class.command_pager(string, :pager_command=>@pager_command)
+      else
+        self.class.default_pager(string, :width=>@width, :height=>@height, :inspect=>inspect_mode)
+      end
+    end
+
+    def slice!(output, inspect_mode=false) #:nodoc:
+      effective_height = @height - 2 # takes into account pager prompt
+      if inspect_mode
+        sliced_output = output.slice(0, @width * effective_height)
+        output.replace output.slice(@width * effective_height..-1)
+        sliced_output
+      else
+        # could use output.scan(/[^\n]*\n?/) instead of split
+        sliced_output = output.split("\n").slice(0, effective_height).join("\n")
+        output.replace output.split("\n").slice(effective_height..-1).join("\n")
+        sliced_output
+      end
+    end
+
+    # Determines if string should be paged based on configured width and height.
+    def activated_by?(string_to_page, inspect_mode=false)
+      inspect_mode ? (string_to_page.size > @height * @width) : (string_to_page.count("\n") > @height)
+    end
+
+    def resize(width, height) #:nodoc:
+      @width, @height = Hirb::View.determine_terminal_size(width, height)
+    end
+  end
+end

data/lib/hirb/util.rb

@@ -0,0 +1,80 @@
+module Hirb
+  # Group of handy utility functions used throughout Hirb.
+  module Util
+    extend self
+    # Returns a constant like Module#const_get no matter what namespace it's nested in.
+    # Returns nil if the constant is not found.
+    def any_const_get(name)
+      return name if name.is_a?(Module)
+      begin
+        klass = Object
+        name.split('::').each {|e|
+          klass = klass.const_get(e)
+        }
+        klass
+      rescue
+         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, converting undescored lowercase to camel uppercase.
+    def camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    # Used by Hirb::Menu to select items from an array. Array counting starts at 1. Ranges of numbers are specified with a '-' or '..'.
+    # Multiple ranges can be comma delimited. Anything that isn't a valid number is ignored. All elements can be returned with a '*'.
+    # Examples:
+    #    1-3,5-6 -> [1,2,3,5,6]
+    #    *   -> all elements in array
+    #    ''  -> [] 
+    def choose_from_array(array, input, options={})
+      options = {:splitter=>","}.merge(options)
+      return array if input.strip == '*'
+      result = []
+      input.split(options[:splitter]).each do |e|
+        if e =~ /-|\.\./
+          min,max = e.split(/-|\.\./)
+          slice_min = min.to_i - 1
+          result.push(*array.slice(slice_min, max.to_i - min.to_i + 1))
+        elsif e =~ /\s*(\d+)\s*/
+          index = $1.to_i - 1
+          next if index < 0
+          result.push(array[index]) if array[index]
+        end
+      end
+      return result
+    end
+
+    # Determines if a shell command exists by searching for it in ENV['PATH'].
+    def command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+    end
+
+    # Returns [width, height] of terminal when detected, nil if not detected.
+    # Think of this as a simpler version of Highline's Highline::SystemExtensions.terminal_size()
+    def detect_terminal_size
+      (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/) ? [ENV['COLUMNS'].to_i, ENV['LINES'].to_i] :
+        ( command_exists?('stty') ? `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse : nil )
+    rescue
+      nil
+    end
+
+    # Captures STDOUT of anything run in its block and returns it as string.
+    def capture_stdout(&block)
+      original_stdout = $stdout
+      $stdout = fake = StringIO.new
+      begin
+        yield
+      ensure
+        $stdout = original_stdout
+      end
+      fake.string
+    end
+  end
+end

data/lib/hirb/view.rb

@@ -0,0 +1,177 @@
+module Hirb
+  # 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 :render_method
+      attr_reader :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::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
+        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
+
+      # 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
+        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. 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 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
+
+      # Current console width
+      def width
+        config ? config[:width] : DEFAULT_WIDTH
+      end
+
+      # Current console height
+      def height
+        config ? config[:height] : DEFAULT_HEIGHT
+      end
+
+      # Current formatter config
+      def formatter_config
+        formatter.config
+      end
+
+      # Sets the helper config for the given output class.
+      def format_class(klass, helper_config)
+        formatter.format_class(klass, helper_config)
+      end
+
+      #:stopdoc:
+      def render_output(output, options={})
+        if (formatted_output = formatter.format_output(output, options))
+          render_method.call(formatted_output)
+          true
+        else
+          false
+        end
+      end
+
+      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 page_output(output, inspect_mode=false)
+        if enabled? && config[:pager] && pager.activated_by?(output, inspect_mode)
+          pager.page(output, inspect_mode)
+          true
+        else
+          false
+        end
+      end
+
+      def pager
+        @pager ||= Pager.new(config[:width], config[:height], :pager_command=>config[:pager_command])
+      end
+
+      def pager=(value); @pager = value; end
+
+      def formatter(reload=false)
+        @formatter = reload || @formatter.nil? ? Formatter.new(config[:output]) : @formatter
+      end
+
+      def formatter=(value); @formatter = value; end
+
+      def load_config(additional_config={})
+        @config = Util.recursive_hash_merge default_config, additional_config
+        formatter(true)
+        true
+      end
+
+      def config_loaded?; !!@config; end
+
+      def config
+        @config
+      end
+
+      def default_render_method
+        lambda {|output| page_output(output) || puts(output) }
+      end
+
+      def default_config
+        Util.recursive_hash_merge({:pager=>true, :formatter=>true}, Hirb.config || {})
+      end
+      #:startdoc:
+    end
+  end
+
+  # Namespace for autoloaded views
+  module Views
+  end
+end

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