cliutils 1.0.0

data/lib/cliutils/ext/Hash+Extensions.rb

@@ -0,0 +1,145 @@
+#  ======================================================
+#  Hash Class
+#
+#  Contains many convenient methods borrowed from Rails
+#  http://api.rubyonrails.org/classes/Hash.html
+#  ======================================================
+class Hash
+  #  ====================================================
+  #  Methods
+  #  ====================================================
+  #  ----------------------------------------------------
+  #  deep_merge! method
+  #
+  #  Deep merges a hash into the current one.
+  #  @param other_hash The hash to merge in
+  #  @param &block
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      if tv.is_a?(Hash) && v.is_a?(Hash)
+        self[k] = tv.deep_merge(v, &block)
+      else
+        self[k] = block && tv ? block.call(k, tv, v) : v
+      end
+    end
+    self
+  end
+
+  #  ----------------------------------------------------
+  #  deep_stringify_keys method
+  #
+  #  Recursively turns all Hash keys into strings and
+  #  returns the new Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  #  ----------------------------------------------------
+  #  deep_symbolize_keys! method
+  #
+  #  Same as deep_stringify_keys, but destructively
+  #  alters the original Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  #  ----------------------------------------------------
+  #  deep_symbolize_keys method
+  #
+  #  Recursively turns all Hash keys into symbols and
+  #  returns the new Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  #  ----------------------------------------------------
+  #  deep_symbolize_keys! method
+  #
+  #  Same as deep_symbolize_keys, but destructively
+  #  alters the original Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  #  ----------------------------------------------------
+  #  deep_transform_keys method
+  #
+  #  Generic method to perform recursive operations on a
+  #  Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  #  ----------------------------------------------------
+  #  deep_transform_keys! method
+  #
+  #  Same as deep_transform_keys, but destructively
+  #  alters the original Hash.
+  #  @return Hash
+  #  ----------------------------------------------------
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  private
+
+  #  ----------------------------------------------------
+  #  _deep_transform_keys_in_object method
+  #
+  #  Modification to deep_transform_keys that allows for
+  #  the existence of arrays.
+  #  https://github.com/rails/rails/pull/9720/files?short_path=4be3c90
+  #  @param object The object to examine
+  #  @param &block A block to execute on the opject
+  #  @return Object
+  #  ----------------------------------------------------
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map {|e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  #  ----------------------------------------------------
+  #  _deep_transform_keys_in_object! method
+  #
+  #  Same as _deep_transform_keys_in_object, but
+  #  destructively alters the original Object.
+  #  @param object The object to examine
+  #  @param &block A block to execute on the opject
+  #  @return Object
+  #  ----------------------------------------------------
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+    else
+      object
+    end
+  end
+end

data/lib/cliutils/ext/Logger+Extensions.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+#  ======================================================
+#  Logger Class
+#  ======================================================
+class Logger
+  #  ----------------------------------------------------
+  #  custom_level method
+  #
+  #  Creates a custom Logger level based on the passed
+  #  tag.
+  #  @param tag The Logger level to create
+  #  @return Void
+  #  ----------------------------------------------------
+  def self.custom_level(tag)
+    SEV_LABEL << tag 
+    idx = SEV_LABEL.size - 1 
+
+    define_method(tag.downcase.gsub(/\W+/, '_').to_sym) do |progname, &block|
+      add(idx, nil, progname, &block)
+    end 
+  end 
+  
+  custom_level('PROMPT')
+  custom_level('SECTION')
+  custom_level('SUCCESS')
+end

data/lib/cliutils/ext/String+Extensions.rb

@@ -0,0 +1,26 @@
+#  ======================================================
+#  String Class
+#  ======================================================
+class String
+  #  ====================================================
+  #  Color String Methods
+  #  ====================================================
+  #  ----------------------------------------------------
+  #  colorize method
+  #
+  #  Outputs a string in a formatted color.
+  #  @param color_code The code to use
+  #  @return Void
+  #  ----------------------------------------------------
+  def colorize(color_code)
+    "\033[#{ color_code }m#{ self }\033[0m"
+  end
+  
+  def blue; colorize(34) end
+  def cyan; colorize(36) end
+  def green; colorize(32) end
+  def purple; colorize(35) end
+  def red; colorize(31) end
+  def white; colorize(37) end
+  def yellow; colorize(33) end
+end

data/lib/cliutils/logger-delegator.rb

@@ -0,0 +1,66 @@
+module CLIUtils
+  #  ======================================================
+  #  LoggerDelegator Class
+  #
+  #  Manages any configuration values and the flat YAML file
+  #  into which they get stored.
+  #  ======================================================
+  class LoggerDelegator
+    #  ====================================================
+    #  Attributes
+    #  ====================================================  
+    attr_reader :devices
+
+    #  ====================================================
+    #  Methods
+    #  ====================================================
+    #  ----------------------------------------------------
+    #  initialize method
+    #
+    #  Initializer
+    #  @param *targets The endpoints to delegate to
+    #  @return void
+    #  ----------------------------------------------------
+    def initialize(*targets)
+      @targets = targets
+      LoggerDelegator.delegate
+    end
+
+    #  ----------------------------------------------------
+    #  attach method
+    #
+    #  Attaches a new target to delegate to.
+    #  @return void
+    #  ----------------------------------------------------  
+    def attach(target)
+      @targets << target
+      LoggerDelegator.delegate
+    end
+
+    #  ----------------------------------------------------
+    #  delegate_all method
+    #
+    #  Creates delegator methods for all of the methods
+    #  on IO.
+    #  @return void
+    #  ----------------------------------------------------
+    def self.delegate
+      %w(log debug info warn error section success).each do |m|
+        define_method(m) do |*args|
+          @targets.map { |t| t.send(m, *args) }
+        end
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  detach method
+    #
+    #  Detaches a delegation target.
+    #  @return void
+    #  ----------------------------------------------------  
+    def detach(target)
+      @targets.delete(target)
+      LoggerDelegator.delegate
+    end
+  end
+end

data/lib/cliutils/messenging.rb

@@ -0,0 +1,51 @@
+module CLIUtils
+  #  ======================================================
+  #  CLIMessenger Module
+  #  Outputs color-coordinated messages to a CLI
+  #  ======================================================
+  module Messenging
+    include CLIUtils::PrettyIO
+
+    #  ====================================================
+    #  Methods
+    #  ====================================================
+    #  ----------------------------------------------------
+    #  included method
+    #
+    #  Hook called when this module gets mixed in; extends
+    #  the includer with the methods defined here.
+    #  @param k The includer
+    #  @return Void
+    #  ----------------------------------------------------
+    def self.included(k)
+      k.extend(self)
+    end
+
+    #  ----------------------------------------------------
+    #  default_instance method
+    #
+    #  Returns a default instance of LoggerDelegator that
+    #  delegates to STDOUT only.
+    #  @return LoggerDelegator
+    #  ----------------------------------------------------
+    def default_instance
+      stdout_logger = Logger.new(STDOUT)
+      stdout_logger.formatter = proc do |severity, datetime, progname, msg|
+        send(severity.downcase, msg)
+      end
+      
+      LoggerDelegator.new(stdout_logger)
+    end
+
+    #  ----------------------------------------------------
+    #  messenger method
+    #
+    #  Singleton method to return (or initialize, if needed)
+    #  a LoggerDelegator.
+    #  @return LoggerDelegator
+    #  ----------------------------------------------------
+    def messenger
+      @messenger ||= default_instance
+    end
+  end
+end

data/lib/cliutils/prefs.rb

@@ -0,0 +1,116 @@
+module CLIUtils
+  #  ======================================================
+  #  PrefManager Class
+  #
+  #  Engine to derive preferences from a YAML file, deliver
+  #  those to a user via a prompt, and collect the results.
+  #  ======================================================
+  class Prefs
+    include PrettyIO
+    #  ====================================================
+    #  Attributes
+    #  ====================================================
+    attr_reader :answers, :config_path, :prompts
+
+    #  ====================================================
+    #  Methods
+    #  ====================================================
+    #  ----------------------------------------------------
+    #  initialize method
+    #
+    #  Reads prompt data from YAML file.
+    #  @return Void
+    #  ----------------------------------------------------
+    def initialize(data)
+      @answers = []
+      @prompts = {}
+
+      case data
+      when String
+        if File.exists?(data)
+          @config_path = data
+
+          prompts = YAML::load_file(data)
+          @prompts.deep_merge!(prompts).deep_symbolize_keys!
+        else
+          fail "Invalid configuration file: #{ yaml_path }"
+        end
+      when Array
+        @config_path = nil
+
+        prompts = {:prompts => data}
+        @prompts.deep_merge!(prompts).deep_symbolize_keys!
+      else
+        fail 'Invalid configuration data'
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  ask method
+    #
+    #  Runs through all of the prompt questions and collects
+    #  answers from the user. Note that all questions w/o
+    #  requirements are examined first; once those are
+    #  complete, questions w/ requirements are examined.
+    #  @return Void
+    #  ----------------------------------------------------
+    def ask
+      @prompts[:prompts].reject { |p| p[:requirements] }.each do |p|
+        _deliver_prompt(p)
+      end
+
+      @prompts[:prompts].find_all { |p| p[:requirements] }.each do |p|
+        _deliver_prompt(p) if _requirements_fulfilled?(p)
+      end
+    end
+
+    private
+
+    #  ----------------------------------------------------
+    #  _deliver_prompt method
+    #
+    #  Utility method for prompting the user to answer the
+    #  question (taking into account any options).
+    #  @param p The prompt
+    #  @return Void
+    #  ----------------------------------------------------
+    def _deliver_prompt(p)
+      if p[:options].nil?
+        pref = prompt(p[:prompt], p[:default])
+      else
+        valid_option_chosen = false
+        until valid_option_chosen
+          pref = prompt(p[:prompt], p[:default])
+          if p[:options].include?(pref)
+            valid_option_chosen = true
+          else
+            error("Invalid option chosen: #{ pref }")
+          end
+        end
+      end
+
+      p[:answer] = pref
+      @answers << p
+    end
+
+    #  ----------------------------------------------------
+    #  _requirements_fulfilled? method
+    #
+    #  Utility method for determining whether a prompt's
+    #  requirements have already been fulfilled.
+    #  @param p The prompt
+    #  @return Void
+    #  ----------------------------------------------------
+    def _requirements_fulfilled?(p)
+      ret = true
+      p[:requirements].each do |req|
+        a = @answers.detect do |answer|
+          answer[:key] == req[:key] &&
+          answer[:answer] == req[:value]
+        end
+        ret = false if a.nil?
+      end
+      ret
+    end
+  end
+end

data/lib/cliutils/pretty-io.rb

@@ -0,0 +1,255 @@
+begin
+   require 'Win32/Console/ANSI' if (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+rescue LoadError
+   raise 'You must run `gem install win32console` to use CLIMessage on Windows'
+end
+
+require 'readline'
+
+module CLIUtils
+  #  ======================================================
+  #  CLIMessenger Module
+  #  Outputs color-coordinated messages to a CLI
+  #  ======================================================
+  module PrettyIO
+    @@wrap = true
+    @@wrap_char_limit = 40
+
+    #  ====================================================
+    #  Methods
+    #  ====================================================  
+    #  ----------------------------------------------------
+    #  included method
+    #
+    #  Hook called when this module gets mixed in; extends
+    #  the includer with the methods defined here.
+    #  @param k The includer
+    #  @return Void
+    #  ----------------------------------------------------
+    def self.included(k)
+      k.extend(self)
+    end
+
+    #  ----------------------------------------------------
+    #  color_chart method
+    #
+    #  Displays a chart of all the possible ANSI foreground
+    #  and background color combinations.
+    #  @return Void
+    #  ----------------------------------------------------
+    def color_chart
+      [0, 1, 4, 5, 7].each do |attr|
+        puts '----------------------------------------------------------------'
+        puts "ESC[#{attr};Foreground;Background"
+        30.upto(37) do |fg|
+          40.upto(47) do |bg|
+            print "\033[#{attr};#{fg};#{bg}m #{fg};#{bg}  "
+          end
+        puts "\033[0m"
+        end
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  debug method
+    #
+    #  Empty method so that Messenging doesn't freak
+    #  out when passed a debug message.
+    #  @return Void
+    #  ----------------------------------------------------
+    def debug(m); end
+
+    #  ----------------------------------------------------
+    #  error method
+    #
+    #  Outputs a formatted-red error message.
+    #  @param m The message to output
+    #  @return Void
+    #  ----------------------------------------------------
+    def error(m)
+      puts _word_wrap(m, '# ').red
+    end
+
+    #  ----------------------------------------------------
+    #  info method
+    #
+    #  Outputs a formatted-blue informational message.
+    #  @param m The message to output
+    #  @return Void
+    #  ----------------------------------------------------
+    def info(m)
+      puts _word_wrap(m, '# ').blue
+    end
+
+    #  ----------------------------------------------------
+    #  info_block method
+    #
+    #  Wraps a block in an opening and closing info message.
+    #  @param m1 The opening message to output
+    #  @param m2 The closing message to output
+    #  @param multiline Whether the message should be multiline
+    #  @return Void
+    #  ----------------------------------------------------
+    def info_block(m1, m2 = 'Done.', multiline = false)
+      if block_given?
+        if multiline
+          info(m1)
+        else
+          print _word_wrap(m1, '# ').blue
+        end
+
+        yield
+
+        if multiline
+          info(m2)
+        else
+          puts _word_wrap(m2, '# ').blue
+        end
+      else
+        fail 'Did not specify a valid block'
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  log method
+    #
+    #  Empty method so that Messenging doesn't freak
+    #  out when passed a debug message.
+    #  @return Void
+    #  ----------------------------------------------------
+    def log(m); end
+
+    #  ----------------------------------------------------
+    #  prompt method
+    #
+    #  Outputs a prompt, collects the user's response, and
+    #  returns it.
+    #  @param prompt The prompt to output
+    #  @param default The default option
+    #  @return String
+    #  ----------------------------------------------------
+    def prompt(prompt, default = nil, start_dir = '')
+      Readline.completion_append_character = nil
+      Readline.completion_proc = lambda do |prefix|
+        files = Dir["#{start_dir}#{prefix}*"]
+        files.
+          map { |f| File.expand_path(f) }.
+          map { |f| File.directory?(f) ? f + "/" : f }
+      end
+      choice = Readline.readline("# #{ prompt }#{ default.nil? ? ':' : " [default: #{ default }]:" } ".cyan)
+      if choice.empty?
+        default
+      else
+        choice
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  section method
+    #
+    #  Outputs a formatted-purple section message.
+    #  @param m The message to output
+    #  @return Void
+    #  ----------------------------------------------------
+    def section(m)
+      puts _word_wrap(m, '---> ').purple
+    end
+
+    #  ----------------------------------------------------
+    #  section_block method
+    #
+    #  Wraps a block in an opening and closing section
+    #  message.
+    #  @param m1 The opening message to output
+    #  @param m2 The closing message to output
+    #  @param multiline A multiline message or not
+    #  @return Void
+    #  ----------------------------------------------------
+    def section_block(m, multiline = true)
+      if block_given?
+        if multiline
+          section(m)
+        else
+          print _word_wrap(m, '---> ').purple
+        end
+
+        yield
+      else
+        fail 'Did not specify a valid block'
+      end
+    end
+
+    #  ----------------------------------------------------
+    #  success method
+    #
+    #  Outputs a formatted-green success message.
+    #  @param m The message to output
+    #  @return Void
+    #  ----------------------------------------------------
+    def success(m)
+      puts _word_wrap(m, '# ').green
+    end
+
+    #  ----------------------------------------------------
+    #  warning method
+    #
+    #  Outputs a formatted-yellow warning message.
+    #  @param m The message to output
+    #  @return Void
+    #  ----------------------------------------------------
+    def warn(m)
+      puts _word_wrap(m, '# ').yellow
+    end
+
+    #  ----------------------------------------------------
+    #  wrap method
+    #
+    #  Toggles wrapping on or off
+    #  @return Integer
+    #  ----------------------------------------------------
+    def self.wrap(on)
+      @@wrap = on
+    end
+
+    #  ----------------------------------------------------
+    #  wrap_limit method
+    #
+    #  Returns the current character wrap amount
+    #  @return Integer
+    #  ----------------------------------------------------
+    def self.wrap_limit
+      @@wrap_char_limit
+    end
+
+    #  ----------------------------------------------------
+    #  wrap_at method
+    #
+    #  Sets the number of characters at which to wrap
+    #  @return Integer
+    #  ----------------------------------------------------
+    def self.wrap_at(chars)
+      @@wrap_char_limit = chars
+    end
+    
+    private
+
+    #  ----------------------------------------------------
+    #  _word_wrap method
+    #
+    #  Outputs a wrapped string (where each line is limited
+    #  to a certain number of characters).
+    #  @param text The text to wrap
+    #  @param prefix_str The prefix for each line
+    #  @param line_width The number of characters per line
+    #  @return String
+    #  ----------------------------------------------------
+    def _word_wrap(text, prefix_str) 
+      if @@wrap
+        return text if @@wrap_char_limit <= 0
+        text.gsub(/\n/, ' ').gsub(/(.{1,#{@@wrap_char_limit - prefix_str.length}})(\s+|$)/, "#{ prefix_str }\\1\n").strip
+      else
+        text
+      end
+    end
+  end
+end

data/lib/cliutils/version.rb

@@ -0,0 +1,3 @@
+module CLIUtils
+  VERSION = "1.0.0"
+end

data/lib/cliutils.rb

@@ -0,0 +1,15 @@
+require 'cliutils/ext/Hash+Extensions'
+require 'cliutils/ext/Logger+Extensions'
+require 'cliutils/ext/String+Extensions'
+
+require 'cliutils/pretty-io'
+require 'cliutils/configurator'
+require 'cliutils/configuration'
+require 'cliutils/logger-delegator'
+require 'cliutils/messenging'
+require 'cliutils/prefs'
+require 'cliutils/version'
+
+module CLIUtils
+
+end