cli_tool 0.0.3 → 0.1.0

data/lib/cli_tool/option_parser.rb

@@ -1,4 +1,6 @@
 require 'getoptlong'
+require 'pry'
+require 'awesome_print'
 
 module CliTool
   module OptionParser
@@ -6,15 +8,30 @@ module CliTool
     # Use to add the methods below to any class
     def self.included(base)
       base.extend(ClassMethods)
+      base.options({
+        debug: {
+          argument: :none,
+          documentation: [
+            "This is used to trigger debug mode in your app. It will be set to #{base}.debug.",
+            "In debug mode we do not respect the secure option and your secure fields will be displayed in clear text!",
+            [:black, :white_bg]
+          ]
+        },
+        help: {
+          argument: :none,
+          short: :'?',
+          documentation: "Shows this help record."
+        }
+      })
     end
 
     module ClassMethods
 
       # Map for symbol types
       GOL_MAP = {
-        :none     => GetoptLong::NO_ARGUMENT,
-        :optional => GetoptLong::OPTIONAL_ARGUMENT,
-        :required => GetoptLong::REQUIRED_ARGUMENT
+        none: GetoptLong::NO_ARGUMENT,
+        optional: GetoptLong::OPTIONAL_ARGUMENT,
+        required: GetoptLong::REQUIRED_ARGUMENT
       }
 
       # Create the options array
@@ -24,93 +41,319 @@ module CliTool
         # If no options were passed then return
         return @@options.uniq unless opts
 
-        _create_attrs_(opts)
-        default_options(opts)
+        _create_preprocess_(opts)
         @@options = @@options.concat(_create_gola_(opts)).uniq
       end
 
-      def default_options(opts = {})
-        @@defaults ||= []
+      # Ensure the right format of the options (primarily dashes and casing)
+      def optionify(option, retval = false)
+        if option.is_a?(Array)
+          optionify_all(option)
+        else
+          option = "#{option}".gsub(/^[\-]+/, '').gsub(/(-| )/, '_').to_sym
 
-        # If no options were passed then return
-        return @@defaults.uniq.inject({}) { |o,(k,v)| o[k] = v; o } unless opts
+          # Help us get the primary option over the alias
+          option =
+            case retval
+            when :set, :setter
+              "#{option}="
+            when :primary
+              all_opts = __get_options(:all_options)
 
-        # Set the default options
-        opts.each do |opt, details|
-          next unless details.is_a?(Hash)
-          next unless details[:default]
-          opt = opt.first if opt.is_a?(Array)
-          @@defaults << [optionify(opt), details[:default]]
+              if all_opts.has_key?(option)
+                option
+              else
+                all_opts.map { |opt, option_args|
+                  aliases = option_args[:aliases]
+                  if aliases && aliases.include?(option)
+                    opt
+                  else
+                    nil
+                  end
+                }.compact.flatten.first
+              end
+            else
+              option
+            end
+
+          option.to_sym
         end
+      end
 
-        @@defaults = @@defaults.uniq
+      def optionify_all(option, retval = false)
+        [option].compact.flatten.map { |x| optionify(x, retval) }
       end
 
-      # Parse to correct option set
-      def optionify(option, setter = false)
-        option = "#{option}".gsub(/^[\-]+/, '').gsub(/(-| )/, '_')
-        (setter ? option + '=' : option).to_sym
+      def trap!
+        Signal.trap("INT") do |signo|
+          if Signal.respond_to?(:signame)
+            signal = Signal.signame(signo)
+            puts "Received: #{signal}..."
+            puts "Exiting..."
+          else
+            puts "#{signo} Exiting..."
+          end
+          exit 1
+        end
       end
 
       # Handle running options
-      def run(entrypoint = false, *args)
-        if args.last.instance_of?(self)
-          instance = args.pop
-        else
-          instance = new
-        end
+      def run(entrypoint = false, *args, &block)
 
-        # Option Setter Proc
+        # Get the object to work with
+        object =
+          if args.last.class <= self
+            args.pop
+          elsif self < Singleton
+            instance
+          else
+            new
+          end
+
+        # Get class variable hash
+        class_vars = __get_options
+
+        # Cache variables
+        exit_code = 0
+        max_puts_length = 0
+        processed_options = []
+        missing_arguments = []
+
+        # Option setter proc
         option_setter = Proc.new do |option, value|
