shell_test 0.1.0

data/History.rdoc

@@ -0,0 +1,7 @@
+== 0.1.0 2011/07/07
+
+Initial release.
+
+Much of this code started in the {Tap-Test}[http://rubygems.org/gems/tap-test]
+gem and was later added-to by Linecook[http://rubygems.org/gems/linecook]. It
+has long wished to be it's own gem, and now it is.

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011, Simon Chiang.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.rdoc

@@ -0,0 +1,146 @@
+= ShellTest
+
+Test modules for shell scripts.
+
+== Description
+
+Provides test modules to simplify testing of shell scripts.
+
+ShellTest is not a testing framework. ShellTest integrates with Test::Unit and
+MiniTest out of the box, but it should be possible to include the test modules
+into other test frameworks.
+
+== Usage
+
+ShellTest builds on modules that provide specific functionality. The modules
+may be used independently, but by including ShellTest you get them all:
+
+  require 'shell_test/unit'
+  
+  class ShellTestExample < Test::Unit::TestCase
+    include ShellTest
+  
+    def test_a_script
+      script = prepare('script.sh') do |io|
+        io.puts "echo goodnight $1"
+      end
+  
+      assert_script %{
+        $ sh '#{script}' moon
+        goodnight moon
+      }
+    end
+  end
+
+==== {ShellMethods}[link:classes/ShellTest/ShellMethods.html]
+
+Provides the shell testing methods. These methods are designed to input a
+string that looks like terminal input/output. Commands are parsed out of the
+string, run, and then anything printed to stdout is compared to the expected
+output. In addition the exit status is checked for success (0).
+
+Special comments following the first line of a command can turn off
+output/status checking, or specify a different exit status to expect.
+
+  require 'shell_test/unit'
+  
+  class ShellMethodsExample < Test::Unit::TestCase
+    include ShellTest::ShellMethods
+  
+    def test_a_script_using_variables
+      with_env("THING" => "moon") do
+        assert_script %{
+          $ echo "goodnight $THING"
+          goodnight moon
+        }
+      end
+    end
+    
+    def test_multiple_commands
+      assert_script %{
+        $ echo one
+        one
+        $ echo two
+        two
+      }
+    end
+  
+    def test_multiline_commands
+      assert_script %{
+        $ for n in one two; do
+        >   echo $n
+        > done
+        one
+        two
+      }
+    end
+ 
+    def test_exit_statuses
+      assert_script %{
+        $ true  # [0]
+        $ false # [1]
+      }
+    end
+    
+    def test_exit_status_and_not_ouptut
+      assert_script %{
+        $ date  # [0] ...
+      }
+    end
+    
+    def test_output_with_inline_regexps
+      assert_script_match %{
+        $ cal
+        :...:
+        Su Mo Tu We Th Fr Sa
+        :...:
+      }
+    end
+  end
+
+==== {FileMethods}[link:classes/ShellTest/FileMethods.html]
+
+Sets up a temporary, test-specific directory for working with files. This
+approach is better in most cases than using Tempfile because you can flag the
+directory to be saved on a failure (using ENV['KEEP_OUTPUTS']='true').
+
+By default the directory is guessed based off of the test file and test
+method. If this example were located in the 'test/file_methods_example.rb'
+file, then the directory for the test case would be
+'test/file_methods_example/test_preparation_of_a_test_specific_file'.
+
+  require 'shell_test/unit'
+  
+  class FileMethodsExample < Test::Unit::TestCase
+    include ShellTest::FileMethods
+
+    def test_preparation_of_a_test_specific_file
+      path = prepare('dir/file.txt') {|io| io << 'content' }
+      assert_equal "content", File.read(path)
+    end
+  end
+
+== Installation
+
+ShellTest is available as a gem[http://rubygems.org/gems/shell_test].
+
+  $ gem install shell_test
+
+== Development
+
+To get started, checkout the code from GitHub[http://github.com/thinkerbot/shell_test] and run:
+
+  git clone https://thinkerbot@github.com/thinkerbot/shell_test.git
+  cd shell_test
+  rake test
+
+To test against multiple platforms I suggest using rvm.  In that case:
+
+  rvm rake test
+
+Please report any issues {here}[http://github.com/thinkerbot/shell_test/issues].
+
+== Info
+
+Developer:: {Simon Chiang}[http://thinkerbot.posterous.com]
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/lib/shell_test/command_parser.rb

@@ -0,0 +1,67 @@
+module ShellTest
+  class CommandParser
+    attr_reader :ps1
+    attr_reader :ps2
+
+    def initialize(options={})
+      options = {
+        :ps1 => '$ ',
+        :ps2 => '> '
+      }.merge(options)
+
+      @ps1 = options[:ps1]
+      @ps2 = options[:ps2]
+    end
+
+    def parse_cmd(cmd)
+      cmd =~ /.*?#\s*(?:\[(\d+)\])?\s*(\.{3})?/
+      exit_status = $1 ? $1.to_i : 0
+      output = $2 ? nil : ""
+
+      [cmd, output, exit_status]
+    end
+
+    def parse(script)
+      commands = []
+
+      command, output, exit_status = nil, "", 0
+      script.each_line do |line|
+        case
+        when line.index(ps1) == 0
+          if command
+            commands << [command, output, exit_status]
+          end
+
+          command, output, exit_status = parse_cmd lchomp(ps1, line)
+
+        when command.nil?
+          unless line.strip.empty?
+            command, output, exit_status = parse_cmd(line)
+          end
+
+        when line.index(ps2) == 0
+          command << lchomp(ps2, line)
+
+        when output.nil?
+          output = line
+
+        else
+          output << line
+        end
+      end
+
+      if command
+        commands << [command, output, exit_status]
+      end
+
+      commands
+    end
+
+    private
+
+    def lchomp(prefix, line) # :nodoc:
+      length = prefix.length
+      line[length, line.length - length]
+    end
+  end
+end

data/lib/shell_test/file_methods.rb

@@ -0,0 +1,208 @@
+require 'fileutils'
+
+module ShellTest
+  module FileMethods
+    module ClassMethods
+      attr_accessor :class_dir
+
+      attr_reader :cleanup_method_registry
+
+      def cleanup_methods
+        @cleanup_methods ||= begin
+          cleanup_methods = {}
+
+          ancestors.reverse.each do |ancestor|
+            next unless ancestor.kind_of?(ClassMethods)
+            ancestor.cleanup_method_registry.each_pair do |key, value|
+              if value.nil?
+                cleanup_methods.delete(key)
+              else
+                cleanup_methods[key] = value
+              end
+            end
+          end
+
+          cleanup_methods
+        end
+      end
+
+      def reset_cleanup_methods
+        @cleanup_methods = nil
+      end
+
+      protected
+
+      def self.initialize(base)
+        # Infers the test directory from the calling file.
+        #   'some_class_test.rb' => 'some_class_test'
+        call_line = caller.find {|value| value !~ /`(includ|inherit|extend)ed'$/ }
+
+        if call_line
+          calling_file   = call_line.gsub(/:\d+(:in .*)?$/, "")
+          base.class_dir = calling_file.chomp(File.extname(calling_file))
+        else
+          unless Dir.respond_to?(:tmpdir)
+            require 'tmpdir'
+          end
+          base.class_dir = Dir.tmpdir
+        end
+
+        base.reset_cleanup_methods
+        unless base.instance_variable_defined?(:@cleanup_method_registry)
+          base.instance_variable_set(:@cleanup_method_registry, {})
+        end
+
+        unless base.instance_variable_defined?(:@cleanup_paths)
+          base.instance_variable_set(:@cleanup_paths, ['.'])
+        end
+
+        unless base.instance_variable_defined?(:@cleanup)
+          base.instance_variable_set(:@cleanup, true)
+        end
+      end
+
+      def inherited(base) # :nodoc:
+        ClassMethods.initialize(base)
+        super
+      end
+
+      def define_method_cleanup(method_name, dirs)
+        reset_cleanup_methods
+        cleanup_method_registry[method_name.to_sym] = dirs
+      end
+
+      def remove_method_cleanup(method_name)
+        reset_cleanup_methods
+        cleanup_method_registry.delete(method_name.to_sym)
+      end
+
+      def undef_method_cleanup(method_name)
+        reset_cleanup_methods
+        cleanup_method_registry[method_name.to_sym] = nil
+      end
+
+      def cleanup_paths(*dirs)
+        @cleanup_paths = dirs
+      end
+
+      def cleanup(*method_names)
+        if method_names.empty?
+          @cleanup = true
+        else
+          method_names.each do |method_name|
+            define_method_cleanup method_name, @cleanup_paths
+          end
+        end
+      end
+
+      def no_cleanup(*method_names)
+        if method_names.empty?
+          @cleanup = false
+        else
+          method_names.each do |method_name|
+            undef_method_cleanup method_name
+          end
+        end
+      end
+
+      def method_added(sym)
+        if @cleanup && !cleanup_method_registry.has_key?(sym.to_sym) && sym.to_s[0, 5] == "test_"
+          cleanup sym
+        end
+      end
+    end
+
+    module ModuleMethods
+      module_function
+
+      def included(base)
+        base.extend ClassMethods
+        base.extend ModuleMethods unless base.kind_of?(Class)
+
+        ClassMethods.initialize(base)
+        super
+      end
+    end
+
+    extend ModuleMethods
+
+    def setup
+      super
+      cleanup
+    end
+
+    def teardown
+      Dir.chdir(user_dir)
+
+      unless ENV["KEEP_OUTPUTS"] == "true"
+        cleanup
+
+        dir = method_dir
+        while dir != class_dir
+          dir = File.dirname(dir)
+          Dir.rmdir(dir)
+        end rescue(SystemCallError)
+      end
+
+      super
+    end
+
+    def user_dir
+      @user_dir   ||= File.expand_path('.')
+    end
+
+    def class_dir
+      @class_dir  ||= File.expand_path(self.class.class_dir, user_dir)
+    end
+
+    def method_dir
+      @method_dir ||= File.expand_path(method_name.to_s, class_dir)
+    end
+
+    def method_name
+      __name__
+    end
+
+    def cleanup_methods
+      self.class.cleanup_methods
+    end
+
+    def cleanup
+      if cleanup_paths = cleanup_methods[method_name.to_sym]
+        cleanup_paths.each {|relative_path| remove(relative_path) }
+      end
+    end
+
+    def path(relative_path)
+      path = File.expand_path(relative_path, method_dir)
+
+      unless path.index(method_dir) == 0
+        raise "does not make a path relative to method_dir: #{relative_path.inspect}"
+      end
+
+      path
+    end
+
+    def prepare(relative_path, content=nil, &block)
+      target = path(relative_path)
+
+      if File.exists?(target)
+        FileUtils.rm(target)
+      else
+        target_dir = File.dirname(target)
+        FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
+      end
+
+      FileUtils.touch(target)
+      File.open(target, 'w') {|io| io << content } if content
+      File.open(target, 'a', &block) if block
+
+      target
+    end
+
+    def remove(relative_path)
+      full_path = path(relative_path)
+      FileUtils.rm_r(full_path) if File.exists?(full_path)
+    end
+  end
+end

data/lib/shell_test/regexp_escape.rb

@@ -0,0 +1,84 @@
+module ShellTest
+  # RegexpEscape is a subclass of regexp that escapes all but the text in a
+  # special escape sequence.  This allows the creation of complex regexps
+  # to match, for instance, console output.
+  #
+  # The RegexpEscape.escape (or equivalently the quote) method does the
+  # work; all regexp-active characters are escaped except for characters
+  # enclosed by ':.' and '.:' delimiters.
+  #
+  #   RegexpEscape.escape('reg[exp]+ chars. are(quoted)')       # => 'reg\[exp\]\+\ chars\.\ are\(quoted\)'
+  #   RegexpEscape.escape('these are not: :.a(b*)c.:')          # => 'these\ are\ not:\ a(b*)c'
+  #
+  # In addition, all-period regexps are automatically upgraded to '.*?';
+  # use the '.{n}' notation to specify n arbitrary characters.
+  #
+  #   RegexpEscape.escape('_:..:_:...:_:....:')        # => '_.*?_.*?_.*?'
+  #   RegexpEscape.escape(':..{1}.:')                  # => '.{1}'
+  #
+  # RegexpEscape instances are initialized using the escaped input string
+  # and return the original string upon to_s.
+  #
+  #   str = %q{
+  #   a multiline
+  #   :...:
+  #   example}
+  #   r = RegexpEscape.new(str)
+  #
+  #   r =~ %q{
+  #   a multiline
+  #   matching
+  #   example}  # => true
+  #
+  #   r !~ %q{
+  #   a failing multiline
+  #   example}  # => true
+  #
+  #   r.to_s    # => str
+  #
+  class RegexpEscape < Regexp
+
+    # matches the escape sequence
+    ESCAPE_SEQUENCE = /:\..*?\.:/
+
+    class << self
+
+      # Escapes regexp-active characters in str, except for character
+      # delimited by ':.' and '.:'.  See the class description for
+      # details.
+      def escape(str)
+        substituents = []
+        str.scan(ESCAPE_SEQUENCE) do
+          regexp_str = $&[2...-2]
+          regexp_str = ".*?" if regexp_str =~ /^\.*$/
+          substituents << regexp_str
+        end
+        substituents << ""
+
+        splits = str.split(ESCAPE_SEQUENCE).collect do |split|
+          super(split)
+        end
+        splits << "" if splits.empty?
+
+        splits.zip(substituents).to_a.flatten.join
+      end
+
+      # Same as escape.
+      def quote(str)
+        escape(str)
+      end
+    end
+
+    # Generates a new RegexpEscape by escaping the str, using the same
+    # options as Regexp.
+    def initialize(str, *options)
+      super(RegexpEscape.escape(str), *options)
+      @original_str = str
+    end
+
+    # Returns the original string for self
+    def to_s
+      @original_str
+    end
+  end
+end

data/lib/shell_test/shell_methods.rb

@@ -0,0 +1,176 @@
+require 'shell_test/regexp_escape'
+require 'shell_test/command_parser'
+
+module ShellTest
+  module ShellMethods
+    def setup
+      super
+      @notify_method_name = true
+    end
+
+    # Parse a script into an array of [cmd, output, status] triplets.
+    def parse_script(script, options={})
+      CommandParser.new(options).parse(script)
+    end
+
+    # Returns true if the ENV variable 'VERBOSE' is true.  When verbose,
+    # ShellTest prints the expanded commands of sh_test to $stdout.
+    def verbose?
+      verbose = ENV['VERBOSE']
+      verbose && verbose =~ /^true$/i ? true : false
+    end
+
+    # Sets the specified ENV variables and returns the *current* env.
+    # If replace is true, current ENV variables are replaced; otherwise
+    # the new env variables are simply added to the existing set.
+    def set_env(env={}, replace=false)
+      current_env = {}
+      ENV.each_pair do |key, value|
+        current_env[key] = value
+      end
+
+      ENV.clear if replace
+
+      env.each_pair do |key, value|
+        if value.nil?
+          ENV.delete(key)
+        else
+          ENV[key] = value
+        end
+      end if env
+
+      current_env
+    end
+
+    # Sets the specified ENV variables for the duration of the block.
+    # If replace is true, current ENV variables are replaced; otherwise
+    # the new env variables are simply added to the existing set.
+    #
+    # Returns the block return.
+    def with_env(env={}, replace=false)
+      current_env = nil
+      begin
+        current_env = set_env(env, replace)
+        yield
+      ensure
+        if current_env
+          set_env(current_env, true)
+        end
+      end
+    end
+
+    def sh(cmd)
+      if @notify_method_name && verbose?
+        @notify_method_name = false
+        puts
+        puts method_name 
+      end
+
+      start  = Time.now
+      result = `#{cmd}`
+      finish = Time.now
+
+      if verbose?
+        elapsed = "%.3f" % [finish-start]
+        puts "  (#{elapsed}s) #{cmd}"
+      end
+
+      result
+    end
+
+    def assert_script(script, options={})
+      _assert_script outdent(script), options
+    end
+
+    def _assert_script(script, options={})
+      parse_script(script, options).each do |cmd, output, status|
+        result = sh(cmd)
+
+        _assert_output_equal(output, result, cmd) if output
+        assert_equal(status, $?.exitstatus, cmd)  if status
+      end
+    end
+
+    def assert_script_match(script, options={})
+      _assert_script_match outdent(script), options
+    end
+
+    def _assert_script_match(script, options={})
+      parse_script(script, options).each do |cmd, output, status|
+        result = sh(cmd)
+
+        _assert_alike(output, result, cmd)       if output
+        assert_equal(status, $?.exitstatus, cmd) if status
+      end
+    end
+
+    # Asserts whether or not the a and b strings are equal, with a more
+    # readable output than assert_equal for large strings (especially large
+    # strings with significant whitespace).
+    def assert_output_equal(a, b, msg=nil)
+      _assert_output_equal outdent(a), b, msg
+    end
+
+    def _assert_output_equal(a, b, msg=nil)
+      if a == b
+        assert true
+      else
+        flunk %Q{
+#{msg}
+==================== expected output ====================
+#{whitespace_escape(a)}
+======================== but was ========================
+#{whitespace_escape(b)}
+=========================================================
+}
+      end
+    end
+
+    # Asserts whether or not b is like a (which should be a Regexp), and
+    # provides a more readable output in the case of a failure as compared
+    # with assert_match.
+    #
+    # If a is a string it is turned into a RegexpEscape.
+    def assert_alike(a, b, msg=nil)
+      a = outdent(a) if a.kind_of?(String)
+      _assert_alike a, b, msg
+    end
+
+    def _assert_alike(a, b, msg=nil)
+      if a.kind_of?(String)
+        a = RegexpEscape.new(a)
+      end
+
+      if b =~ a
+        assert true
+      else
+        flunk %Q{
+#{msg}
+================= expected output like ==================
+#{whitespace_escape(a)}
+======================== but was ========================
+#{whitespace_escape(b)}
+=========================================================
+}
+      end
+    end
+
+    # helper for stripping indentation off a string
+    def outdent(str)
+      str =~ /\A(?:\s*?\n)( *)(.*)\z/m ? $2.gsub!(/^ {0,#{$1.length}}/, '') : str
+    end
+
+    # helper for formatting escaping whitespace into readable text
+    def whitespace_escape(str)
+      str.to_s.gsub(/\s/) do |match|
+        case match
+        when "\n" then "\\n\n"
+        when "\t" then "\\t"
+        when "\r" then "\\r"
+        when "\f" then "\\f"
+        else match
+        end
+      end
+    end
+  end
+end

data/lib/shell_test/unit/shim.rb

@@ -0,0 +1,72 @@
+# :stopdoc:
+module ShellTest
+  module Unit
+    
+    # An exception class to flag skips.
+    class SkipException < StandardError
+    end
+    
+    # Modifies how errors related to a SkipException are displayed.
+    module SkipDisplay
+      # Display S rather than E in the progress.
+      def single_character_display
+        "S"
+      end
+
+      # Removes the exception class from the message.
+      def message
+        @exception.message
+      end
+
+      # Updates the output to look like a MiniTest skip error.
+      def long_display
+        backtrace = filter_backtrace(@exception.backtrace)
+        "Skipped:\n#@test_name [#{backtrace[0].sub(/:in `.*$/, "")}]:\n#{message}\n"
+      end
+    end
+  end
+end
+
+require 'test/unit/testresult'
+class Test::Unit::TestResult
+  # Returns an array of skips recorded for self.
+  def skips
+    @skips ||= []
+  end
+
+  # Partition errors from a SkipException from other errors and records as
+  # them as skips (the error is extended to display as a skip).
+  def add_error(error)
+    if error.exception.kind_of?(ShellTest::Unit::SkipException)
+      error.extend ShellTest::Unit::SkipDisplay
+      skips << error
+    else
+      @errors << error
+    end
+
+    notify_listeners(FAULT, error)
+    notify_listeners(CHANGED, self)
+  end
+
+  alias shell_test_original_to_s to_s
+
+  # Adds the skip count to the summary.
+  def to_s
+    "#{shell_test_original_to_s}, #{skips.length} skips"
+  end
+end
+
+require 'test/unit/testcase'
+class Test::Unit::TestCase
+  # Alias method_name to __name__ such that FileMethods can redefine
+  # method_name to call __name__ (circular I know, but necessary for
+  # compatibility with MiniTest)
+  alias __name__ method_name
+
+  # Call to skip a test.
+  def skip(msg = nil, bt = caller)
+    msg ||= "Skipped, no message given"
+    raise ShellTest::Unit::SkipException, msg, bt
+  end
+end
+# :startdoc:

data/lib/shell_test/unit.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'shell_test'
+
+module ShellTest
+  # ShellTest is designed to work with MiniTest, which is the standard testing
+  # framework included in ruby 1.9.  Minor changes in the API break backward
+  # compatibility with Test::Unit and/or add functionality expected by
+  # ShellTest.
+  #
+  # Test::Unit can be patched by requiring the shim file before defining
+  # specific TestCase subclasses.
+  #
+  #   require 'test/unit'
+  #   unless Object.const_defined?(:MiniTest)
+  #     require 'shell_test/unit/shim'
+  #   end
+  #
+  # To let ShellTest do this for you:
+  #
+  #  require 'shell_test/unit'
+  #
+  # Note that the shim script has only been tested vs the Test::Unit that
+  # comes with ruby 1.8.x.  A Test::Unit 2.0 gem exists; use with caution.
+  #
+  # ==== Patches
+  #
+  # The shim script adds two things to Test::Unit:
+  #
+  # 1) A __name__ method which returns the test method name (alias for
+  # method_name)
+  #
+  # 2) A skip method which can be used to skip a test (use it like flunk)
+  #
+  module Unit
+  end
+end
+
+unless Object.const_defined?(:MiniTest)
+  require 'shell_test/unit/shim'
+end

data/lib/shell_test/version.rb

@@ -0,0 +1,3 @@
+module ShellTest
+  VERSION = "0.1.0"
+end

data/lib/shell_test.rb

@@ -0,0 +1,8 @@
+require 'shell_test/version'
+require 'shell_test/file_methods'
+require 'shell_test/shell_methods'
+
+module ShellTest
+  include FileMethods
+  include ShellMethods
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: shell_test
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-07 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Provides test modules to simplify testing of shell scripts. ShellTest is not a testing framework. ShellTest integrates with Test::Unit and MiniTest out of the box, but it should be possible to include the test modules into other test frameworks.
+email: 
+- simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.rdoc
+- README.rdoc
+- MIT-LICENSE
+files: 
+- lib/shell_test.rb
+- lib/shell_test/command_parser.rb
+- lib/shell_test/file_methods.rb
+- lib/shell_test/regexp_escape.rb
+- lib/shell_test/shell_methods.rb
+- lib/shell_test/unit.rb
+- lib/shell_test/unit/shim.rb
+- lib/shell_test/version.rb
+- History.rdoc
+- README.rdoc
+- MIT-LICENSE
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- -S
+- -N
+- --title
+- ShellTest
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: shell_test
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Test modules for shell scripts
+test_files: []
+