grizzled-ruby 0.1.1 → 0.1.3

data/bin/grinc

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+#
+# See the man page or http://software.clapper.org/grizzled-ruby/grinc/
+# for documentation.
+#--
+# This software is released under a BSD license, adapted from
+# http://opensource.org/licenses/bsd-license.php
+#
+# Copyright (c) 2011, Brian M. Clapper
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+# * Neither the names "clapper.org", "Grizzled Ruby Library", nor the
+#   names of its contributors may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'optparse'
+require 'grizzled/fileutil/includer'
+
+include Grizzled::FileUtil
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+DEFAULT_MAX_NEST = 100
+PROGRAM_NAME = 'grinc'
+
+# ---------------------------------------------------------------------------
+# Classes
+# ---------------------------------------------------------------------------
+
+class Parameters
+  attr_reader :output, :max_nesting, :input_paths
+
+  def initialize(options_hash, argv)
+    @output = options_hash[:output]
+    @max_nesting = options_hash[:max_nesting] || DEFAULT_MAX_NEST
+    @input_paths = argv.length == 0 ? nil : argv
+  end
+
+  def to_s
+    inspect
+  end
+end
+
+class UsageError < StandardError; end
+
+# ---------------------------------------------------------------------------
+# Parameter parsing
+# ---------------------------------------------------------------------------
+
+def parse_params
+  options_hash = {}
+  error = nil
+  option_parser = OptionParser.new do |opts|
+    opts.program_name = PROGRAM_NAME
+    opts.banner = "Usage: #{opts.program_name} [OPTIONS] inputfile ..."
+    opts.separator ''
+    opts.separator 'OPTIONS:'
+
+    opts.on('-o FILE', 'Output file. Default: standard output.') do |f|
+      options_hash[:output] = f
+    end
+
+    opts.on('-n', '--nesting n',
+            "Max nesting. Default: #{DEFAULT_MAX_NEST}") do |n|
+      if n !~ /^[0-9]+$/
+        error = "Non-numeric parameter \"#{n}\" to -n option."
+      end
+      options_hash[:max_nesting] = n.to_i
+    end
+  end
+
+  begin
+    option_parser.parse!(ARGV)
+  rescue OptionParser::InvalidOption => ex
+    error = ex.to_s
+  end
+
+  if error
+    $stderr.puts(error) unless error.nil?
+    option_parser.display
+    raise UsageError.new
+  end
+
+  if ARGV.length == 0
+    options_hash[:input_files] = nil
+  else
+    options_hash[:input_files] = ARGV
+  end
+
+  Parameters.new(options_hash, ARGV)
+end
+
+def process_include(input_file, output_file, max_nesting = 100)
+  Includer.new(input_file, :max_nesting => max_nesting).each do |line|
+    output_file.write(line)
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Main logic
+# ---------------------------------------------------------------------------
+
+begin
+  params = parse_params
+  out = params.output.nil? ? $stderr : File.open(params.output, 'w')
+
+  if params.input_paths.nil?
+    process_include($stdin, out, params.max_nesting)
+  else
+    params.input_paths.each do |f|
+      process_include(File.open(f), out, params.max_nesting)
+    end
+  end
+
+rescue UsageError
+  exit 1
+
+rescue
+  $stderr.puts("#{PROGRAM_NAME}: #{$!}")
+  exit 1
+
+else
+  exit 0
+end
+

data/lib/grizzled/dir.rb

@@ -43,6 +43,11 @@ class Dir
   # walked top-down, not depth-first. To terminate the traversal, the block
   # should return +false+. Anything else (including +nil+) continues the
   # traversal.
+  #
+  # Parameters:
+  #
+  # dirname:: The name (path) of the directory to walk.
+  # block::   The block to invoke on each entry.
   def self.walk(dirname, &block)
     Grizzled::Directory.walk(dirname, &block)
   end
@@ -64,6 +69,11 @@ module Grizzled
     # directory is walked top-down, not depth-first. To terminate the
     # traversal, the block should return +false+. Anything else (including
     # +nil+) continues the traversal.
+    #
+    # Parameters:
+    #
+    # dirname:: The name (path) of the directory to walk.
+    # block::   The block to invoke on each entry.
     def self.walk(dirname, &block)
       if block.call(Dir.new(dirname)) != false
         Dir.entries(dirname).each do |entry|

data/lib/grizzled/fileutil.rb

@@ -88,9 +88,9 @@ module Grizzled
     #
     # Parameters:
     #
