cmd-utils 1.0.6

data/lib/cmd-utils.rb

@@ -0,0 +1,187 @@
+# cmd-utils.rb -- simple utilities for ruby command line tools
+#
+# Alan K. Stebbens <aks@stebbens.org>
+#
+#
+#    require 'cmd-utils'
+# 
+# Utilities for output, and running commands.
+#
+# The output and run methods rely on some external variables:
+#
+#    $verbose -- causes certain commands to talk more
+#    $norun   -- causes the "run" command to print its argument, but not actually run it.
+#    $quiet   -- causes certain commands to talk less
+#
+# 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.
+#
+##
+# talk - Print msg on STDERR unless `$quiet` is set
+#
+# :call-seq:
+#    talk        msg
+#    talk      { msg }
+#    talkf fmt, args ...
+#    talkf fmt { [ args ... ] }
+
+def talk msg=nil
+  if !$quiet && (msg || block_given?)
+    $stderr.puts(msg || yield)
+  end
+end
+
+def talkf fmt='%s', *args
+  args = yield if args.size == 0 && block_given?
+  talk { sprintf(fmt, *args) }
+end
+
+##
+# qtalk - Print msg on STDERR only if `$quiet` is set
+#
+# :call-seq:
+#     qtalk   msg
+#     qtalk { msg }
+#     qtalkf fmt,    args ..
+#     qtalkf fmt { [ args .. ] }
+
+def qtalk msg=nil
+  if $quiet && (msg || block_given?)
+    $stderr.puts(msg || yield)
+  end
+end
+
+def qtalkf fmt='%s', *args 
+  args = yield if args.size == 0 && block_given?
+  qtalk { sprintf(fmt, *args) }
+end
+
+##
+# vtalk -- Print msg on STDERR if `$verbose` is set
+#
+# :call-seq:
+#     vtalk   msg
+#     vtalk { msg }
+#     vtalkf fmt, args ..
+#     vtalkf fmt { args .. }
+
+def vtalk msg=nil
+  if $verbose && (msg || block_given?)
+    $stderr.puts(msg || yield)
+  end
+end
+
+def vtalkf fmt='%s', *args
+  args = yield if args.size == 0 && block_given?
+  vtalk { sprintf(fmt, *args) }
+end
+
+##
+# nvtalk -- Print msg on STDERR unless `$verbose` is set
+#
+# :call-seq:
+#     nvtalk msg
+#     nvtalk { msg }
+
+def  nvtalk msg=nil
+  unless $verbose && (msg || block_given?)
+    $stderr.puts(msg || yield)
+  end
+end
+
+def nvtalkf fmt='%s', *args
+  args = yield if args.size == 0 && block_given?
+  nvtalk { sprintf(fmt, *args) }
+end
+
+##
+# nrtalk -- Print msg on STDERR only if `$norun` is set
+#
+# :call-seq:
+#     nrtalk        msg
+#     nrtalk      { msg }
+#     nrtalkf fmt,  msg
+#     nrtalkf fmt { msg }
+
+def nrtalk msg=nil
+  if $norun
+    $stderr.puts(msg || yield)
+  end
+end
+
+def nrtalkf *args
+  args = yield if args.size == 0 && block_given?
+  nrtalk { sprintf(*args) }
+end
+
+##
+# error -- print an error message on STDERR, and then exit.
+# :call-seq:
+#     error [code], msg
+#     errof [code], fmt, args
+#
+# Code defaults to 1 if not given.
+
+def error *args
+  args = yield if args.size == 0 && block_given?
+  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
+  $stderr.puts(*args)
+  $stderr.flush
+  exit code
+end
+
+def errorf *args
+  args = yield if args.size == 0 && block_given?
+  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
+  $stderr.printf(*args)
+  $stderr.flush
+  exit code
+end
+
+##
+# run -- run a command with support for testing, diagnostics and verbosity
+# safe_run -- run a command with support for diagnostics and verbosity
+#
+# :call-seq:
+#     run        cmd
+#     run      { cmd }
+#     safe_run   cmd
+#     safe_run { cmd }
+#
+# 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.
+#
+# The `cmd` can be given either as an argument, or as the returned value from a
+# block.
+
+def run cmd=nil
+  cmd ||= block_given? && yield
+  if $norun
+    $stderr.printf "(norun) %s\n", cmd
+  else
+    safe_run cmd
+  end
+end
+
+def safe_run cmd=nil
+  cmd ||= block_given? && yield
+  vtalkf { [ ">> %s\n", cmd ] }
+  system cmd
+  if $? > 0
+    qtalkf { [ ">> %s\n", cmd ] }
+    errorf $?, "Command failed with code %d!\n", $?
+  end
+end
+
+# end of cmd-utils.sh
+# vim: set ai sw=2

