execute_shell 0.0.4 → 0.0.5

data/Gemfile

@@ -6,7 +6,8 @@ end
 
 group :test do
   gem 'Platform',       '~> 0.4.0', :require => 'platform'
-  gem 'app_mode',       '~> 0.0.1'
   gem 'open4',          '~> 1.0.1'
   gem 'win32-open3-19', '~> 0.0.1', :require => 'open3'
+
+  gem 'app_mode', '~> 1.0.0'
 end

data/Gemfile.lock

@@ -2,10 +2,10 @@ GEM
   remote: http://rubygems.org/
   specs:
     Platform (0.4.0)
-    app_mode (0.0.1)
+    app_mode (1.0.1)
     open4 (1.0.1)
     rake (0.8.7)
-    rake_tasks (0.0.1)
+    rake_tasks (0.0.4)
       rake (~> 0.8.7)
     win32-open3-19 (0.0.1)
 
@@ -14,7 +14,7 @@ PLATFORMS
 
 DEPENDENCIES
   Platform (~> 0.4.0)
-  app_mode (~> 0.0.1)
+  app_mode (~> 1.0.0)
   open4 (~> 1.0.1)
   rake_tasks (~> 0.0.1)
   win32-open3-19 (~> 0.0.1)

data/README

@@ -1,6 +1,8 @@
 == Welcome to ExecuteShell
 
-ExecuteShell allows shell commands to be executed the same across all platforms.
+ExecuteShell provides cross-platform shell command execution.
+In other words, it lays the smack down like a hungry t-rex
+in the octagon with a pig.
 
 == Getting Started
 
@@ -8,19 +10,21 @@ ExecuteShell allows shell commands to be executed the same across all platforms.
 
     gem install execute_shell
 
-2. Require the gem in your gemfile:
+2. Require the gem in your Gemfile:
 
-    gem 'execute_shell', '~> 0.0.1'
+    gem 'execute_shell', '~> 0.0.5'
 
-3. Require the gem wherever you need shell commands:
+3. Require the gem wherever you need to use it:
 
     require 'execute_shell'
 
-4. Include the ExecuteShell module in your class or module:
+== Usage
+
+1. Include the ExecuteShell module in your class or module:
 
     include ExecuteShell
 
-5. Call a shell command:
+2. Call a shell command:
 
     success, output = shell('ls ~')
 

data/execute_shell.gemspec

@@ -1,16 +1,19 @@
 Gem::Specification.new do |s|
   s.name    = 'execute_shell'
-  s.version = '0.0.4'
+  s.version = '0.0.5'
 
   s.summary     = 'Cross-platform shell commands.'
-  s.description = 'Execute Shell provides ' +
-    'cross-platform shell command execution.'
+  s.description = %Q{
+ExecuteShell provides cross-platform shell command execution.
+In other words, it lays the smack down like a hungry t-rex
+in the octagon with a pig.
+}.strip
 
   s.author   = 'Travis Herrick'
   s.email    = 'tthetoad@gmail.com'
   s.homepage = 'http://www.bitbucket.org/ToadJamb/gems_execute_shell'
 
-  s.license = 'GPLV3'
+  s.license = 'GPLv3'
 
   s.extra_rdoc_files << 'README'
 
@@ -21,7 +24,7 @@ Gem::Specification.new do |s|
   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_dependency 'app_mode',       '~> 0.0.1'
+  s.add_dependency 'app_mode',       '~> 1.0.0'
 
   s.add_development_dependency 'rake_tasks', '~> 0.0.1'
 

data/lib/execute_shell.rb

@@ -1,6 +1,8 @@
+gem_name = File.basename(__FILE__, '.rb')
+
 require 'app_mode'
 require 'platform'
 require 'open4' if [:linux].include?(Platform::IMPL)
 require 'open3' if [:mingw].include?(Platform::IMPL)
 
-require_relative 'execute_shell/execute_shell'
+require_relative File.join(gem_name, gem_name)

data/lib/execute_shell/execute_shell.rb

@@ -35,7 +35,7 @@
 # Contains methods for returning output from console commands.
 module ExecuteShell
   # Indicates the mode that ExecuteShell is running in.
-  ExecuteShellMode = AppMode.new(:production)
+  ExecuteShellMode = StateManager.new(:production)
 
   # Returns output from a console command.
   # ==== Input

data/test/execute_shell_test.rb

@@ -34,6 +34,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'require')
 
 class ExecuteShellTest < Test::Unit::TestCase
   def setup
+    @class = ExecuteShell
     @obj = Object.new
     @obj.extend(@class)
 
@@ -72,7 +73,7 @@ class ExecuteShellTest < Test::Unit::TestCase
     assert output.index(@user),
       "'#{command}' does not appear to include " +
       "the current user's folder (#{@user})."
-    assert_true success, "#{command} was not successful"
+    assert success, "#{command} was not successful"
   end
 
   def test_stderr
@@ -99,7 +100,7 @@ class ExecuteShellTest < Test::Unit::TestCase
     assert_equal result, output if Platform::IMPL == :linux
 
     assert output.index(result)
-    assert_false success
+    assert !success
   end
 
   def test_grep

data/test/require.rb

@@ -2,12 +2,6 @@ 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

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Travis Herrick
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-07 00:00:00 -04:00
+date: 2011-08-10 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,10 +70,10 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
+        - 1
         - 0
         - 0
-        - 1
-        version: 0.0.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: *id004
@@ -92,7 +92,10 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id005
-description: Execute Shell provides cross-platform shell command execution.
+description: |-
+  ExecuteShell provides cross-platform shell command execution.
+  In other words, it lays the smack down like a hungry t-rex
+  in the octagon with a pig.
 email: tthetoad@gmail.com
 executables: []
 
@@ -109,12 +112,11 @@ files:
 - rakefile
 - execute_shell.gemspec
 - test/require.rb
-- test/lib/test_case.rb
 - test/execute_shell_test.rb
 has_rdoc: true
 homepage: http://www.bitbucket.org/ToadJamb/gems_execute_shell
 licenses: 
-- GPLV3
+- GPLv3
 post_install_message: 
 rdoc_options: []
 
@@ -125,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3169303462163591821
+      hash: -1239307810502746702
       segments: 
       - 0
       version: "0"
@@ -146,5 +148,4 @@ specification_version: 3
 summary: Cross-platform shell commands.
 test_files: 
 - test/require.rb
-- test/lib/test_case.rb
 - test/execute_shell_test.rb

data/test/lib/test_case.rb

@@ -1,502 +0,0 @@
-# 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