cmd-utils 1.1.2 → 1.2.0

data/lib/error-utils.rb

@@ -0,0 +1,56 @@
+# error-utils.rb -- simple utilities for managing errors to $stderr
+#
+# Alan K. Stebbens <aks@stebbens.org>
+#
+#
+#    require 'error-utils'
+#
+# Provides:
+#
+#    error   [code,]  msg
+#    error(  [code]){ msg }
+#    error  {[code,]  msg }
+#
+#    errorf  [code,]  fmt, *args
+#    errorf( [code,] fmt) { *args }
+#    errorf {[code,] fmt, *args }
+#
+
+require 'arg-utils'
+
+# error -- print an error message on STDERR, and then exit.
+# :call-seq:
+#     error   [code],   msg
+#     error(  [code]) { msg }
+#     error {[[code],   msg ] }
+#
+# Code defaults to 1 if not given.
+
+def error *args
+  args = _msgargs(args, block_given?) { yield }
+  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
+  $stderr.puts(*args)
+  $stderr.flush
+  exit code
+end
+
+##
+# errorf -- print a formatted message on STDERR, and then exit
+#
+# :call-seq:
+#     errorf   [code],   fmt,   args ..
+#     errorf(  [code],   fmt) { args .. }
+#     errorf(  [code]) { fmt,   args .. }
+#     errorf {[[code],   fmt,   args .. ] }
+
+def errorf *args
+  args = _fmtargs(args, block_given?) { yield }
+  # default the error code to 1 unless the first argument is a Fixnum
+  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
+  $stderr.printf(*args)
+  $stderr.flush
+  exit code
+end
+
+# end of error-utils.sh
+# vim: set ai sw=2

data/lib/lookup.rb

@@ -3,7 +3,7 @@
 # Alan K. Stebbens <aks@stebbens.org>
 #
 #    require 'lookup'
-# 
+#
 # lookup - lookup a keyword in a list, in a case-insensitive, disambiguous way
 #
 # :call-seq:
@@ -69,3 +69,6 @@ class Hash
     self.keys.lookup(key, err_notfound, err_ambig)
   end
 end
+
+# end of lookup.rb
+# vim: set sw=2 ai

data/lib/run-utils.rb

@@ -0,0 +1,79 @@
+# run-utils.rb -- simple utilities for running commands
+#
+# Alan K. Stebbens <aks@stebbens.org>
+#
+#
+#    require 'run-utils'
+#
+# Utilities for running commands.
+
+require 'arg-utils'
+require 'talk-utils'
+
+# run -- run a command with support for testing, diagnostics and verbosity
+# safe_run -- run a command with support for diagnostics and verbosity
+#
+# Both may be given optional `errmsg` and `okmsg`, which are printed if given
+# for the corresponding condition.
+#
+# :call-seq:
+#     run         cmd
+#     run      {  cmd }
+#     run         cmd, errmsg
+#     run      { [cmd, errmsg] }
+#     run      { [cmd, errmsg, okmg] }
+#     run         cmd, errmsg, okmsg
+#
+#     safe_run    cmd
+#     safe_run    cmd, errmsg
+#     safe_run    cmd, errmsg, okmsg
+#     safe_run {  cmd }
+#     safe_run { [cmd, errmsg] }
+#     safe_run { [cmd, errmsg, okmsg] }
+#
+# if `$norun` is set, print `(norun) ` followed by `cmd` on `STDERR`, and
+# return.
+#
+# if `$verbose` is set, print `>> ` followed by `cmd` on `STDERR`.
+#
+# Invoke the `cmd` with the `system()` call.
+#
+# If there is an error, show the command (preceded by `>> `) if `$verbose` is
+# not set, then show the error code, followed by the given `errmsg` or the
+# default error message.
+#
+# The `cmd` can be given either as an argument, or as the returned value from a
+# block.  Important: the block should return a string value to be passed to
+# the system call.
+
+def safe_run *args
+  args = _msgargs(args, block_given?) { yield }
+  cmd, errmsg, okmsg = args
+  vtalkf ">> %s\n", cmd
+  if cmd
+    if system cmd              # invoke the command
+      talk okmsg if okmsg
+      return true
+    else                        # an error occured
+      qtalkf ">> %s\n", cmd
+      erm = sprintf(errmsg ? errmsg : "Command failed with code %d", $?>>8)
+      talk erm
+      $stderr.flush
+      raise SystemCallError, erm            # instead of exit, use raise
+    end
+  end
+end
+
+def cmd_run *args
+  args = _msgargs(args, block_given?) { yield }
+  if $norun
+    nrtalk(args.first)
+  elsif args.size > 0
+    safe_run(*args)
+  end
+end
+
+alias run cmd_run
+
+# end of run-utils.sh
+# vim: set ai sw=2

