rhc 1.6.8 → 1.7.8

data/lib/rhc/highline_extensions.rb

@@ -0,0 +1,412 @@
+require 'delegate'
+
+#
+# Add specific improved functionality
+#
+class HighLineExtension < HighLine
+  [:ask, :agree].each do |sym|
+    define_method(sym) do |*args, &block|
+      separate_blocks
+      r = super(*args, &block)
+      @last_line_open = false
+      r
+    end
+  end
+
+  # OVERRIDE
+  def say(msg)
+    if msg.respond_to? :to_str
+      separate_blocks
+
+      statement = msg.to_str
+      return statement unless statement.present?
+
+      template  = ERB.new(statement, nil, "%")
+      statement = template.result(binding)
+
+      statement = statement.textwrap_ansi(@wrap_at, false).join("#{indentation}\n") unless @wrap_at.nil?
+      statement = send(:page_print, statement) unless @page_at.nil?
+
+      @output.print(indentation) unless @last_line_open
+
+      @last_line_open = 
+        if statement[-1, 1] == " " or statement[-1, 1] == "\t"
+          @output.print(statement)
+          @output.flush
+          true
+        else
+          @output.puts(statement)
+          false
+        end
+
+    elsif msg.respond_to? :each
+      separate_blocks
+
+      @output.print if @last_line_open
+      @last_line_open = false
+
+      color = msg.color if msg.respond_to? :color
+      @output.print HighLine::Style(color).code if color
+
+      msg.each do |s|
+        @output.print indentation
+        @output.puts s
+      end
+
+      @output.print HighLine::CLEAR if color
+      @output.flush      
+    end
+
+    msg
+  end
+
+  # given an array of arrays "items", construct an array of strings that can
+  # be used to print in tabular form.
+  def table(items, opts={}, &block)
+    items = items.map(&block) if block_given?
+    opts[:width] ||= default_max_width
+    Table.new(items, opts)
+  end
+
+  def table_args(indent=nil, *args)
+    opts = {}
+    opts[:indent] = indent
+    opts[:width] = [default_max_width, *args]
+    opts
+  end
+
+  def default_max_width
+    @wrap_at ? @wrap_at - indentation.length : nil
+  end
+
+  def header(str,opts = {}, &block)
+    say Header.new(str, default_max_width, '  ')
+    if block_given?
+      indent &block
+    end
+  end
+
+  #:nocov:
+  # Backport from Highline 1.6.16
+  unless HighLine.method_defined? :indent
+    #
+    # Outputs indentation with current settings
+    #
+    def indentation
+      @indent_size ||= 2
+      @indent_level ||= 0
+      return ' '*@indent_size*@indent_level
+    end
+
+    #
+    # Executes block or outputs statement with indentation
+    #
+    def indent(increase=1, statement=nil, multiline=nil)
+      @indent_size ||= 2
+      @indent_level ||= 0
+      @indent_level += increase
+      multi = @multi_indent
+      @multi_indent = multiline unless multiline.nil?
+      if block_given?
+          yield self
+      else
+          say(statement)
+      end
+    ensure
+      @multi_indent = multi
+      @indent_level -= increase
+    end
+  end 
+  #:nocov:
+
+  ##
+  # section
+  #
+  # highline helper mixin which correctly formats block of say and ask
+  # output to have correct margins.  section remembers the last margin
+  # used and calculates the relitive margin from the previous section.
+  # For example:
+  #
+  # section(bottom=1) do
+  #   say "Hello"
+  # end
+  #
+  # section(top=1) do
+  #   say "World"
+  # end
+  #
+  # Will output:
+  #
+  # > Hello
+  # >
+  # > World 
+  #
+  # with only one newline between the two.  Biggest margin wins.
+  #
+  # params:
+  #  top - top margin specified in lines
+  #  bottom - bottom margin specified in line
+  #
+  def section(params={}, &block)
+    top = params[:top] || 0
+    bottom = params[:bottom] || 0
+
+    # the first section cannot take a newline
+    top = 0 unless @margin
+    @margin = [top, @margin || 0].max
+
+    value = block.call
+
+    say "\n" if @last_line_open
+    @margin = [bottom, @margin].max
+
+    value
+  end
+
+  ##
+  # paragraph
+  #
+  # highline helper which creates a section with margins of 1, 1
+  #
+  def paragraph(&block)
+    section(:top => 1, :bottom => 1, &block)
+  end
+
+  def pager
+    #:nocov:
+    return if RHC::Helpers.windows?
+    return unless @output.tty?
+
+    read, write = IO.pipe
+
+    unless Kernel.fork # Child process
+      STDOUT.reopen(write)
+      STDERR.reopen(write) if STDERR.tty?
+      read.close
+      write.close
+      return
+    end
+
+    # Parent process, become pager
+    STDIN.reopen(read)
+    read.close
+    write.close
+
+    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+    Kernel.select [STDIN] # Wait until we have input before we start the pager
+    pager = ENV['PAGER'] || 'less'
+    exec pager rescue exec "/bin/sh", "-c", pager
+    #:nocov:
+  end
+
+  private
+    def separate_blocks
+      if (@margin ||= 0) > 0 && !@last_line_open
+        @output.print "\n" * @margin
+        @margin = 0
+      end
+    end
+end
+
+#
+# An element capable of being split into multiple logical rows
+#
+module RowBased
+  extend Forwardable
+  def_delegators :rows, :each, :to_a, :join
+  alias_method :each_line, :each
+end
+
+class HighLine::Header < Struct.new(:text, :width, :indent, :color)
+  include RowBased
+
+  protected
+    def rows
+      @rows ||= begin
+        if !width || width == 0
+          [text.is_a?(Array) ? text.join(' ') : text]
+
+        elsif text.is_a? Array
+          widths = text.map{ |s| s.strip_ansi.length }
+          chars, join, indented = 0, 1, (indent || '').length
+          narrow = width - indented
+          text.zip(widths).inject([]) do |rows, (section, w)|
+            if rows.empty?
+              if w > width
+                rows.concat(section.textwrap_ansi(width))
+              else
+                rows << section.dup
+                chars += w
+              end
+            else
+              if w + chars + join > narrow
+                rows.concat(section.textwrap_ansi(narrow).map{ |s| "#{indent}#{s}" })
+                chars = 0
+              elsif chars == 0
+                rows << "#{indent}#{section}"
+                chars += w + indented
+              else
+                rows[-1] << " #{section}"
+                chars += w + join
+              end
+            end
+            rows
+          end
+        else
+          text.textwrap_ansi(width)
+        end
+      end.tap do |rows|
+        rows << '-' * rows.map{ |s| s.strip_ansi.length }.max
+      end
+    end
+end
+
+#
+# Represent a columnar layout of items with wrapping and flexible layout.
+# 
+class HighLine::Table
+  include RowBased
+
+  def initialize(items=nil,options={},&mapper)
+    @items, @options, @mapper = items, options, mapper
+  end
+
+  def color
+    opts[:color]
+  end
+
+  protected 
+    attr_reader :items
+
+    def opts
+      @options
+    end
+
+    def align
+      opts[:align] || []
+    end
+    def joiner
+      opts[:join] || ' '
+    end
+    def indent
+      opts[:indent] || ''
+    end
+    def heading
+      @heading ||= opts[:heading] ? HighLine::Header.new(opts[:heading], max_width, indent) : nil
+    end
+
+    def source_rows
+      @source_rows ||= begin
+        (@mapper ? (items.map &@mapper) : items).each do |row|
+          row.map!{ |col| col.is_a?(String) ? col : col.to_s }
+        end
+      end
+    end
+
+    def headers
+      @headers ||= opts[:header] ? [Array(opts[:header])] : []
+    end
+
+    def columns
+      @columns ||= source_rows.map(&:length).max
+    end
+
+    def column_widths
+      @column_widths ||= begin
+        widths = Array.new(columns){ Width.new(0,0,0) }
+        (source_rows + headers).each do |row|
+          row.each_with_index do |col, i|
+            w = widths[i]
+            s = col.strip_ansi
+            word_length = s.scan(/\b\S+/).inject(0){ |l, word| l = word.length if l <= word.length; l }
+            w.min = word_length unless w.min > word_length
+            w.max = s.length unless w.max > s.length
+          end
+        end
+        widths
+      end
+    end
+
+    Width = Struct.new(:min, :max, :set)
+
+    def allocate_widths_for(available)
+      available -= (columns-1) * joiner.length + indent.length
+      return column_widths.map{ |w| w.max } if available >= column_widths.inject(0){ |sum, w| sum + w.max } || column_widths.inject(0){ |sum, w| sum + w.min } > available
+
+      fair = available / columns
+      column_widths.each do |w|
+        if w.set > 0
+          available -= w.set
+          next
+        end
+        w.set = if w.max <= fair
+            available -= w.max
+            w.max
+          else
+            0
+          end
+      end
+
+      remaining = column_widths.inject(0){ |sum, w| if w.set == 0; sum += w.max; available -= w.min; end; sum }
+      fair = available.to_f / remaining.to_f
+
+      column_widths.
+        each do |w| 
+          if w.set == 0
+            available -= (alloc = (w.max * fair).to_i)
+            w.set = alloc + w.min
+          end
+        end.
+        each{ |w| if available > 0 && w.set < w.max; w.set += 1; available -= 1; end }.
+        map(&:set)
+    end
+
+    def widths
+      @widths ||= begin
+        case w = opts[:width]
+        when Array
+          column_widths.zip(w[1..-1]).each do |width, col| 
+            width.set = col || 0
+            width.max = width.set if width.set > width.max
+          end
+          allocate_widths_for(w.first || 0)
+        when Integer
+          allocate_widths_for(w)
+        else
+          column_widths.map{ |w| w.max }
+        end
+      end
+    end
+
+    def max_width
+      @max_width ||= opts[:width].is_a?(Array) ? opts[:width].first : (opts[:width] ? opts[:width] : 0)
+    end
+
+    def header_rows
+      @header_rows ||= begin
+        headers << column_widths.map{ |w| '-' * (w.set > 0 ? w.set : w.max) } if headers.present?
+        headers
+      end
+    end
+
+    def rows
+      @rows ||= begin
+        fmt = "#{indent}#{widths.zip(align).map{ |w, al| "%#{al == :right ? '' : '-'}#{w}s" }.join(joiner)}"
+          
+        body = (header_rows + source_rows).inject([]) do |a,row| 
+          row = row.zip(widths).map{ |column,w| w && w > 0 ? column.textwrap_ansi(w, false) : [column] }
+          row.map(&:length).max.times do |i|
+            a << (fmt % row.map{ |r| r[i] }).rstrip
+          end
+          a
+        end
+        
+        body = heading.to_a.concat(body) if heading
+        body
+      end
+    end
+end
+
+$terminal = HighLineExtension.new
+$terminal.indent_size = 2 if $terminal.respond_to? :indent_size

