hirb 0.2.9 → 0.2.10

data/lib/hirb/helpers/vertical_table.rb

@@ -1,9 +1,11 @@
 class Hirb::Helpers::VerticalTable < Hirb::Helpers::Table
 
-  # Renders a vertical table using the same options as Hirb::Helpers::Table.render except for :field_lengths,
-  # :vertical and :max_width which aren't used.
+  # Renders a vertical table using the same options as Hirb::Helpers::Table.render except for the ones below
+  # and :max_fields, :vertical and :max_width which aren't used.
+  # ==== Options:
+  # [:hide_empty] Boolean which hides empty values (nil or '') from being displayed. Default is false.
   def self.render(rows, options={})
-    new(rows, {:no_newlines=>false}.merge(options)).render
+    new(rows, {:escape_special_chars=>false, :resize=>false}.merge(options)).render
   end
 
   #:stopdoc:
@@ -21,11 +23,15 @@ class Hirb::Helpers::VerticalTable < Hirb::Helpers::Table
     @rows.map do |row|
       row = "#{stars} #{i+1}. row #{stars}\n" +
       @fields.map {|f|
-        "#{Hirb::String.rjust(@headers[f], longest_header)}: #{row[f]}"
-      }.join("\n")
+        if !@options[:hide_empty] || (@options[:hide_empty] && !row[f].empty?)
+          "#{Hirb::String.rjust(@headers[f], longest_header)}: #{row[f]}"
+        else
+          nil
+        end
+      }.compact.join("\n")
       i+= 1
       row
     end
-  #:startdoc:
   end
+  #:startdoc:
 end

data/lib/hirb/menu.rb

@@ -1,47 +1,215 @@
 module Hirb
-  # This class provides a selection menu using Hirb's table helpers by default to display choices.
+  # This class provides a menu using Hirb's table helpers by default to display choices.
+  # Menu choices (syntax at Hirb::Util.choose_from_array) refer to rows. However, when in
+  # two_d mode, choices refer to specific cells by appending a ':field' to a choice.
+  # A field name can be an abbreviated. Menus can also have an action mode, which turns the
+  # menu prompt into a commandline that executes the choices as arguments and uses methods as
+  # actions/commands.
   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.
+    class Error < StandardError; end
+
+    # Detects valid choices and optional field/column
+    CHOSEN_REGEXP = /^(\d([^:]+)?)(?::)?(\S+)?/
+    CHOSEN_ARG = '%s'
+    DIRECTIONS = "Specify individual choices (4,7), range of choices (1-3) or all choices (*)."
+
+
+    # This method will return an array unless it's exited by simply pressing return, which returns nil.
+    # If given a block, the block will yield if and with any menu items are chosen.
+    # 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.
+    # [*: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: ".
+    # [*:ask*] Always ask for input, even if there is only one choice. Default is true.
+    # [*:directions*] Display directions before prompt. Default is true.
+    # [*:readline*] Use readline to get user input if available. Input strings are added to readline history. Default is false.
+    # [*:two_d*] Turn menu into a 2 dimensional (2D) menu by allowing user to pick values from table cells. Default is false.
+    # [*:default_field*] Default field for a 2D menu. Defaults to first field in a table.
+    # [*:action*] Turn menu into an action menu by letting user pass menu choices as an argument to a method/command.
+    #             A menu choice's place amongst other arguments is preserved. Default is false.
+    # [*:multi_action*] Execute action menu multiple times iterating over the menu choices. Default is false.
+    # [*:action_object*] Object that takes method/command calls. Default is main.
+    # [*:command*] Default method/command to call when no command given.
     # 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))
