blufin-lib 1.4.0

data/lib/blufin-lib/core/network.rb

@@ -0,0 +1,25 @@
+require 'open-uri'
+
+module Blufin
+
+    class Network
+
+        # Checks if internet connection is present.
+        # @return boolean|void
+        def self.check_machine_is_online
+
+            begin
+
+                return true if open('http://www.google.com')
+
+            rescue
+
+                Blufin::Terminal::error('No internet connection', 'This script requires an internet connection and your machine is not online.')
+
+            end
+
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/numbers.rb

@@ -0,0 +1,15 @@
+module Blufin
+
+    class Numbers
+
+        # Add's comma's to numbers greater than 1000.
+        # Code from: https://dzone.com/articles/format-number-thousands
+        # @return String
+        def self.add_commas(number)
+            whole_part, decimal_part = number.to_s.split('.')
+            [whole_part.gsub(/(\d)(?=\d{3}+$)/, '\1,'), decimal_part].compact.join('.')
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/routes.rb

@@ -0,0 +1,85 @@
+module Blufin
+
+    class Routes
+
+        # Returns number of flags set for route (from @opts variable)
+        # @param Array (@opts)
+        # @return int
+        def self.flags_set(opts)
+            flags_set = 0
+            opts.each do |key, value|
+                # Only here to prevent code-inspector from complaining.
+                key.strip! if key.nil?
+                if value
+                    flags_set = flags_set + 1
+                end
+            end
+            if flags_set > 0
+                flags_set = flags_set / 2
+            end
+            flags_set
+        end
+
+        # Will throw an error if more than one flag is set.
+        # @param Array (@opts)
+        # @return void
+        def self.max_one_flag(opts)
+            all_flags = []
+            opts.each_key do |key|
+                unless key.to_s =~ /_given\z/i || key == :version || key == :help
+                    all_flags << key.to_s
+                end
+            end
+            if flags_set(opts) >= 2
+                error_text = ['Please set 1 one of the following flags:', nil]
+                all_flags.each do |flag|
+                    error_text << "  \x1B[38;5;244m--#{convert_underscore_to_hypen(flag)}\x1B[0m"
+                end
+                Blufin::Terminal::error("You can set #{Blufin::Terminal::format_highlight('only one')} flag at a time", error_text)
+            end
+        end
+
+        # Will throw an error if no flags are set.
+        # @param Array (@opts)
+        # @return void
+        def self.at_least_one_flag(opts)
+            all_flags = []
+            opts.each_key do |key|
+                unless key.to_s =~ /_given\z/i || key == :version || key == :help
+                    all_flags << key.to_s
+                end
+            end
+            if flags_set(opts) <= 0
+                error_text = ['Available flags are:', nil]
+                all_flags.each do |flag|
+                    error_text << "  \x1B[38;5;244m--#{convert_underscore_to_hypen(flag.to_s)}\x1B[0m"
+                end
+                Blufin::Terminal::error("You must set #{Blufin::Terminal::format_highlight('atleast one')} flag", error_text)
+            end
+        end
+
+        # Will throw an error if more than 1 of the possible flags is set.
+        # Having NONE of the flags set is OK.
+        # @return void
+        def self.only_one_of(opts, possible_flags = [])
+            raise RuntimeError, "Expected Array, instead got: #{possible_flags.class}" unless possible_flags.is_a?(Array)
+            raise RuntimeError, 'possible_flags cannot be an empty Array.' unless possible_flags.any?
+            flags_set = 0
+            possible_flags.each { |possible_flag|
+                raise RuntimeError, "@opts does not contain flag: #{possible_flag}" unless opts.has_key?(possible_flag)
+                flags_set += 1 if opts[possible_flag]
+            }
+            Blufin::Terminal::error("Cannot set #{Blufin::Terminal::format_highlight('more than one')} of the following flags: \x1B[38;5;172m#{possible_flags.join(', ')}\x1B[0m") if flags_set > 1
+        end
+
+        private
+
+        # Does exactly what it says on the Tin.
+        # @return string
+        def self.convert_underscore_to_hypen(flag)
+            flag.gsub('_', '-')
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/ssh.rb