-          value = case value
-          when ''
-            true
-          when 'true'
-            true
-          when 'false'
-            false
+          option = optionify(option, :primary)
+          processed_options << option
+
+          # Help process values
+          value =
+            case value
+            when ''
+              true
+            when 'true'
+              true
+            when 'false'
+              false
+            when 'nil', 'null'
+              nil
+            else
+              value
+            end
+
+          # Run preprocessor on the data (if applicable)
+          preprocessor = class_vars[:preprocessors][option]
+          if preprocessor
+            value = object.__send__(:instance_exec, value, &preprocessor)
+          end
+
+          # Show notice of the setting being set on the instance
+          if class_vars[:private_options].include?(option) && ! instance.debug
+            m = "Setting @#{option} = #{'*' * value.length} :: Value hidden for privacy"
+            max_puts_length = m.length if m.length > max_puts_length
+            puts m, :blue
           else
-            value
+            m = "Setting @#{option} = #{value}"
+            max_puts_length = m.length if m.length > max_puts_length
+            puts m, :green
           end
 
-          puts "Setting @#{optionify(option)} = #{value}"
-          instance.__send__(optionify(option, :set), value)
+          # Do the actual set for us
+          object.__send__(optionify(option, :set), value)
         end
 
-        # Set options
-        puts "CliTool... Loading Options..."
-        default_options.each(&option_setter)
-        GetoptLong.new(*options).each(&option_setter)
+        # Actually grab the options from GetoptLong and process them
+        puts "\nCliTool... Loading Options...\n", :blue
+        puts '#' * 29, [:red_bg, :red]
+        class_vars[:default_options].to_a.each(&option_setter)
+        begin
+          GetoptLong.new(*options).each(&option_setter)
+        rescue GetoptLong::MissingArgument => e
+          missing_arguments << e.message
+        end
+        puts '#' * 29, [:red_bg, :red]
         puts ''
 
+        # If we wanted help in the first place then don't do any option dependency validations
+        unless object.help
+
+          # Handle any missing arguments that are required!
+          unless missing_arguments.empty?
+            missing_arguments.each { |m| puts "The required #{m}", :red }
+            puts ''
+
+            object.help = true
+            exit_code   = 1
+          end
+
+          # Get the missing options that were expected
+          missing_options = class_vars[:required_options].keys - processed_options
+
+          # Handle missing options and their potential alternatives
+          __slice_hash(class_vars[:required_options], *missing_options).each do |option, option_args|
+            if (option_args[:alternatives] & processed_options).empty?
+              object.help = true
+              exit_code   = 1
+            else
+              missing_options.delete(option)
+            end
+          end
+
+          # Ensure that the dependencies for options are met (if applicable)
+          __slice_hash(class_vars[:required_options], *processed_options).each do |option, option_args|
+            missing_dependencies = option_args[:dependencies] - processed_options
+            missing_dependencies.each do |dep_opt|
+              puts "The option `--#{option}' expected a value for `--#{dep_opt}', but not was received", :red
+              missing_options << dep_opt
+
+              object.help = true
+              exit_code   = 1
+            end
+
+            puts '' unless missing_dependencies.empty?
+          end
+
+          # Raise an error when required options were not provided.
+          # Change the exit code and enable help output (which will exit 1; on missing opts)
+          unless missing_options.empty?
+            missing_options.uniq.each do |option|
+              puts "The required option `--#{option}' was not provided.", :red
+            end
+
+            object.help = true
+            exit_code   = 1
+          end
+        end
+
+        # Show the help text
+        if object.help || exit_code == 1
+          puts help(nil, missing_options || [])
+          exit(exit_code || 0)
+        end
+
         # Handle the entrypoint
         if entrypoint
           entrypoint = optionify(entrypoint)
-          instance.__send__(entrypoint, *args)
+          object.__send__(entrypoint, *args, &block)
         else
-          instance
+          object
         end
       end
 
-      private
+      def help(message = nil, missing_options = [])
+        if message.nil?
+          help_text = __get_options(:all_options).map do |option, option_args|
+
+            # Show the argument with the default value (if applicable)
+            case option_args[:argument]
+            when :required
+              long_dep = "=<#{option_args[:default] || 'value'}>"
+              short_dep = " <#{option_args[:default] || 'value'}>"
+            when :optional
+              long_dep = "=[#{option_args[:default] || 'value'}]"
+              short_dep = " [#{option_args[:default] || 'value'}]"
+            when :none
+              long_dep = ''
+              short_dep = ''
+            end
 