data/lib/ssh-utils.rb

@@ -9,16 +9,16 @@
 #
 #    require 'ssh-utils'
 #
-#    on serverlist, :debug = true do |server|
-#      as user do
-#        with PATH
+#    on SERVERLIST, :debug = true do |server|
+#      as USER do
+#        with PATH do
 #          remote_run :whoami
 #        end
 #      end
 #    end
 
 require 'rubygems'
-require 'cmd-utils'
+require 'talk-utils'
 
 module SSH_Utils
 
@@ -53,11 +53,19 @@ module SSH_Utils
     end
   end
 
-  # on SERVERLIST, :with => %w(PATH RUBYLIB), :debug => [true|false], :norun => [true|false]
+  # merge_opts_with_env opts
+  #
+  # Invokes merge_env, then merge_opts
 
-  def on servers, opts = {}
+  def merge_opts_with_env opts = {}
     merge_env (opts = opts.dup)
     merge_opts opts
+  end
+
+  # on SERVERLIST, :with => %w(PATH RUBYLIB), :debug => [true|false], :norun => [true|false]
+
+  def on servers, opts = {}
+    merge_opts_with_env opts
     (@servers = servers).each do |server|
       @server = server
       talk("--> Running block for server #{server}..") if @opts[:debug] || $debug
@@ -69,16 +77,15 @@ module SSH_Utils
 
   def as user, opts = {}
     @user = user
-    merge_env (opts = opts.dup)
-    merge_opts opts
+    merge_opts_with_env opts
     yield if block_given?
   end
 
   # with ENVARLIST, :VAR1 => value, :debug => ...
 
   def with env, opts = {}
-    merge_env (opts = opts.dup)
-    merge_opts opts
+    merge_opts_with_env opts
+    yield if block_given?
   end
 
   def ssh_command cmd
@@ -116,8 +123,7 @@ module SSH_Utils
 
 
   def remote_run_with_output cmd, opts = {}
-    merge_env (opts = opts.dup)
-    merge_opts opts
+    merge_opts_with_env opts
     ssh = ssh_command cmd
     _show_cmd ssh
     out = nil
@@ -131,4 +137,5 @@ end
 
 include SSH_Utils
 
+# end of ssh-utils.rb
 # vim: sw=2:ai

data/lib/talk-utils.rb

