color-console 0.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013, Adam Gardiner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,76 @@
+# ColorConsole
+
+ColorConsole is a small cross-platform library for outputting text to the console.
+
+
+## Usage
+
+ColorConsole is supplied as a gem, and has no dependencies. To use it, simply:
+```
+gem install color-console
+```
+
+ColorConsole provides methods for outputting lines of text in different colors, using the `Console.write` and `Console.puts` functions.
+
+```ruby
+require 'color-console'
+
+Console.puts "Some text"                    # Outputs text using the current console colours
+Console.puts "Some other text", :red        # Outputs red text with the current background
+Console.puts "Yet more text", nil, :blue    # Outputs text using the current foreground and a blue background
+
+# The following lines output BlueRedGreen on a single line, each word in the appropriate color
+Console.write "Blue ", :blue
+Console.write "Red ", :red
+Console.write "Green", :green
+```
+
+## Features
+
+In addition to `Console.puts` and `Console.write` for outputting text in color, ColorConsole also supports:
+* __Setting the console title__: The title bar of the console window can be set using `Console.title = 'My title'`.
+* __Status messages__: Status messages (i.e. a line of text at the current scroll position) can be output and
+  updated at any time. The status message will remain at the current scroll point even as new text is output
+  using `Console.puts`.
+* __Progress bars__: A progress bar can be rendered like a status message, but with a pseudo-graphical representation
+  of the current completion percentage:
+
+    ```ruby
+    (0..100).do |i|
+        Console.show_progress('Processing data', i)
+    end
+    Console.clear_progress
+    ```
+    Output:
+    ```
+    [==============    35%                   ]  Processing data
+    ```
+* __Tables__: Data can be output in a tabular representation:
+
+    ```ruby
+    HEADER_ROW = ['Column 1', 'Column 2', 'Column 3', 'Column 4']
+    MIXED_ROW = [17,
+                 'A somewhat longer column',
+                 'A very very very long column that should wrap multple lines',
+                 'Another medium length column']
+    SECOND_ROW = [24,
+                  'Lorem ipsum',
+                  'Some more text',
+                  'Lorem ipsum dolor sit amet']
+
+    Console.display_table([HEADER_ROW, MIXED_ROW, SECOND_ROW], width: 100,
+                          col_sep: '|', row_sep: '-')
+    ```
+    Output:
+    ```
+    +----------+--------------------------+-----------------------------+-----------------------------+
+    | Column 1 | Column 2                 | Column 3                    | Column 4                    |
+    +----------+--------------------------+-----------------------------+-----------------------------+
+    |       17 | A somewhat longer column | A very very very long       | Another medium length       |
+    |          |                          | column that should wrap     | column                      |
+    |          |                          | multple lines               |                             |
+    +----------+--------------------------+-----------------------------+-----------------------------+
+    |       24 | Lorem ipsum              | Some more text              | Lorem ipsum dolor sit amet  |
+    +----------+--------------------------+-----------------------------+-----------------------------+
+    ```
+

data/lib/color-console.rb

@@ -0,0 +1,2 @@
+require 'console/console'
+

data/lib/color_console.rb

@@ -0,0 +1,2 @@
+require 'console/console'
+

data/lib/console/console.rb

