execute_shell 0.0.1

data/Gemfile.lock

@@ -0,0 +1,18 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    Platform (0.4.0)
+    highline (1.6.1)
+    open4 (1.0.1)
+    rake (0.8.7)
+    win32-open3-19 (0.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  Platform (~> 0.4.0)
+  highline (~> 1.6.1)
+  open4 (~> 1.0.1)
+  rake (= 0.8.7)
+  win32-open3-19 (~> 0.0.1)

data/execute_shell.gemspec

@@ -0,0 +1,26 @@
+gem_spec = Gem::Specification.new do |s|
+  s.name = 'execute_shell'
+  s.version = '0.0.1'
+
+  s.summary = 'Executes shell commands.'
+
+  s.author = 'Travis Herrick'
+  s.email = 'tthetoad@gmail.com'
+
+  s.license = 'MIT'
+
+  s.extra_rdoc_files << 'README'
+
+  s.require_paths = ['lib']
+  s.files = Dir['lib/**/*.rb', '*']
+  s.test_files = Dir['test/**/*.rb']
+
+  s.add_dependency 'Platform',       '~> 0.4.0'
+  s.add_dependency 'open4',          '~> 1.0.1'
+  s.add_dependency 'win32-open3-19', '~> 0.0.1'
+
+  s.add_development_dependency 'rake',        '0.8.7'
+  s.add_development_dependency 'highline', '~> 1.6.1'
+
+  s.has_rdoc = true
+end

data/gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem 'Platform',       '~>  0.4.0', :group => [:rake, :test],
+  :require => 'platform'
+gem 'open4',          '~>  1.0.1', :group => [:rake, :test]
+gem 'win32-open3-19', '~>  0.0.1', :group => [:rake, :test], :require => 'open3'
+
+group :rake do
+	gem 'rake', '0.8.7'
+	gem 'highline', '~>  1.6.1', :require => 'highline/import'
+end

data/lib/execute_shell.rb

@@ -0,0 +1,6 @@
+require 'platform'
+require 'open4' if [:linux].include?(Platform::IMPL)
+require 'open3' if [:mingw].include?(Platform::IMPL)
+
+require_relative 'execute_shell/script_env'
+require_relative 'execute_shell/execute_shell'

data/lib/execute_shell/execute_shell.rb

@@ -0,0 +1,180 @@
+# This file contains a module for returning output from console commands.
+
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+# Contains methods for returning output from console commands.
+module ExecuteShell
+
+  # Returns output from a console command.
+  # ==== Input
+  # [command : String] The command to be run.
+  # [path : String : Dir.getwd] The path to use for the command.
+  # ==== Output
+  # [Boolean] Whether the shell execution was successful.
+  # [String]
+  def shell(command, path = Dir.getwd)
+    raise_not_implemented(__method__) unless
+      [:linux, :mingw].include?(Platform::IMPL)
+
+    out = ''
+    err = ''
+    success = nil
+
+    path ||= Dir.getwd
+
+    begin
+      STDOUT.puts command if ScriptEnv.development
+
+      block = case Platform::IMPL
+        when :mingw
+          lambda {
+            # Run the command and wait for it to execute.
+            result = Open3::popen3('cmd') do |std_in, std_out, std_err, thread|
+              # Set up the command.
+              std_in.puts command
+
+              # Run it.
+              std_in.close
+
+              # Get the output.
+              out = std_out.read.strip
+              err = std_err.read.strip
+            end
+          }
+        when :linux
+          lambda {
+            # Run the command and wait for it to execute.
+            result = Open4::popen4('bash') do |pid, std_in, std_out, std_err|
+              # Set up the command.
+              std_in.puts command
+
+              # Run it.
+              std_in.close
+
+              # Get the output.
+              out = std_out.read.strip
+              err = std_err.read.strip
+            end
+          }
+      end
+
+      wrap_success, wrap_out = wrap_path(path, block)
+
+      # Success is determined by lack of error text.
+      success = err.empty?
+
+      # Remove all the extra stuff that the cmd prompt adds.
+      if Platform::IMPL == :mingw
+        out.gsub!(/\n\n#{path.gsub(%r[/], '\\\\\\')}>\Z/, '')
+
+        # replace contains the command line prompt
+        # and the command up to the first space.
+        replace = path.gsub(%r[/], '\\\\\\')
+        replace += '>'
+        replace += command[0..(command.index(/ /) || 0) - 1]
+
+        # Remove the header portion of the text.
+        # This includes the Microsoft 'banner' text
+        # that consumes the first two lines.
+        out = out.gsub(/\A.+#{replace}.*?$/m, '').strip
+      end
+
+      # Set the error flag and notify the user if anything went wrong.
+      out = (out + "\n" + err).strip unless success
+      out += wrap_out.strip unless wrap_success
+
+      # Include the wrapper's success flag in the resulting success flag.
+      success = success && wrap_success
+    rescue Exception => exc
+      # Format exception messages.
+      success = false
+      out += format_error(exc)
+    end
+
+    return success, out
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  # Formats error messages.
+  # ==== Input
+  # [exception : Exception] The error that was raised.
+  # ==== Output
+  # [String] The error information in a readable format.
+  def format_error(exception)
+    error_format = '%s: %s%s'
+    error_format % [exception.class, exception.message,
+      ScriptEnv.development ? "\n#{exception.backtrace.join("\n")}" : '']
+  end
+
+  # Raises a NotImplementedError.
+  # ==== Input
+  # [method : String] The method that does not have
+  #                   an implementation for the current platform.
+  def raise_not_implemented(method)
+    raise NotImplementedError,
+      "#{method} " +
+      "has not been implemented for #{Platform::IMPL}."
+  end
+
+  # Runs a block of code by changing the path first.
+  # ==== Input
+  # [path : String] The path to change to prior to running the block.
+  # [block : Proc] The code block to execute.
+  # [*args : Array] Any other parameters
+  #                 that will be passed on to <tt>block</tt>.
+  # ==== Output
+  # [Boolean] Indicates whether the block was executed successfully.
+  # [String] Any error messages from trapped errors.
+  def wrap_path(path, block, *args)
+    path ||= File.expand_path(Dir.getwd)
+    original = File.expand_path(Dir.getwd)
+    out = nil
+
+    STDOUT.puts path if ScriptEnv.development
+
+    begin
+      Dir.chdir path unless path == original
+      block.call(*args)
+    rescue Exception => exc
+      # Format exception messages.
+      out = format_error(exc)
+    ensure
+      Dir.chdir original unless path == original
+    end
+
+    return out.nil?, out
+  end
+end

data/lib/execute_shell/script_env.rb

@@ -0,0 +1,81 @@
+# This file contains a class to manage information about the environment.
+
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+# This class manages environment information.
+class ScriptEnv
+  # Contains valid environments for the script.
+  STATES = {
+    :development => :development,
+    :test        => :testing,
+    :production  => :production,
+  }
+
+  # Indicates the current environment of the script.
+  @@env = nil
+
+  class << self
+    # Retrieves the current environment setting.
+    def env
+      if @@env.nil? && File.expand_path(Dir.getwd) ==
+          File.expand_path(File.join(File.dirname(__FILE__), '..'))
+        return STATES[:development]
+      else
+        return STATES[@@env] || STATES[:production]
+      end
+    end
+
+    # Black magic.
+    #
+    # Allows the getting and setting of the 'state' of the script.
+    # Only one environment can be active at a time.
+    # Setting one environment to true means the others are false.
+    # ==== Input
+    # [method : Symbol] The method that was called.
+    # [*args : Array] Any arguments that were passed in.
+    # [&block : Block] A block, if specified.
+    def method_missing(method, *args, &block)
+      if STATES.keys.include?(method.to_s.sub(/=$/, '').to_sym)
+        if method.to_s.match(/=$/) # Setter method.
+          value = args && args.shift || nil
+          @@env = method.to_s[0..-2].to_sym if value == true
+        else # ------------------- # Getter method.
+          states = STATES.select { |k, v| v == env }
+          return !states[method].nil?
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/rakefile

@@ -0,0 +1,121 @@
+root_path = File.expand_path(File.dirname(__FILE__))
+require 'bundler'
+Bundler.require :rake
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/clean'
+require_relative 'lib/execute_shell'
+
+include ExecuteShell
+
+task :default => [:tests]
+
+# Include any ruby files in the tasks folder.
+task_files = Dir[
+  File.join(File.expand_path(File.dirname(__FILE__)), 'tasks', '*.rb')]
+
+task_files.each do |rake_file|
+  require rake_file
+end
+
+# Add a task to run all tests.
+Rake::TestTask.new('tests') do |task|
+  task.pattern = 'test/*_test.rb'
+  task.verbose = true
+  task.warning = true
+end
+Rake::Task[:tests].comment = 'Run all tests'
+
+################################################################################
+namespace :test do
+################################################################################
+  file_list = Dir['test/*_test.rb']
+
+  # Add a distinct test task for each test file.
+  file_list.each do |item|
+    # Get the name to use for the task by removing '_test.rb' from the name.
+    task_name = File.basename(item, '.rb').gsub(/_test$/, '')
+
+    # Add each test.
+    Rake::TestTask.new(task_name) do |task|
+      task.pattern = item
+      task.verbose = true
+      task.warning = true
+    end
+  end
+################################################################################
+end # :test
+################################################################################
+
+################################################################################
+namespace :rdoc do
+################################################################################
+
+  # Set the paths used by each of the rdoc options.
+  RDOC_FILES = {
+    :all     => ['**/*.rb'],
+    :test    => ['test/lib/**/*.rb'],
+    :app     => [
+      '*.rb',
+      'lib/**/*.rb',
+    ],
+  }
+
+  # Loop through the typs of rdoc files to generate an rdoc task for each one.
+  RDOC_FILES.keys.each do |rdoc_task|
+    Rake::RDocTask.new(
+        :rdoc         => rdoc_task,
+        :clobber_rdoc => "#{rdoc_task}:clobber",
+        :rerdoc       => "#{rdoc_task}:force") do |rdtask|
+      rdtask.rdoc_dir = "help/#{rdoc_task}"
+      rdtask.options << '--charset' << 'utf8'
+      rdtask.rdoc_files.include(RDOC_FILES[rdoc_task])
+    end
+
+    Rake::Task[rdoc_task].comment =
+      "Generate #{rdoc_task} RDoc documentation."
+  end
+################################################################################
+end # :rdoc
+################################################################################
+
+desc 'Search for a string in all files using a case insensitive search.'
+task :grep, [:text] do |task, args|
+  # Set default search text to t-o-d-o.
+  # It is done this way to prevent coming up in the search itself.
+  args.with_defaults(:text => 't' + 'o' + 'd' + 'o')
+
+  # Use the sample color scheme, since it provides us with bold red via :error.
+  HighLine.color_scheme = HighLine::SampleColorScheme.new
+  COLOR = "<%%= color('%s', :error) %%>"
+
+  notification = "\nSearching for '%s':\n\n"
+
+  # Output the text that is being searched for.
+  case Platform::IMPL
+    when :linux
+      notification = notification % [COLOR % args[:text]]
+    when :mingw
+      notification = notification % args[:text]
+    else
+      raise_not_implemented('grep')
+  end
+
+  say notification
+
+  command = "grep #{args[:text]} * -ri"
+  success, output = shell(command)
+
+  # Send the results to the console.
+  case Platform::IMPL
+    when :linux
+      output = output.gsub(/(#{args[:text]})/i, COLOR % '\1')
+    when :mingw
+    else
+      raise_not_implemented('grep')
+  end
+
+  say output
+end
+
+CLOBBER.include('help')

data/test/execute_shell_test.rb

@@ -0,0 +1,126 @@
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+require File.join(File.dirname(File.expand_path(__FILE__)), 'require')
+
+class ExecuteShellTest < Test::Unit::TestCase
+  def setup
+    @obj = Object.new
+    @obj.extend(@class)
+
+    @working_path = Dir.getwd
+    @home_path = File.expand_path(File.join('~', '..'))
+    @user = File.basename(File.expand_path('~'))
+
+    Dir.chdir @home_path
+
+    # Setting $stderr to STDERR does not work due to the way
+    # STDERR was being redirected (or something).
+    @stdout_inspect = $stdout.inspect
+    @stderr_inspect = $stderr.inspect
+  end
+
+  def teardown
+    Dir.chdir @working_path
+    assert_equal(@stdout_inspect, $stdout.inspect)
+    assert_equal(@stderr_inspect, $stderr.inspect)
+  end
+
+  def test_stdout
+    command = nil
+
+    case Platform::IMPL
+      when :linux
+        command = "ls #{@home_path}"
+      when :mingw
+        command = "dir #{convert_to_backslash(@home_path)}"
+      else
+        raise_not_implemented
+    end
+
+    success, output = @obj.shell(command)
+
+    assert output.index(@user),
+      "'#{command}' does not appear to include " +
+      "the current user's folder (#{@user})."
+    assert_true success, "#{command} was not successful"
+  end
+
+  def test_stderr
+    command = nil
+    result = nil
+
+    folder = 'giggidygiggidy'
+
+    test_path = File.join(@home_path, folder)
+
+    case Platform::IMPL
+      when :linux
+        command = "ls #{test_path}"
+        result = "ls: cannot access #{test_path}: No such file or directory"
+      when :mingw
+        command = "dir #{convert_to_backslash(test_path)}"
+        result = 'File Not Found'
+      else
+        raise_not_implemented
+    end
+
+    success, output = @obj.shell(command)
+
+    assert_equal result, output if Platform::IMPL == :linux
+
+    assert output.index(result)
+    assert_false success
+  end
+
+  def test_grep
+    Dir.chdir @working_path
+    command = 'grep jabberwocky' + 'riseagain * -ri'
+    result = nil
+
+    assert_equal [true, ''], @obj.shell(command)
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  def convert_to_backslash(text)
+    text.gsub(%r[/], "\\")
+  end
+
+  def raise_not_implemented(method)
+    raise NotImplementedError,
+      "#{method} " +
+      "has not been implemented for #{Platform::IMPL}."
+  end
+end

data/test/lib/test_case.rb

@@ -0,0 +1,502 @@
+# This file contains a monkey patch of Test::Unit::TestCase.
+
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+# Monkey patch Test::Unit::TestCase to make it do cool stuff.
+Test::Unit::TestCase.class_eval do
+  # Since this is in a class_eval, instance methods need to be wrapped up
+  # in class_variable_set or ruby will throw warnings.
+
+  # Indicates whether the class has already been initialized.
+  # This combined with @@class_name prevents duplicate patching.
+  class_variable_set(:@@initialized, false)
+
+  # Keeps track of the class that has most recently been initialized.
+  # This combined with @@initialized prevents duplicate patching.
+  class_variable_set(:@@class_name, '')
+
+  # Initializes the class
+  # and exposes private methods and variables of the class that is being tested.
+  def initialize(*args)
+    # Call initialize on the superclass.
+    super
+
+    @obj = nil
+
+    reset_io
+    reset_trace
+
+    # This block ensures that tests still work if there is not a class that
+    # corresponds with the test file/class.
+    @class = nil
+    begin
+      # Get the class that is being tested.
+      # Assume that the name of the class is found by removing 'Test'
+      # from the test class.
+      @class = Kernel.const_get(self.class.name.gsub(/Test$/, ''))
+      @@initialized = ((@class.name == @@class_name) && @@initialized)
+      @@class_name = @class.name
+    rescue
+      @@initialized = true
+      @@class_name = ''
+    end
+
+    # Only patch if this code has not yet been run.
+    if !@@initialized and @class.class.name != 'Module'
+      set_instance_method_wrappers
+
+      # Expose private class methods.
+      # We will only expose the methods we are responsible for creating.
+      # (i.e. subtracting the superclass's private methods)
+      expose_private_methods(:class,
+        @class.private_methods - 
+        @class.superclass.private_methods)
+
+      # Expose private instance methods.
+      # We will only expose the methods we are responsible for creating.
+      # (i.e. subtracting the superclass's private methods)
+      expose_private_methods(:instance,
+        @class.private_instance_methods -
+        @class.superclass.private_instance_methods)
+
+      # Expose variables.
+      # Requires that variables are assigned to in the constructor.
+      wrap_output {
+        expose_variables(@class.class_variables +
+          @class.new([]).instance_variables)
+      }
+
+      # Indicate that this code has been run.
+      @@initialized = true
+    end
+  end
+
+  # Sets up functionality for all tests.
+  #
+  # Tracing is set up here so that it is only running during tests.
+  #
+  # If you want to disable tracing, simply override the setup method
+  # without calling super. (It would be good form to also override teardown).
+  def setup
+    set_trace_func proc { |event, file, line, id, binding, class_name|
+      if class_name == @class and
+          @stack_trace.last != {:class => class_name.name, :method => id}
+        @stack_trace  << {
+          :class => class_name.name,
+          :method => id,
+        }
+      end
+    }
+  end
+
+  # Clean up after each test.
+  #
+  # If you disable tracing, it would be good form to override this method
+  # as well without calling super.
+  def teardown
+    set_trace_func nil
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  ############################################################################
+  # Monkey patching methods for the class being tested.
+  ############################################################################
+
+  # Monkey patch the class's initializer to enable tracing
+  # with parameters and results.
+  def set_initializer
+    @class.class_eval do
+      attr_accessor :trace
+
+      alias :test_case_initialize :initialize
+      def initialize(*args)
+        @trace = []
+        result = test_case_initialize(*args)
+        return result
+      end
+    end
+  end
+
+  # Loop through the instance methods, calling set_instance_methods for each.
+  def set_instance_method_wrappers
+    [
+      :public_instance_methods,
+      :protected_instance_methods,
+      :private_instance_methods
+    ].each do |method_id|
+
+      scope = method_id.to_s.gsub(/_.*/, '')
+
+      set_instance_methods(@class.send(method_id) -
+        @class.superclass.send(method_id), scope)
+    end
+
+    # If this is not at the end, the loop will attempt to do it's thing
+    # with the constructor created in this method, which is not necessary.
+    set_initializer
+  end
+
+  # Loop through the list of methods that are passed in,
+  # creating a wrapper method that enables tracing.
+  #
+  # Tracing data includes method name, parameters, and result.
+  # ==== Input
+  # [method_list : Array] A list of methods that will have wrapping functions
+  #                       created to enable tracing.
+  # [scope : String] The scope of the original function.
+  def set_instance_methods(method_list, scope)
+    method_list.each do |method_id|
+      # Setters and methods that accept blocks do not appear to work.
+      next if method_id =~ /=/ or method_id =~ /wrap_output/
+
+      # Build the method.
+      new_method = <<-DOC
+        alias :test_case_#{method_id} :#{method_id}
+        def #{method_id}(*args)
+          result = test_case_#{method_id}(*args)
+          @trace << {
+            :method => '#{method_id}',
+            :args => args,
+            :result => result
+          }
+          return result
+        end
+        #{scope} :#{method_id}
+      DOC
+
+      # Add the method to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Expose the private methods that are passed in.  New methods will be created
+  # with the old method name followed by '_public_test'.  If the original
+  # method contained a '?', it will be removed in the new method.
+  # ==== Input
+  # [type : Symbol] Indicates whether to handle instance or class methods.
+  #
+  #                 Only :class and :instance are supported.
+  # [methods : Array] An array of the methods to expose.
+  def expose_private_methods(type, methods)
+    # Get the text that the method should be wrapped in.
+    method_wrapper = wrapper(type)
+
+    # Loop through the methods.
+    methods.each do |method|
+      # Remove ?s.
+      new_method = method.to_s.gsub(/\?/, '')
+
+      # This is the new method.
+      new_method = <<-DOC
+        def #{new_method}_public_test(*args)
+          #{method}(*args)
+        end
+      DOC
+
+      # Add the wrapping text.
+      new_method = method_wrapper % [new_method]
+
+      # Add the method to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Expose the variables.
+  #
+  # New methods will be created (a getter and a setter) for each variable.
+  #
+  # Regardless of the type of variable, these methods are only available
+  # via an instance.
+  # ==== Input
+  # [variables : Array] An array of variables to expose.
+  def expose_variables(variables)
+    # Get the text that the methods should be wrapped in.
+    var_wrapper = wrapper(:instance)
+
+    # Loop through the variables
+    variables.each do |var|
+      # Remove any @s.
+      new_method = var.to_s.gsub(/@/, '')
+
+      # These are the new getter and setters.
+      new_method = <<-DOC
+        def #{new_method}_variable_method
+          #{var}
+        end
+
+        def #{new_method}_variable_method=(value)
+          #{var} = value
+        end
+      DOC
+
+      # Add the wrapping text.
+      new_method = var_wrapper % [new_method]
+
+      # Add the methods to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Returns the wrapping text for the specified type of method.
+  # ==== Input
+  # [type : Symbol] Indicates whether to handle instance or class methods.
+  #
+  #                 Only :class & :instance are supported.
+  # ==== Output
+  # [String] The text that the specified type of method should be wrapped in.
+  def wrapper(type)
+    case type
+      when :class then 'class << self;%s;end'
+      when :instance then '%s'
+    end
+  end
+
+  ############################################################################
+  # I/O support methods.
+  ############################################################################
+
+  # Return the actual output to stdout and stderr.
+  # ==== Output
+  # [Array] Two element array of strings.
+  #
+  #         The first element is from stdout.
+  #
+  #         The second element is from stderr.
+  def real_finis
+    return out, err
+  end
+
+  # Wrap a block to capture the output to stdout and stderr.
+  # ==== Input
+  # [&block : Block] The block of code that will have stdout and stderr trapped.
+  def wrap_output(&block)
+    begin
+      $stdout = @out
+      $stderr = @err
+      yield
+    ensure
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+  end
+
+  # Returns the output from stdout as a string.
+  # ==== Output
+  # [String] The output from stdout.
+  #
+  #          All trailing line feeds are removed.
+  def out
+    @out.respond_to?(:string) ?  @out.string.gsub(/\n*\z/, '') : ''
+  end
+
+  # Returns the output from stderr as a string.
+  # ==== Output
+  # [String] The output from stderr.
+  #
+  #          All trailing line feeds are removed.
+  def err
+    @err.respond_to?(:string) ?  @err.string.gsub(/\n*\z/, '') : ''
+  end
+
+  # Reset the stdout and stderr stream variables.
+  def reset_io
+    @out = StringIO.new
+    @err = StringIO.new
+  end
+
+  ############################################################################
+  # Support methods.
+  ############################################################################
+
+  # Indicates whether the specified method has been called on a given class.
+  # ==== Input
+  # [method_name : String] The name of the method.
+  #
+  #                        This value may be a string or a symbol.
+  # [class_name : String : @class.name] The name of the class that the method
+  #                                     should have been invoked from.
+  def method_called?(method_name, class_name = @class.name)
+    !@stack_trace.index(
+      {:method => method_name.to_sym, :class => class_name}).nil?
+  end
+
+  # Resets the trace arrays.
+  #
+  # This is intended for use in cases where code may be called multiple
+  # times in a single test.
+  def reset_trace
+    @stack_trace = []
+    @obj.trace = [] if @obj.respond_to?(:trace=)
+  end
+
+  # Shows the trace history as it stands, if the object supports it.
+  def show_trace
+    return unless defined? @obj
+    puts @obj.trace.join("\n" + '-' * 80 + "\n") if @obj.respond_to?(:trace)
+  end
+
+  ############################################################################
+  # Assertions.
+  ############################################################################
+
+  # Asserts that a value is equal to false.
+  # ==== Input
+  # [value : Any] The value to check for equality against false.
+  # [message : String : nil] The message to display if the value is not false.
+  def assert_false(value, message = nil)
+    assert_equal false, value, message
+  end
+
+  # Asserts that a value is equal to true.
+  # ==== Input
+  # [value : Any] The value to check for equality against true.
+  # [message : String : nil] The message to display if the value is not true.
+  def assert_true(value, message = nil)
+    assert_equal true, value, message
+  end
+
+  # Asserts that the negation of a value is true.
+  # ==== Input
+  # [value : Any] The value which will be negated and then asserted.
+  # [message : String : nil] The message to display if the assertion fails.
+  def assert_not(value, message = nil)
+    assert !value, message
+  end
+
+  # Assert that an array has a specified number of elements.
+  # ==== Input
+  # [array : Array] The array that will have it's length checked.
+  # [length : Fixnum] The length that the array should be.
+  # [message : String : nil] The message to display if the assertion fails.
+  def assert_array_count(array, length, message = nil)
+    if message.nil?
+      message = "#{array} has #{array.length} item(s), " +
+        "but was expected to have #{length}."
+    end
+
+    assert array.length == length, message
+  end
+
+  ############################################################################
+  # Assertions - Stack trace.
+  ############################################################################
+
+  # Asserts that a method was called on a class.
+  # ==== Input
+  # [method_name : String] The name of the method to check for.
+  # [class_name : String : @class.name] The name of the class
+  #                                     on which <tt>method_name</tt>
+  #                                     should have been invoked.
+  def assert_method(method_name, class_name = @class.name)
+    assert method_called?(method_name.to_sym, class_name),
+      "#{class_name}.#{method_name} has not been called."
+  end
+
+  # Asserts that a method was not called on a class.
+  # ==== Input
+  # [method_name : String] The name of the method to check for.
+  # [class_name : String : @class.name] The name of the class
+  #                                     on which <tt>method_name</tt>
+  #                                     should not have been invoked.
+  def assert_not_method(method_name, class_name = @class.name)
+    assert !method_called?(method_name.to_sym, class_name),
+      "#{class_name}.#{method_name} should not be called."
+  end
+
+  # Asserts that a method was called with the specified parameters.
+  # ==== Input
+  # [method_name : String] The name of the method to check.
+  # [*args : Array] The parameters that were passed in to the method.
+  def assert_trace_args(method_name, *args)
+    match = false
+
+    list = []
+
+    # Loop through the stack trace to see if the method was called
+    # with the specified arguments.
+    @obj.trace.each do |trace|
+      if trace[:method] == method_name and trace[:args] == args
+        match = true
+        break
+      elsif trace[:method] == method_name
+        list << trace[:args]
+      end
+    end
+
+    assert match,
+      "#{method_name} was not called with the following parameters:\n" +
+      "#{args.join("\n" + '-' * 80 + "\n")}\n" +
+      '*' * 80 + "\n" +
+      "#{method_name} was recorded as follows:\n" +
+      "#{list.join("\n" + '-' * 80 + "\n")}"
+  end
+
+  # Asserts that a method was called with the specified parameters
+  # and returned the specified result.
+  # ==== Input
+  # [method_name : String] The name of the method to check.
+  # [result : Any] The expected result of the method call.
+  # [*args : Array] The parameters that were passed in to the method.
+  def assert_trace_info(method_name, result, *args)
+    match = (@obj.trace.index(
+      {:methd => method_name, :args => args, :result => result}))
+
+    list = []
+
+    # Only get a list of possible results if a match was not found.
+    unless match
+      @obj.trace.each do |trace|
+        if trace[:method] == method_name
+          list << {:args => trace[:args], :result => trace[:result]}
+        end
+      end
+    end
+
+    assert match,
+      "#{method_name} was not called with the following parameters:\n" +
+      "#{args}\n" +
+      "or did not return the following result:\n" +
+      "#{result}\n" +
+      "#{method_name} was recorded as follows:\n" +
+      "#{list.join("\n" + '-' * 80 + "\n")}"
+  end
+end

data/test/require.rb

@@ -0,0 +1,13 @@
+root_path = File.join(File.dirname(File.expand_path(__FILE__)), '..')
+root_path = File.expand_path(root_path)
+
+Bundler.require :test
+
+require 'test/unit'
+
+require_relative '../lib/execute_shell'
+
+file_list = Dir[File.join(root_path, 'test', 'lib', '*.rb')]
+file_list.each do |file|
+  require file
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: execute_shell
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Travis Herrick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: Platform
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: win32-open3-19
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :development
+  version_requirements: *id005
+description: 
+email: tthetoad@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/execute_shell/execute_shell.rb
+- lib/execute_shell/script_env.rb
+- lib/execute_shell.rb
+- Gemfile.lock
+- README
+- gemfile
+- rakefile
+- execute_shell.gemspec
+- test/require.rb
+- test/lib/test_case.rb
+- test/execute_shell_test.rb
+has_rdoc: true
+homepage: 
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Executes shell commands.
+test_files: 
+- test/require.rb
+- test/lib/test_case.rb
+- test/execute_shell_test.rb