lenc 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9ce6a4fc8b6c84fa002e82abda1e1f736c9e893
-  data.tar.gz: b7a33e7faac481c0aa8525970c4fce8e3d8bc88e
+  metadata.gz: b4b56f1960462bf9fd9382ff2059182a881e51dd
+  data.tar.gz: 0cb704fcc7bda5e7a326202be609027d1cb7edfa
 SHA512:
-  metadata.gz: 2110c704af356d26953cd3fdf7adb7c15bf045464e66d195724e3c45359eba9aa77f117e8ebbed9a9edd06658ec50a578187aca2c740715c1ecb68554729f62a
-  data.tar.gz: ae79cf0f60550963f8eab2eb1db540682230ecebef1e3466441d3f60ee420788c4e6b4bbf05ba94511a35ee13f43438719dd2bef08bf9a21aacd16af05748094
+  metadata.gz: 41948757b4d963f3b7cc23f6c8292e8ce51b918b2f1860087cb34c3d95765f6b82900fee46c47adb399b01cb6050a09761c6d56caf3c921badbb542263f45a1a
+  data.tar.gz: da5a5af9488d3901d29b71c29556df4c343f0dfa82c882556dad404ef24148e593e046d022604abef1cb2b4859c832fa49b41695d1d20fbb4e49bcf7fb3ad038

data/CHANGELOG.txt

@@ -18,4 +18,6 @@
   * 1.1.2  released
   * Now hosting on GitHub
   * Updated README file
-  
+
+2013-04-15
+  * No longer updating CHANGELOG; see git commit comments instead.  

data/lib/lenc/_OLD_tools.rb