data/lib/rhc/output_helpers.rb

@@ -34,35 +34,23 @@ module RHC
     # Application information
     #---------------------------
     def display_app(app,cartridges = nil)
-      heading = "%s @ %s (uuid: %s)" % [app.name, app.app_url, app.uuid]
       paragraph do
-        header heading do
+        header [app.name, "@ #{app.app_url}", "(uuid: #{app.uuid})"] do
           section(:bottom => 1) do
-            display_app_properties(
-              app,
-              :creation_time,
-              :gear_info,
-              :git_url,
-              :initial_git_url,
-              :ssh_string,
-              :aliases)
+            say format_table \
+              nil,
+              get_properties(
+                app,
+                :creation_time,
+                :gear_info,
+                :git_url,
+                :initial_git_url,
+                :ssh_string,
+                :aliases
+              ),
+              :delete => true
           end
-          display_included_carts(cartridges) if cartridges
-        end
-      end
-    end
-
-    def display_app_properties(app,*properties)
-      say_table \
-        nil,
-        get_properties(app,*properties),
-        :delete => true
-    end
-
-    def display_included_carts(carts)
-      carts.each do |c|
-        section(:bottom => 1) do
-          display_cart(c)
+          cartridges.each{ |c| section(:bottom => 1){ display_cart(c) } } if cartridges
         end
       end
     end