+    #     >> extend Hirb::Console
+    #     => self
+    #     >> menu [1,2,3], :prompt=> "So many choices, so little time: "
+    #     >> menu [{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:a,b], :two_d=>true)
+    def self.render(output, options={}, &block)
+      new(options).render(output, &block)
+    rescue Error=>e
+      $stderr.puts "Error: #{e.message}"
+    end
+
+    #:stopdoc:
+    def initialize(options={})
+      @options = {:helper_class=>Hirb::Helpers::AutoTable, :prompt=>"Choose: ", :ask=>true,
+        :directions=>true}.merge options
+    end
+
+    def render(output, &block)
+      @output = Array(output)
+      return [] if @output.size.zero?
+      chosen = choose_from_menu
+      block.call(chosen) if block && chosen.size > 0
+      @options[:action] ? execute_action(chosen) : chosen
+    end
+
+    def get_input
+      prompt = pre_prompt + @options[:prompt]
+      prompt = DIRECTIONS+"\n"+prompt if @options[:directions]
+
+      if @options[:readline] && readline_loads?
+        get_readline_input(prompt)
+      else
+        print prompt
+        $stdin.gets.chomp.strip
+      end
+    end
+
+    def get_readline_input(prompt)
+      input = Readline.readline prompt
+      Readline::HISTORY << input
+      input
+    end
+
+    def pre_prompt
+      prompt = ''
+      prompt << "Default field: #{default_field}\n" if @options[:two_d] && default_field
+      prompt << "Default command: #{@options[:command]}\n" if @options[:action] && @options[:command]
+      prompt
+    end
+
+    def choose_from_menu
+      return unasked_choice 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
+
+      parse_input get_input
+    end
+
+    def unasked_choice
+      return @output unless @options[:action]
+      raise(Error, "Default command and field required for unasked action menu") unless default_field && @options[:command]
+      @new_args = [@options[:command], CHOSEN_ARG]
+      map_tokens([[@output, default_field]])
+    end
+
+    def execute_action(chosen)
+      return nil if chosen.size.zero?
+      if @options[:multi_action]
+        chosen.each {|e| invoke command, add_chosen_to_args(e) }
+      else
+        invoke command, add_chosen_to_args(chosen)
+      end
+    end
+
+    def invoke(cmd, args)
+      action_object.send(cmd, *args)
+    end
+
+    def parse_input(input)
+      if (@options[:two_d] || @options[:action])
+        tokens = input_to_tokens(input)
+        map_tokens(tokens)
+      else
+        Util.choose_from_array(@output, input)
+      end
+    end
+
+    def map_tokens(tokens)
+      if return_cell_values?
+        @output[0].is_a?(Hash) ? tokens.map {|arr,f| arr.map {|e| e[f]} }.flatten :
+          tokens.map {|arr,f| arr.map {|e| e.send(f) } }.flatten
       else
-        output.each_with_index {|e,i| puts "#{i+1}: #{e}" }
+        tokens.map {|e| e[0] }.flatten
       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
+
+    def return_cell_values?
+      @options[:two_d]
+    end
+
+    def input_to_tokens(input)
+      @new_args = []
+      tokens = (@args = split_input_args(input)).map {|word| parse_word(word) }.compact
+      cleanup_new_args
+      tokens
+    end
+
+    def parse_word(word)
+      if word[CHOSEN_REGEXP]
+        @new_args << CHOSEN_ARG
+        field = $3 ? unalias_field($3) : default_field ||
+          raise(Error, "No default field/column found. Fields must be explicitly picked.")
+        [Util.choose_from_array(@output, word), field ]
+      else
+        @new_args << word
+        nil
+      end
+    end
+
+    def cleanup_new_args
+      if @new_args.all? {|e| e == CHOSEN_ARG }
+        @new_args = [CHOSEN_ARG]
+      else
+        i = @new_args.index(CHOSEN_ARG) || raise(Error, "No rows chosen")
+        @new_args.delete(CHOSEN_ARG)
+        @new_args.insert(i, CHOSEN_ARG)
       end
-      chosen
     end