@@ -0,0 +1,135 @@
+# Require the platform specific functionality
+if Gem.win_platform?
+    require_relative 'platform/windows'
+else
+    require_relative 'platform/ansi'
+end
+
+
+# Implements cross-platform functionality for working with a console window to
+# provide color and progress-bar functionality.
+module Console
+
+    attr_reader :status, :status_enabled
+
+
+    # Mutex used to ensure we don't intermingle output from multiple threads
+    @lock = Mutex.new
+
+
+    # Returns the width of the console window
+    #
+    # @return the width in characters, or nil if no console is available.
+    def width
+        sz = _window_size
+        sz && sz.first
+    end
+    module_function :width
+
+
+    # Returns the height of the console window
+    #
+    # @return the height in characters, or nil if no console is available.
+    def height
+        sz = _window_size
+        sz && sz.last
+    end
+    module_function :height
+
+
+    # Writes a partital line of text to the console, with optional foreground
+    # and background colors. No line-feed is output.
+    #
+    # @see #puts
+    #
+    # @param text [String] The text to be written to the console.
+    # @param fg [Symbol] An optional foreground colour name or value.
+    # @param bg [Symbol] An optional background color name or value.
+    def write(text, fg = nil, bg = nil)
+        @lock.synchronize do
+            _write(text, fg, bg)
+        end
+    end
+    module_function :write
+
+
+    # Send a line of text to the screen, terminating with a new-line.
+    #
+    # @see #write
+    #
+    # @param text [String] The optional text to be written to the console.
+    # @param fg [Symbol] An optional foreground colour name or value.
+    # @param bg [Symbol] An optional background color name or value.
+    def puts(text = nil, fg = nil, bg = nil)
+        @lock.synchronize do
+            _puts(text, fg, bg)
+        end
+    end
+    module_function :puts
+
+
+
+    # Utility method for wrapping lines of +text+ at +width+ characters.
+    #
+    # @param text [Object] a string of text that is to be wrapped to a
+    #   maximum width. If +text+ is not a String, #to_s is called to convert it.
+    # @param width [Integer] the maximum length of each line of text.
+    # @return [Array] an Array of lines of text, each no longer than +width+
+    #   characters.
+    def wrap_text(text, width)
+        text = text.to_s
+        if width > 0 && (text.length > width || text.index("\n"))
+            lines = []
+            start, nl_pos, ws_pos, wb_pos, end_pos = 0, 0, 0, 0, text.rindex(/[^\s]/)
+            while start < end_pos
+                last_start = start
+                nl_pos = text.index("\n", start)
+                ws_pos = text.rindex(/ +/, start + width)
+                wb_pos = text.rindex(/[\-,.;#)}\]\/\\]/, start + width - 1)
+                ### Debug code ###
+                #STDERR.puts self
+                #ind = ' ' * end_pos
+                #ind[start] = '('
+                #ind[start+width < end_pos ? start+width : end_pos] = ']'
+                #ind[nl_pos] = 'n' if nl_pos
+                #ind[wb_pos] = 'b' if wb_pos
+                #ind[ws_pos] = 's' if ws_pos
+                #STDERR.puts ind
+                ### End debug code ###
+                if nl_pos && nl_pos <= start + width
+                    lines << text[start...nl_pos].strip
+                    start = nl_pos + 1
+                elsif end_pos < start + width
+                    lines << text[start..end_pos]
+                    start = end_pos
+                elsif ws_pos && ws_pos > start && ((wb_pos.nil? || ws_pos > wb_pos) ||
+                      (wb_pos && wb_pos > 5 && wb_pos - 5 < ws_pos))
+                    lines << text[start...ws_pos]
+                    start = text.index(/[^\s]/, ws_pos + 1)
+                elsif wb_pos && wb_pos > start
+                    lines << text[start..wb_pos]
+                    start = wb_pos + 1
+                else
+                    lines << text[start...(start+width)]
+                    start += width
+                end
+                if start <= last_start
+                    # Detect an infinite loop, and just return the original text
+                    STDERR.puts "Inifinite loop detected at #{__FILE__}:#{__LINE__}"
+                    STDERR.puts "  width: #{width}, start: #{start}, nl_pos: #{nl_pos}, " +
+                                "ws_pos: #{ws_pos}, wb_pos: #{wb_pos}"
+                    return [text]
+                end
+            end
+            lines
+        else
+            [text]
+        end
+    end
+    module_function :wrap_text
+
+end
+
+require_relative 'progress'
+require_relative 'table'
+

data/lib/console/platform/ansi.rb

@@ -0,0 +1,134 @@
+module Console
+
+    FOREGROUND_COLORS = {
+        black: '30',
+        blue: '34',
+        dark_blue: '2;34',
+        light_blue: '1;34',
+        cyan: '36',
+        green: '32',
+        dark_green: '2;32',
+        light_green: '1;32',
+        red: '31',
+        dark_red: '2;31',
+        light_red: '1;31',
+        magenta: '35',
+        dark_magenta: '2;35',
+        light_magenta: '1;35',
+        yellow: '33',
+        gray: '37',
+        dark_gray: '2;37',
+        light_gray: '37',
+        white: '1;37'
+    }
+
+    BACKGROUND_COLORS = {
+        black: '40',
+        blue: '44',
+        dark_blue: '2;44',
+        light_blue: '1;44',
+        cyan: '46',
+        green: '42',
+        dark_green: '2;42',
+        light_green: '1;42',
+        red: '41',
+        dark_red: '2;41',
+        light_red: '1;41',
+        magenta: '45',
+        dark_magenta: '2;45',
+        light_magenta: '1;45',
+        yellow: '43',
+        gray: '47',
+        dark_gray: '2;47',
+        light_gray: '47',
+        white: '1;47'
+    }
+
+
+    # Sets the title bar text of the console window.
+    def title=(text)
+        STDOUT.write "\e]0;#{text}\007"
+    end
+    module_function :title=
+
+
+    private
+
+
+    # Get the current console window size.
+    #
+    # @return [Array, nil] Returns a two-dimensional array of [cols, rows], or
+    #   nil if the console has been redirected.
+    def _window_size
+        unless @window_size
+            rows = `tput lines`
+            cols = `tput cols`
+            @window_size = [cols.chomp.to_i, rows.chomp.to_i]
+        end
+        @window_size
+    end
+    module_function :_window_size
+
+
+    # Write a line of text to the console, with optional foreground and
+    # background colors.
+    #
+    # @param text [String] The text to be written to the console.
+    # @param fg [Symbol, String] An optional foreground colour name or ANSI code.
+    # @param bg [Symbol, String] An optional background color name or ANSI code.
+    def _write(text, fg = nil, bg = nil)
+        if fg || bg
+            reset = true
+            if fg
+                fg_code = FOREGROUND_COLORS[fg] || fg
+                STDOUT.write "\e[#{fg_code}m"
+            end
+
+            if bg
+                bg_code = BACKGROUND_COLORS[bg] || bg
+                STDOUT.write "\e[#{bg_code}m"
+            end
+        end
+
+        STDOUT.write text
+
+        if reset
+            STDOUT.write "\e[0m"
+        end
+    end
+    module_function :_write
+
+
+    # Send a line of text to the screen, terminating with a new-line.
+    #
+    # @param text [String] The optional text to be written to the console.
+    # @param fg [Symbol, String] An optional foreground colour name or ANSI code.
+    # @param bg [Symbol, String] An optional background color name or ANSI code.
+    def _puts(text = nil, fg = nil, bg = nil)
+        if @status
+            _clear_line (@status.length / self.width) + 1
+        end
+        _write("#{text}", fg, bg)
+        STDOUT.write "\n"
+        if @status
+            _write @status, @status_fg, @status_bg
+        end
+    end
+    module_function :_puts
+
+
+    # Clears the current +lines+ line(s)
+    #
+    # @param lines [Fixnum] Number of lines to clear
+    def _clear_line(lines = 1)
+        raise ArgumentError, "Number of lines to clear (#{lines}) must be > 0" if lines < 1
+        while lines > 0
+            STDOUT.write "\r\e[2K"
+            lines -= 1
+            STDOUT.write "\e[A" if lines > 0
+        end
+    end
+    module_function :_clear_line
+
+end
+

data/lib/console/platform/windows.rb

@@ -0,0 +1,253 @@
+require 'ffi'
+
+
+module Console
+
+    # Implements Windows-specific platform functionality
+    module Windows
+
+        extend FFI::Library
+
+        ffi_lib 'kernel32.dll'
+        ffi_convention :stdcall
+
+
+        # FFI structure used to get/set information about the current console
+        # window buffer
+        class BufferInfo < FFI::Struct
+            layout  :width, :short,
+                    :height, :short,
+                    :cursor_x, :short,
+                    :cursor_y, :short,
+                    :text_attributes, :ushort,
+                    :window_left, :short,
+                    :window_top, :short,
+                    :window_right, :short,
+                    :window_bottom, :short,
+                    :max_width, :short,
+                    :max_height, :short
+        end
+
+
+        # FFI structure used to get/set buffer co-ordinates
+        class Coord < FFI::Struct
+            layout  :x, :short,
+                    :y, :short
+
+            def initialize(x, y)
+                self[:x] = x
+                self[:y] = y
+            end
+        end
+
+        # Define Windows console functions we need
+        attach_function :get_std_handle, :GetStdHandle, [:uint], :pointer
+        attach_function :get_console_screen_buffer_info, :GetConsoleScreenBufferInfo, [:pointer, :pointer], :bool
+        attach_function :set_console_cursor_position, :SetConsoleCursorPosition, [:pointer, Coord.by_value], :bool
+        attach_function :set_console_text_attribute, :SetConsoleTextAttribute, [:pointer, :ushort], :bool
+        attach_function :set_console_title, :SetConsoleTitleA, [:pointer], :bool
+
+
+        # Constants representing STDIN, STDOUT, and STDERR
+        STD_OUTPUT_HANDLE = 0xFFFFFFF5
+        STD_INPUT_HANDLE = 0xFFFFFFF6
+        STD_ERROR_HANDLE = 0xFFFFFFF7
+
+
+        # Retrieve a handle to STDOUT
+        def stdout
+            @stdout ||= self.get_std_handle(STD_OUTPUT_HANDLE)
+        end
+        module_function :stdout
+        private :stdout
+
+
+        # Retrieve a BufferInfo object
+        def buffer_info
+            @buffer_info ||= BufferInfo.new
+        end
+        module_function :buffer_info
+        private :buffer_info
+
+
+        # Populate a BufferInfo structure with details about the current
+        # buffer state.
+        #
+        # @return [BufferInfo] A BufferInfo structure containing fields for
+        #   various bits of console state.
+        def get_buffer_info
+            if stdout
+                self.get_console_screen_buffer_info(stdout, buffer_info)
+                @buffer_info
+            end
+        end
+        module_function :get_buffer_info
+
+
+        # Sets the console foreground and background colors.
+        def set_color(color)
+            if stdout && color
+                self.set_console_text_attribute(stdout, color)
+            end
+        end
+        module_function :set_color
+
+
+        # Sets the cursor position to the specified +x+ and +y+ locations in the
+        # console output buffer. If +y+ is nil, the cursor is positioned at +x+ on
+        # the current line.
+        def set_cursor_position(x, y)
+            if stdout && x && y
+                coord = Coord.new(x, y)
+                self.set_console_cursor_position(stdout, coord)
+            end
+        end
+        module_function :set_cursor_position
+
+    end
+
+
+    # Constants for colour components
+    BLUE = 0x1
+    GREEN = 0x2
+    RED = 0x4
+    INTENSITY = 0x8
+
+    # Constants for foreground and background colors
+    FOREGROUND_COLORS = {
+        black: 0,
+        blue: BLUE | INTENSITY,
+        dark_blue: BLUE,
+        light_blue: BLUE | INTENSITY,
+        cyan: BLUE | GREEN | INTENSITY,
+        green: GREEN,
+        dark_green: GREEN,
+        light_green: GREEN | INTENSITY,
+        red: RED | INTENSITY,
+        dark_red: RED,
+        light_red: RED | INTENSITY,
+        magenta: RED | BLUE,
+        dark_magenta: RED | BLUE,
+        light_magenta: RED | BLUE | INTENSITY,
+        yellow: GREEN | RED | INTENSITY,
+        gray: BLUE | GREEN | RED,
+        dark_gray: INTENSITY,
+        light_gray: BLUE | GREEN | RED,
+        white: BLUE | GREEN | RED | INTENSITY
+    }
+    BACKGROUND_COLORS = {}
+    FOREGROUND_COLORS.each{ |k, c| BACKGROUND_COLORS[k] = c << 4 }
+
+
+    # Sets the title bar text of the console window.
+    def title=(text)
+        Windows.set_console_title(text)
+    end
+    module_function :title=
+
+
+    private
+
+
+    # Save the reset text and background colors
+    buffer = Windows.get_buffer_info
+    @reset_colors = buffer && buffer[:text_attributes]
+
+
+    # Get the current console window size.
+    #
+    # @return [Array, nil] Returns a two-dimensional array of [cols, rows], or
+    #   nil if the console has been redirected.
+    def _window_size
+        unless @window_size
+            buffer = Windows.get_buffer_info
+            if buffer
+                if buffer[:window_right] > 0 && buffer[:window_bottom] > 0
+                    @window_size = [buffer[:window_right] - buffer[:window_left] + 1,
+                                    buffer[:window_bottom] - buffer[:window_top] + 1]
+                else
+                    @window_size = -1
+                end
+            else
+                @window_size = -1
+            end
+        end
+        @window_size == -1 ? nil : @window_size
+    end
+    module_function :_window_size
+
+
+    # Write a line of text to the console, with optional foreground and
+    # background colors.
+    #
+    # @param text [String] The text to be written to the console.
+    # @param fg [Symbol, Integer] An optional foreground colour name or value.
+    # @param bg [Symbol, Integer] An optional background color name or value.
+    def _write(text, fg = nil, bg = nil)
+        if fg || bg
+            reset = @reset_colors
+            if fg
+                fg_code = FOREGROUND_COLORS[fg] || fg
+                unless fg_code >= 0 && fg_code <= 0x0F
+                    raise ArgumentError, "Text color must be a recognised symbol or int"
+                end
+            else
+                fg_code = reset & 0x0F
+            end
+
+            if bg
+                bg_code = BACKGROUND_COLORS[bg] || bg
+                unless bg_code >= 0 && bg_code <= 0xF0
+                    raise ArgumentError, "Background color must be a recognised symbol or int"
+                end
+            else
+                bg_code = reset & 0xF0
+            end
+            Windows.set_color(fg_code | bg_code)
+        end
+
+        STDOUT.write text
+
+        if reset
+            Windows.set_color(reset)
+        end
+    end
+    module_function :_write
+
+
+    # Send a line of text to the screen, terminating with a new-line.
+    #
+    # @param text [String] The optional text to be written to the console.
+    # @param fg [Symbol, Integer] An optional foreground colour name or value.
+    # @param bg [Symbol, Integer] An optional background color name or value.
+    def _puts(text = nil, fg = nil, bg = nil)
+        if @status
+            _clear_line (@status.length / self.width) + 1
+        end
+        _write("#{text}\r\n", fg, bg)
+        if @status
+            _write(@status, @status_fg, @status_bg)
+        end
+    end
+    module_function :_puts
+
+
+    # Clears the current line
+    def _clear_line(lines = 1)
+        raise ArgumentError, "Number of lines to clear (#{lines}) must be > 0" if lines < 1
+        buffer = Windows.get_buffer_info
+        if buffer
+            y = buffer[:cursor_y]
+            while lines > 0
+                Windows.set_cursor_position(0, y)
+                STDOUT.write ' ' * (buffer[:window_right] - buffer[:window_left])
+                Windows.set_cursor_position(0, y)
+                lines -= 1
+                y -= 1
+            end
+        end
+    end
+    module_function :_clear_line
+
+end
+

data/lib/console/progress.rb

@@ -0,0 +1,70 @@
+module Console
+
+    # Sets text to be displayed temporarily on the current line. Status text can
+    # be updated or cleared.
+    #
+    # @param status [String] The text to be displayed as the current status.
+    #   Pass +nil+ to clear the status display.
+    # @params opts [Hash] Options to control the colour of the status display.
+    # @option opts [Symbol] :text_color The text color to use when displaying
+    #   the status message.
+    # @option opts [Symbol] :background_color The background color to use when
+    #   rendering the status message
+    def status(msg, opts = {})
+        if self.width
+            @lock.synchronize do
+                if @status
+                    # Clear existing status
+                    _clear_line (@status.length / self.width) + 1
+                end
+                @completed = nil
+                @status = msg
+                if @status
+                    @status_fg = opts.fetch(:text_color, opts.fetch(:color, :cyan))
+                    @status_bg = opts[:background_color]
+                    _write @status, @status_fg, @status_bg
+                end
+            end
+        end
+    end
+    module_function :status
+
+
+    # Displays a progress bar as the current status line. The status line is a
+    # partial line of text printed at the current scroll location, and which
+    # can be updated or cleared.
+    #
+    # @param label [String] The label to be displayed after the progress bar.
+    # @param complete [Fixnum] Number of completed steps.
+    # @param opts [Fixnum, Hash] If a Fixnum is passed, this is the total number
+    #   of steps. If a Hash is passed, it is an options hash with the following
+    #   possible options.
+    # @option opts [Fixnum] :total The total number of steps; default is 100.
+    # @see #status for other supported options
+    def show_progress(label, complete, opts = {})
+        if self.width
+            opts = {total: opts} if opts.is_a?(Fixnum)
+            total = opts.fetch(:total, 100)
+            complete = total if complete > total
+            bar_length = opts.fetch(:bar_length, 40)
+            completion = complete * bar_length / total
+            pct = "#{complete * 100 / total}%"
+            bar = "#{'=' * completion}#{' ' * (bar_length - completion)}"
+            bar[(bar_length - pct.length) / 2, pct.length] = pct
+            if @completed.nil? || pct != @completed
+                self.status("[#{bar}]  #{label}", opts)
+                @completed = pct
+            end
+        end
+    end
+    module_function :show_progress
+
+
+    # Clears any currently displayed progress bar or status message.
+    def clear_progress
+        self.status nil
+    end
+    alias_method :clear_status, :clear_progress
+    module_function :clear_progress, :clear_status
+
+end

data/lib/console/table.rb

@@ -0,0 +1,155 @@
+module Console
+
+    # Displays an array of arrays as a table of data. The content of each row
+    # is aligned and wrapped if necessary to fit the column widths.
+    #
+    # @param rows [Array] An array of arrays containing the data to be output.
+    #   The number of elements in the first array determines the number of
+    #   columns that will be output, unless the :column_widths options is passed;
+    #   in that case, the number of column width specifications determines the
+    #   number of columns output.
+    # @param opts [Hash] An options hash containing settings that determine how
+    #   the table is rendered.
+    # @options opts [Array<Fixnum>] :col_widths The width to use for each column.
+    # @option opts [Fixnum] :width The width of the table. If omitted, the width
+    #   is determined instead by the :col_widths option.
+    # @options opts [Char] :col_sep The character to use between each column.
+    #   If omitted, no column line is drawn. Note though that each column is
+    #   rendered with 1 space of padding on the left and right.
+    # @options opts [Char] :row_sep The character to use to render a row
+    #   separator. If omitted, no row separators are rendered.
+    # @options opts [Fixnum] :indent The number of characters to indent the
+    #   table from the left margin of the console. If omitted, no indent is
+    #   used.
+    # @options opts [Symbol] :color The color in which to render the text of the
+    #   table.
+    # @options opts [Symbol] :text_color The color in which to render the text
+    #   of the table.
+    # @options opts [Symbol] :background_color The color in which to render the
+    #   background of the table.
+    def display_table(rows, opts = {})
+        return unless rows && rows.size > 0 && rows.first.size > 0
+        col_widths = opts[:col_widths]
+        unless col_widths
+            col_count = rows.first.size
+            avail_width = (opts[:width] || ((width || 10000) - opts.fetch(:indent, 0))) -
+                (" #{opts[:col_sep]} ".length * col_count)
+            col_widths = _calculate_widths(rows, col_count, avail_width - 1)
+        end
+
+        @lock.synchronize do
+            _output_row_sep(col_widths, opts) if opts[:row_sep]
+            rows.each do |row|
+                _display_row(row, col_widths, opts)
+            end
+        end
+    end
+    module_function :display_table
+
+
+    # Displays a single +row+ of data within columns of +widths+ width. If the
+    # contents of a cell exceeds the available width, it is wrapped, and the row
+    # is displayed over multiple lines.
+    #
+    # @param row [Array] An array of data to display as a single row.
+    # @param widths [Array<Fixnum>] An array of column widths to use for each
+    #   column.
+    # @param opts [Hash] An options hash containing settings that determine how
+    #   the table is rendered.
+    # @see #display_table for details of the supported options.
+    def display_row(row, widths, opts = {})
+        return unless row && row.size > 0
+        @lock.synchronize do
+            _display_row(row, widths, opts)
+        end
+    end
+    module_function :display_row
+
+
+    private
+
+
+    # Calculates the widths to use to display a table of data.
+    def _calculate_widths(rows, col_count, avail_width)
+        max_widths = Array.new(col_count)
+        rows.each do |row|
+            row.each_with_index do |col, i|
+                max_widths[i] = col.to_s.length if !max_widths[i] || col.to_s.length > max_widths[i]
+            end
+        end
+        max_width = max_widths.reduce(0, &:+)
+        while avail_width < max_width
+            # Reduce longest width(s) to next longest
+            longest = max_widths.max
+            num_longest = max_widths.count{ |w| w == longest }
+            next_longest = max_widths.select{ |w| w < longest }.max
+            if !next_longest || (num_longest * (longest - next_longest) > max_width - avail_width)
+                reduction = (max_width - avail_width) / num_longest
+                reduction = 1 if reduction <= 0
+                if !next_longest
+                    max_widths.map!{ |w| w - reduction }
+                else
+                    max_widths.map!{ |w| w > next_longest ? w - reduction : w }
+                end
+            else
+                max_widths.map!{ |w| w > next_longest ? next_longest : w }
+            end
+            max_width = max_widths.reduce(0, &:+)
+        end
+        max_widths
+    end
+    module_function :_calculate_widths
+
+
+    # Displays a single +row+ of data within columns of +widths+ width. If the
+    # contents of a cell exceeds the available width, it is wrapped, and the row
+    # is displayed over multiple lines.
+    def _display_row(row, widths, opts = {})
+        fg = opts.fetch(:text_color, opts.fetch(:color, :cyan))
+        bg = opts[:background_color]
+        indent = opts.fetch(:indent, 0)
+        col_sep = opts[:col_sep]
+        row_sep = opts[:row_sep]
+
+        line_count = 0
+        lines = row.each_with_index.map do |col, i|
+            cell_lines = wrap_text(col, widths[i])
+            line_count = cell_lines.size if cell_lines.size > line_count
+            cell_lines
+        end
+        (0...line_count).each do |i|
+            _write(' ' * indent)
+            _write("#{col_sep} ", fg, bg) if col_sep
+            line = (0...widths.size).map do |col|
+                "%#{row[col].is_a?(Numeric) ? '' : '-'}#{widths[col]}s" %
+                (lines[col] && lines[col][i])
+            end.join(" #{col_sep} ")
+            _write(line, fg, bg)
+            _write(" #{col_sep}", fg, bg) if col_sep
+            _puts
+        end
+        _output_row_sep(widths, opts) if row_sep
+    end
+    module_function :_display_row
+
+
+    # Outputs a row separator line
+    def _output_row_sep(widths, opts)
+        fg = opts.fetch(:text_color, opts.fetch(:color, :cyan))
+        bg = opts[:background_color]
+        indent = opts.fetch(:indent, 0)
+        col_sep = opts[:col_sep]
+        row_sep = opts[:row_sep]
+        corner = opts.fetch(:corner, col_sep ? '+' * col_sep.length : '')
+
+        sep_row = widths.map{ |width| row_sep * (width + 2) }
+        _write(' ' * indent)
+        _write(corner, fg, bg)
+        _write(sep_row.join(corner), fg, bg)
+        _write(corner, fg, bg)
+        _puts
+    end
+    module_function :_output_row_sep
+
+end
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: color-console
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Adam Gardiner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-22 00:00:00.000000000 Z
+dependencies: []
+description: ! "        ColorConsole supports cross-platform (ANSI and Windows) colored
+  text output to the console.\n        It also provides useful methods for building
+  command-line interfaces that provide status\n        messages and progress bars.\n"
+email: adam.b.gardiner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/color-console.rb
+- lib/color_console.rb
+- lib/console/console.rb
+- lib/console/platform/ansi.rb
+- lib/console/platform/windows.rb
+- lib/console/progress.rb
+- lib/console/table.rb
+homepage: https://github.com/agardiner/color-console
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: ColorConsole is a cross-platform library for outputting colored text to the
+  console
+test_files: []