@@ -71,13 +59,14 @@ module RHC
       [
         cart.name,
         cart.name != cart.display_name ? "(#{cart.display_name})" : nil,
-      ].compact.join(' ')
+      ].compact
     end
 
     def format_scaling_info(scaling)
       "x%d (minimum: %s, maximum: %s) on %s gears" %
         [:current_scale, :scales_from, :scales_to, :gear_profile].map{ |key| format_value(key, scaling[key]) } if scaling
     end
+
     def format_cart_gears(cart)
       if cart.scalable?
         format_scaling_info(cart.scaling)
@@ -87,6 +76,7 @@ module RHC
         "%d %s" % [format_value(:current_scale, cart.current_scale), format_value(:gear_profile, cart.gear_profile)]
       end
     end
+
     def format_gear_info(info)
       "%d (defaults to %s)" %
         [:gear_count, :gear_profile].map{ |key| format_value(key, info[key]) } if info
@@ -97,25 +87,19 @@ module RHC
     #---------------------------
 
     def display_cart(cart, *properties)
-      @table_displayed = false
-
-      say_table \
+      say format_table \
         format_cart_header(cart),
         get_properties(cart, *properties).
           concat([[cart.scalable? ? :scaling : :gears, format_cart_gears(cart)]]).
           concat(cart.properties.map{ |p| ["#{table_heading(p['name'])}:", p['value']] }.sort{ |a,b| a[0] <=> b[0] }),
         :delete => true
