convoy 1.0.0

data/lib/convoy/formatter/shell_command_executor.rb

@@ -0,0 +1,49 @@
+require 'open3'
+
+module Convoy
+    module Formatter
+        class ShellCommandExecutor
+            attr_reader :command
+
+            def initialize(command)
+                @command = command
+            end
+
+            def execute_in_current_shell(success_callback = nil, error_callback = nil)
+                begin
+                    result = `#{command}`
+                    process_status = $?
+                    raise Convoy::InternalError.new("Shell command exited with a non-zero (#{process_status.exitstatus}) exit code") if process_status.exitstatus != 0
+                    success_callback.call(command, result) if success_callback
+                rescue => e
+                    error_callback.call(command, e) if error_callback
+                    nil
+                end
+            end
+
+            #def execute_in_new_shell(success_callback = nil, error_callback = nil)
+            #stdin, stdout, stderr = nil, nil, nil
+            #begin
+            #stdin, stdout, stderr, thread = ensure_successful_exit do
+            #Open3.popen3(command)
+            #end
+            #success_callback.call(command, stdin, stdout, stderr) if success_callback
+            #rescue => e
+            #error_callback.call(command, e) if error_callback
+            #nil
+            #ensure
+            #[stdin, stdout, stderr].each {|io| io.close if io}
+            #end
+            #end
+
+            #private
+
+            #def ensure_successful_exit(&block)
+            #stdin, stdout, stderr, thread = block.call
+            #process_status = thread.value
+            #raise Convoy::InternalError.new("Shell command exited with a non-zero (#{process_status.exitstatus}) exit code") if process_status.exitstatus != 0
+            #[stdin, stdout, stderr, thread]
+            #end
+        end
+    end
+end

data/lib/convoy/formatter/stream_output_formatter.rb