-      def _create_attrs_(opts)
+            # Set up the options list
+            message = "\t" + (option_args[:aliases] << option).map{ |x| "--#{x}#{long_dep}"}.join(', ')
+            message << ", -#{option_args[:short]}#{short_dep}" if option_args[:short]
+            message << %{ :: Default: "#{option_args[:default]}"} if option_args[:default]
 
-        # Get the option keys for attr creation
-        keys = opts.keys
+            # Highlight missing options
+            unless missing_options.empty?
+              missing_required_option = ! (missing_options & option_args[:aliases]).empty?
+              message = colorize(message, missing_required_option ? :red : :default)
+            end
 
-        # "symlink" the additional names to the original method
-        keys.each do |key|
-          default = nil
-          key = [key] unless key.is_a?(Array)
-          key.each_with_index do |k, i|
-            if i < 1
-              default = optionify(k)
-              attr_accessor(default)
-            else
-              define_method(optionify(k, :set), Proc.new { |x| send("#{default}=", x) })
+            # Prepare the option documentation
+            if option_args[:documentation]
+              doc = option_args[:documentation]
+              if doc.is_a?(Array) \
+                 && (doc.last.is_a?(Symbol) \
+                 || (doc.last.is_a?(Array) \
+                     && doc.last.reduce(true) { |o, d| o && d.is_a?(Symbol) }
+                 ))
+
+                colors = doc.pop
+                len = doc.reduce(0) { |o, s| s.length > o ? s.length : o }
+                doc = doc.map{ |s| colorize(s.ljust(len, ' '), colors) }.join("\n\t\t")
+              elsif doc.is_a?(Array)
+                doc = doc.join("\n\t\t")
+              end
+
+              message << %{\n\t\t#{doc}}
+              message << "\n"
             end
           end
+
+          # Print and format the message
+          %{\nHelp: #{$0}\n\n### Options ###\n\n#{help_text.join("\n")}\n### Additional Details ###\n\n#{@@help_message || "No additional documentation"}\n}
+        else
+          @@help_message = message.split(/\n/).map{ |x| "\t#{x.strip}" }.join("\n")
+        end
+      end
+
+      private
+
+      def _create_preprocess_(opts)
+
+        # Set the preprocessor for options (used primarily for formatting or changing types)
+        __generic_option_reducer(:preprocessors, {}, opts, only_with: :preprocess) do |pre_proc, (options, option_args)|
+          pre_proc.merge(options.shift => option_args[:preprocess])
+        end
+
+        # Set the required options and dependencies for the parser
+        __generic_option_reducer(:required_options, {}, opts, only_with: :required) do |req_opts, (options, option_args)|
+          primary_name = options.shift
+
+          # Set the aliases for the required option
+          hash = (option_args[:required].is_a?(Hash) ? option_args[:required] : {}).merge(aliases: options)
+
+          # Ensure that the option names are properly formatted in the alternatives and dependencies
+          hash[:dependencies] = optionify_all(hash[:dependencies])
+          hash[:alternatives] = optionify_all(hash[:alternatives])
+
+          # Merge together the options as required
+          if option_args[:required].is_a?(Hash)
+            req_opts.merge(primary_name => hash)
+          else
+            req_opts.merge(primary_name => hash.merge(force: !! option_args[:required]))
+          end
+        end
+
+        # Create a cache of all the options available
+        __generic_option_reducer(:all_options, {}, opts) do |opt_cache, (options, option_args)|
+          primary_name = options.shift
+
+          if option_args.is_a?(Hash)
+            opt_cache.merge(primary_name => option_args.merge(aliases: options))
+          else
+            opt_cache.merge(primary_name => {aliases: options, argument: option_args})
+          end
+        end
+
+        # Create a list of the "secure options" (hide value from client; as much as possible)
+        __generic_option_reducer(:private_options, [], opts, only_with: :private) do |priv_opts, (options, option_args)|
+          primary_name = options.shift
+
+          if option_args[:private]
+            priv_opts << primary_name
+          else
+            priv_opts
+          end
+        end
+
+        # Set the default options to be set when no values are passed
+        __generic_option_reducer(:default_options, {}, opts, only_with: :default) do |default_opts, (options, option_args)|
+          default_opts.merge(options.shift => option_args[:default])
+        end
+
+        # Create the attribute accessors
+        opts.keys.each do |options|
+          options = optionify_all(options)
+          primary_name = options.shift
+          attr_accessor(primary_name)
         end
       end
 
@@ -127,7 +370,7 @@ module CliTool
           # If we have extended details determine them
           if details.is_a?(Hash)
             short = details[:short]
-            dependency = details[:dependency]
+            dependency = details[:argument]
           else
             dependency = details
           end
@@ -140,8 +383,9 @@ module CliTool
           # If the option has aliases then create
           # additional GetoptLong Array options
           if opt.is_a?(Array)
-            opt.each do |key|
+            opt.each_with_index do |key, i|
               golaot = golao.dup
+              golaot.shift if i > 0 # Remove Short Code
               golaot.unshift("--#{key}")
               gola << golaot
             end
@@ -153,6 +397,36 @@ module CliTool
 
         gola
       end
+
+      private
+
+      def __generic_option_reducer(instance_var, default = [], opts = {}, args = {}, &block)
+        opts = opts.reduce({}) { |o, (k, v)| o.merge(optionify_all(k) => v) }
+
+        # Require certain keys be in the option cache. This is done to save time of the processing and make it easier to write
+        # the code to parse the options and set the requirements and dependencies of each option.
+        if args[:only_with]
+          opts = opts.select { |k, v| v.is_a?(Hash) && [args[:only_with]].flatten.reduce(true) { |o, key| o && v.has_key?(key) } }
+        end
+
+        # Run the reducer and set the class variables accordingly
+        class_variable_set("@@__#{instance_var}", default) unless class_variable_defined?("@@__#{instance_var}")
+        class_variable_set("@@__#{instance_var}", opts.reduce(class_variable_get("@@__#{instance_var}") || default, &block))
+      end
+
+      def __get_options(instance_var = nil)
+        instance_var ? class_variable_get("@@__#{instance_var}") : Proc.new {
+          self.class_variables.reduce({}) do |o, x|
+            o.merge(x[4..-1].to_sym => class_variable_get(x))
+          end
+        }.call
+      end
+
+      def __slice_hash(hash, *keys)
+        keys.reduce({}) do |out, key|
+          hash.has_key?(key) ? out.merge(key => hash[key]) : out
+        end
+      end
     end
   end
 end

data/lib/cli_tool/remote.rb

@@ -1,130 +1,355 @@
+require 'singleton'
+require 'pry'
+
 module CliTool
   module Remote
     class WaitingForSSH < StandardError; end;
     class Failure < StandardError; end;
 
-    class Script < String
-      def <<(script)
-        script = script.strip + ';' unless script.match(/;$/)
-        script = Script.new(script)
-        super("#{script}\n")
+    class Script
+      include CliTool::StdinOut
+      attr_accessor :commands
+      attr_accessor :environment
+      attr_accessor :indent
+
+      def initialize
+        @environment = {}
+        @commands    = []
+        @apt         = {}
+        @remote_installed = 0
+        @indent      = 0
+      end
+      alias reset initialize
+
+      ################
+      #= User Tools =#
+      ################
+
+      # def adduser(user, system = false)
+      #   script "adduser --disabled-password --quiet --gecos '' #{user}".squeeze(' '), :sudo
+      # end
+
+      ###############
+      #= Apt Tools =#
+      ###############
+
+      def install(*packages); apt(:install, *packages) end
+
+      def purge(*packages);   apt(:purge, *packages)   end
+
+      def remove(*packages);  apt(:remove, *packages)  end
+
+      def update;             apt(:update)             end
+
+      def upgrade;            apt(:upgrade)            end
+
+      def upgrade!;           apt(:'dist-upgrade')     end
+
+      def aptkey(*keys)
+        @environment['DEBIAN_FRONTEND'] = %{noninteractive}
+        keyserver = yield if block_given?
+        keyserver ||= 'keyserver.ubuntu.com'
+        exec("apt-key adv --keyserver #{keyserver} --recv-keys #{keys.join(' ')}", :sudo)
+        self
+      end
+
+      ##########
+      #= DPKG =#
+      ##########
+
+      def if_installed?(*packages);     check_installed(true, *packages)  end
+
+      def unless_installed?(*packages); check_installed(false, *packages) end
+
+      def dpkg_install(*packages)
+        packages.each do |package|
+          exec("dpkg -i #{package}", :sudo)
+        end
+        self
+      end
+
+      def remote_install(*packages)
+        @remote_installed = 0
+        packages.each do |package|
+          @remote_installed += 1
+          num = "#{@remote_installed}".rjust(3,'0')
+          tmp = "/tmp/package#{num}.deb"
+          curl(package, tmp, :sudo)
+          dpkg_install(tmp)
+          exec("rm -f #{tmp}", :sudo)
+        end
+        self
+      end
+
+      ###########
+      #= Tools =#
+      ###########
+
+      def wget(from, to, sudo = false, sudouser = :root)
+        install(:wget)
+        exec("wget -O #{to} #{from}", sudo, sudouser)
+        self
+      end
+
+      def curl(from, to, sudo = false, sudouser = :root)
+        install(:curl)
+        exec("curl -# -o #{to} #{from}", sudo, sudouser)
+        self
+      end
+
+      def service(name, action)
+        exec("service #{name} #{action}", :sudo)
+      end
+
+      def file_exist?(file, exist = true, &block)
+        if?((exist ? '' : '! ') + %{-f "#{file}"}, &block)
+      end
+
+      def directory_exist(directory, exist = true, &block)
+        if?((exist ? '' : '! ') + %{-d "#{file}"}, &block)
+      end
+
+      ##########
+      #= Exec =#
+      ##########
+
+      def exec(script, sudo = false, sudouser = :root)
+        if File.exist?(script)
+          script = File.read(script)
+        end
+
+        # Wrap the script in a sudoers block
+        if sudo || sudo == :sudo
+          sudo_script  = %{sudo su -c "/bin/bash" #{sudouser || :root}}
+          sudo_script << %{ <<-EOF\n#{get_environment_exports}#{script.rstrip}\nEOF}
+          script = sudo_script
+        end
+
+        @commands << script.rstrip
+        self
+      end
+
+      def to_s(indent = 0)
+        @commands.reduce([get_environment_exports(@indent)]){ |out, x|  out << ((' ' * @indent) + x) }.join("\n")
       end
 
-      def prepend(script)
-        script = script.strip + ';' unless script.match(/;$/)
-        script = Script.new(script)
-        super("#{script}\n")
+      private
+
+      def apt(command, *p, &b)
+        @environment['DEBIAN_FRONTEND'] = %{noninteractive}
+        return aptkey(*p, &b) if command == :key
+        #return if ((@apt[command] ||= []) - p).empty? && [:install, :purge, :remove].include?(command)
+        #((@apt[command] ||= []) << p).flatten!
+        exec(("apt-get -o Dpkg::Options::='--force-confnew' -q -y --force-yes #{command} " + p.map(&:to_s).join(' ')), :sudo)
+        self
+      end
+
+      def check_installed(installed, *p, &block)
+        installed = installed ? '1' : '0'
+
+        condition = packages.reduce([]) { |command, package|
+          command << %{[ "$(dpkg -s #{package} > /dev/null 2>1 && echo '1' || echo '0')" == '#{installed}' ]}
+        }.join(' && ')
+
+        if?(condition, &block)
+        self
+      end
+
+      def if?(condition, &block)
+        exec(%{if [ #{condition} ]; then\n"} << Script.new.__send__(:instance_exec, &block).to_s(@indent + 2) << "\nfi")
+        self
+      end
+
+      def get_environment_exports(indent = 0)
+        @environment.reduce([]) { |out, (key, val)|
+          out << %{export #{(' ' * indent)}#{key.upcase}=#{val}}
+        }.join("\n") << "\n"
       end
     end
 
     def self.included(base)
+      base.__send__(:include, ::Singleton)
       base.__send__(:include, ::CliTool::StdinOut)
       base.__send__(:include, ::CliTool::OptionParser)
       base.__send__(:include, ::CliTool::SoftwareDependencies)
       base.extend(ClassMethods)
       base.software(:ssh, :nc)
-      base.options host: :required,
-        identity: :required,
-        debug: :none,
-        user: {
-          dependency: :required,
-          default: %x{whoami}.strip
+      base.options({
+        [:username, :user] => {
+          default: %x{whoami}.strip,
+          argument: :required,
+          short: :u,
+          documentation: 'SSH username'
+        },
+        [:password, :pass] => {
+          argument: :required,
+          short: :p,
+          documentation: 'SSH password (not implemented)',
+          secure: true
+        },
+        identity: {
+          argument: :required,
+          short: :i,
+          documentation: 'SSH key to use'
+        },
+        host: {
+          argument: :required,
+          short: :h,
+          documentation: 'SSH host to connect to',
+          required: true
         },
         port: {
-          dependency: :required,
-          default: '22'
+          default: '22',
+          argument: :required,
+          documentation: 'SSH port to connect on'
+        },
+        [:tags, :tag] => {
+          argument: :required,
+          short: :t,
+          documentation: 'Run tags (limit scripts to run)',
+          preprocess: ->(tags) { tags.split(',').map{ |x| x.strip.to_sym } }
         }
+      })
     end
 
-    def script(script = nil, sudo = false, sudouser = nil)
-      @_script ||= Script.new
-      return Script.new(@_script.strip) if script.nil?
-      return @_script = Script.new if script == :reset
-      @_script << (sudo == :sudo ? %{sudo su -l -c "#{script.strip.gsub('"','\"')}" #{sudouser}} : script).strip
-    end
+    module ClassMethods
+      def script(options = {}, &block)
+        script = Proc.new do
+          run = true
 
-    def script_exec
-      wait4ssh
+          # Allow restricting the runs based on the tags provided
+          if self.tags
+            script_tags = (options[:tags] || []).concat([options[:tag]]).compact.flatten
+            run = false if (self.tags & script_tags).empty?
+          end
 
-      command =[ "ssh -t -t" ]
-      command << "-I #{@identity}" if @identity
-      command << "-p #{@port}" if @port
-      command << "#{@user}@#{@host}"
-      command << "<<-SCRIPT\n#{script}\nexit;\nSCRIPT"
-      command  = command.join(' ')
-      script :reset
+          # Run only when the tag is provided if tag_only option is provided
+          run = false if run && options[:tag_only] == true && self.tags.empty?
 
-      puts("Running Remotely:\n#{command}\n", [:blue, :white_bg])
+          if run # Do we want to run this script?
+            build_script = Script.new
+            build_script.__send__(:instance_exec, self, &block)
+            if options[:reboot] == true
+              build_script.exec('shutdown -r now', :sudo)
+              puts "\nServer will reboot upon completion of this block!\n", [:blue, :italic]
+            elsif options[:shutdown] == true
+              build_script.exec('shutdown -h now', :sudo)
+              puts "\nServer will shutdown upon completion of this block!\n", [:blue, :italic]
+            end
 
-      system(command)
+            build_script
+          else
+            false # Don't run anything
+          end
+        end
 
-      unless $?.success?
-        raise Failure, "Error running \"#{command}\" on #{@host} exited with code #{$?.to_i}."
+        queue(script)
       end
-    end
 
-    def aptget(action = :update, *software)
-      software = software.map(&:to_s).join(' ')
-      script "apt-get #{action} -q -y --force-yes #{software}", :sudo
-    end
+      def shutdown!
+        queue(Script.new.exec('shutdown -h now', :sudo))
+      end
 
-    def aptkeyadd(*keys)
-      keys = keys.map(&:to_s).join(' ')
-      script "apt-key adv --keyserver keyserver.ubuntu.com --recv-keys #{keys}", :sudo
-    end
+      def restart!
+        queue(Script.new.exec('shutdown -r now', :sudo))
+      end
 
-    def restart
-      script :reset
-      script "shutdown -r now &", :sudo
-      script_exec
+      def run_suite!(*a, &b)
+        run(:run_suite!, *a, &b)
+      end
 
-      # Let the server shutdown
-      sleep 5
-    end
+      def custom!(*a, &b)
+        Proc.new { |obj| obj.instance_exec(*a, &b) }
+        false
+      end
 
-    def adduser(user, system = false)
-      script "adduser --disabled-password --quiet --gecos '' #{user}".squeeze(' '), :sudo
+      private
+
+      def queue(*items)
+        return @@queue || [] if items.empty?
+        items.map!{ |x| x.is_a?(Script) ? x.to_s : x }.flatten!
+        ((@@queue ||= []) << items).flatten!
+        self
+      end
     end
 
-    def wait4ssh
-      _retry ||= false
-      %x{nc -z #{@host} #{@port}}
-      raise WaitingForSSH unless $?.success?
-      puts("\nSSH is now available!", :green) if _retry
-    rescue WaitingForSSH
-      print "Waiting for ssh..." unless _retry
-      _retry = true
-      print '.'
-      sleep 2
-      retry
+    def export(dir = nil)
+      self.class.queue.select{ |x| x.is_a?(String) }
     end
 
-    module ClassMethods
+    def remote_exec!(script)
+      ssh_cmd =[ 'ssh -t -t' ]
+      ssh_cmd << "-I #{@identity}" if @identity
+      ssh_cmd << "-p #{@port}"     if @port
+      ssh_cmd << "#{@username}@#{@host}"
+      ssh_cmd << "/bin/bash -s"
 
-      # Create the options array
-      def software(*soft)
-        @@software ||= []
+      # Show debug script
+      if self.debug
+        pretty_cmd = ssh_cmd.concat(["<<-SCRIPT\n#{script}\nexit;\nSCRIPT"]).join(' ')
+        message = "About to run remote process over ssh on #{@username}@#{@host}:#{@port}"
+        puts message, :blue
+        puts '#' * message.length, :blue
+        puts pretty_cmd, :green
+        puts '#' * message.length, :blue
+        confirm "Should we continue?", :orange
+      else
+        sleep 2
+      end
 
-        # If no software dependencies were passed then return
-        return @@software.uniq unless soft
+      #ssh_cmd << %{"#{script.gsub(/"/, '\\\1')}"}
+      ssh_cmd << "<<-SCRIPT\n#{script}\nexit;\nSCRIPT"
+      ssh_cmd << %{| grep -v 'stdin: is not a tty'}
 
-        # Find missing software
-        missing = []
-        soft.each do |app|
-          %x{which #{app}}
-          missing << app unless $?.success?
-        end
+      puts "Running Script", [:blue, :italic]
 
-        # Raise if there were any missing software's
-        unless missing.empty?
-          missing = missing.join(', ')
-          raise CliTool::MissingDependencies,
-            %{The required software packages "#{missing}" could not be found in your $PATH.}
-        end
+      # Run command if a connection is available
+      return false unless ssh_connection?
+      puts "" # Empty Line
+      system(ssh_cmd.join(' '))
+      exec_success = $?.success?
+      puts "" # Empty Line
 
-        # Append to the software list
-        @@software = @@software.concat(soft).uniq
+      # Print message with status
+      if exec_success
+        puts "Script finished successfully.", [:green, :italic]
+      else
+        puts "There was an error running remote execution!", [:red, :italic]
       end
+
+      # Return status
+      exec_success
+    end
+
+    def run_suite!
+      self.class.__send__(:queue).each do |item|
+        item = instance_exec(self, &item) if item.is_a?(Proc)
+        remote_exec!(item.to_s) if item.is_a?(String) || item.is_a?(Script)
+      end
+    end
+
+    def tag?(*tgs)
+      self.tags && ! (self.tags & tgs).empty?
+    end
+
+    private
+
+    def ssh_connection?
+      port_available = false
+      tries = 0
+
+      while ! port_available && tries < 6
+        %x{nc -z #{@host} #{@port}}
+        port_available = $?.success?
+        break if port_available
+        print 'Waiting for ssh...', [:blue, :italic] if tries < 1
+        print '.'
+        tries += 1
+        sleep 4
+      end
+
+      puts ''
+      port_available
     end
   end
 end

data/lib/cli_tool/stdin_out.rb

@@ -1,3 +1,4 @@
+require 'io/console'
 require 'timeout'
 
 module CliTool
@@ -5,37 +6,37 @@ module CliTool
     class MissingInput < StandardError; end;
 
     ANSI_COLORS = {
-      :reset         => 0,
-      :bold          => 1,
-      :italic        => 3,
-      :underline     => 4,
-      :inverse       => 7,
-      :strike        => 9,
-      :bold_off      => 22,
-      :italic_off    => 23,
-      :underline_off => 24,
-      :inverse_off   => 27,
-      :strike_off    => 29,
-      :black         => 30,
-      :red           => 31,
-      :green         => 32,
-      :yellow        => 33,
-      :blue          => 34,
-      :magenta       => 35,
-      :purple        => 35,
-      :cyan          => 36,
-      :white         => 37,
-      :default       => 39,
-      :black_bg      => 40,
-      :red_bg        => 41,
-      :green_bg      => 42,
-      :yellow_bg     => 43,
-      :blue_bg       => 44,
-      :magenta_bg    => 45,
-      :purple_bg     => 45,
-      :cyan_bg       => 46,
-      :white_bg      => 47,
-      :default_bg    => 49
+      reset: 0,
+      bold: 1,
+      italic: 3,
+      underline: 4,
+      inverse: 7,
+      strike: 9,
+      bold_off: 22,
+      italic_off: 23,
+      underline_off: 24,
+      inverse_off: 27,
+      strike_off: 29,
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      purple: 35,
+      cyan: 36,
+      white: 37,
+      default: 39,
+      black_bg: 40,
+      red_bg: 41,
+      green_bg: 42,
+      yellow_bg: 43,
+      blue_bg: 44,
+      magenta_bg: 45,
+      purple_bg: 45,
+      cyan_bg: 46,
+      white_bg: 47,
+      default_bg: 49
     }
 
     def self.included(base)
@@ -49,11 +50,23 @@ module CliTool
       def puts(text, color = :reset, timer = nil)
 
         # Process information for ANSI color codes
-        super(_colorize_(text, color))
+        super(colorize(text, color))
 
         # Sleep after displaying the message
         if timer
-          puts(_colorize_("Sleeping for #{timer} seconds...", color))
+          puts(colorize("Sleeping for #{timer} seconds...", color))
+          sleep(timer)
+        end
+      end
+
+      def print(text, color = :reset, timer = nil)
+
+        # Process information for ANSI color codes
+        super(colorize(text, color))
+
+        # Sleep after displaying the message
+        if timer
+          puts(colorize("Sleeping for #{timer} seconds...", color))
           sleep(timer)
         end
       end
@@ -61,11 +74,18 @@ module CliTool
       def input(message = '', color = :reset, timer = nil, default = nil)
 
         # Prompt for input
-        puts(message, color)
+        print("#{message} ", color)
 
         # Get the input from the CLI
-        gets = Proc.new do
-          STDIN.gets.strip
+        if block_given? && yield == :noecho
+          gets = Proc.new do
+            STDIN.noecho(&:gets).strip
+            print "\n"
+          end
+        else
+          gets = Proc.new do
+            STDIN.gets.strip
+          end
         end
 
         # Handle timing out
@@ -82,6 +102,10 @@ module CliTool
         result
       end
 
+      def password(*a)
+        input(*a) { :noecho }
+      end
+
       def confirm(message, color = :reset, default = :n, timer = nil)
 
         # Handle the default value
@@ -107,9 +131,7 @@ module CliTool
         result
       end
 
-      private
-
-      def _colorize_(text, *color)
+      def colorize(text, *color)
 
         # Determine what to colors we should use
         color = [:reset] if color.empty?

data/lib/cli_tool/version.rb

@@ -1,3 +1,3 @@
 module CliTool
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: cli_tool
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Kelly Becker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-26 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -27,29 +30,33 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Have trouble with advanced command line options, software dependency
@@ -78,26 +85,27 @@ files:
 homepage: http://kellybecker.me
 licenses:
 - MIT
-metadata: {}
 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: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Tools to help with writing command line applications
 test_files: []
 has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 5d6bebdc51c5d3fa303521a576030ef09a2a2f1e
-  data.tar.gz: 44314ab4226493adced0d5300540c55de8194801
-SHA512:
-  metadata.gz: c4f62e534448942a0f7ef307b7c3be7b37807ca658692f89c7df97a11db30de081c6ec5eb82fdc3a6f0408df5e922e92edcc1e2351d636d64124e8bfffa5b57d
-  data.tar.gz: 0f5cc7400c20e4c3732aba67f733873d89843eff4f17901a362617e021518d72dfc22a65dd8d1217b12abdda98eb4c838b35553f26bc48854408397de2f12ec0