-      display_no_info("cartridge") unless @table_displayed
-
-      if cart.usage_rate?
-         say "\n"
-         say format_usage_message(cart)
-      end
+      
+      say format_usage_message(cart) if cart.usage_rate?
     end
 
     def display_key(key, *properties)
       properties = [:fingerprint, :visible_to_ssh?] if properties.empty?
-      say_table(
+      say format_table(
         properties.include?(:name) ? nil : format_key_header(key),
         get_properties(key, *properties),
         {
@@ -126,7 +110,7 @@ module RHC
     end
 
     def display_authorization(auth, default=nil)
-      say_table(
+      say format_table(
         auth.note || "<no description>",
         get_properties(auth, :token, :scopes, :creation_time, :expires_in_seconds),
         {
@@ -140,59 +124,39 @@ module RHC
       [
         key.name,
         "(type: #{key.type})",
-      ].compact.join(' ')
+      ].compact
     end
 
     def display_cart_storage_info(cart, title="Storage Info")
-      say_table \
+      say format_table \
         title,
         get_properties(cart,:base_gear_storage,:additional_gear_storage)
     end
 
     def display_cart_storage_list(carts)
-      carts.each do |cart|
-        puts
-        display_cart_storage_info(cart, cart.display_name)
-      end
+      carts.each{ |cart| paragraph{ display_cart_storage_info(cart, cart.display_name) } }
     end
 
     def format_usage_message(cart)
       "This gear costs an additional $#{cart.usage_rate} per gear after the first 3 gears."
     end
 
-    #---------------------------
-    # Misc information
-    #---------------------------
-
-    def display_no_info(type)
-      say_table \
-        nil,
-        [["This #{type} has no information to show"]]
-    end
-
     private
-      def say_table(heading,values,opts = {})
-        @table_displayed = true
-
+      def format_table(heading,values,opts = {})
         values = values.to_a if values.is_a? Hash
         values.delete_if do |arr|
           arr[0] = "#{table_heading(arr.first)}:" if arr[0].is_a? Symbol
           opts[:delete] and arr.last.blank?
         end
 
-        table = self.table(values)
-        table = table.map{ |s| color(s, opts[:color]) } if opts[:color]
+        table(values, :heading => heading, :indent => heading ? '  ' : nil, :color => opts[:color])
+      end
 
-        # Make sure we nest properly
-        if heading
-          header(heading, opts) do
-            say table
-          end
-        else
-          say table
-        end
+      def format_no_info(type)
+        ["This #{type} has no information to show"]
       end
 
+
       # This uses the array of properties to retrieve them from an object
       def get_properties(object,*properties)
         properties.map do |prop|