-    # [+directory+] The starting directory, which is created if it does not
-    #               exist.
-    # [+tree+]      The entry tree, as described above
+    # directory:: The starting directory, which is created if it does not
+    #             exist.
+    # tree::      The entry tree, as described above
     #
     # Returns:
     #

data/lib/grizzled/fileutil/includer.rb

@@ -123,17 +123,19 @@ module Grizzled
       #
       # Parameters:
       #
-      # [+source+]  A string, representing a file name or URL (http, https or
-      #             ftp), a +File+ object, or an object with an +each_line+
-      #             method that returns individual lines of input.
-      # [+options+] Various processing options. See below.
+      # source::  A string, representing a file name or URL (http, https or
+      #           ftp), a +File+ object, or an object with an +each_line+
+      #           method that returns individual lines of input.
+      # options:: Various processing options. See below.
       #
       # Options:
       #
-      # [+:max_nesting+]      Maximum include nesting level. Default: 100
-      # [+:include_pattern+]  String regex pattern to match include directives.
-      #                       Must have a single regex group for the file name
-      #                       or URL. Default: ^%include\s"([^"]+)"
+      # **NOTE**: Options are symbols (e.g., +:recursive+).
+      #
+      # max_nesting::      Maximum include nesting level. Default: 100
+      # include_pattern::  String regex pattern to match include directives.
+      #                    Must have a single regex group for the file name
+      #                    or URL. Default: ^%include\s"([^"]+)"
       def initialize(source, options={})
         @max_nesting = options.fetch(:max_nesting, 100)
         inc_pattern = options.fetch(:include_pattern, '^%include\s"([^"]+)"')

data/lib/grizzled/fileutil/ziputil.rb

@@ -58,10 +58,10 @@ module Grizzled
       # class mixes in methods that will allow you to zip up files. Related
       # modules and classes:
       #
-      # [Grizzled::FileUtil::Zipper]     A class that includes this module
+      # Grizzled::FileUtil::Zipper::     A class that includes this module
       #                                  and can be instantiated by itself.
-      # [Grizzled::FileUtil::UnzipMixin] A module mixin for unzipping zip files.
-      # [Grizzled::FileUtil::Unzipper]   A class that includes `UnzipMixin'
+      # Grizzled::FileUtil::UnzipMixin:: A module mixin for unzipping zip files.
+      # Grizzled::FileUtil::Unzipper::   A class that includes `UnzipMixin'
       #                                  and can be instantiated by itself.
       module ZipMixin
 
@@ -69,31 +69,33 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+zip_file+]  The zip file to open. The file is created if it doesn't
-        #               already exists.
-        # [+directory+] The directory whose contents are to be included in
-        #               the file.
-        # [+options+]   Options hash, as described below.
-        # [+&select+]   If a block (+select+) is given, then +zip+ passes each
-        #               file or directory to the block and only adds the entry
-        #               to the zip file if the block returns +true+. If no
-        #               block is given, then all files and directories are
-        #               added (subject also to the +:recursive+ option, below).
+        # zip_file::  The zip file to open. The file is created if it doesn't
+        #             already exists.
+        # directory:: The directory whose contents are to be included in
+        #             the file.
+        # options::   Options hash, as described below.
+        # select::    If a block (+select+) is given, then +zip+ passes each
+        #             file or directory to the block and only adds the entry
+        #             to the zip file if the block returns +true+. If no
+        #             block is given, then all files and directories are
+        #             added (subject also to the +:recursive+ option, below).
         #
         # Options:
         #
-        # [+:recursive+]   If +false+, only zip the files in the directory; if
-        #                  +true+ (the default), recursively zip the entire
-        #                  directory.
-        # [+:dir_at_top+]  If +false+, don't include zip the directory itself
-        #                  (i.e., the top-level files will be at the top level
-        #                  of the zip file). If +true+ (the default), the
-        #                  the directory itself (the basename) will be the
-        #                  top-level element of the zip file.
-        # [+:recreate]     If +true+, remove the zip file if it exists already,
-        #                  so it's recreated from scratch. If +false+ (the 
-        #                  default), don't recreate the zip file if it doesn't
-        #                  exist; instead, update the existing file.
+        # **NOTE**: Options are symbols (e.g., +:recursive+).
+        #
+        # recursive::   If +false+, only zip the files in the directory; if
+        #               +true+ (the default), recursively zip the entire
+        #               directory.
+        # dir_at_top::  If +false+, don't include zip the directory itself
+        #               (i.e., the top-level files will be at the top level
+        #               of the zip file). If +true+ (the default), the
+        #               the directory itself (the basename) will be the
+        #               top-level element of the zip file.
+        # recreate::    If +true+, remove the zip file if it exists already,
+        #               so it's recreated from scratch. If +false+ (the 
+        #               default), don't recreate the zip file if it doesn't
+        #               exist; instead, update the existing file.
         #
         # Returns:
         #