@@ -0,0 +1,88 @@
+module Convoy
+    module Formatter
+        class StreamOutputFormatter
+            DEFAULT_OUTPUT_WIDTH = 80
+            DEFAULT_INDENT_STRING = ' '
+            DEFAULT_INDENT = 0
+
+            attr_reader :stream, :indent_string, :current_indent, :max_output_width, :cursor_position
+
+            def initialize(stream = $stdout, options = {}, &block)
+                @stream = stream
+                @max_output_width = options[:max_output_width] || DEFAULT_OUTPUT_WIDTH
+                @indent_string = options[:indent_string] || DEFAULT_INDENT_STRING
+                @current_indent = options[:current_indent] || DEFAULT_INDENT
+                @cursor_position = CursorPosition.new(@max_output_width)
+                block.call(self) if block_given?
+            end
+
+            def print(string)
+                splitter_input = pad_string_to_account_for_cursor_position(string.to_s)
+                segments = StringSplitter.new(max_output_width).split(splitter_input)
+                segments = remove_padding_that_account_for_cursor_position(segments)
+                segments.each do |segment|
+                    output_string = "#{current_indent_string}#{segment}"
+                    output_string = segment unless cursor_position.newline?
+                    stream.print output_string
+                    cursor_position.update_for(segment)
+                    newline if segments.last != segment
+                end
+            end
+
+            def puts(string, options = {:newlines => 1})
+                print(string)
+                newline(options[:newlines])
+            end
+
+            def newline(newline_count = 1)
+                stream.print("\n" * newline_count)
+                cursor_position.reset if newline_count > 0
+            end
+
+            def indent(count, &block)
+                newline unless cursor_position.newline?
+                new_indent = current_indent + count
+                self.class.new(stream, :max_output_width => max_output_width - count, :indent_string => indent_string, :current_indent => new_indent, &block)
+            end
+
+            def grid(options = {}, &block)
+                if block_given?
+                    options[:width] ||= max_output_width
+                    grid = StringGrid.new(options, &block)
+                    puts grid.to_s
+                end
+            end
+
+            private
+
+            def pad_string_to_account_for_cursor_position(string)
+                "#{padding_string}#{string}"
+            end
+
+            def remove_padding_that_account_for_cursor_position(segments)
+                first_string = segments.first
+                if first_string
+                    segments[0] = first_string.sub(/#{padding_string}/, '')
+                end
+                segments
+            end
+
+            def padding_string
+                "." * cursor_position.position
+            end
+
+            def current_indent_width
+                current_indent_string.length
+            end
+
+            def current_indent_string
+                indent_string * current_indent
+            end
+
+            #def table(options = {}, &block)
+            #BorderlessTable.new(self, options).output(&block)
+            #newline(options[:newlines] || 1)
+            #end
+        end
+    end
+end

data/lib/convoy/formatter/string_grid.rb

@@ -0,0 +1,108 @@
+module Convoy
+    module Formatter
+        class StringGrid
+            DEFAULT_WIDTH = 80
+
+            attr_reader :column_count, :width
+            attr_accessor :rows
+
+            def initialize(options = {}, &block)
+                @width = options[:width] || DEFAULT_WIDTH
+                @column_count = options[:columns] || 3
+                @rows = []
+                block.call(self) if block_given?
+            end
+
+            def row(*column_values)
+                while column_values.size < @column_count
+                    column_values << ''
+                end
+                rows << column_values.map(&:to_s)
+            end
+
+            def to_s
+                buffer = []
+                rows.each do |cells|
+                    virtual_row = normalize_virtual_row(virtual_row_for(cells))
+                    physical_row_count_for(virtual_row).times do |physical_count|
+                        physical_row = format_physical_row_values(physical_row_for(virtual_row, physical_count))
+                        buffer << physical_row.join("").chomp
+                    end
+                end
+                buffer.join("\n")
+            end
+
+            private
+
+            def format_physical_row_values(physical_row)
+                physical_row.each_with_index.map do |value, index|
+                    cell_value(value, index)
+                end
+            end
+
+            def physical_row_for(virtual_row, index)
+                virtual_row.map { |physical| physical[index] }
+            end
+
+            def virtual_row_for(column_values)
+                virtual_row = []
+                column_values.each_with_index do |cell, index|
+                    virtual_row << Convoy::Formatter::StringSplitter.new(column_width(index) - 1).split(cell)
+                end
+                normalize_virtual_row(virtual_row)
+            end
+
+            def normalize_virtual_row(virtual_row)
+                virtual_row.map do |physical|
+                    while physical.size < physical_row_count_for(virtual_row)
+                        physical << ""
+                    end
+                    physical
+                end
+            end
+
+            def physical_row_count_for(virtual_row)
+                virtual_row.map { |physical| physical.size }.max
+            end
+
+            def column_width(column_index)
+                width = fair_column_width(column_index)
+                if column_index == column_count - 1
+                    width = last_column_width
+                end
+                width
+            end
+
+            def fair_column_width(index)
+                width = values_in_column(index).map(&:length).max
+                width = width + 1
+                width > max_column_width ? max_column_width : width
+            end
+
+            def last_column_width
+                full_fair_column_width = max_column_width * column_count + max_column_width_remainder
+                all_but_last_fair_column_width = 0
+                (column_count - 1).times do |index|
+                    all_but_last_fair_column_width += fair_column_width(index)
+                end
+                full_fair_column_width - all_but_last_fair_column_width
+            end
+
+            def values_in_column(column_index)
+                rows.map { |cells| cells[column_index] }
+            end
+
+            def max_column_width
+                width/column_count
+            end
+
+            def max_column_width_remainder
+                width%column_count
+            end
+
+            def cell_value(value, column_index)
+                sprintf("%-#{column_width(column_index)}s", value)
+            end
+        end
+    end
+end

data/lib/convoy/formatter/string_splitter.rb

@@ -0,0 +1,50 @@
+module Convoy
+    module Formatter
+        class StringSplitter
+            attr_reader :max_segment_width #, :first_segment_max_length
+
+            def initialize(max_segment_width, options = {})
+                @max_segment_width = max_segment_width
+                #@first_segment_max_length = options[:first_segment_max_length] || max_segment_width
+            end
+
+            def split(input_string)
+                input_strings = input_string.split("\n")
+                [split_strings(input_strings)].flatten
+                #first_string = strings.shift
+                #other_strings = strings
+                #result = [split_first_string(first_string) + split_strings(other_strings)].flatten
+                #result
+            end
+
+            private
+
+            #def split_first_string(string)
+            #if first_segment_max_length >= string.length
+            #split_string(string)
+            #else
+            #first = string.slice(0, first_segment_max_length)
+            #last = string.slice(first_segment_max_length..-1)
+            #split_strings([first, last])
+            #end
+            #end
+
+            def split_strings(strings)
+                strings.map { |s| split_string(s) }
+            end
+
+            def split_string(string)
+                result = []
+                if string.length > max_segment_width
+                    first_part = string.slice(0, max_segment_width)
+                    second_part = string.slice(max_segment_width..-1)
+                    result << first_part
+                    result << split_string(second_part)
+                else
+                    result << string
+                end
+                result
+            end
+        end
+    end
+end

data/lib/convoy/formatter/terminal.rb

@@ -0,0 +1,30 @@
+module Convoy
+    module Formatter
+        class Terminal
+            DEFAULT_WIDTH = 80
+
+            class << self
+                def width
+                    tput_width
+                end
+
+                private
+
+                def tput_width
+                    ShellCommandExecutor.new('/usr/bin/env tput cols').execute_in_current_shell(tput_cols_command_success_callback, tput_cols_command_error_callback) || DEFAULT_WIDTH
+                end
+
+                def tput_cols_command_success_callback
+                    lambda { |command, result| result.to_i }
+                end
+
+                def tput_cols_command_error_callback
+                    lambda do |command, e|
+                        error_logger.debug { e }
+                        error_logger.info { "Unable to find terminal width via '#{command}', using default of #{DEFAULT_WIDTH}" }
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/convoy/global_pre_parser.rb

@@ -0,0 +1,43 @@
+module Convoy
+    class GlobalPreParser
+        attr_reader :setup
+
+        def initialize(setup)
+            @setup = setup
+        end
+
+        def parse(cli_options)
+            AutoOptions.new(parse_global_options(cli_options))
+        end
+
+        private
+
+        def parse_global_options(cli_options, context = [])
+            stop_words = setup.command_names_for(context).map(&:to_s)
+            parser = init_parser(stop_words)
+            parser = add_setup_options_to(parser, context)
+            parser.version(setup.version) #set the version if it was provided
+            parser.help_formatter(Convoy::Formatter::DefaultHelpFormatter.new(setup, context))
+            parsed_options = parse_options_string(parser, cli_options)
+        end
+
+        def init_parser(stop_words)
+            Trollop::Parser.new.tap do |parser|
+                parser.stop_on(stop_words)
+            end
+        end
+
+        def add_setup_options_to(parser, context = [])
+            setup.options_for(context).each do |name, opts|
+                parser.opt name, opts[:desc] || "", opts
+            end
+            parser
+        end
+
+        def parse_options_string(parser, cli_options)
+            Trollop::with_standard_exception_handling(parser) do
+                parser.parse(cli_options)
+            end
+        end
+    end
+end

data/lib/convoy/logger.rb

@@ -0,0 +1,75 @@
+require 'logger'
+
+module Convoy
+    class Logger
+        class << self
+            def close
+                error.close
+                output.close
+            end
+
+            def error
+                @error_logger ||= ::Logger.new($stderr).tap do |l|
+                    #l.formatter = advanced_error_formatter
+                    l.formatter = basic_error_formatter
+                    l.sev_threshold = ::Logger::WARN
+                end
+            end
+
+            def output
+                @output_logger ||= ::Logger.new($stdout).tap do |l|
+                    l.formatter = output_formatter
+                    l.sev_threshold = ::Logger::DEBUG
+                    l.instance_eval do
+                        def puts(message = nil, &block)
+                            if block_given?
+                                fatal(&block)
+                            else
+                                fatal(message || "")
+                            end
+                        end
+                    end
+                end
+            end
+
+            def setup_error_logger(auto_options)
+                error.formatter = send(:"#{auto_options.error_formatter}_error_formatter")
+                error.sev_threshold = ::Logger.const_get(auto_options.verbosity)
+            end
+
+            private
+
+            def basic_error_formatter
+                proc do |severity, datetime, progname, msg|
+                    "#{msg2str(msg)}\n"
+                end
+            end
+
+            #"#{severity} [#{datetime.strftime("%d/%b/%Y %H:%M:%S")}] \"#{msg}\"\n"
+            def advanced_error_formatter
+                proc do |severity, datetime, progname, msg|
+                    sprintf("%-8s #{msg2str(msg, 10)}\n", severity)
+                end
+            end
+
+            def output_formatter
+                proc do |severity, datetime, progname, msg|
+                    "#{msg}\n"
+                end
+            end
+
+            def msg2str(msg, backtrace_indent = 0)
+                case msg
+                    when ::String
+                        msg
+                    when ::Exception
+                        "#{msg.message} (#{ msg.class })\n" <<
+                            (msg.backtrace || []).map { |line| sprintf("%#{backtrace_indent}s#{line}", "") }.join("\n")
+                    else
+                        msg.inspect
+                end
+            end
+        end
+    end
+end
+