@@ -0,0 +1,628 @@
+require 'set'
+require 'fileutils'
+
+# Various utility and debug convenience functions.
+#
+
+# Convenience method to perform 'require_relative' on a set of files
+#
+# @param fileListStr  space-delimited file/path items, without .rb extensions
+# @param subdir  optional path to files relative to this file
+#
+def req(fileListStr,subdir = nil)
+  fileListStr.split(' ').each do |x|
+    if subdir
+      x = File.join(subdir,x)
+    end
+    x += '.rb'
+    require_relative(x)
+  end
+end
+
+# Shorthand for printf(...)
+# @param args passed to printf
+def pr(*args)
+  printf(*args)
+end
+
+# Convert an object to a human-readable string,
+# or <nil>; should be considered a debug-only feature
+# 
+def d(arg)
+  arg.nil? ? "<nil>" : arg.inspect
+end
+
+# Convert an object to a human-readable string,
+# by calling a type-appropriate function: da, dh, or just d.
+# @param arg object
+# @param indent optional indentation for pretty printing; if result
+#          spans multiple lines, each line should be indented by this amount
+#
+def d2(arg, indent = 0)
+  return da(arg, indent) if arg.is_a? Array
+  return dh(arg, indent) if arg.is_a? Hash
+  return df(arg) if arg.class == FalseClass || arg.class == TrueClass
+  return d(arg)  
+end
+
+# Convert an object to a human-readable string, prefixed with its type
+#
+def dt(arg)
+  if arg.nil?
+    return "<nil>"
+  end
+  s = arg.class.to_s
+  s << ':'
+  s << arg.inspect
+  s
+end
+
+# Append a particular number of spaces to a string
+def add_sp(s, indent = 0)
+  s << ' ' * indent
+end
+
+# Pretty-print an array,
+# one element to a line
+# @param indent indentation of each line, in spaces
+def da(array, indent = 0)
+  return d(array) if !array
+  s = 'Array ['
+  indent += 2
+  array.each do |x| 
+    s << "\n"
+    add_sp(s,indent)
+    s2 = d2(x, indent + 2)
+    s << s2
+  end
+  s << " ]"
+  s
+end
+
+# Pretty-print a hash,
+# one element to a line
+# @param indent indentation of each line, in spaces
+def dh(hash, indent = 0)
+  return d(hash) if !hash
+  s = 'Hash {'
+  indent += 2
+  hash.each_pair do |key,val| 
+    s2 = d(key)
+    s3 = d2(val, indent + 4)
+    s << "\n " 
+    add_sp(s,indent)
+    s << s2.chomp << " => " << s3.chomp
+  end
+  s << " }"
+  s
+end
+
+# Generate debug description of a boolean value
+# @param flag value to interpret as a boolean; prints 'T' iff not nil
+# @param label optional label 
+def df(flag, label=nil)
+  s = ''
+  if label
+    s << label << ':'
+  end
+  s << (flag ? "T" : "F")
+  s << ' '
+  s
+end
+
+# Assert that a value is true.  Should be considered a 
+# very temporary, debug-only option; it is slow and
+# generates a warning that it is being called.
+# @param cond condition
+# @param msg generates additional message using printf(), if these arguments exist
+def assert!(cond, *msg)
+  one_time_alert("warning",0,"Checking assertion")
+  if not cond
+    str = (msg.size == 0) ? "assertion error" : sprintf(*msg)
+    raise Exception, str
+  end
+end
+
+# Extensions to the Enumerable module
+#
+module Enumerable
+  # Calculate a value for each item, and return the item with the
+  # highest value, its index, and the value.
+  # @yieldparam function to calculate value of an object, given that object as a parameter
+  # @return the triple [object, index, value] reflecting the maximum value, or
+  #   nil if there were no items
+  def max_with_index 
+    
+    best = nil
+    
+    each_with_index do |obj,ind|
+      sc = yield(obj)
+      if !best || best[2] < sc
+        best = [obj,ind,sc]
+      end
+    end
+    best
+  end
+end
+
+# Get a nice, concise description of the file and line
+# of some caller within the stack.
+# 
+# @param nSkip the number of items deep in the call stack to look
+#
+def get_caller_location(nSkip = 2) 
+  
+  filename = nil
+  linenumber = nil
+  
+  if nSkip >= 0 && nSkip < caller.size
+    fi = caller[nSkip]   
+    
+    i = fi.index(':')
+    j = nil
+    if i
+      j = fi.index(':',i+1)
+    end
+    if j
+      pth = fi[0,i].split('/')
+      if pth.size
+        filename = pth[-1]
+      end
+      linenumber = fi[i+1,j-i-1]  
+    end
+  end
+  if filename && linenumber
+    loc = filename + " ("+linenumber+")"
+  else 
+    loc = "(UNKNOWN LOCATION)"
+  end
+  loc
+end
+
+# Set of alert strings that have already been reported
+# (to avoid printing anything on subsequent invocations)
+#
+$AlertStrings = Set.new
+
+# Print a message if it hasn't yet been printed,
+# which includes the caller's location
+#
+# @param typeString  e.g., "warning", "unimplemented"
+# @param nSkip    the number of levels deep that the caller is in the stack
+# @param args    if present, calls sprintf(...) with these to append to the message
+#
+def one_time_alert(typeString, nSkip, *args) 
+  loc = get_caller_location(nSkip + 2)
+  s = "*** "+typeString+" " + loc
+  if args && args.size
+    s2 = sprintf(args[0], *args[1..-1])
+    msg = s + ": " + s2
+  else 
+    msg = s
+  end
+
+  if $AlertStrings.add?(msg)
+    puts msg
+  end
+end
+     
+# Print a 'warning' alert, one time only 
+# @param args if present, calls printf() with these
+def warn(*args) 
+  one_time_alert("warning",0, *args)
+end
+
+# Convenience method for setting 'db' true within methods,
+# and to print a one-time warning if so.
+# @param val value to set db to; it is convenient to disable
+#    debug printing quickly by adding a zero, e.g., 'warndb 0'
+#
+def warndb(val = true)
+  if !val || val == 0
+    return false
+  end
+  one_time_alert("warning",1, "Debug printing enabled")
+  true
+end
+
+# Print an 'unimplemented' alert, one time only 
+# @param args if present, calls printf() with these
+def unimp(*args)
+  one_time_alert("unimplemented", 0, *args)
+end
+
+# Write a string to a text file
+#
+def write_text_file(path, contents)
+    File.open(path, "wb") {|f| f.write(contents) }
+end
+
+# Read a file's contents, return as a string
+#
+def read_text_file(path)
+  contents = nil
+  File.open(path,"rb") {|f| contents = f.read }
+  contents
+end
+
+# Method that takes a code block as an argument to 
+# achieve the same functionality as Java/C++'s
+#  do {
+#    ...
+#    ...  possibly with 'break' to jump to the end ...
+#  } while (false);
+#
+def block
+  yield
+end
+
+# Exception class for objects in illegal states
+#
+class IllegalStateException < Exception
+end
+
+def to_hex(value, num_digits=4) 
+  s = sprintf("%x", value)
+  s.rjust(num_digits,'0')
+end
+
+def hex_dump(byte_array_or_string, title=nil, offset=0, length= -1, bytes_per_row=16, with_text=true) 
+  ss = hex_dump_to_string(byte_array_or_string, title, offset, length, bytes_per_row, with_text)
+  puts ss
+end
+
+def hex_dump_to_string(byte_array_or_string, title=nil, offset=0, length= -1, bytes_per_row=16, with_text=true)
+  
+  byte_array = byte_array_or_string
+  if byte_array.is_a? String
+    byte_array = byte_array.bytes.to_a
+  end
+  
+  ss = ''
+  
+  if title 
+    ss << title << ":\n"
+  end
+  
+  if length < 0 
+    length = byte_array.size - offset
+  end
+    
+  length = [length, byte_array.size - offset].min
+  
+  max_addr = offset + length - 1
+  num_digits = 4
+  while (1 << (4 * num_digits)) <= max_addr
+    num_digits += 1
+  end
+  
+  while true
+    ss << to_hex(offset, num_digits)
+    ss << ': '
+    
+    chunk = [length, bytes_per_row].min
+    bytes_per_row.times do |i|
+      if i % 4 == 0 
+        ss << '  '
+      end
+      
+      if i < chunk 
+        v = byte_array[offset + i]
+        ss << ((v != 0) ? to_hex(v,2) : '..')
+        ss << ' '
+      else
+        ss << '   '
+      end
+  
+    end
+        
+        
+    if with_text 
+      ss << '  |'
+      bytes_per_row.times do |i|
+        if i < chunk 
+          v = byte_array[offset + i]
+          ss << ((v >= 32 && v < 127) ? v : '_')
+        end
+      end
+      ss << '|'
+    end
+    ss << "\n"
+    
+    length -= chunk
+    offset += chunk
+    break if length <= 0
+  end
+    
+  ss << "\n"
+  ss
+end
+
+$prevTime = nil
+
+# Calculate time elapsed, in seconds, from last call to this function;
+# if it's never been called, returns zero
+def elapsed 
+  curr = Time.now.to_f
+  elap = 0
+  if $prevTime
+    elap = curr - $prevTime
+  end
+  $prevTime = curr
+  elap
+end
+
+# Delete a file or directory, if it exists.
+# Caution!  If directory, deletes all files and subdirectories.
+def remove_file_or_dir(pth)
+  if File.directory?(pth)
+    FileUtils.remove_dir(pth)
+  elsif File.file?(pth)
+    FileUtils.remove_file(pth)
+  end
+end  
+
+require 'stringio'
+
+$IODest = nil
+$OldStdOut = nil
+
+def capture_begin
+    raise IllegalStateException if $IODest
+    $IODest = StringIO.new
+    $OldStdOut, $stdout = $stdout, $IODest
+end
+
+def capture_end
+  raise IllegalStateException if !$IODest
+  $stdout = $OldStdOut  
+  ret = $IODest.string
+  $IODest = nil
+  ret
+end
+
+def match_expected_output(str = nil)
+  
+  if !str
+    str = capture_end
+  end
+  
+  cl_method = caller[0][/`.*'/][1..-2]
+  if (cl_method.start_with?("test_"))
+    cl_method = cl_method[5..-1]
+  end
+  path = "_output_" + cl_method + ".txt"
+#  path = File.absolute_path(path)
+  
+  if !File.file?(path)
+    printf("no such file #{path} exists, writing it...\n")
+    writeTextFile(path,str)
+  else
+    exp_cont = read_text_file(path)  
+    if str != exp_cont
+      d1 = str
+      d2 = exp_cont
+#      d1 = hex_dump_to_string(str,"Output")
+#      d2 = hex_dump_to_string(exp_cont,"Expected")
+            
+      raise IllegalStateException,"output did not match expected:\n#{d1}#{d2}"
+    end
+  end
+end
+
+# Convenience method to detect if a script is being run
+# e.g. as a 'main' method (for debug purposes only).
+# If so, it changes the current directory to the 
+# directory containing the script (if such a directory exists).
+#
+# @param file pass __FILE__ in here
+# @return true if so
+# 
+def main?(file)
+  
+  scr = $0
+
+  # The test/unit framework seems to be adding a suffix ": xxx#xxx.."
+  # to the .rb filename, so adjust in this case
+  i = scr.index(".rb: ")
+  if i
+    scr = scr[0...i+3]
+  end
+
+  if (ret = (file == scr))
+    dr = File.dirname(file)
+    if File.directory?(dr)
+      Dir.chdir(dr)
+    end
+  end
+  ret
+end
+
+if defined? Test::Unit
+  
+  # A simple extension to Ruby's Test::Unit class that provides
+  # suite-level setup/teardown methods.
+  # 
+  # If test suite functionality is desired within a script,
+  # then require 'test/unit' before requiring 'tools.rb'.
+  # This will cause the following class, MyTestSuite, to be defined.
+  #
+  # The user's test script can define subclasses of this,
+  # and declare test methods with the name 'test_xxxx', where
+  # xxxx is lexicographically between 01 and zz.
+  #
+  # There are two levels of setup/teardown called : suite level, and
+  # method level.  For example, if the user's test class performs two tests:
+  #
+  #  def test_b   ... end
+  #  def test_c   ... end
+  #
+  # Then the test framework will make these calls:
+  #
+  #     suite_setup
+  #   
+  #     method_setup
+  #     test_b
+  #     method_teardown
+  #   
+  #     method_setup
+  #     test_c
+  #     method_teardown
+  #   
+  #     suite_teardown
+  #
+  # Notes
+  # -----
+  # 1) The usual setup / teardown methods should NOT be overridden; instead,
+  # use the method_xxx alternatives.
+  #
+  # 2) The base class implementations of method_/suite_xxx do nothing.
+  # 
+  # 3) The number of test cases reported may be higher than you expect, since
+  # there are additional test methods defined by the TestSuite class to
+  # implement the suite setup / teardown functionality.
+  #
+  # 4) Avoid naming test methods that fall outside of test_01 ... test_zz.
+  #
+  class MyTestSuite < Test::Unit::TestCase
+    
+    # This is named to be the FIRST test called.  It
+    # will do suite-level setup, and nothing else.
+    def test_00_setup
+      @@suiteSetup = true
+      suite_setup()
+    end
+    
+    # This is named to be the LAST test called.  It
+    # will do suite-level teardown, and nothing else.
+    def test_zzzzzz_teardown
+      suite_teardown()
+      @@suiteSetup = false
+    end
+    
+    # True if called within suite-level setup/teardown window
+    def _suite_active?
+      !(@__name__ == "test_00_setup" || @__name__ == "test_zzzzzz_teardown")
+    end
+    
+    def setup
+      if _suite_active?
+        # If only a specific test was requested, the
+        # suite setup may not have run... if not, do it now.
+        if !defined? @@suiteSetup
+          suite_setup
+        end
+        return 
+      end
+      method_setup
+    end
+    
+    def teardown
+      if _suite_active?
+        if !defined? @@suiteSetup
+          suite_teardown
+        end
+        return 
+      end
+      method_teardown
+    end
+  
+    def suite_setup
+    end
+    
+    def suite_teardown
+    end
+    
+    def method_setup
+    end
+    
+    def method_teardown
+    end
+  end
+end
+
+# Construct a string from an array of bytes 
+# @param byte_array array of bytes, or string (in which case it
+#   returns it unchanged)
+#
+def bytes_to_str(byte_array)
+  return byte_array if byte_array.is_a? String
+  
+  byte_array.pack('C*')
+end
+
+# Construct an array of bytes from a string  
+# @param str string, or array of bytes (in which case it
+#   returns it unchanged)
+#
+def str_to_bytes(str)
+  return str if str.is_a? Array
+  str.bytes
+end
+
+# Get directory entries, excluding '.' and '..'
+#
+def dir_entries(path)
+  ents = Dir.entries(path)
+  ents.reject!{|entry| entry == '.' || entry == '..'}
+end
+
+def int_to_bytes(x)
+  [(x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff]
+end
+  
+def short_to_bytes(x) 
+  [(x >> 8) & 0xff, x & 0xff]
+end
+ 
+# Decode a short from an array of bytes (big-endian).
+# @param ba array of bytes
+# @param offset offset of first (most significant) byte
+#
+def short_from_bytes(ba, offset=0) 
+  (ba[offset] << 8) | ba[offset + 1] 
+end
+    
+# Decode an int from an array of bytes (big-endian).
+# @param ba array of bytes
+# @param offset offset of first (most significant) byte
+#
+def int_from_bytes(ba, offset=0) 
+  (((((ba[offset] << 8) | ba[offset + 1]) << 8) | \
+      ba[offset + 2]) << 8) | ba[offset + 3]
+end
+
+# Transform string to 8-bit ASCII (i.e., just treat each byte as-is)
+#
+def to_ascii8(str)
+  str.force_encoding("ASCII-8BIT")
+end
+
+# Verify that a string is encoded as ASCII-8BIT
+def simple_str(s)
+  if s.encoding.name != 'ASCII-8BIT' && s.encoding.name != 'UTF-8'
+    pr("string [%s]\n encoding is %s,\n expected ASCII-8BIT\n",s,s.encoding.name)
+    assert!(false)
+  end
+end
+
+# Truncate or pad string so it has a particular size
+#
+# @param s input string
+# @param size 
+# @param pad padding character to use if string needs to grow
+# @return modified string
+#
+def str_sized(s, size, pad="\0")
+  s[0...size].ljust(size,pad)
+end
+
+# Determine if running on the Windows operating system.
+# Note: there is some debate about the best way to do this.
+#
+def windows?
+  if !defined? $__windows__
+    $__windows__ = (RUBY_PLATFORM =~ /mswin/)
+  end
+  $__windows__
+end

data/lib/lenc/tools.rb

@@ -1,8 +1,26 @@
 require 'set'
 require 'fileutils'
 
+###############################################################
+#
 # Various utility and debug convenience functions.
 #
+###############################################################
+
+# Exception class for objects in illegal states
+#
+class IllegalStateException < Exception
+end
+
+# A string containing a single zero, with ASCII 8-bit encoding (i.e., plain old bytes)
+ZERO_CHAR = "\0".force_encoding("ASCII-8BIT")
+
+# Construct a string of zeros
+# @param count number of zeros
+#
+def zero_bytes(count)
+  ZERO_CHAR * count
+end
 
 # Convenience method to perform 'require_relative' on a set of files
 #
@@ -20,20 +38,16 @@ def req(fileListStr,subdir = nil)
 end
 
 # Shorthand for printf(...)
-# @param args passed to printf
-def pr(*args)
-  printf(*args)
-end
-
+#
+alias :pr :printf
 
 # Convert an object to a human-readable string,
-# or <nil>
+# or <nil>; should be considered a debug-only feature
 # 
 def d(arg)
   arg.nil? ? "<nil>" : arg.inspect
 end
 
-
 # Convert an object to a human-readable string,
 # by calling a type-appropriate function: da, dh, or just d.
 # @param arg object
@@ -112,8 +126,6 @@ def df(flag, label=nil)
   s
 end
 
-
-
 # Assert that a value is true.  Should be considered a 
 # very temporary, debug-only option; it is slow and
 # generates a warning that it is being called.
@@ -127,63 +139,37 @@ def assert!(cond, *msg)
   end
 end
 
+# Abort with message about unimplemented code
+#
+def unimp!(msg = nil)
+  msg2 = "Unimplemented code"
+  if msg
+    msg2 << ": " << msg
+  end
+  raise Exception, msg2
+end
 
-## Set test directory.  If nil, sets to home directory + "__test__"
-#def setTestDir(d = nil)
-#  $testDir = d || File.join(Dir.home,"__test__")
-#end
- 
-## Get a path within the test directory;
-## create test directory if it doesn't exist.
-##
-## relPath : if nil, returns the test directory; else 
-##   returns the test directory joined to this one
-##
-#def withinTestDir(relPath = nil)
-#  if !$testDir
-#    raise IllegalStateException, "No test directory has been defined"
-#  end
-#  if !File.directory?($testDir)  
-#    Dir::mkdir($testDir)
-#  end
-#  relPath ? File.join($testDir,relPath) : $testDir
-#end
-
-## Convert a .dot file (string) to a PDF file "__mygraph__nnn.pdf" 
-## in the test directory.
-## 
-## It does this by making a system call to the 'dot' utility.
-##
-#def dotToPDF(dotFile, name = "")
-#  gr = dotFile
-#  dotPath = withinTestDir(".__mygraph__.dot")
-#  write_text_file(dotPath,gr)
-#  destName = withinTestDir( "__mygraph__"+name+".pdf")
-#  system("dot -Tpdf "+dotPath+" -o "+destName)
-#end
-
-## Extensions to the Enumerable module
-##
-#module Enumerable
-#  # Calculate a value for each item, and return the item with the
-#  # highest value, its index, and the value.
-#  # @yieldparam function to calculate value of an object, given that object as a parameter
-#  # @return the triple [object, index, value] reflecting the maximum value, or
-#  #   nil if there were no items
-#  def max_with_index 
-#    
-#    best = nil
-#    
-#    each_with_index do |obj,ind|
-#      sc = yield(obj)
-#      if !best || best[2] < sc
-#        best = [obj,ind,sc]
-#      end
-#    end
-#    best
-#  end
-#end
-
+# Extensions to the Enumerable module
+#
+module Enumerable
+  # Calculate a value for each item, and return the item with the
+  # highest value, its index, and the value.
+  # @yieldparam function to calculate value of an object, given that object as a parameter
+  # @return the triple [object, index, value] reflecting the maximum value, or
+  #   nil if there were no items
+  def max_with_index 
+    
+    best = nil
+    
+    each_with_index do |obj,ind|
+      sc = yield(obj)
+      if !best || best[2] < sc
+        best = [obj,ind,sc]
+      end
+    end
+    best
+  end
+end
 
 # Get a nice, concise description of the file and line
 # of some caller within the stack.
@@ -252,6 +238,19 @@ def warn(*args)
   one_time_alert("warning",0, *args)
 end
 
+# Convenience method for setting 'db' true within methods,
+# and to print a one-time warning if so.
+# @param val value to set db to; it is convenient to disable
+#    debug printing quickly by adding a zero, e.g., 'warndb 0'
+#
+def warndb(val = true)
+  if !val || val == 0
+    return false
+  end
+  one_time_alert("warning",1,"Debug printing enabled")
+  true
+end
+
 # Print an 'unimplemented' alert, one time only 
 # @param args if present, calls printf() with these
 def unimp(*args)
@@ -283,22 +282,30 @@ def block
   yield
 end
 
-# Exception class for objects in illegal states
+# Construct hex representation of value
+# @param value integer value
+# @param num_digits number of hex digits
 #
-class IllegalStateException < Exception
-end
-
-
 def to_hex(value, num_digits=4) 
   s = sprintf("%x", value)
   s.rjust(num_digits,'0')
 end
 
+# Hex dump a string or byte array
+# @param byte_array_or_string
+# @param title
+# @param offset offset to first value within array
+# @param length number of values to dump
+# @param bytes_per_row 
+# @param with_text if true, displays ASCII values to right of hex dump
+#
 def hex_dump(byte_array_or_string, title=nil, offset=0, length= -1, bytes_per_row=16, with_text=true) 
   ss = hex_dump_to_string(byte_array_or_string, title, offset, length, bytes_per_row, with_text)
   puts ss
 end
 
+# Hex dump a string or byte array to a string; see hex_dump for parameter descriptions
+#
 def hex_dump_to_string(byte_array_or_string, title=nil, offset=0, length= -1, bytes_per_row=16, with_text=true)
   
   byte_array = byte_array_or_string
@@ -341,10 +348,8 @@ def hex_dump_to_string(byte_array_or_string, title=nil, offset=0, length= -1, by
       else
         ss << '   '
       end
-  
     end
         
-        
     if with_text 
       ss << '  |'
       bytes_per_row.times do |i|
@@ -361,8 +366,6 @@ def hex_dump_to_string(byte_array_or_string, title=nil, offset=0, length= -1, by
     offset += chunk
     break if length <= 0
   end
-    
-  ss << "\n"
   ss
 end
 
@@ -370,6 +373,7 @@ $prevTime = nil
 
 # Calculate time elapsed, in seconds, from last call to this function;
 # if it's never been called, returns zero
+#
 def elapsed 
   curr = Time.now.to_f
   elap = 0
@@ -380,74 +384,9 @@ def elapsed
   elap
 end
 
-# Construct a string from an array of bytes 
-# @param byte_array array of bytes, or string (in which case it
-#   returns it unchanged)
-#
-def bytes_to_str(byte_array)
-  return byte_array if byte_array.is_a? String
-  
-  byte_array.pack('C*')
-end
-
-# Construct an array of bytes from a string  
-# @param str string, or array of bytes (in which case it
-#   returns it unchanged)
-#
-def str_to_bytes(str)
-  return str if str.is_a? Array
-  str.bytes
-end
-
-# Get directory entries, excluding '.' and '..'
-#
-def dir_entries(path)
-  ents = Dir.entries(path)
-  ents.reject!{|entry| entry == '.' || entry == '..'}
-end
-
-# Convenience method for setting 'db' true within methods,
-# and to print a one-time warning if so.
-# @param val value to set db to; it is convenient to disable
-#    debug printing quickly by adding a zero, e.g., 'warndb 0'
-#
-def warndb(val = true)
-  if !val || val == 0
-    return false
-  end
-  one_time_alert("warning",1, "Debug printing enabled")
-  true
-end
-
-
-def int_to_bytes(x)
-  [(x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff]
-end
-  
-def short_to_bytes(x) 
-  [(x >> 8) & 0xff, x & 0xff]
-end
- 
-# Decode a short from an array of bytes (big-endian).
-# @param ba array of bytes
-# @param offset offset of first (most significant) byte
-#
-def short_from_bytes(ba, offset=0) 
-  (ba[offset] << 8) | ba[offset + 1] 
-end
-    
-# Decode an int from an array of bytes (big-endian).
-# @param ba array of bytes
-# @param offset offset of first (most significant) byte
-#
-def int_from_bytes(ba, offset=0) 
-  (((((ba[offset] << 8) | ba[offset + 1]) << 8) | \
-      ba[offset + 2]) << 8) | ba[offset + 3]
-end
-
-
 # Delete a file or directory, if it exists.
 # Caution!  If directory, deletes all files and subdirectories.
+#
 def remove_file_or_dir(pth)
   if File.directory?(pth)
     FileUtils.remove_dir(pth)
@@ -456,52 +395,96 @@ def remove_file_or_dir(pth)
   end
 end  
 
-# Transform string to 8-bit ASCII (i.e., just treat each byte as-is)
+require 'stringio'
+
+$IODest = nil
+$OldStdOut = nil
+
+# Redirect standard output to an internal string
 #
-def to_ascii8(str)
-  str.force_encoding("ASCII-8BIT")
+def capture_begin
+    raise IllegalStateException if $IODest
+    $IODest = StringIO.new
+    $OldStdOut, $stdout = $stdout, $IODest
 end
 
-# Verify that a string is encoded as ASCII-8BIT
-def simple_str(s)
-  if s.encoding.name != 'ASCII-8BIT' && s.encoding.name != 'UTF-8'
-    pr("string [%s]\n encoding is %s,\n expected ASCII-8BIT\n",s,s.encoding.name)
-    assert!(false)
-  end
+# Restore standard output; return captured text
+# @return text that was redirected
+#
+def capture_end
+  raise IllegalStateException if !$IODest
+  $stdout = $OldStdOut  
+  ret = $IODest.string
+  $IODest = nil
+  ret
 end
 
-# Truncate or pad string so it has a particular size
+# Compare a string with disk file; abort if different.  Disk filename is derived
+# from caller function name; e.g., test_xxx produces filename _output_xxx
 #
-# @param s input string
-# @param size 
-# @param pad padding character to use if string needs to grow
-# @return modified string
+# @param str if not nil, string to compare; if nil, calls capture_end to get string
 #
-def str_sized(s, size, pad="\0")
-  s[0...size].ljust(size,pad)
-end
+def match_expected_output(str = nil)
 
-# Determine if running on the Windows operating system.
-# Note: there is some debate about the best way to do this.
-#
-def windows?
-  if !defined? $__windows__
-    $__windows__ = (RUBY_PLATFORM =~ /mswin/)
+  if !str
+    str = capture_end
   end
-  $__windows__
-end
 
-# I didn't end up needing this:
-#
-#module Kernel
-#  def suppress_warnings
-#    original_verbosity = $VERBOSE
-#    $VERBOSE = nil
-#    result = yield
-#    $VERBOSE = original_verbosity
-#    return result
-#  end
-#end
+  cl_method = caller[0][/`.*'/][1..-2]
+  if (cl_method.start_with?("test_"))
+    cl_method = cl_method[5..-1]
+  end
+  path = "_output_" + cl_method + ".txt"
+
+  if !File.file?(path)
+    printf("no such file #{path} exists, writing it...\n")
+    write_text_file(path,str)
+  else
+    exp_cont = read_text_file(path)
+    if str != exp_cont
+      d1 = str
+      d2 = exp_cont
+
+      # Find location where they differ
+      lines1 = d1.split("\n")
+      lines2 = d2.split("\n")
+      j = [lines1.size, lines2.size].max
+
+      s = "???"
+      found_diff = false
+      hist = []
+
+      found_count = 0
+      j.times do |i|
+        found_diff ||= (i >= lines1.size || i >= lines2.size || lines1[i] != lines2[i])
+        s = sprintf("%3d:",i)
+        if !found_diff
+          hist << "#{s}  #{lines1[i]}\n      #{lines2[i]}\n"
+        else
+          if found_count < 3
+            if i < lines1.size
+              s << "  #{lines1[i]}\n"
+            else
+              s << "  ---END---\n"
+            end
+            if i < lines2.size
+              s << "      #{lines2[i]}\n"
+            else
+              s << "      ---END---\n"
+            end
+            hist << s
+          end
+          found_count += 1
+        end
+        while hist.size > 6
+          hist.shift
+        end
+      end
+      dash = "-" * 95 + "\n"
+      raise IllegalStateException,"output did not match expected:\n#{dash}#{hist.join('')}#{dash}"
+    end
+  end
+end
 
 # Convenience method to detect if a script is being run
 # e.g. as a 'main' method (for debug purposes only).
@@ -634,3 +617,136 @@ if defined? Test::Unit
   end
 end
 
+# Construct a string from an array of bytes 
+# @param byte_array array of bytes, or string (in which case it
+#   returns it unchanged)
+#
+def bytes_to_str(byte_array)
+  return byte_array if byte_array.is_a? String
+  
+  byte_array.pack('C*')
+end
+
+# Construct an array of bytes from a string  
+# @param str string, or array of bytes (in which case it
+#   returns it unchanged)
+#
+def str_to_bytes(str)
+  return str if str.is_a? Array
+  str.bytes
+end
+
+# Get directory entries, excluding '.' and '..'
+#
+def dir_entries(path)
+  ents = Dir.entries(path)
+  ents.reject!{|entry| entry == '.' || entry == '..'}
+end
+
+def int_to_bytes(x)
+  [(x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff]
+end
+  
+def short_to_bytes(x) 
+  [(x >> 8) & 0xff, x & 0xff]
+end
+ 
+# Decode a short from an array of bytes (big-endian).
+# @param ba array of bytes
+# @param offset offset of first (most significant) byte
+#
+def short_from_bytes(ba, offset=0) 
+  (ba[offset] << 8) | ba[offset + 1] 
+end
+    
+# Decode an int from an array of bytes (big-endian).
+# @param ba array of bytes
+# @param offset offset of first (most significant) byte
+#
+def int_from_bytes(ba, offset=0) 
+  (((((ba[offset] << 8) | ba[offset + 1]) << 8) | \
+      ba[offset + 2]) << 8) | ba[offset + 3]
+end
+
+# Transform string to 8-bit ASCII (i.e., just treat each byte as-is)
+#
+def to_ascii8(str)
+  str.force_encoding("ASCII-8BIT")
+end
+
+# Verify that a string is encoded as ASCII-8BIT
+def simple_str(s)
+  if s.encoding.name != 'ASCII-8BIT' && s.encoding.name != 'UTF-8'
+    pr("string [%s]\n encoding is %s,\n expected ASCII-8BIT\n",s,s.encoding.name)
+    assert!(false)
+  end
+end
+
+# Truncate or pad string so it has a particular size
+#
+# @param s input string
+# @param size 
+# @param pad padding character to use if string needs to grow
+# @return modified string
+#
+def str_sized(s, size, pad="\0")
+  s[0...size].ljust(size,pad)
+end
+
+# Determine if running on the Windows operating system.
+# Note: there is some debate about the best way to do this.
+#
+def windows?
+  if !defined? $__windows__
+    $__windows__ = (RUBY_PLATFORM =~ /mswin/)
+  end
+  $__windows__
+end
+
+# Mark all constants ending with '_' as private constants
+#
+# @param entity the class to examine
+# @param add_non_suffix_versions if true, for each constant ABC_ found, also
+#    defines a constant ABC with the same value that is also private
+#
+def privatize(entity, add_non_suffix_versions = false)
+  
+  db = false
+  
+  # First command defines constants ABC = n for each constant ABC_ = n;
+  # Second declares both versions to be private
+  
+  cmd1 = nil
+  cmd2 = nil
+  
+  entity.constants.each do |c|
+    nm = c.to_s
+    
+    if nm.end_with?('_')
+      nm_small = nm[0..-2]
+      
+      if !cmd2
+        if add_non_suffix_versions
+          cmd1 = ''
+        end
+        cmd2 = 'private_constant '
+      else
+        cmd2 << ','
+      end 
+      
+      
+      !cmd1 || cmd1 << entity.to_s << '::' << nm_small << '=' << entity.const_get(c).to_s << "\n"
+      !cmd1 || cmd2 << ':' << nm_small << ','
+      cmd2 << ':' << nm
+    end
+  end
+  
+  if cmd2
+     if cmd1
+       !db || pr("about to eval:\n%s\n",cmd1)
+       eval(cmd1)
+     end
+     !db || pr("about to eval:\n%s\n",cmd2)
+     eval(cmd2)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lenc
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Jeff Sember
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-09 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies: []
 description: "Encrypts a set of local files, and copies the encrypted versions to
   a repository, \nwhich may be located within a free cloud service (Dropbox, Google
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/lenc.rb
+- lib/lenc/_OLD_tools.rb
 - lib/lenc/aes.rb
 - lib/lenc/config_file.rb
 - lib/lenc/lencrypt.rb