@@ -157,35 +159,37 @@ module Grizzled
       # class mixes in methods that will allow you to unzip zip files.
       # Related modules and classes:
       #
-      # [Grizzled::FileUtil::Zipper]    A class that includes this module
+      # Grizzled::FileUtil::Zipper::    A class that includes this module
       #                                 and can be instantiated by itself.
-      # [Grizzled::FileUtil::ZipMixin]  A module mixin for zipping zip files.
-      # [Grizzled::FileUtil::Unzipper]  A class that includes `UnzipMixin'
+      # Grizzled::FileUtil::ZipMixin::  A module mixin for zipping zip files.
+      # Grizzled::FileUtil::Unzipper::  A class that includes `UnzipMixin'
       #                                 and can be instantiated by itself.
       module UnzipMixin
         # Unzips a zip file into a directory.
         #
         # Parameters:
         #
-        # [+zip_file+]  The zip file to unzip.
-        # [+directory+] The directory into which to unzip the file. The
-        #               directory is created if it doesn't already exist.
-        # [+options+]   Options hash, as described below.
-        # [+&select+]   If a block (+select+) is given, then +unzip+ passes each
-        #               zip file entry name to the block and only unzips the
-        #               entry if the block returns +true+. If no block is
-        #               given, then everything is unzipped (subject also to
-        #               the +:recursive+ option, below).
+        # zip_file::  The zip file to unzip.
+        # directory:: The directory into which to unzip the file. The
+        #             directory is created if it doesn't already exist.
+        # options::   Options hash, as described below.
+        # select::    If a block (+select+) is given, then +unzip+ passes each
+        #             zip file entry name to the block and only unzips the
+        #             entry if the block returns +true+. If no block is
+        #             given, then everything is unzipped (subject also to
+        #              the +:recursive+ option, below).
         #
         # Options:
         #
-        # [+:recursive+]  If +false+, only extract the top-level files from
-        #                 the zip file. If +true+ (the default),
-        #                 recursively extract everything.
-        # [+:overwrite+]  If +false+ (the default), do not overwrite existing
-        #                 files in the directory. If +true+, overwrite
-        #                 any existing files in the directory with extracted
-        #                 zip files whose names match.
+        # **NOTE**: Options are symbols (e.g., +:recursive+).
+        #
+        # recursive::  If +false+, only extract the top-level files from the
+        #              zip file. If +true+ (the default), recursively
+        #              extract everything.
+        # overwrite::  If +false+ (the default), do not overwrite existing
+        #              files in the directory. If +true+, overwrite
+        #              any existing files in the directory with extracted
+        #              zip files whose names match.
         #
         # Example:
         #
@@ -198,7 +202,6 @@ module Grizzled
         #      unzip zipfile_path, d
         #      # muck with unpacked contents
         #    end
-
         def unzip(zip_file, directory, options = {}, &select)
           overwrite = options.fetch(:overwrite, false)
           recurse = options.fetch(:recursive, true)
@@ -228,10 +231,10 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+zip_file+]  The zip file to unzip.
-        # [+block+]     Block to execute on each entry. If omitted, an
-        #               Enumerator is returned. The block receives a string
-        #               representing the path of the item in the file.
+        # zip_file::  The zip file to unzip.
+        # block::     Block to execute on each entry. If omitted, an
+        #             Enumerator is returned. The block receives a string
+        #             representing the path of the item in the file.
         def zip_file_entries(zip_file, &block)
           if not block_given?
             a = []

data/lib/grizzled/forwarder.rb

@@ -70,6 +70,13 @@ module Grizzled
 
     # Forward all unimplemented method calls to +obj+, except those
     # whose symbols are listed in the +exceptions+ array.
+    #
+    # Parameters:
+    #
+    # obj::        The object to which to forward unimplemented method calls
+    # exception+:: A list of symbols for unimplemented methods that should
+    #              not be forwarded to +obj+. Note: You do _not_ have to put
+    #              methods you've implemented in here.
     def forward_to(obj, exceptions=[])
       @forward_obj = obj
 

data/lib/grizzled/stack.rb

@@ -53,8 +53,8 @@ module Grizzled
     #
     # Parameters:
     #