+
+    def add_chosen_to_args(items)
+      args = @new_args.dup
+      args[args.index(CHOSEN_ARG)] = items
+      args
+    end
+
+    def command
+      @command ||= begin
+        cmd = (@new_args == [CHOSEN_ARG]) ? nil : @new_args.shift
+        cmd ||= @options[:command] || raise(Error, "No command given for action menu")
+      end
+    end
+
+    def action_object
+      @options[:action_object] || eval("self", TOPLEVEL_BINDING)
+    end
+
+    def split_input_args(input)
+      input.split(/\s+/)
+    end
+
+    def default_field
+      @default_field ||= @options[:default_field] || fields[0]
+    end
+
+    # Has to be called after displaying menu
+    def fields
+      @fields ||= @options[:fields] || (@options[:ask] && table_helper_class? && Helpers::Table.last_table ?
+        Helpers::Table.last_table.fields[1..-1] : [])
+    end
+
+    def table_helper_class?
+      @options[:helper_class].is_a?(Class) && (@options[:helper_class] < Helpers::Table || @options[:helper_class] == Helpers::AutoTable)
+    end
+
+    def unalias_field(field)
+      fields.sort_by {|e| e.to_s }.find {|e| e.to_s[/^#{field}/] } || raise(Error, "Invalid field '#{field}'")
+    end
+
+    def readline_loads?
+      require 'readline'
+      true
+    rescue LoadError
+      false
+    end
+    #:startdoc:
   end
 end

data/lib/hirb/util.rb

@@ -48,7 +48,7 @@ module Hirb
           result.push(array[index]) if array[index]
         end
       end
-      return result
+      result
     end
 
     # Determines if a shell command exists by searching for it in ENV['PATH'].
@@ -61,7 +61,7 @@ module Hirb
     def detect_terminal_size
       if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
         [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
-      elsif RUBY_PLATFORM =~ /java/ && command_exists?('tput')
+      elsif (RUBY_PLATFORM =~ /java/ || !STDIN.tty?) && command_exists?('tput')
         [`tput cols`.to_i, `tput lines`.to_i]
       else
         command_exists?('stty') ? `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse : nil
@@ -81,5 +81,14 @@ module Hirb
       end
       fake.string
     end
+
+    # From Rubygems, determine a user's home.
+    def find_home
+      ['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
+      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      File.expand_path("~")
+    rescue
+      File::ALT_SEPARATOR ? "C:/" : "/"
+    end
   end
 end

data/lib/hirb/view.rb

@@ -9,11 +9,12 @@ module Hirb
       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
+      # method with Hirb::View.view_output. When called multiple times, new configs are merged into the existing config.
+      # 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.
+      # * config_file: Name of config file(s) that are merged into existing config
       # * output_method: Specify an object's class and instance method (separated by a period) to be realiased with
       #   hirb's view system. The instance method should take a string to be output. Default is IRB::Irb.output_value
       #   if using irb.
@@ -22,15 +23,15 @@ module Hirb
       #   Hirb::View.enable :formatter=>false, :output_method=>"Mini.output"
       #   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]
-        @output_method = "IRB::Irb.output_value" if Object.const_defined?(:IRB)
-        @output_method = options.delete(:output_method) if options[:output_method]
-        load_config(Util.recursive_hash_merge(options, HashStruct.block_to_hash(block)))
+        Array(options.delete(:config_file)).each {|e|
+          @new_config_file = true
+          Hirb.config_files << e
+        }
+        enable_output_method(options.delete(:output_method))
+        puts "Using a block with View.enable will be *deprecated* in the next release" if block_given?
+        merge_or_load_config(Util.recursive_hash_merge(options, HashStruct.block_to_hash(block)))
         resize(config[:width], config[:height])
-        alias_output_method(@output_method) if @output_method
-        true
+        @enabled = true
       end
 
       # Indicates if Hirb::View is enabled.
@@ -112,6 +113,13 @@ module Hirb
       end
 
       #:stopdoc:
+      def enable_output_method(meth)
+        if (meth ||= Object.const_defined?(:IRB) ? "IRB::Irb.output_value" : false) && !@output_method
+          @output_method = meth
+          alias_output_method(@output_method)
+        end
+      end
+
       def unalias_output_method(output_method)
         klass, klass_method = output_method.split(".")
         eval %[
@@ -119,6 +127,7 @@ module Hirb
             alias_method :#{klass_method}, :non_hirb_view_output
           end
         ]
+        @output_method = nil
       end
 
       def alias_output_method(output_method)
@@ -176,6 +185,16 @@ module Hirb
 
       def formatter=(value); @formatter = value; end
 
+      def merge_or_load_config(additional_config={})
+        if @config && (@new_config_file || !additional_config.empty?)
+          Hirb.config = nil
+          load_config Util.recursive_hash_merge(@config, additional_config)
+          @new_config_file = false
+        elsif !@enabled
+          load_config(additional_config)
+        end
+      end
+
       def load_config(additional_config={})
         @config = Util.recursive_hash_merge default_config, additional_config
         formatter(true)

data/test/auto_table_test.rb

@@ -17,31 +17,16 @@ class Hirb::Helpers::AutoTableTest < Test::Unit::TestCase
       Hirb::Helpers::AutoTable.render(::Set.new([1,2,3])).should == expected_table
     end
 
-    test "converts hash with any value hashes to inspected values" do
+    test "renders hash" do
       expected_table = <<-TABLE.unindent
-      +---+---------+
-      | 0 | 1       |
-      +---+---------+
-      | c | "ok"    |
-      | a | {:b=>1} |
-      +---+---------+
-      2 rows in set
+      +---+-------+
+      | 0 | 1     |
+      +---+-------+
+      | a | 12345 |
+      +---+-------+
+      1 row in set
       TABLE
-      Hirb::Helpers::AutoTable.render({:a=>{:b=>1}, :c=>'ok'}).should == expected_table
-    end
-
-    test "doesn't convert hash with value hashes if filter exists for value" do
-      expected_table = <<-TABLE.unindent
-      +------+-------+
-      | name | value |
-      +------+-------+
-      | c    | ok    |
-      | a    | b1    |
-      +------+-------+
-      2 rows in set
-      TABLE
-      Hirb::Helpers::AutoTable.render({:a=>{:b=>1}, :c=>'ok'}, :change_fields=>['name', 'value'],
-       :filters=>{'value'=>:to_s}).should == expected_table
+      Hirb::Helpers::AutoTable.render({:a=>12345}).should == expected_table
     end
   end
 end

data/test/formatter_test.rb

@@ -75,9 +75,9 @@ class FormatterTest < Test::Unit::TestCase
       formatter_config["Blah"].should == {:class=>"Hirb::Views::Blah", :ancestor=>true}
     end
   
-    test "with block sets formatter config" do
+    test "sets formatter config" do
       class_hash = {"Something::Base"=>{:class=>"BlahBlah"}}
-      Hirb.enable {|c| c.output = class_hash }
+      Hirb.enable :output=>class_hash
       formatter_config['Something::Base'].should == class_hash['Something::Base']
     end
   end