@@ -0,0 +1,145 @@
+module Blufin
+
+    class SSH
+
+        SSH_PREFIX = 'ssh_'
+
+        # SSH into remote host.
+        # @return void
+        def self.ssh_into_remote(config_key)
+            if config_key.nil?
+                show_available_ssh_hosts
+            else
+                ssh_user, ssh_host, ssh_cert = get_ssh_credentials(config_key)
+                ssh_into_remote_credentials(ssh_user, ssh_host, ssh_cert)
+            end
+        end
+
+        # SSH into remote with pre-supplied credentials.
+        # @return void
+        def self.ssh_into_remote_credentials(ssh_user, ssh_host, ssh_cert = nil)
+            if ssh_cert.nil?
+                Blufin::Terminal::command("ssh #{ssh_user}@#{ssh_host}", nil, false, false)
+            else
+                Blufin::Terminal::command("ssh -i #{ssh_cert} #{ssh_user}@#{ssh_host}", nil, false, false)
+            end
+        end
+
+        # Source can be a file or directory but whatever it is, target must be the same (a file or directory).
+        # @return void
+        def self.scp_to_remote(config_key, source, target)
+            if config_key.nil?
+                show_available_ssh_hosts
+            else
+                ssh_user, ssh_host, ssh_cert = get_ssh_credentials(config_key)
+                unless Blufin::Files::file_exists(source)
+                    Blufin::Terminal::error("The file doesn't exist: #{Blufin::Terminal::format_directory(source)}", nil, true)
+                    return
+                end
+                Blufin::Terminal::command("scp -i #{ssh_cert} #{source} #{ssh_user}@#{ssh_host}:#{target}", nil)
+            end
+        end
+
+        private
+
+        # Get SSH credentials from the config file.
+        # @return Array
+        def self.get_ssh_credentials(config_key)
+            ssh_parts    = Blufin::Config.get_custom_key(SSH_PREFIX, config_key).split('|')
+            ssh_user     = ssh_parts[0]
+            ssh_host     = ssh_parts[1]
+            ssh_cert     = ssh_parts[2].to_s.strip.length == 0 ? nil : ssh_parts[2]
+            help_message = [
+                "The file: #{Blufin::Terminal::format_directory(ConfigUnique::CONFIG_FILE)} must contain a line similar to the following:",
+                nil,
+                'ssh_ec2=ec2-user|ec2-XX-XX-XX-XX.eu-west-1.compute.amazonaws.com|~/.ssh/pem-key.pem',
+                'ssh_ec2=ec2-user|ec2-XX-XX-XX-XX.eu-west-1.compute.amazonaws.com',
+            ]
+            Blufin::Terminal::error("SSH #{Blufin::Terminal::format_highlight('user')} required", help_message, true) if ssh_user.nil? || ssh_user == ''
+            Blufin::Terminal::error("SSH #{Blufin::Terminal::format_highlight('host')} required", help_message, true) if ssh_host.nil? || ssh_host == ''
+            unless ssh_cert.nil?
+                unless Blufin::Files::file_exists(File.expand_path(ssh_cert))
+                    Blufin::Terminal::error("PEM key not found: #{Blufin::Terminal::format_directory(ssh_cert)}")
+                end
+            end
+            return ssh_user, ssh_host, ssh_cert
+        end
+
+        # Check that SSHPASS is installed.
+        # @return void
+        def self.check_sshpass_is_installed
+            Blufin::UtilsTools::check_sshpass_is_installed
+        end
+
+        # Runs a series of commands on the VM.
+        # @return void
+        def self.command(commands, ssh_user, ssh_host, ssh_cert, verbose = true)
+            commands = [commands] unless commands.is_a?(Array)
+            if commands.any?
+                commands.each do |command|
+                    puts "\x1B[48;5;136m Executing \x1B[0m \xe2\x86\x92\x1B[0m #{Blufin::Terminal::format_command("#{command} \x1B[0m\xe2\x86\x92 \x1B[38;5;202m[\x1B[38;5;168m#{ssh_user}@#{ssh_host}\x1B[38;5;202m]\x1B[0m")}" if verbose
+                    if ssh_cert.nil?
+                        Blufin::Terminal::command("ssh #{ssh_user}@#{ssh_host} '#{command}'", nil, false, false)
+                    else
+                        Blufin::Terminal::command("ssh -i #{ssh_cert} #{ssh_user}@#{ssh_host} '#{command}'", nil, false, false)
+                    end
+                end
+            end
+        end
+
+        # Runs a series of commands on the VM and capture output.
+        # Currently only works for single-line output (IE: Won't capture multi-line output properly).
+        # @return void
+        def self.command_capture(commands, ssh_user, ssh_host, ssh_cert, verbose = true)
+            commands = [commands] unless commands.is_a?(Array)
+            results  = []
+            if commands.any?
+                commands.each do |command|
+                    puts "\x1B[48;5;136m Executing \x1B[0m \xe2\x86\x92\x1B[0m #{Blufin::Terminal::format_command("#{command} \x1B[0m\xe2\x86\x92 \x1B[38;5;202m[\x1B[38;5;168m#{ssh_user}@#{ssh_host}\x1B[38;5;202m]\x1B[0m")}" if verbose
+                    if ssh_cert.nil?
+                        results << Blufin::Terminal::command_capture("ssh #{ssh_user}@#{ssh_host} '#{command}'", nil, false, false)[0].gsub(/\n$/, '')
+                    else
+                        results << Blufin::Terminal::command_capture("ssh -i #{ssh_cert} #{ssh_user}@#{ssh_host} '#{command}'", nil, false, false)[0].gsub(/\n$/, '')
+                    end
+                end
+            end
+            results
+        end
+
+        # Show a list of available SSH hosts.
+        # @return void
+        def self.show_available_ssh_hosts
+            all_keys          = Blufin::Config::params
+            ssh_hosts         = []
+            ssh_hosts_lengths = []
+            all_keys.keys.each do |key|
+                if key =~ /\A#{SSH_PREFIX}.+/i
+                    ssh_hosts_lengths << key.length
+                end
+            end
+            if ssh_hosts_lengths.any?
+                ssh_hosts_lengths.uniq!
+                max_key_length = ssh_hosts_lengths.max - SSH_PREFIX.length
+                all_keys.keys.sort!.each do |key|
+                    if key =~ /\A#{SSH_PREFIX}.+/i
+                        ssh_user, ssh_host, ssh_cert = get_ssh_credentials(key.gsub(SSH_PREFIX, ''))
+                        ssh_hosts << "\x1B[38;5;154m#{key.gsub(SSH_PREFIX, '').rjust(max_key_length, ' ')}\x1B[0m\x1B[38;5;240m \xe2\x80\x94 #{ssh_host} \x1B[38;5;245m(#{ssh_user})#{ssh_cert.nil? ? '' : "\x1B[38;5;204m #{ssh_cert}"}"
+                    end
+                end
+                Blufin::Terminal::info('Pre-configured hosts to SSH into:', ssh_hosts)
+            else
+                help_message = [
+                    "To define a remote host \xe2\x80\x94 run #{Blufin::Terminal::format_command("#{ConfigUnique::GEM_NAME} x")} and add a line similar to:",
+                    nil,
+                    "\x1B[38;5;154mssh_ec2=ec2-user|ec2-XX-XX-XX-XX.eu-west-1.compute.amazonaws.com|~/.ssh/pem-key.pem",
+                    "\x1B[38;5;154mssh_ec2=ec2-user|ec2-XX-XX-XX-XX.eu-west-1.compute.amazonaws.com",
+                    nil,
+                    "IMPORTANT: Configuration key must start with prefix: #{Blufin::Terminal::format_highlight(SSH_PREFIX)}"
+                ]
+                Blufin::Terminal::info('No remote host(s) defined in configuration file', help_message)
+            end
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/strings.rb

@@ -0,0 +1,109 @@
+module Blufin
+
+    class Strings
+
+        # Convert 'snake_case' or 'SnAKE_cAse' to 'SnakeCase'.
+        # @param String
+        # @return String
+        def self.snake_case_to_camel_case(string)
+            validate_string(string)
+            string = string.downcase
+            return string if string !~ /_/ && string =~ /[A-Z]+.*/
+            string.split('_').map { |e| e.capitalize }.join
+        end
+
+        # Convert 'snake_case' or 'SnAKE_cAse' to 'snakeCase'.
+        # @param String
+        # @return String
+        def self.snake_case_to_camel_case_lower(string)
+            string = snake_case_to_camel_case(string)
+            "#{string[0, 1].downcase}#{string[1..-1]}"
+        end
+
+        # Convert 'CamelCase' to 'snake_case'
+        # @param String
+        # @return String
+        def self.camel_case_to_snake_case(string)
+            string.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
+        end
+
+        # Remove preceding/trailing slashes from a string (and trim preceding/trailing whitespace).
+        # @param String - The string to be trimmed (and returned).
+        # @return String
+        def self.remove_surrounding_slashes(string)
+            raise RuntimeError, "Expected String, instead got:#{string.class}" unless string.is_a?(String)
+            string = string.strip
+            validate_string(string)
+            string = string.gsub(/\A\/+/, '')
+            string = string.gsub(/\/+\z/, '')
+            string
+        end
+
+        # Extracts parts of a string. Regex is what to match, array is what to remove (gsub) afterwards.
+        # @return boolean
+        def self.extract_using_regex(string, regex, strings_to_remove)
+            unless strings_to_remove.is_a?(Array)
+                raise RuntimeError, "'strings_to_remove' must be an Array. You passed: #{strings_to_remove.class}"
+
+            end
+            match = string.match(regex)
+            raise RuntimeError, "No match found for '#{string}' and regex '#{regex}'." if match.nil?
+            match_to_return = match[0]
+            strings_to_remove.each do |string_to_remove|
+                match_to_return = match_to_return.gsub(string_to_remove, '')
+            end
+            match_to_return
+        end
+
+        # Finds the difference between 2 string
+        # Anything up to 0.15 means they're fairly similar.
+        # @return Float
+        def self.string_difference_percent(a, b)
+            validate_string(a)
+            validate_string(b)
+            x             = a.dup.gsub(' ', '')
+            y             = b.dup.gsub(' ', '')
+            x_hash        = string_difference_as_hash(x)
+            y_hash        = string_difference_as_hash(y)
+            total_letters = x.length + y.length
+            x_hash.each do |key, value|
+                if y_hash.has_key?(key)
+                    if y_hash[key] == x_hash[key]
+                        y_hash.delete(key)
+                    else
+                        y_hash[key] = (x_hash[key].to_i - y_hash[key].to_i).abs
+                    end
+                end
+            end
+            discrepancies = 0
+            y_hash.each do |key, value|
+                discrepancies = discrepancies + value.to_i
+            end
+            return ((discrepancies.to_f / total_letters.to_f) * 100).round
+        end
+
+        private
+
+        # Internal string validation.
+        # @return void
+        def self.validate_string(string)
+            raise RuntimeError, "Expected String, instead got:#{string.class}" if string.nil? || !string.is_a?(String)
+        end
+
+        # Internal method helper for string_difference_percent().
+        # @return Hash
+        def self.string_difference_as_hash(string)
+            hash = {}
+            string.split('').each do |letter|
+                if !hash.has_key?(letter)
+                    hash[letter] = 1
+                else
+                    hash[letter] = hash[letter].to_i + 1
+                end
+            end
+            hash
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/terminal.rb

@@ -0,0 +1,413 @@
+require 'highline/import'
+require 'columnist'
+require 'readline'
+require 'tty-spinner'
+
+module Blufin
+
+    class Terminal
+
+        extend Columnist
+
+        MSG_INFO            = 'info'
+        MSG_WARNING         = 'warning'
+        MSG_ERROR           = 'error'
+        MSG_TODO            = 'todo'
+        MSG_AUTOMATIC       = 'automatic'
+        MSG_GENERATED       = 'generated'
+        MSG_PROCESSED       = 'processed'
+        MSG_PROGRESS        = 'progress'
+        MSG_CUSTOM          = 'custom'
+        MSG_CUSTOM_AUTO_PAD = 'custom_auto_pad'
+
+        # Runs a series of commands in the terminal.
+        # @return void
+        def self.command(commands, location = nil, verbose = true, verbose_cd = true, capture_real_output = false)
+            unless commands.is_a?(Array)
+                commands = [commands]
+            end
+            unless location.nil?
+                unless File.directory?(File.expand_path(location))
+                    error('Directory not found.', "Cannot find the following directory: \x1B[38;5;205m#{location}\x1B[0m", true)
+                end
+            end
+            output = []
+            if verbose_cd && verbose && commands.any? && !location.nil?
+                puts "\x1B[38;5;231m\x1B[42m Executing \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m #{Blufin::Terminal::format_command("cd #{location}")}\n"
+            end
+            if commands.any?
+                commands.each do |command|
+                    if verbose
+                        puts "\x1B[38;5;231m\x1B[42m Executing \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m #{Blufin::Terminal::format_command("#{command}")}\n"
+                    end
+                    if location.nil?
+                        if capture_real_output
+                            output << `#{command}`
+                        else
+                            output << system("#{command}")
+                        end
+                    else
+                        if capture_real_output
+                            output << `cd #{location} && #{command}`
+                        else
+                            output << system("cd #{location} && #{command}")
+                        end
+                    end
+                end
+            end
+            if capture_real_output
+                output.map! { |v| v.gsub('\n', "\n") }
+            end
+            output
+        end
+
+        # Runs a series of commands in the terminal (and captures the output).
+        # @return void
+        def self.command_capture(commands, location = nil, verbose = true, verbose_cd = true)
+            command(commands, location, verbose, verbose_cd, true)
+        end
+
+        # Executes a command and shows that something is happening (via a cli-spinner)
+        # See: https://github.com/piotrmurach/tty-spinner/blob/master/lib/tty/spinner/formats.rb (for spinner options).
+        # @return void
+        def self.execute(command, path, format = :dots)
+
+            # TODO NOW - Add execution time to this.
+
+        spinner = TTY::Spinner.new("[:spinner] \x1B[38;5;208m#{command} \x1B[38;5;246m\xe2\x86\x92 \x1B[38;5;240m#{path}\x1B[0m", format: format)
+            spinner.auto_spin
+            res = system("cd #{path} && #{command} > /dev/null")
+            spinner.success("\x1B[38;5;246m\xe2\x86\x92 \x1B[38;5;46mComplete\x1B[0m") if res
+            spinner.error("\x1B[38;5;246m\xe2\x86\x92 \x1B[38;5;196mFailed\x1B[0m") unless res
+            res
+        end
+
+        # Outputs messages to the terminal.
+        # If CUSTOM, title must be 11 characters to match existing scheme.
+        # @return void
+        def self.output(message = 'No message', type = MSG_INFO, title = nil, bg_color = nil)
+
+            raise RuntimeError, "'title' cannot be nil." if title.nil? && [MSG_CUSTOM, MSG_CUSTOM_AUTO_PAD].include?(type)
+            raise RuntimeError, "'bg_color' cannot be nil." if bg_color.nil? && [MSG_CUSTOM, MSG_CUSTOM_AUTO_PAD].include?(type)
+            raise RuntimeError, "'title' cannot be more that 9 characerts when MSG_CUSTOM_AUTO_PAD is the message type." if type == MSG_CUSTOM_AUTO_PAD && title.length > 9
+
+            case type
+                when MSG_INFO
+                    puts "\x1B[38;5;231m\x1B[48;5;2m Executing \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_WARNING
+                    puts "\x1B[38;5;231m\x1B[48;5;202m  Warning  \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_ERROR
+                    puts "\x1B[38;5;231m\x1B[48;5;196m   Error   \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_TODO
+                    puts "\x1B[38;5;231m\x1B[48;5;199m   @TODO   \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_AUTOMATIC
+                    puts "\x1B[38;5;231m\x1B[48;5;96m Automatic \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_GENERATED
+                    puts "\x1B[38;5;231m\x1B[48;5;96m Generated \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_PROCESSED
+                    puts "\x1B[38;5;231m\x1B[48;5;238m Processed \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_PROGRESS
+                    puts "    \x1B[38;5;240m#{message}\x1B[0m\n"
+                when MSG_CUSTOM
+                    puts "\x1B[38;5;231m\x1B[48;5;#{bg_color}m#{title}\x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                when MSG_CUSTOM_AUTO_PAD
+                    puts "\x1B[38;5;231m#{''.rjust((9 - title.length), ' ')}\x1B[48;5;#{bg_color}m #{title} \x1B[0m \x1B[0m\xe2\x86\x92\x1B[0m \x1B[0m#{message}\x1B[0m\n"
+                else
+                    puts "'#{type}' is not a valid Terminal::output() type.\n"
+                    exit
+            end
+        end
+
+        # Displays error and exits script by default.
+        # @return void
+        def self.abort(title = nil, message = nil, exit_script = true, preceding_blank_line = false)
+            title   = 'Abandon ship!' if title.nil?
+            message = "You have chosen to \x1B[38;5;196mABORT\x1B[38;5;240m the script." if message.nil?
+            Blufin::Terminal::error(title, message, exit_script, preceding_blank_line, 'ABORT')
+        end
+
+        # Displays error and exits script by default.
+        # @return void
+        def self.error(title = nil, message = nil, exit_script = true, preceding_blank_line = true, error_text = 'Error')
+            puts if preceding_blank_line
+            puts "    \x1B[38;5;231m\x1B[48;5;196m #{error_text} \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+            if exit_script
+                exit
+            end
+        end
+
+        # Displays automatic message.
+        # @return void
+        def self.automatic(title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "\x1B[38;5;231m\x1B[48;5;96m Automatic \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Displays info message.
+        # @return void
+        def self.info(title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;240m Message \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Displays success message.
+        # @return void
+        def self.success(title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;2m Success \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Displays warning message.
+        # @return void
+        def self.warning(title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;202m Warning \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Displays custom message (ideally, keyword should be 7 characters long to match the rest of the output).
+        # @return void
+        def self.custom(keyword = 'N/A', color = 1, title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;#{color}m #{keyword} \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Displays custom message with a progress indicator.
+        # @return void
+        def self.custom_progress(keyword = 'N/A', color = 1, title = nil, message = nil, preceding_blank_line = true)
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;#{color}m #{keyword} \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+        end
+
+        # Returns action message in consistent, uniform manner.
+        # @return String
+        def self.format_action(action_text, capitalize = true)
+            action_text = action_text.nil? ? 'N/A' : action_text
+            action_text = action_text.upcase if capitalize
+            "\x1B[38;5;170m#{action_text}\x1B[0m"
+        end
+
+        # Returns branch name in consistent, uniform manner.
+        # @return String
+        def self.format_branch(branch_name)
+            "\x1B[38;5;40m[#{branch_name}]\x1B[0m"
+        end
+
+        # Returns command name in consistent, uniform manner.
+        # @return String
+        def self.format_command(command_name)
+            "\x1B[38;5;220m#{command_name}\x1B[0m"
+        end
+
+        # Returns directory name in consistent, uniform manner.
+        # @return String
+        def self.format_directory(directory_name, expand_path = true)
+            return "\x1B[38;5;48m#{File.expand_path(directory_name)}\x1B[0m" if expand_path
+            return "\x1B[38;5;48m#{directory_name}\x1B[0m" unless expand_path
+        end
+
+        # Returns flag name in consistent, uniform manner.
+        # @return String
+        def self.format_flag(flag_letter, display_flag_text = true)
+            letter_array = []
+            if flag_letter.is_a? String
+                letter_array = Array[flag_letter]
+            elsif flag_letter.is_a? Array
+                letter_array = flag_letter
+            else
+                Blufin::Terminal::error('Terminal::format_flag expects either String or Array.', nil, true)
+            end
+            flag_txt = ''
+            letter_array.each do |letter|
+                flag_txt = "#{flag_txt}, -#{letter}"
+            end
+            xtra_txt = letter_array.length > 1 ? ' flags' : ' flag'
+            flag_txt = flag_txt[2..-1]
+            "\x1B[38;5;152m#{flag_txt}#{display_flag_text ? xtra_txt : ''}\x1B[0m"
+        end
+
+        # Returns action message in consistent, uniform manner.
+        # @return String
+        def self.format_highlight(highlighted_text, capitalize = false)
+            if capitalize
+                return "\x1B[38;5;117m#{highlighted_text.upcase}\x1B[0m"
+            else
+                return "\x1B[38;5;117m#{highlighted_text}\x1B[0m"
+            end
+        end
+
+        # Returns invalid data in consistent, uniform manner.
+        # @return String
+        def self.format_invalid(invalid_string, capitalize = false)
+            if capitalize
+                return "\x1B[38;5;196m#{invalid_string.upcase}\x1B[0m"
+            else
+                return "\x1B[38;5;196m#{invalid_string}\x1B[0m"
+            end
+        end
+
+        # Generates 'filler' string.
+        # @return String
+        def self.fill(length = 0, string = ' ')
+            fill_string = ''
+            (0..length - 1).each {
+                fill_string = "#{fill_string}#{string}"
+            }
+            fill_string
+        end
+
+        # Gives a prompt where 'y/Y' will return TRUE, 'n/N' will return false, and ANY other key will do nothing.
+        # @return void
+        def self.prompt_yes_no(title = nil, message = nil, confirmation_message = nil, preceding_blank_line = true)
+            title                = 'Please confirm YES or NO.' if title.nil?
+            confirmation_message = 'Would you like to continue?' if confirmation_message.nil?
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;56m Confirm \x1B[0m #{title.nil? ? '' : "\xe2\x86\x92 "}#{title}\n"
+            parse_messages(message)
+            response = ''
+            until %w[y Y n N x X a A].include? response
+                response = Readline::readline("     \x1B[38;5;161m#{confirmation_message} \x1B[0m[y/n]\x1B[90m => \x1B[0m", true)
+            end
+            case response.downcase
+                when 'y'
+                    puts "\n"
+                    return true
+                when 'n'
+                    puts "\n"
+                    return false
+                when 'a'
+                    Blufin::Terminal::error('Abandon ship!', ["You have chosen to \x1B[38;5;9mABORT\x1B[38;5;240m the script.", nil, 'Please note that whenever you do this, any scripted tasks which were running', 'will have been interrupted mid-script. This may (or may not) cause problems.'], true)
+                when 'x'
+                    Blufin::Terminal::error('Abandon ship!', ["You have chosen to \x1B[38;5;9mABORT\x1B[38;5;240m the script.", nil, 'Please note that whenever you do this, any scripted tasks which were running', 'will have been interrupted mid-script. This may (or may not) cause problems.'], true)
+                else
+            end
+        end
+
+        # Shows a prompt waiting for user input.
+        # If validation_proc is passed, the Proc must return TRUE in order for validation to pass.
+        # @return string
+        def self.prompt_for_input(message, subtitle_array = nil, nil_allowed = true, preceding_blank_line = true, clear_screen = true, validation_proc = nil, validation_message = 'Invalid value!')
+            system('clear') if clear_screen
+            puts if preceding_blank_line
+            puts "  \x1B[38;5;231m\x1B[48;5;125m Question \x1B[0m \xe2\x86\x92 #{message}\n"
+            parse_messages(subtitle_array) unless subtitle_array.nil?
+            puts if subtitle_array.nil?
+            response = nil
+            while response.nil?
+                response = Readline::readline("     \x1B[38;5;245m=>\x1B[0m ", true)
+                unless nil_allowed
+                    response.strip!
+                    response = nil if response == '' || response.nil?
+                end
+                unless validation_proc.nil?
+                    raise RuntimeError, "Expected validation_proc to be an instance of Proc, instead got: #{validation_proc.class}" unless validation_proc.is_a?(Proc)
+                    unless validation_proc.call(response)
+                        puts "     \x1B[38;5;245m=>\x1B[0m \x1B[38;5;196mERROR\x1B[0m \xe2\x80\x94 #{validation_message}\n"
+                        response = nil
+                    end
+                end
+            end
+            puts
+            response
+        end
+
+        # Gives a prompt where ANY KEY will continue executing the script.
+        # @return void
+        def self.any_key_to_continue(text = nil, preceding_blank_line = true)
+            STDOUT.flush
+            puts if preceding_blank_line
+            text = 'Press any key to continue' if text.nil?
+            print "     \x1B[38;5;240m#{text}\x1B[0m => "
+            STDIN.gets
+            puts
+            nil
+        end
+
+        # Gets the Terminal width
+        # @return Integer
+        def self.get_terminal_width
+            terminal_size = HighLine::SystemExtensions.terminal_size
+            terminal_size[0]
+        end
+
+        # Gets the Terminal height
+        # @return Integer
+        def self.get_terminal_height
+            terminal_size = HighLine::SystemExtensions.terminal_size
+            terminal_size[1]
+        end
+
+        # Outputs Exceptions in a pretty, standardized format.
+        # @return void
+        def self.print_exception(e)
+            if e.is_a?(Exception)
+                custom('Exception', 235, "There was an error in your code: \x1B[48;5;124m #{e.message} \x1B[0m", e.backtrace)
+            elsif e.is_a?(String)
+                custom('Exception', 235, "There was an error in your code: \x1B[48;5;124m #{e} \x1B[0m")
+            else
+                raise RuntimeError, "Expected String|Exception, instead got:#{e.class}"
+            end
+            exit 1
+        end
+
+        # Outputs Array of files/directories in a pretty, standardized format.
+        # @return void
+        def self.print_files_written(array_of_paths_or_files, message = nil, limit = 10, preceding_blank_line = true)
+            raise RuntimeError, "Expected Array of files, instead got: #{array_of_paths_or_files.class}" unless array_of_paths_or_files.is_a?(Array)
+            message     = "Wrote the following #{Blufin::Terminal::format_highlight('files/directories')}" if message.nil?
+            limit       = limit.nil? ? 99999999999 : limit.to_i
+            file_output = []
+            file_count  = 0
+            file_more   = 0
+            array_of_paths_or_files.compact!
+            array_of_paths_or_files.sort!
+            array_of_paths_or_files.each do |path_or_file|
+                file_count += 1
+                if file_count > limit
+                    file_more += 1
+                    next
+                end
+                if Blufin::Files::path_exists(path_or_file)
+                    file_output << "Path: \x1B[38;5;248m#{path_or_file.strip}\x1B[0m"
+                else
+                    file_output << "File: \x1B[38;5;46m#{path_or_file.strip}\x1B[0m"
+                end
+            end
+            file_output << "\x1B[38;5;168m#{file_more} more...\x1B[0m" if file_more > 0
+            Blufin::Terminal::automatic(message, file_output, preceding_blank_line)
+        end
+
+        private
+
+        # Parses messages for various output functions.
+        # @return void
+        def self.parse_messages(message)
+            puts
+            unless message.nil?
+                if message.is_a?(Array)
+                    messages = message
+                else
+                    messages = message.split("\n")
+                end
+                table(:border => false) do
+                    messages.each do |line|
+                        new_line = line.nil? ? '' : line.to_s.gsub("\x1B[0m", "\x1B[38;5;240m")
+                        row do
+                            column('', :align => 'left', :width => 4)
+                            column("\x1B[38;5;240m#{new_line}\x1B[0m", :align => 'left', :width => 180)
+                        end
+                    end
+                end
+                puts
+            end
+        end
+
+    end
+
+end