-    # [+pop_empty_nil+]  +true+ if popping an empty stack should just return
-    #                    +nil+, +false+ if it should thrown an exception.
+    # pop_empty_nil::  +true+ if popping an empty stack should just return
+    #                  +nil+, +false+ if it should thrown an exception.
     def initialize(pop_empty_nil=true)
       @the_stack = []
       @pop_empty_nil = pop_empty_nil
@@ -93,6 +93,10 @@ module Grizzled
     #
     #     stack = Stack.new
     #     [1, 2, 3].each {|i| stack.push i}
+    #
+    # Parameters:
+    #
+    # element:: The object to push onto the stack.
     def push(element)
       if element.class == Array
         element.each {|e| @the_stack.push e}

data/lib/grizzled/string/template.rb

@@ -81,14 +81,14 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+resolver+] A hash-like object that can take a variable name (via
+        # +resolver+:: A hash-like object that can take a variable name (via
         #              the +[]+ function) and resolve its value, returning
         #              the value (which is converted to string) or +nil+.
-        # [+options+]  hash of options. See below.
+        # +options+::  hash of options. See below.
         #
         # Options:
         #
-        # [+:safe+]    +true+ for a safe template that substitutes a blank
+        # +:safe+::    +true+ for a safe template that substitutes a blank
         #              string for a non-existent variable, instead of
         #              throwing an exception. Defaults to +true+.
         def initialize(resolver, options={})
@@ -108,7 +108,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string in which to replace variable references
+        # +s+:: the string in which to replace variable references
         #
         # Returns the substituted result.
         def substitute(s)
@@ -135,7 +135,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string
+        # +s+:: the string
         #
         # Returns a +Variable+ object, or +nil+.
         def find_variable_ref(s)
@@ -147,8 +147,8 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+name+]    Variable name
-        # [+default+] Default value, or +nil+
+        # +name+::    Variable name
+        # +default+:: Default value, or +nil+
         def get_variable(name, default)
           
           def handle_no_value(default, name)