@@ -0,0 +1,160 @@
+# talk-utils.rb -- simple utilties for "talking" to $stderr
+#
+# Alan K. Stebbens <aks@stebbens.org>
+#
+#    require 'talk-utils'
+#
+# Utilities for option-controlled output, and running commands.
+#
+# The output and run methods rely on some external variables:
+#
+#    $verbose -- enables vtalk(f) output
+#    $norun   -- enables nrtalk(f) output and controls the "run" command
+#    $quiet   -- enables qtalk(f) output, and disables talk(f) output
+#    $debug   -- enables dtalk(f) output
+#
+# These routines provide conditional output.  The arguments can be given as
+# part of the the function calls, or, can be provided as the return value of a
+# block.  The advantage of using a block is that the block is not evaluated
+# unless the conditions requiring output are met.  So, if the expression to
+# compute a value that _might_ be printed is expensive, do the computation
+# inside a block.
+#
+
+require 'arg-utils'
+
+##
+# talk - Print msg on STDERR unless `$quiet` is set
+#
+# :call-seq:
+#    talk        msg ..
+#    talk      { msg .. }
+#    talkf fmt, args ...
+#    talkf fmt { [ args ... ] }
+
+def talk *args
+  if !$quiet && (args.size > 0 || block_given?)
+    $stderr.puts(*_msgargs(args, block_given?) { yield })
+  end
+end
+
+def talkf *args
+  if !$quiet && (args.size > 0 || block_given?)
+    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
+  end
+end
+
+##
+# dtalk - "debug talk"
+# Print msg on STDERR only if `$debug` is set
+#
+# :call-seq:
+#     dtalk   msg
+#     dtalk { msg }
+#     dtalkf fmt,    args ..
+#     dtalkf fmt { [ args .. ] }
+
+def dtalk *args
+  if $debug && (args.size > 0 || block_given?)
+    $stderr.puts(*_msgargs(args, block_given?) { yield })
+  end
+end
+
+def dtalkf *args
+  if $debug && (args.size> 0 || block_given?)
+    $stderr.printf(*_fmtargs(args, block_given?) { yield })
+  end
+end
+
+##
+# qtalk - "quiet talk"
+# print msg on STDERR only if `$quiet` is set
+#
+# :call-seq:
+#     qtalk   msg
+#     qtalk { msg }
+#     qtalkf fmt,    args ..
+#     qtalkf fmt { [ args .. ] }
+
+def qtalk *args
+  if $quiet && (args.size > 0 || block_given?)
+    $stderr.puts(*_msgargs(args, block_given?) { yield })
+  end
+end
+
+def qtalkf *args
+  if $quiet && (args.size > 0 || block_given?)
+    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
+  end
+end
+
+##
+# vtalk - "verbose talk"
+# Print msg on STDERR if `$verbose` is set
+#
+# :call-seq:
+#     vtalk   msg
+#     vtalk { msg }
+#     vtalkf fmt, args ..
+#     vtalkf fmt { args .. }
+
+def vtalk *args
+  if $verbose && (args.size > 0 || block_given?)
+    $stderr.puts(*_msgargs(args, block_given?) { yield })
+  end
+end
+
+def vtalkf *args
+  if $verbose && (args.size > 0 || block_given?)
+    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
+  end
+end
+
+##
+# nvtalk -- "non-verbose" talk
+# Print msg on STDERR unless `$verbose` is set
+#
+# :call-seq:
+#     nvtalk msg
+#     nvtalk { msg }
+
+def  nvtalk *args
+  unless $verbose && (args.size > 0 || block_given?)
+    $stderr.puts(*_msgargs(args, block_given?) { yield })
+  end
+end
+
+def nvtalkf *args
+  unless $verbose && (args.size > 0 || block_given?)
+    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
+  end
+end
+
+##
+# nrtalk -- "no run" talk
+# Print msg, prefixed with "(norun) ", on STDERR only if `$norun` is set
+#
+# :call-seq:
+#     nrtalk        msg
+#     nrtalk      { msg }
+#     nrtalkf fmt,  msg
+#     nrtalkf fmt { msg }
+
+def nrtalk *args
+  if $norun && (args.size > 0 || block_given?)
+    newargs = _msgargs(args, block_given?) { yield }
+    newargs[0] = '(norun) ' + newargs[0] unless newargs.size == 0 || newargs[0].nil? || newargs[0].include?('(norun)')
+    $stderr.puts(*newargs)
+  end
+end
+
+def nrtalkf *args
+  if $norun && (args.size > 0 || block_given?)
+    newargs = _fmtargs(args, block_given?) { yield }
+    newargs[0] = '(norun) ' + newargs[0] unless newargs.size == 0 || newargs[0].nil? || newargs[0].include?('(norun)')
+    $stderr.printf(*newargs)
+  end
+end
+
+# end of talk-utils.sh
+# vim: set ai sw=2

data/test/helper.rb

@@ -1,19 +1,5 @@
-require 'simplecov'
+# test/helper.rb
 
-module SimpleCov::Configuration
-  def clean_filters
-    @filters = []
-  end
-end
-
-SimpleCov.configure do
-  clean_filters
-  load_adapter 'test_frameworks'
-end
-
-ENV["COVERAGE"] && SimpleCov.start do
-  add_filter "/.rvm/"
-end
 require 'rubygems'
 require 'bundler'
 begin
@@ -24,12 +10,60 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 require 'minitest'
-require 'test/unit'
-require 'shoulda'
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'cmd-utils'
 
-class Test::Unit::TestCase
+module IO_Assert
+  def io_assert ioname, name, actual, expected
+    if expected
+      case expected
+      when TrueClass  then refute_empty(actual, "#{name} $#{ioname} should not be empty")
+      when FalseClass then assert_empty(actual, "#{name} $#{ioname} should be empty")
+      when String     then assert_match(actual, expected, "#{name} $#{ioname}: expected '#{expected}', got: '#{actual}'")
+      end
+    end
+    true
+  end
+end
+
+module Gen_Test
+  include IO_Assert
+
+  #def gen_test name, norun, verbose, quiet, debug, output
+  def gen_test name, flags, output
+    $norun   = flags.include?('n')
+    $verbose = flags.include?('v')
+    $quiet   = flags.include?('q')
+    $debug   = flags.include?('d')
+    out, err = capture_io { yield }
+    assert_empty(out, "#{name} $stdout should be empty")
+    io_assert :stderr, name, err, output
+  end
+end
+
+module Run_Test
+  include IO_Assert
+  def run_test name, flags, output=nil, errput=nil
+    $norun   = flags.include?('n')
+    $verbose = flags.include?('v')
+    $quiet   = flags.include?('q')
+    $debug   = flags.include?('d')
+    begin
+      out, err = capture_subprocess_io do
+        begin
+          yield
+        rescue
+        end
+      end
+    rescue
+    end
+    io_assert :stdout, name, out, output
+    io_assert :stderr, name, err, errput
+    true
+  end
+end
+
+class Minitest::Test
 end