data/lib/lookup.rb

@@ -0,0 +1,71 @@
+# lookup.rb -- simple keyword lookup routine
+#
+# Alan K. Stebbens <aks@stebbens.org>
+#
+#    require 'lookup'
+# 
+# lookup - lookup a keyword in a list, in a case-insensitive, disambiguous way
+#
+# :call-seq:
+#     result = lookup list, key, err_notfound="%s not found", err_ambig="% is ambiguous"
+#     result = list.lookup( key, err_notfound, err_ambig )
+#     result = list.lookup( key, err_notfound )
+#     result = list.lookup( key )
+#
+# Lookup key in list, which can be an array or a hash.  Return the one that
+# matches exactly, or matches using case-insensitive, unambiguous matches, or
+# raise a LookupError with a message.
+#
+# LookupError is a subclass of StandardError.
+#
+# LookupNotFoundError, a subclass of LookupError, is raised when a keyword is
+# not found, and only if `err_notfound` is not nil.
+#
+# LookupAmbigError, a subsclass of LookupError, is raised when a keyword search
+# matches multiple entries from the list, and only if `err_ambig` is not nil.
+#
+# If err_notfound is nil, do not raise a LookupNotFoundError error, and return
+# nil.
+#
+# If err_ambigmsg is nil, do not raise a LookupAmbigError, and return the list
+# of possible results.
+
+class LookupError         < StandardError ; end
+class LookupNotFoundError < LookupError ; end
+class LookupAmbigError    < LookupError ; end
+
+def key_lookup list, key, err_notfound="%s not found\n", err_ambig="%s is ambiguous\n"
+  keylist = list.is_a?(Hash) ? list.keys : list
+  if exact = keylist.grep(/^#{key}$/i)         # exact match?
+    return exact.shift if exact && exact.size == 1
+  end
+  keys = keylist.grep(/^#{key}/i)
+  case keys.size
+  when 0
+    unless err_notfound.nil?
+      raise LookupNotFoundError, sprintf(err_notfound, key)
+    end
+    return nil
+  when 1
+    return keys[0]
+  else
+    unless err_ambig.nil?
+      raise LookupAmbigError, sprintf(err_ambig, key)
+    end
+    return keys
+  end
+end
+
+alias lookup key_lookup
+
+class Array
+  def lookup key, err_notfound="%s not found\n", err_ambig="%s is ambiguous\n"
+    key_lookup self, key, err_notfound, err_ambig
+  end
+end
+
+class Hash
+  def lookup key, err_notfound="%s not found\n", err_ambig="%s is ambiguous\n"
+    self.keys.lookup(key, err_notfound, err_ambig)
+  end
+end

data/tests/test-cmd-utils.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+# test-cmd-utils.rb -- simple tester for cmd-utils
+#
+require 'rubygems'
+require 'minitest'
+require 'minitest/autorun'
+require 'cmd-utils'
+
+# these routines produce output on STDERR depending on $norun, $verbose, and $quiet.
+
+class TestCmdUtils < MiniTest::Test
+
+  def gen_test name, norun, verbose, quiet, output
+    $norun   = norun > 0
+    $verbose = verbose > 0
+    $quiet   = quiet > 0
+    out, err = capture_io { yield }
+    assert_empty(out, "#{name} $stdout should be empty")
+    case output
+    when TrueClass
+      refute_empty(err, "#{name} $stderr should not be empty")
+    when FalseClass
+      assert_empty(err, "#{name} $stderr should be empty")
+    when String
+      assert_match(out, output, "#{name} $stderr should match #{output}")
+    end
+    true
+  end
+
+
+  def test_talk_arg
+    #           nr, verb, quiet, output?
+    gen_test('talk_arg', 0, 0, 0, true)    { talk "hello" }
+    gen_test('talk_arg', 0, 0, 1, false)   { talk "hello" }
+    gen_test('talk_arg', 0, 1, 0, true)    { talk "hello" }
+    gen_test('talk_arg', 0, 1, 1, false)   { talk "hello" }
+    gen_test('talk_arg', 1, 0, 0, true)    { talk "hello" }
+    gen_test('talk_arg', 1, 0, 1, false)   { talk "hello" }
+    gen_test('talk_arg', 1, 1, 0, true)    { talk "hello" }
+    gen_test('talk_arg', 1, 1, 1, false)   { talk "hello" }
+  end
+
+  def test_talk_content
+    gen_test('talk_content', 0, 0, 0, "hello") { talk "hello" }
+    gen_test('talk_content_block', 0, 0, 0, "hello") { talk { "hello" } }
+  end
+
+  def test_talk_block
+    #           nr, verb, quiet, output?
+    gen_test('talk', 0, 0, 0, true)    { talk { "hello" } }
+    gen_test('talk', 0, 0, 1, false)   { talk { "hello" } }
+    gen_test('talk', 0, 1, 0, true)    { talk { "hello" } }
+    gen_test('talk', 0, 1, 1, false)   { talk { "hello" } }
+    gen_test('talk', 1, 0, 0, true)    { talk { "hello" } }
+    gen_test('talk', 1, 0, 1, false)   { talk { "hello" } }
+    gen_test('talk', 1, 1, 0, true)    { talk { "hello" } }
+    gen_test('talk', 1, 1, 1, false)   { talk { "hello" } }
+  end
+
+  def test_talkf_arg
+    #           nr, verb, quiet, output?
+    gen_test('talkf_arg', 0, 0, 0, true)    { talkf "%s", "hello" }
+    gen_test('talkf_arg', 0, 0, 1, false)   { talkf "%s", "hello" }
+    gen_test('talkf_arg', 0, 1, 0, true)    { talkf "%s", "hello" }
+    gen_test('talkf_arg', 0, 1, 1, false)   { talkf "%s", "hello" }
+    gen_test('talkf_arg', 1, 0, 0, true)    { talkf "%s", "hello" }
+    gen_test('talkf_arg', 1, 0, 1, false)   { talkf "%s", "hello" }
+    gen_test('talkf_arg', 1, 1, 0, true)    { talkf "%s", "hello" }
+    gen_test('talkf_arg', 1, 1, 1, false)   { talkf "%s", "hello" }
+  end
+
+  def test_talkf_block
+    #           nr, verb, quiet, output?
+    gen_test('talkf_block', 0, 0, 0, true)    { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 0, 0, 1, false)   { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 0, 1, 0, true)    { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 0, 1, 1, false)   { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 1, 0, 0, true)    { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 1, 0, 1, false)   { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 1, 1, 0, true)    { talkf("%s") { "hello" } }
+    gen_test('talkf_block', 1, 1, 1, false)   { talkf("%s") { "hello" } }
+  end
+
+  def test_talkf_content
+    gen_test('talkf_content', 0, 0, 0, "-hello-")       { talkf "-%s-",   "hello" }
+    gen_test('talkf_content', 0, 0, 0, "-hello-")       { talkf("-%s-") { "hello" } }
+    gen_test('talkf_default_content', 0, 0, 0, 'hello') { talkf           "hello" }
+    gen_test('talkf_default_content', 0, 0, 0, 'hello') { talkf         { "hello" } }
+  end
+
+  def test_qtalk_arg
+    #                nr,vrb,q, out?
+    gen_test('qtalk', 0, 0, 0, false)   { qtalk "hello" }
+    gen_test('qtalk', 0, 0, 1, true)    { qtalk "hello" }
+    gen_test('qtalk', 0, 1, 0, false)   { qtalk "hello" }
+    gen_test('qtalk', 0, 1, 1, true)    { qtalk "hello" }
+    gen_test('qtalk', 1, 0, 0, false)   { qtalk "hello" }
+    gen_test('qtalk', 1, 0, 1, true)    { qtalk "hello" }
+    gen_test('qtalk', 1, 1, 0, false)   { qtalk "hello" }
+    gen_test('qtalk', 1, 1, 1, true)    { qtalk "hello" }
+  end
+
+  def test_qtalk_block
+    #           nr, verb, quiet, output?
+    gen_test('qtalk', 0, 0, 0, false)   { qtalk { "hello" } }
+    gen_test('qtalk', 0, 0, 1, true)    { qtalk { "hello" } }
+    gen_test('qtalk', 0, 1, 0, false)   { qtalk { "hello" } }
+    gen_test('qtalk', 0, 1, 1, true)    { qtalk { "hello" } }
+    gen_test('qtalk', 1, 0, 0, false)   { qtalk { "hello" } }
+    gen_test('qtalk', 1, 0, 1, true)    { qtalk { "hello" } }
+    gen_test('qtalk', 1, 1, 0, false)   { qtalk { "hello" } }
+    gen_test('qtalk', 1, 1, 1, true)    { qtalk { "hello" } }
+  end
+
+  def test_qtalk_content
+    gen_test('qtalk_content', 0, 0, 1, "-hello-") { qtalk "hello" }
+    gen_test('qtalk_content', 0, 0, 1, "-hello-") { qtalk { "hello" } }
+  end
+
+  def test_qtalkf_content
+    gen_test('qtalkf_content', 0, 0, 1, "-hello-")         { qtalkf "-%s-",   "hello" }
+    gen_test('qtalkf_content', 0, 0, 1, "-hello-")         { qtalkf("-%s-") { "hello" } }
+    gen_test('qtalkf_default_content', 0, 0, 1, "-hello-") { qtalkf           "hello" }
+    gen_test('qtalkf_default_content', 0, 0, 1, "-hello-") { qtalkf         { "hello" } }
+  end
+
+  def test_vtalk_arg
+    #           nr, verb, quiet, output?
+    gen_test('vtalk_arg', 0, 0, 0, false)   { vtalk "hello" }
+    gen_test('vtalk_arg', 0, 0, 1, false)   { vtalk "hello" }
+    gen_test('vtalk_arg', 0, 1, 0, true)    { vtalk "hello" }
+    gen_test('vtalk_arg', 0, 1, 1, true)    { vtalk "hello" }
+    gen_test('vtalk_arg', 1, 0, 0, false)   { vtalk "hello" }
+    gen_test('vtalk_arg', 1, 0, 1, false)   { vtalk "hello" }
+    gen_test('vtalk_arg', 1, 1, 0, true)    { vtalk "hello" }
+    gen_test('vtalk_arg', 1, 1, 1, true)    { vtalk "hello" }
+  end
+
+  def test_vtalk_block
+    #           nr, verb, quiet, output?
+    gen_test('vtalk_block', 0, 0, 0, false)   { vtalk { "hello" } }
+    gen_test('vtalk_block', 0, 0, 1, false)   { vtalk { "hello" } }
+    gen_test('vtalk_block', 0, 1, 0, true)    { vtalk { "hello" } }
+    gen_test('vtalk_block', 0, 1, 1, true)    { vtalk { "hello" } }
+    gen_test('vtalk_block', 1, 0, 0, false)   { vtalk { "hello" } }
+    gen_test('vtalk_block', 1, 0, 1, false)   { vtalk { "hello" } }
+    gen_test('vtalk_block', 1, 1, 0, true)    { vtalk { "hello" } }
+    gen_test('vtalk_block', 1, 1, 1, true)    { vtalk { "hello" } }
+  end
+
+  def test_nvtalk_arg
+    #           nr, verb, quiet, output?
+    gen_test('nvtalk_arg', 0, 0, 0, true)     { nvtalk "hello" }
+    gen_test('nvtalk_arg', 0, 0, 1, true)     { nvtalk "hello" }
+    gen_test('nvtalk_arg', 0, 1, 0, false)    { nvtalk "hello" }
+    gen_test('nvtalk_arg', 0, 1, 1, false)    { nvtalk "hello" }
+    gen_test('nvtalk_arg', 1, 0, 0, true)     { nvtalk "hello" }
+    gen_test('nvtalk_arg', 1, 0, 1, true)     { nvtalk "hello" }
+    gen_test('nvtalk_arg', 1, 1, 0, false)    { nvtalk "hello" }
+    gen_test('nvtalk_arg', 1, 1, 1, false)    { nvtalk "hello" }
+  end
+
+  def test_nvtalk_block
+    #           nr, verb, quiet, output?
+    gen_test('nvtalk_block', 0, 0, 0, true)     { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 0, 0, 1, true)     { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 0, 1, 0, false)    { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 0, 1, 1, false)    { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 1, 0, 0, true)     { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 1, 0, 1, true)     { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 1, 1, 0, false)    { nvtalk { "hello" } }
+    gen_test('nvtalk_block', 1, 1, 1, false)    { nvtalk { "hello" } }
+  end
+
+  def test_nrtalk_arg
+    #           nr, verb, quiet, output?
+    gen_test('nrtalk_arg', 0, 0, 0, false)     { nrtalk "hello" }
+    gen_test('nrtalk_arg', 0, 0, 1, false)     { nrtalk "hello" }
+    gen_test('nrtalk_arg', 0, 1, 0, false)     { nrtalk "hello" }
+    gen_test('nrtalk_arg', 0, 1, 1, false)     { nrtalk "hello" }
+    gen_test('nrtalk_arg', 1, 0, 0, true)      { nrtalk "hello" }
+    gen_test('nrtalk_arg', 1, 0, 1, true)      { nrtalk "hello" }
+    gen_test('nrtalk_arg', 1, 1, 0, true)      { nrtalk "hello" }
+    gen_test('nrtalk_arg', 1, 1, 1, true)      { nrtalk "hello" }
+  end
+
+  def test_nrtalk_block
+    #           nr, verb, quiet, output?
+    gen_test('nrtalk_block', 0, 0, 0, false)    { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 0, 0, 1, false)    { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 0, 1, 0, false)    { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 0, 1, 1, false)    { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 1, 0, 0, true)     { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 1, 0, 1, true)     { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 1, 1, 0, true)     { nrtalk { "hello" } }
+    gen_test('nrtalk_block', 1, 1, 1, true)     { nrtalk { "hello" } }
+  end
+
+  def test_nrtalkf_content
+    gen_test('nrtalkf_content', 0, 0, 1, "-hello-")         { nrtalkf "-%s-",   "hello" }
+    gen_test('nrtalkf_content', 0, 0, 1, "-hello-")         { nrtalkf("-%s-") { "hello" } }
+    gen_test('nrtalkf_default_content', 0, 0, 1, "-hello-") { nrtalkf           "hello" }
+    gen_test('nrtalkf_default_content', 0, 0, 1, "-hello-") { nrtalkf         { "hello" } }
+  end
+
+end

data/tests/test-lookup.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# test-cmd-utils.rb -- simple tester for cmd-utils
+#
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
+require 'lookup'
+
+class NilClass ; def to_s ; '' ; end ; end
+
+class TestLookup < MiniTest::Test
+
+  # do_lookup input-text, output-text, true-if-notfound, true-if-ambiguous
+
+  def do_lookup input, output, notfound=nil, ambig=nil
+    found = nil
+    if notfound
+      assert_raises(LookupNotFoundError) { 
+        found = lookup(@keywords, input)
+      }
+    elsif ambig
+      assert_raises(LookupAmbigError)    { 
+        found = lookup(@keywords, input)
+      }
+    else
+      found = lookup(@keywords, input)
+      #found = found.first if found && found.size == 1
+      assert_equal found, output, "Input = #{input}\nOutput = #{output}\n"
+    end
+  end
+
+  def test_lookup_many
+    @keywords = %w( set get show edit reset delete count )
+    do_lookup 'se',   'set'
+    do_lookup 'set',  'set'
+    do_lookup 'SET',  'set'
+    do_lookup 'show', 'show'
+    do_lookup 'showme', nil, true
+    do_lookup 'sh',   'show'
+    do_lookup 'e',    'edit'
+    do_lookup 'ed',   'edit'
+    do_lookup 's',    [%w( set show )], nil, true
+  end
+
+  def test_lookup_exact
+    @keywords = %w( email emails reason reasons )
+    do_lookup 'email',  'email'
+    do_lookup 'emails', 'emails'
+    do_lookup 'emai',   'email',  nil, true
+    do_lookup 'rea',    'reason', nil, true
+    do_lookup 'reason', 'reason'
+    do_lookup 'reasons', 'reasons'
+  end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: cmd-utils
+version: !ruby/object:Gem::Version
+  version: 1.0.6
+  prerelease: 
+platform: ruby
+authors:
+- Alan K. Stebbens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-19 00:00:00.000000000 Z
+dependencies: []
+description: Some handy utilities for writing command line scripts in ruby.
+email: aks@stebbens.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cmd-utils.rb
+- lib/lookup.rb
+- tests/test-cmd-utils.rb
+- tests/test-lookup.rb
+homepage: http://github.com/aks/cmd-utils
+licenses:
+- GPL-2
+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: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Utilities for ruby command line scripts
+test_files:
+- tests/test-cmd-utils.rb
+- tests/test-lookup.rb