@@ -193,17 +193,17 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+resolver+] A hash-like object that can take a variable name (via
+        # +resolver+:: A hash-like object that can take a variable name (via
         #              the +[]+ function) and resolve its value, returning
         #              the value (which is converted to string) or +nil+.
-        # [+options+]  hash of options. See below.
+        # +options+::  hash of options. See below.
         #
         # Options:
         #
-        # [+:safe+]         +true+ for a safe template that substitutes a blank
+        # +:safe+::         +true+ for a safe template that substitutes a blank
         #                   string for a non-existent variable, instead of
         #                   throwing an exception. Defaults to +true+.
-        # [+:var_pattern+]  Regular expression pattern (as a string, not a
+        # +:var_pattern+::  Regular expression pattern (as a string, not a
         #                   Regexp object) to match a variable name. Defaults
         #                   to "[A-Za-z0-9_]+"
         def initialize(resolver, options={})
@@ -225,7 +225,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string in which to replace variable references
+        # +s+:: the string in which to replace variable references
         #
         # Returns the substituted result.
         def substitute(s)
@@ -269,7 +269,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string
+        # +s+:: the string
         #
         # Returns a +Variable+ object, or +nil+.
         def find_variable_ref(s)
@@ -319,17 +319,17 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+resolver+] A hash-like object that can take a variable name (via
+        # +resolver+:: A hash-like object that can take a variable name (via
         #              the +[]+ function) and resolve its value, returning
         #              the value (which is converted to string) or +nil+.
-        # [+options+]  hash of options. See below.
+        # +options+::  hash of options. See below.
         #
         # Options:
         #
-        # [+:safe+]         +true+ for a safe template that substitutes a blank
+        # +:safe+::         +true+ for a safe template that substitutes a blank
         #                   string for a non-existent variable, instead of
         #                   throwing an exception. Defaults to +true+.
-        # [+:var_pattern+]  Regular expression pattern (as a string, not a
+        # +:var_pattern+::  Regular expression pattern (as a string, not a
         #                   Regexp object) to match a variable name. Defaults
         #                   to "[A-Za-z0-9_]+"
         def initialize(resolver, options={})
@@ -350,7 +350,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string in which to replace variable references
+        # +s+:: the string in which to replace variable references
         #
         # Returns the substituted result.
         def substitute(s)
@@ -392,7 +392,7 @@ module Grizzled
         #
         # Parameters:
         #
-        # [+s+] the string
+        # +s+:: the string
         #
         # Returns a +Variable+ object, or +nil+.
         def find_variable_ref(s)

data/lib/grizzled/unix.rb

@@ -55,8 +55,10 @@ module Grizzled
 
       # Run a block of code as this user.
       #
-      # [+block+] the block to execute as that user. It will receive this
-      #           +User+ object as a parameter.
+      # Parameters:
+      #
+      # block:: the block to execute as that user. It will receive this
+      #         +User+ object as a parameter.
       #
       # This function will only run as 'root'.
       #

data/test/fileutil/tc_includer.rb

@@ -0,0 +1,114 @@
+require '../test_helper'
+require 'test/unit'
+require 'tempfile'
+require 'grizzled/fileutil/includer'
+
+include Grizzled::FileUtil
+
+class IncluderTestDriver < Test::Unit::TestCase
+  include GrizzledTestHelper
+
+  def test_successful_file_include
+    make_include_file do |test_file|
+      inc = Includer.new(test_file.main_file)
+      lines = inc.readlines.map {|line| line.chomp}
+      assert_equal(['one-1', 'one-2', 'two-2', 'two-1'], lines)
+      inc.close
+    end
+  end
+
+  def test_recursive_include
+    temp = Tempfile.new('inctest')
+    temp.write <<EOF
+%include "#{temp.path}"
+EOF
+    temp.close
+    assert_raise(IncludeException) do
+      inc = Includer.new(temp.path)
+      inc.readlines
+      inc.close
+    end
+  end
+
+  def test_uri_include
+    make_include_file do |test_file|
+      inc = Includer.new(test_file.main_file)
+      lines = inc.readlines.map {|line| line.chomp}
+      assert_equal(['one-1', 'one-2', 'two-2', 'two-1'], lines)
+      inc.close
+    end
+  end
+
+  def test_path
+    make_include_file do |test_file|
+      path = test_file.main_file
+      inc = Includer.new(test_file.main_file)
+      assert_equal(test_file.main_file, inc.path)
+      inc.close
+    end
+  end
+
+  def test_each_byte
+    make_include_file do |test_file|
+      inc = Includer.new(test_file.main_file)
+      contents = inc.read.split(//)
+      inc.close
+
+      inc = Includer.new(test_file.main_file)
+      bytes = []
+      inc.each_byte do |b|
+        bytes << b.chr
+      end
+      inc.close
+
+      assert_equal(contents, bytes)
+    end
+  end
+    
+  private
+
+  def make_include_file
+    temp1 = Tempfile.new('inctest')
+    temp2 = Tempfile.new('inctest')
+
+    temp2.write <<EOF2
+one-2
+two-2
+EOF2
+
+    temp1.write <<EOF1
+one-1
+%include "#{temp2.path}"
+two-1
+EOF1
+    temp1.close
+    temp2.close
+    t = TestIncludeFile.new([temp1, temp2].map {|t| t.path})
+    if block_given?
+      begin
+        yield t
+      ensure
+        t.unlink
+      end
+    else
+      t
+    end
+  end
+end
+
+class TestIncludeFile
+  attr_reader :main_file
+
+  def initialize(files)
+    @main_file = files[0]
+    @files = files
+  end
+
+  def unlink
+    @files.each do |f|
+      if File.exists? f
+        File.unlink f
+      end
+    end
+  end
+end

data/test/fileutil/tc_make_dir_tree.rb

@@ -0,0 +1,55 @@
+require '../test_helper'
+require 'test/unit'
+require 'tempfile'
+require 'tmpdir'
+require 'fileutils'
+require 'grizzled/fileutil'
+
+include Grizzled::FileUtil
+
+class MakeDirTreeTester < Test::Unit::TestCase
+  include GrizzledTestHelper
+
+  def test_make_directory_tree
+    tree = {"bmc" => {"moe" => {"a" => "aaaaaaaaaa",
+                                "b" => "bbbbbbbbb"},
+                      "larry" => "larry",
+                      "curley" => "curley"}}
+    Dir.mktmpdir('ziptest') do |tmpdir|
+      make_directory_tree(tmpdir, tree)
+
+      # Now, reload the directory tree, and ensure that the tree
+      # matches what we created.
+      new_tree = {}
+      FileUtils.cd tmpdir do
+        new_tree = dir_to_hash "bmc"
+      end
+
+      assert_equal tree, new_tree
+    end
+  end
+
+  private
+
+  def dir_to_hash(dir)
+
+    def load_dir_hash(dir)
+      h = {}
+      Dir.new(dir).entries.each do |dirent|
+        if dirent[0..0] != '.'
+          path = File.join(dir, dirent)
+          if File.directory? path
+            FileUtils.cd dir do
+              h[dirent] = load_dir_hash(dirent)
+            end
+          else
+            h[dirent] = File.open(path).read
+          end
+        end
+      end
+      h
+    end
+
+    {dir => load_dir_hash(dir)}
+  end
+end

data/test/fileutil/tc_zip.rb

@@ -0,0 +1,139 @@
+require '../test_helper'
+require 'test/unit'
+require 'tempfile'
+require 'tmpdir'
+require 'grizzled/fileutil/ziputil'
+
+include Grizzled::FileUtil::ZipUtil
+
+class ZipMixinTestDriver < Test::Unit::TestCase
+  include GrizzledTestHelper
+  include ZipMixin, UnzipMixin
+
+  def test_zip_unzip_with_dir
+    with_tempfile('ziptest', '.zip') do |t|
+
+      # Create a zip file of the current directory
+      zip t.path, '.'
+      assert_equal(true, File.exists?(t.path))
+
+      # Now, unzip it and compare this file with its zipped-and-unzipped
+      # counterpart.
+      this_file_size = File.size(__FILE__)
+      this_file_contents = File.open(__FILE__).readlines.join('')
+      Dir.mktmpdir('ziptest') do |tmpdir|
+        unzip t.path, tmpdir
+
+        # File was unzipped under this directory name.
+        entry_dir = File.basename(File.dirname(File.expand_path(__FILE__)))
+        unzipped_this_file = File.join(tmpdir, entry_dir,
+                                       File.basename(__FILE__))
+        FileUtils.cd(tmpdir) do
+          assert_equal true, File.exists?(unzipped_this_file)
+          assert_equal this_file_size, File.size(unzipped_this_file)
+          contents = File.open(unzipped_this_file).readlines.join('')
+          assert_equal this_file_contents, contents
+        end
+      end
+    end
+  end
+
+  def test_zip_unzip_without_dir
+    with_tempfile('ziptest', '.zip') do |t|
+
+      # Create a zip file of the current directory
+      zip t.path, '.', :dir_at_top => false
+      assert_equal(true, File.exists?(t.path))
+
+      # Now, unzip it and compare this file with its zipped-and-unzipped
+      # counterpart.
+      this_file_size = File.size(__FILE__)
+      this_file_contents = File.open(__FILE__).readlines.join('')
+      Dir.mktmpdir('ziptest') do |tmpdir|
+        unzip t.path, tmpdir
+
+        # File was unzipped in top level.
+        unzipped_this_file = File.join(tmpdir, File.basename(__FILE__))
+        FileUtils.cd(tmpdir) do
+          assert_equal true, File.exists?(unzipped_this_file)
+          assert_equal this_file_size, File.size(unzipped_this_file)
+          contents = File.open(unzipped_this_file).readlines.join('')
+          assert_equal this_file_contents, contents
+        end
+      end
+    end
+  end
+
+  def test_non_recursive
+    expected_files = ['foo.txt', 'bar.txt']
+    Dir.mktmpdir 'ziptest' do |tmpdir|
+      FileUtils.cd tmpdir do
+
+        expected_files.each { |f| create_file(f, (f * 5) + "\n") }
+
+        # Now create a subdirectory.
+        Dir.mkdir 'subdir' do |subdir|
+          FileUtils.cd subdir do
+            # Create a couple more files which should NOT be zipped.
+            ['moe', 'larry', 'curley'].each { |f| create_file(f, f) }
+          end
+        end
+      end
+
+      # Now, zip up the temporary directory.
+
+      with_tempfile('ziptest', '.zip') do |t|
+        zip t.path, tmpdir, :dir_at_top => false, :recursive => false
+
+        assert_equal expected_files, zip_file_entries(t.path).to_a
+      end
+    end
+  end
+
+  def test_zip_with_block
+    create_files = ['foo.txt', 'bar.txt']
+    expected_files = ['foo.txt']
+
+    Dir.mktmpdir 'ziptest' do |tmpdir|
+      FileUtils.cd tmpdir do
+        create_files.each { |f| create_file(f, (f * 5) + "\n") }
+      end
+
+      with_tempfile('ziptest', '.zip') do |t|
+        zip t.path, tmpdir, :dir_at_top => false, :recursive => false do |path|
+          expected_files.include? path
+        end
+
+        assert_equal expected_files, zip_file_entries(t.path).to_a
+      end
+    end
+  end
+
+  def test_zip_file_entries
+    with_tempfile('ziptest', '.zip') do |t|
+
+      # Create a zip file of the current directory
+      zip t.path, '.', :dir_at_top => false, :recursive => false
+      assert_equal(true, File.exists?(t.path))
+
+      files_here = Dir.entries('.').select {|e| File.file? e}
+      entries = Hash[* files_here.map {|e| [e, 0]}.flatten]
+
+      zip_file_entries t.path do |e|
+        assert entries.has_key? e
+        entries[e] = 1
+      end
+
+      assert_equal 0, (entries.values.select {|v| v == 0}).length
+    end
+  end
+
+  private
+
+  def create_file(path, contents)
+    f = File.open(path, 'w')
+    f.write(contents)
+    f.close
+  end
+
+end

data/test/string/tc_template.rb

@@ -0,0 +1,68 @@
+require '../test_helper'
+require 'test/unit'
+require 'grizzled/string/template'
+
+include Grizzled::String::Template
+
+module TemplateTestDriver
+
+  def do_safe_expansion(template_class, resolver, test_data)
+    u = template_class.new(resolver, :safe => true)
+    test_data.each do |string, expected, has_missing|
+      assert_equal(expected, u.substitute(string))
+    end
+  end
+
+  def do_unsafe_expansion(template_class, resolver, test_data)
+    u = template_class.new(resolver, :safe => false)
+    test_data.each do |string, expected, has_missing|
+      if has_missing
+        assert_raise(VariableNotFoundException) do
+          u.substitute(string)
+        end
+      end
+    end
+  end
+end
+
+class TestUnixShellStringTemplate < Test::Unit::TestCase
+
+  include TemplateTestDriver
+
+  RESOLVER  = {"a" => "alpha", "foo" => "FOOBAR"}
+  TEST_DATA = 
+    [
+     ['${a} $foo ${b?bdef} $b ${foo}\$x', 'alpha FOOBAR bdef  FOOBAR$x', true],
+     ['\$a $foo $b', '$a FOOBAR ', true],
+     ['$a', 'alpha', false]
+    ]
+
+  def test_safe_expansion
+    do_safe_expansion(UnixShellStringTemplate, RESOLVER, TEST_DATA)
+  end
+
+  def test_unsafe_expansion
+    do_unsafe_expansion(UnixShellStringTemplate, RESOLVER, TEST_DATA)
+  end
+end
+
+class TestWindowsCmdStringTemplate < Test::Unit::TestCase
+
+  include TemplateTestDriver
+
+  RESOLVER  = {"a" => "alpha", "foo" => "FOOBAR"}
+  TEST_DATA = 
+    [
+     ['%a% %foo% %b% %foo%\%x', 'alpha FOOBAR  FOOBAR%x', true],
+     ['\%a% %foo% %b%', '%a% FOOBAR ', true],
+     ['%a%', 'alpha', false]
+    ]
+
+  def test_safe_expansion
+    do_safe_expansion(WindowsCmdStringTemplate, RESOLVER, TEST_DATA)
+  end
+
+  def test_unsafe_expansion
+    do_unsafe_expansion(WindowsCmdStringTemplate, RESOLVER, TEST_DATA)
+  end
+end

data/test/tc_forwarder.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+require 'test/unit'
+require 'tempfile'
+require 'grizzled/forwarder'
+
+class ForwarderTestDriver < Test::Unit::TestCase
+
+  class ForwardToFile
+    include Grizzled::Forwarder
+
+    def initialize(file, exceptions=[])
+      forward_to file, exceptions
+    end
+  end
+
+  def test_forward_all
+    path = create_file
+    begin
+      contents = File.open(path).read
+
+      fwd = ForwardToFile.new(File.open(path))
+      contents2 = fwd.read
+      assert_equal(contents, contents2)
+
+      lines = []
+      fwd = ForwardToFile.new(File.open(path))
+      fwd.each_line do |line|
+        lines << line
+      end
+      contents2 = lines.join('')
+      assert_equal(contents, contents2)
+    ensure
+      File.unlink path
+    end
+  end
+
+  def test_forward_all_but_each
+    path = create_file
+    begin
+      contents = File.open(path).read
+
+      fwd = ForwardToFile.new(File.open(path), [:each])
+      contents2 = fwd.read
+      assert_equal(contents, contents2)
+
+      assert_raise(NoMethodError) do
+        fwd.each
+      end
+    ensure
+      File.unlink path
+    end
+  end
+
+  def test_forward_all_but_each_and_each_line
+    path = create_file
+    begin
+      contents = File.open(path).read
+
+      fwd = ForwardToFile.new(File.open(path), [:each, :each_line])
+      contents2 = fwd.read
+      assert_equal(contents, contents2)
+
+      assert_raise(NoMethodError) do
+        fwd.each do |c|
+          puts(c) # should not get here
+        end
+      end
+
+      assert_raise(NoMethodError) do
+        fwd.each_line do |line|
+          puts(line) # should not get here
+        end
+      end
+    ensure
+      File.unlink path
+    end
+  end
+
+  private
+
+  def create_file
+    temp = Tempfile.new('fwdtest')
+    temp.write((1..80).to_a.join(', '))
+    temp.write((1..10).to_a.join(', '))
+    temp.close
+    temp.path
+  end
+
+end

data/test/tc_stack.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+require 'test/unit'
+require 'grizzled/stack'
+
+include Grizzled
+
+class StackTestDriver < Test::Unit::TestCase
+
+  def test_correct_class
+    assert_equal(Grizzled::Stack, Stack.new.class)
+  end
+
+  def test_underflow_no_exception
+    stack = Stack.new
+    assert_equal(nil, stack.pop)
+  end
+
+  def test_underflow_exception
+    stack = Stack.new(false)
+    assert_raise(StackUnderflowException) {stack.pop}
+  end
+
+  def test_push
+    stack = Stack.new.push(5)
+    assert_equal([5], stack.to_a)
+    stack.push(10)
+    assert_equal([10, 5], stack.to_a)
+    stack.push(10)
+    assert_equal([10, 10, 5], stack.to_a)
+    stack.push([1, 2, 3])
+    assert_equal([3, 2, 1, 10, 10, 5], stack.to_a)
+  end
+
+  def test_length
+    stack = Stack.new.push(5)
+    assert_equal(1, stack.length)
+
+    stack.push(5)
+    assert_equal(2, stack.length)
+
+    stack.push((1..10).to_a)
+    assert_equal(12, stack.length)
+
+    stack.pop
+    assert_equal(11, stack.length)
+
+    stack.pop until stack.is_empty?
+    assert_equal(0, stack.length)
+  end
+
+  def test_clear
+    stack = Stack.new.push((1..10).to_a)
+    assert_equal(10, stack.length)
+    stack.clear
+    assert_equal(0, stack.length)
+  end
+
+  def test_pop_all
+    a = (1..10).to_a
+    stack = Stack.new.push(a)
+    assert_equal(10, stack.length)
+    a2 = stack.pop_all
+    assert_equal(0, stack.length)
+    assert_equal(a2, a.reverse)
+  end
+
+  def test_immutable
+    # Ensure that the to_a method doesn't return a stack that's
+    stack = Stack.new.push(5).push(10)
+    a = stack.to_a
+    assert_equal([10, 5], a)
+    a.pop
+    assert_equal([10, 5], stack.to_a)
+  end
+
+  def test_enumerable
+    stack = Stack.new.push([1, 2, 3])
+    assert_equal([3, 2, 1], stack.to_a)
+    a = []
+    stack.each {|element| a << element}
+    assert_equal(stack.to_a, a)
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: grizzled-ruby
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Brian M. Clapper
@@ -15,16 +15,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-18 00:00:00 -04:00
+date: 2011-03-24 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
 description: |
-  Grizzled Ruby is a general purpose library of Ruby modules and classes
+  Grizzled Ruby is a general purpose library of Ruby modules and classes.
 
 email: bmc@clapper.org
-executables: []
-
+executables: 
+- grinc
 extensions: []
 
 extra_rdoc_files: []
@@ -39,10 +39,17 @@ files:
 - lib/grizzled/string/template.rb
 - lib/grizzled/unix.rb
 - lib/grizzled.rb
+- test/tc_stack.rb
+- test/tc_forwarder.rb
+- test/fileutil/tc_zip.rb
+- test/fileutil/tc_includer.rb
+- test/fileutil/tc_make_dir_tree.rb
+- test/string/tc_template.rb
+- bin/grinc
 has_rdoc: true
 homepage: http://software.clapper.org/grizzled-ruby
-licenses: []
-
+licenses: 
+- BSD
 post_install_message: 
 rdoc_options: []
 
@@ -73,5 +80,10 @@ rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Miscellaneous, general-purpose Ruby modules and classes
-test_files: []
-
+test_files: 
+- test/tc_stack.rb
+- test/tc_forwarder.rb
+- test/fileutil/tc_zip.rb
+- test/fileutil/tc_includer.rb
+- test/fileutil/tc_make_dir_tree.rb
+- test/string/tc_template.rb