mixlib-shellout 1.0.0-x86-mingw32 → 1.1.0-x86-mingw32

data/README.md

@@ -28,6 +28,14 @@ Run a command as the `www` user with no extra ENV settings from `/tmp`
       cmd = Mixlib::ShellOut.new("apachectl", "start", :user => 'www', :env => nil, :cwd => '/tmp')
       cmd.run_command # etc.
 
+## STDIN Example
+Invoke crontab to edit user cron:
+
+      # :input only supports simple strings
+      crontab_lines = [ "* * * * * /bin/true", "* * * * * touch /tmp/here" ]
+      crontab = Mixlib::ShellOut.new("crontab -l -u #{@new_resource.user}", :input => crontab_lines.join("\n"))
+      crontab.run_command
+
 ## Platform Support
 Mixlib::ShellOut does a standard fork/exec on Unix, and uses the Win32
 API on Windows. There is not currently support for JRuby.

data/lib/mixlib/shellout.rb

@@ -55,6 +55,11 @@ module Mixlib
     # the command's output will be echoed to STDOUT.
     attr_accessor :live_stream
 
+    # ShellOut will push data from :input down the stdin of the subprocss.
+    # Normally set via options passed to new.
+    # Default: nil
+    attr_accessor :input
+
     # If a logger is set, ShellOut will log a message before it executes the
     # command.
     attr_accessor :logger
@@ -140,6 +145,7 @@ module Mixlib
     def initialize(*command_args)
       @stdout, @stderr = '', ''
       @live_stream = nil
+      @input = nil
       @log_level = :debug
       @log_tag = nil
       @environment = DEFAULT_ENVIRONMENT
@@ -267,6 +273,8 @@ module Mixlib
           self.valid_exit_codes = Array(setting)
         when 'live_stream'
           self.live_stream = setting
+        when 'input'
+          self.input = setting
         when 'logger'
           self.logger = setting
         when 'log_level'

data/lib/mixlib/shellout/exceptions.rb

@@ -5,4 +5,3 @@ module Mixlib
     class InvalidCommandOption < RuntimeError; end
   end
 end
-

data/lib/mixlib/shellout/unix.rb

@@ -40,6 +40,8 @@ module Mixlib
         @result = nil
         @execution_time = 0
 
+        write_to_child_stdin
+
         # Ruby 1.8.7 and 1.8.6 from mid 2009 try to allocate objects during GC
         # when calling IO.select and IO#read. Some OS Vendors are not interested
         # in updating their ruby packages (Apple, *cough*) and we *have to*
@@ -114,10 +116,14 @@ module Mixlib
       end
 
       def initialize_ipc
-        @stdout_pipe, @stderr_pipe, @process_status_pipe = IO.pipe, IO.pipe, IO.pipe
+        @stdin_pipe, @stdout_pipe, @stderr_pipe, @process_status_pipe = IO.pipe, IO.pipe, IO.pipe, IO.pipe
         @process_status_pipe.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
       end
 
+      def child_stdin
+        @stdin_pipe[1]
+      end
+
       def child_stdout
         @stdout_pipe[0]
       end
@@ -131,23 +137,25 @@ module Mixlib
       end
 
       def close_all_pipes
+        child_stdin.close   unless child_stdin.closed?
         child_stdout.close  unless child_stdout.closed?
         child_stderr.close  unless child_stderr.closed?
         child_process_status.close unless child_process_status.closed?
       end
 
-      # replace stdout, and stderr with pipes to the parent, and close the
-      # reader side of the error marshaling side channel. Close STDIN so when we
-      # exec, the new program will know it's never getting input ever.
+      # Replace stdout, and stderr with pipes to the parent, and close the
+      # reader side of the error marshaling side channel.
+      #
+      # If there is no input, close STDIN so when we exec,
+      # the new program will know it's never getting input ever.
       def configure_subprocess_file_descriptors
         process_status_pipe.first.close
 
         # HACK: for some reason, just STDIN.close isn't good enough when running
         # under ruby 1.9.2, so make it good enough:
-        stdin_reader, stdin_writer = IO.pipe
-        stdin_writer.close
-        STDIN.reopen stdin_reader
-        stdin_reader.close
+        stdin_pipe.last.close
+        STDIN.reopen stdin_pipe.first
+        stdin_pipe.first.close unless input
 
         stdout_pipe.first.close
         STDOUT.reopen stdout_pipe.last
@@ -158,14 +166,18 @@ module Mixlib
         stderr_pipe.last.close
 
         STDOUT.sync = STDERR.sync = true
+        STDIN.sync = true if input
       end
 
       def configure_parent_process_file_descriptors
         # Close the sides of the pipes we don't care about
+        stdin_pipe.first.close
+        stdin_pipe.last.close unless input
         stdout_pipe.last.close
         stderr_pipe.last.close
         process_status_pipe.last.close
         # Get output as it happens rather than buffered
+        child_stdin.sync = true if input
         child_stdout.sync = true
         child_stderr.sync = true
 
@@ -178,6 +190,13 @@ module Mixlib
         @open_pipes ||= [child_stdout, child_stderr]
       end
 
+      # Keep this unbuffered for now
+      def write_to_child_stdin
+        return unless input
+        child_stdin << input
+        child_stdin.close # Kick things off
+      end
+
       def read_stdout_to_buffer
         while chunk = child_stdout.read_nonblock(READ_SIZE)
           @stdout << chunk

data/lib/mixlib/shellout/version.rb

@@ -1,5 +1,5 @@
 module Mixlib
   class ShellOut
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
   end
 end

data/lib/mixlib/shellout/windows.rb

@@ -1,7 +1,8 @@
 #--
 # Author:: Daniel DeLeo (<dan@opscode.com>)
 # Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Author:: Ho-Sheng Hsiao (<hosh@opscode.com>)
+# Copyright:: Copyright (c) 2011, 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,6 +23,8 @@ require 'windows/handle'
 require 'windows/process'
 require 'windows/synchronize'
 
+require 'mixlib/shellout/windows/core_ext'
+
 module Mixlib
   class ShellOut
     module Windows
@@ -50,7 +53,7 @@ module Mixlib
           #
           # Set cwd, environment, appname, etc.
           #
-          app_name, command_line = command_to_run
+          app_name, command_line = command_to_run(self.command)
           create_process_args = {
             :app_name => app_name,
             :command_line => command_line,
@@ -69,6 +72,11 @@ module Mixlib
           #
           process = Process.create(create_process_args)
           begin
+            # Start pushing data into input
+            stdin_write << input if input
+
+            # Close pipe to kick things off
+            stdin_write.close
 
             #
             # Wait for the process to finish, consuming output as we go
@@ -90,7 +98,7 @@ module Mixlib
               when WAIT_TIMEOUT
                 # Kill the process
                 if (Time.now - start_wait) > timeout
-                  raise Mixlib::ShellOut::Exceptions::CommandTimeout, "command timed out:\n#{format_for_exception}"
+                  raise Mixlib::ShellOut::CommandTimeout, "command timed out:\n#{format_for_exception}"
                 end
 
                 consume_output(open_streams, stdout_read, stderr_read)
@@ -154,33 +162,52 @@ module Mixlib
         return true
       end
 
-      IS_BATCH_FILE = /\.bat|\.cmd$/i
+      IS_BATCH_FILE = /\.bat"?$|\.cmd"?$/i
 
-      def command_to_run
-        if command =~ /^\s*"(.*)"/
-          # If we have quotes, do an exact match
-          candidate = $1
-        else
-          # Otherwise check everything up to the first space
-          candidate = command[0,command.index(/\s/) || command.length].strip
-        end
+      def command_to_run(command)
+        return _run_under_cmd(command) if Utils.should_run_under_cmd?(command)
+
+        candidate = candidate_executable_for_command(command)
 
         # Don't do searching for empty commands.  Let it fail when it runs.
-        if candidate.length == 0
-          return [ nil, command ]
-        end
+        return [ nil, command ] if candidate.length == 0
 
         # Check if the exe exists directly.  Otherwise, search PATH.
-        exe = find_exe_at_location(candidate)
-        if exe.nil? && exe !~ /[\\\/]/
-          exe = which(command[0,command.index(/\s/) || command.length])
-        end
+        exe = Utils.find_executable(candidate)
+        exe = Utils.which(unquoted_executable_path(command)) if exe.nil? && exe !~ /[\\\/]/
 
+        # Batch files MUST use cmd; and if we couldn't find the command we're looking for,
+        # we assume it must be a cmd builtin.
         if exe.nil? || exe =~ IS_BATCH_FILE
-          # Batch files MUST use cmd; and if we couldn't find the command we're looking for, we assume it must be a cmd builtin.
-          [ ENV['COMSPEC'], "cmd /c #{command}" ]
+          _run_under_cmd(command)
+        else
+          _run_directly(command, exe)
+        end
+      end
+
+
+      # cmd does not parse multiple quotes well unless the whole thing is wrapped up in quotes.
+      # https://github.com/opscode/mixlib-shellout/pull/2#issuecomment-4837859
+      # http://ss64.com/nt/syntax-esc.html
+      def _run_under_cmd(command)
+        [ ENV['COMSPEC'], "cmd /c \"#{command}\"" ]
+      end
+
+      def _run_directly(command, exe)
+        [ exe, command ]
+      end
+
+      def unquoted_executable_path(command)
+        command[0,command.index(/\s/) || command.length]
+      end
+
+      def candidate_executable_for_command(command)
+        if command =~ /^\s*"(.*?)"/
+          # If we have quotes, do an exact match
+          $1
         else
-          [ exe, command ]
+          # Otherwise check everything up to the first space
+          unquoted_executable_path(command).strip
         end
       end
 
@@ -200,389 +227,74 @@ module Mixlib
         result
       end
 
-      def pathext
-        @pathext ||= ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') + [''] : ['']
-      end
-
-      def which(cmd)
-        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-          exe = find_exe_at_location("#{path}/${cmd}")
-          return exe if exe
-        end
-        return nil
-      end
-
-      def find_exe_at_location(path)
-        return path if File.executable? path
-        pathext.each do |ext|
-          exe = "#{path}#{ext}"
-          return exe if File.executable? exe
+      module Utils
+        # api: semi-private
+        # If there are special characters parsable by cmd.exe (such as file redirection), then
+        # this method should return true.
+        #
+        # This parser is based on
+        # https://github.com/ruby/ruby/blob/9073db5cb1d3173aff62be5b48d00f0fb2890991/win32/win32.c#L1437
+        def self.should_run_under_cmd?(command)
+          return true if command =~ /^@/
+
+          quote = nil
+          env = false
+          env_first_char = false
+
+          command.dup.each_char do |c|
+            case c
+            when "'", '"'
+              if (!quote)
+                quote = c
+              elsif quote == c
+                quote = nil
+              end
+              next
+            when '>', '<', '|', '&', "\n"
+              return true unless quote
+            when '%'
+              return true if env
+              env = env_first_char = true
+              next
+            else
+              next unless env
+              if env_first_char
+                env_first_char = false
+                env = false and next if c !~ /[A-Za-z_]/
+              end
+              env = false if c !~ /[A-Za-z1-9_]/
+            end
+          end
+          return false
         end
-        return nil
-      end
-    end # class
-  end
-end
-
-#
-# Override module Windows::Process.CreateProcess to fix bug when
-# using both app_name and command_line
-#
-module Windows
-  module Process
-    API.new('CreateProcess', 'SPPPLLLPPP', 'B')
-  end
-end
-
-#
-# Override Win32::Process.create to take a proper environment hash
-# so that variables can contain semicolons
-# (submitted patch to owner)
-#
-module Process
-  def create(args)
-    unless args.kind_of?(Hash)
-      raise TypeError, 'Expecting hash-style keyword arguments'
-    end
-
-    valid_keys = %w/
-      app_name command_line inherit creation_flags cwd environment
-      startup_info thread_inherit process_inherit close_handles with_logon
-      domain password
-    /
-
-    valid_si_keys = %/
-      startf_flags desktop title x y x_size y_size x_count_chars
-      y_count_chars fill_attribute sw_flags stdin stdout stderr
-    /
-
-    # Set default values
-    hash = {
-      'app_name'       => nil,
-      'creation_flags' => 0,
-      'close_handles'  => true
-    }
-
-    # Validate the keys, and convert symbols and case to lowercase strings.
-    args.each{ |key, val|
-      key = key.to_s.downcase
-      unless valid_keys.include?(key)
-        raise ArgumentError, "invalid key '#{key}'"
-      end
-      hash[key] = val
-    }
 
-    si_hash = {}
-
-    # If the startup_info key is present, validate its subkeys
-    if hash['startup_info']
-      hash['startup_info'].each{ |key, val|
-        key = key.to_s.downcase
-        unless valid_si_keys.include?(key)
-          raise ArgumentError, "invalid startup_info key '#{key}'"
-        end
-        si_hash[key] = val
-      }
-    end
-
-    # The +command_line+ key is mandatory unless the +app_name+ key
-    # is specified.
-    unless hash['command_line']
-      if hash['app_name']
-        hash['command_line'] = hash['app_name']
-        hash['app_name'] = nil
-      else
-        raise ArgumentError, 'command_line or app_name must be specified'
-      end
-    end
-
-    # The environment string should be passed as an array of A=B paths, or
-    # as a string of ';' separated paths.
-    if hash['environment']
-      env = hash['environment']
-      if !env.respond_to?(:join)
-        # Backwards compat for ; separated paths
-        env = hash['environment'].split(File::PATH_SEPARATOR)
-      end
-      # The argument format is a series of null-terminated strings, with an additional null terminator.
-      env = env.map { |e| e + "\0" }.join("") + "\0"
-      if hash['with_logon']
-        env = env.multi_to_wide(e)
-      end
-      env = [env].pack('p*').unpack('L').first
-    else
-      env = nil
-    end
-
-    startinfo = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-    startinfo = startinfo.pack('LLLLLLLLLLLLSSLLLL')
-    procinfo  = [0,0,0,0].pack('LLLL')
-
-    # Process SECURITY_ATTRIBUTE structure
-    process_security = 0
-    if hash['process_inherit']
-      process_security = [0,0,0].pack('LLL')
-      process_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
-      process_security[8,4] = [1].pack('L')  # TRUE
-    end
-
-    # Thread SECURITY_ATTRIBUTE structure
-    thread_security = 0
-    if hash['thread_inherit']
-      thread_security = [0,0,0].pack('LLL')
-      thread_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
-      thread_security[8,4] = [1].pack('L')  # TRUE
-    end
-
-    # Automatically handle stdin, stdout and stderr as either IO objects
-    # or file descriptors.  This won't work for StringIO, however.
-    ['stdin', 'stdout', 'stderr'].each{ |io|
-      if si_hash[io]
-        if si_hash[io].respond_to?(:fileno)
-          handle = get_osfhandle(si_hash[io].fileno)
-        else
-          handle = get_osfhandle(si_hash[io])
+        def self.pathext
+          @pathext ||= ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') + [''] : ['']
         end
 
-        if handle == INVALID_HANDLE_VALUE
-          raise Error, get_last_error
+        # which() mimicks the Unix which command
+        # FIXME: it is not working
+        def self.which(cmd)
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exe = find_executable("#{path}/#{cmd}")
+            return exe if exe
+          end
+          return nil
         end
 
-        # Most implementations of Ruby on Windows create inheritable
-        # handles by default, but some do not. RF bug #26988.
-        bool = SetHandleInformation(
-          handle,
-          HANDLE_FLAG_INHERIT,
-          HANDLE_FLAG_INHERIT
-        )
+        # Windows has a different notion of what "executable" means
+        # The OS will search through valid the extensions and look
+        # for a binary there.
+        def self.find_executable(path)
+          return path if File.executable? path
 
-        raise Error, get_last_error unless bool
-
-        si_hash[io] = handle
-        si_hash['startf_flags'] ||= 0
-        si_hash['startf_flags'] |= STARTF_USESTDHANDLES
-        hash['inherit'] = true
+          pathext.each do |ext|
+            exe = "#{path}#{ext}"
+            return exe if File.executable? exe
+          end
+          return nil
+        end
       end
-    }
-
-    # The bytes not covered here are reserved (null)
-    unless si_hash.empty?
-      startinfo[0,4]  = [startinfo.size].pack('L')
-      startinfo[8,4]  = [si_hash['desktop']].pack('p*') if si_hash['desktop']
-      startinfo[12,4] = [si_hash['title']].pack('p*') if si_hash['title']
-      startinfo[16,4] = [si_hash['x']].pack('L') if si_hash['x']
-      startinfo[20,4] = [si_hash['y']].pack('L') if si_hash['y']
-      startinfo[24,4] = [si_hash['x_size']].pack('L') if si_hash['x_size']
-      startinfo[28,4] = [si_hash['y_size']].pack('L') if si_hash['y_size']
-      startinfo[32,4] = [si_hash['x_count_chars']].pack('L') if si_hash['x_count_chars']
-      startinfo[36,4] = [si_hash['y_count_chars']].pack('L') if si_hash['y_count_chars']
-      startinfo[40,4] = [si_hash['fill_attribute']].pack('L') if si_hash['fill_attribute']
-      startinfo[44,4] = [si_hash['startf_flags']].pack('L') if si_hash['startf_flags']
-      startinfo[48,2] = [si_hash['sw_flags']].pack('S') if si_hash['sw_flags']
-      startinfo[56,4] = [si_hash['stdin']].pack('L') if si_hash['stdin']
-      startinfo[60,4] = [si_hash['stdout']].pack('L') if si_hash['stdout']
-      startinfo[64,4] = [si_hash['stderr']].pack('L') if si_hash['stderr']
-    end
-
-    if hash['with_logon']
-      logon  = multi_to_wide(hash['with_logon'])
-      domain = multi_to_wide(hash['domain'])
-      app    = hash['app_name'].nil? ? nil : multi_to_wide(hash['app_name'])
-      cmd    = hash['command_line'].nil? ? nil : multi_to_wide(hash['command_line'])
-      cwd    = multi_to_wide(hash['cwd'])
-      passwd = multi_to_wide(hash['password'])
-
-      hash['creation_flags'] |= CREATE_UNICODE_ENVIRONMENT
-
-      process_ran = CreateProcessWithLogonW(
-        logon,                  # User
-        domain,                 # Domain
-        passwd,                 # Password
-        LOGON_WITH_PROFILE,     # Logon flags
-        app,                    # App name
-        cmd,                    # Command line
-        hash['creation_flags'], # Creation flags
-        env,                    # Environment
-        cwd,                    # Working directory
-        startinfo,              # Startup Info
-        procinfo                # Process Info
-      )
-    else
-      process_ran = CreateProcess(
-        hash['app_name'],       # App name
-        hash['command_line'],   # Command line
-        process_security,       # Process attributes
-        thread_security,        # Thread attributes
-        hash['inherit'],        # Inherit handles?
-        hash['creation_flags'], # Creation flags
-        env,                    # Environment
-        hash['cwd'],            # Working directory
-        startinfo,              # Startup Info
-        procinfo                # Process Info
-      )
-    end
-
-    # TODO: Close stdin, stdout and stderr handles in the si_hash unless
-    # they're pointing to one of the standard handles already. [Maybe]
-    if !process_ran
-      raise_last_error("CreateProcess()")
-    end
-
-    # Automatically close the process and thread handles in the
-    # PROCESS_INFORMATION struct unless explicitly told not to.
-    if hash['close_handles']
-      CloseHandle(procinfo[0,4].unpack('L').first)
-      CloseHandle(procinfo[4,4].unpack('L').first)
-    end
-
-    ProcessInfo.new(
-      procinfo[0,4].unpack('L').first, # hProcess
-      procinfo[4,4].unpack('L').first, # hThread
-      procinfo[8,4].unpack('L').first, # hProcessId
-      procinfo[12,4].unpack('L').first # hThreadId
-    )
-  end
-
-  def self.raise_last_error(operation)
-    error_string = "#{operation} failed: #{get_last_error}"
-    last_error_code = GetLastError()
-    if ERROR_CODE_MAP.has_key?(last_error_code)
-      raise ERROR_CODE_MAP[last_error_code], error_string
-    else
-      raise Error, error_string
-    end
+    end # class
   end
-
-  # List from ruby/win32/win32.c
-  ERROR_CODE_MAP = {
-    ERROR_INVALID_FUNCTION => Errno::EINVAL,
-    ERROR_FILE_NOT_FOUND => Errno::ENOENT,
-    ERROR_PATH_NOT_FOUND => Errno::ENOENT,
-    ERROR_TOO_MANY_OPEN_FILES => Errno::EMFILE,
-    ERROR_ACCESS_DENIED => Errno::EACCES,
-    ERROR_INVALID_HANDLE => Errno::EBADF,
-    ERROR_ARENA_TRASHED => Errno::ENOMEM,
-    ERROR_NOT_ENOUGH_MEMORY => Errno::ENOMEM,
-    ERROR_INVALID_BLOCK => Errno::ENOMEM,
-    ERROR_BAD_ENVIRONMENT => Errno::E2BIG,
-    ERROR_BAD_FORMAT => Errno::ENOEXEC,
-    ERROR_INVALID_ACCESS => Errno::EINVAL,
-    ERROR_INVALID_DATA => Errno::EINVAL,
-    ERROR_INVALID_DRIVE => Errno::ENOENT,
-    ERROR_CURRENT_DIRECTORY => Errno::EACCES,
-    ERROR_NOT_SAME_DEVICE => Errno::EXDEV,
-    ERROR_NO_MORE_FILES => Errno::ENOENT,
-    ERROR_WRITE_PROTECT => Errno::EROFS,
-    ERROR_BAD_UNIT => Errno::ENODEV,
-    ERROR_NOT_READY => Errno::ENXIO,
-    ERROR_BAD_COMMAND => Errno::EACCES,
-    ERROR_CRC => Errno::EACCES,
-    ERROR_BAD_LENGTH => Errno::EACCES,
-    ERROR_SEEK => Errno::EIO,
-    ERROR_NOT_DOS_DISK => Errno::EACCES,
-    ERROR_SECTOR_NOT_FOUND => Errno::EACCES,
-    ERROR_OUT_OF_PAPER => Errno::EACCES,
-    ERROR_WRITE_FAULT => Errno::EIO,
-    ERROR_READ_FAULT => Errno::EIO,
-    ERROR_GEN_FAILURE => Errno::EACCES,
-    ERROR_LOCK_VIOLATION => Errno::EACCES,
-    ERROR_SHARING_VIOLATION => Errno::EACCES,
-    ERROR_WRONG_DISK => Errno::EACCES,
-    ERROR_SHARING_BUFFER_EXCEEDED => Errno::EACCES,
-#    ERROR_BAD_NETPATH => Errno::ENOENT,
-#    ERROR_NETWORK_ACCESS_DENIED => Errno::EACCES,
-#    ERROR_BAD_NET_NAME => Errno::ENOENT,
-    ERROR_FILE_EXISTS => Errno::EEXIST,
-    ERROR_CANNOT_MAKE => Errno::EACCES,
-    ERROR_FAIL_I24 => Errno::EACCES,
-    ERROR_INVALID_PARAMETER => Errno::EINVAL,
-    ERROR_NO_PROC_SLOTS => Errno::EAGAIN,
-    ERROR_DRIVE_LOCKED => Errno::EACCES,
-    ERROR_BROKEN_PIPE => Errno::EPIPE,
-    ERROR_DISK_FULL => Errno::ENOSPC,
-    ERROR_INVALID_TARGET_HANDLE => Errno::EBADF,
-    ERROR_INVALID_HANDLE => Errno::EINVAL,
-    ERROR_WAIT_NO_CHILDREN => Errno::ECHILD,
-    ERROR_CHILD_NOT_COMPLETE => Errno::ECHILD,
-    ERROR_DIRECT_ACCESS_HANDLE => Errno::EBADF,
-    ERROR_NEGATIVE_SEEK => Errno::EINVAL,
-    ERROR_SEEK_ON_DEVICE => Errno::EACCES,
-    ERROR_DIR_NOT_EMPTY => Errno::ENOTEMPTY,
-#    ERROR_DIRECTORY => Errno::ENOTDIR,
-    ERROR_NOT_LOCKED => Errno::EACCES,
-    ERROR_BAD_PATHNAME => Errno::ENOENT,
-    ERROR_MAX_THRDS_REACHED => Errno::EAGAIN,
-#    ERROR_LOCK_FAILED => Errno::EACCES,
-    ERROR_ALREADY_EXISTS => Errno::EEXIST,
-    ERROR_INVALID_STARTING_CODESEG => Errno::ENOEXEC,
-    ERROR_INVALID_STACKSEG => Errno::ENOEXEC,
-    ERROR_INVALID_MODULETYPE => Errno::ENOEXEC,
-    ERROR_INVALID_EXE_SIGNATURE => Errno::ENOEXEC,
-    ERROR_EXE_MARKED_INVALID => Errno::ENOEXEC,
-    ERROR_BAD_EXE_FORMAT => Errno::ENOEXEC,
-    ERROR_ITERATED_DATA_EXCEEDS_64k => Errno::ENOEXEC,
-    ERROR_INVALID_MINALLOCSIZE => Errno::ENOEXEC,
-    ERROR_DYNLINK_FROM_INVALID_RING => Errno::ENOEXEC,
-    ERROR_IOPL_NOT_ENABLED => Errno::ENOEXEC,
-    ERROR_INVALID_SEGDPL => Errno::ENOEXEC,
-    ERROR_AUTODATASEG_EXCEEDS_64k => Errno::ENOEXEC,
-    ERROR_RING2SEG_MUST_BE_MOVABLE => Errno::ENOEXEC,
-    ERROR_RELOC_CHAIN_XEEDS_SEGLIM => Errno::ENOEXEC,
-    ERROR_INFLOOP_IN_RELOC_CHAIN => Errno::ENOEXEC,
-    ERROR_FILENAME_EXCED_RANGE => Errno::ENOENT,
-    ERROR_NESTING_NOT_ALLOWED => Errno::EAGAIN,
-#    ERROR_PIPE_LOCAL => Errno::EPIPE,
-    ERROR_BAD_PIPE => Errno::EPIPE,
-    ERROR_PIPE_BUSY => Errno::EAGAIN,
-    ERROR_NO_DATA => Errno::EPIPE,
-    ERROR_PIPE_NOT_CONNECTED => Errno::EPIPE,
-    ERROR_OPERATION_ABORTED => Errno::EINTR,
-#    ERROR_NOT_ENOUGH_QUOTA => Errno::ENOMEM,
-    ERROR_MOD_NOT_FOUND => Errno::ENOENT,
-    WSAEINTR => Errno::EINTR,
-    WSAEBADF => Errno::EBADF,
-#    WSAEACCES => Errno::EACCES,
-    WSAEFAULT => Errno::EFAULT,
-    WSAEINVAL => Errno::EINVAL,
-    WSAEMFILE => Errno::EMFILE,
-    WSAEWOULDBLOCK => Errno::EWOULDBLOCK,
-    WSAEINPROGRESS => Errno::EINPROGRESS,
-    WSAEALREADY => Errno::EALREADY,
-    WSAENOTSOCK => Errno::ENOTSOCK,
-    WSAEDESTADDRREQ => Errno::EDESTADDRREQ,
-    WSAEMSGSIZE => Errno::EMSGSIZE,
-    WSAEPROTOTYPE => Errno::EPROTOTYPE,
-    WSAENOPROTOOPT => Errno::ENOPROTOOPT,
-    WSAEPROTONOSUPPORT => Errno::EPROTONOSUPPORT,
-    WSAESOCKTNOSUPPORT => Errno::ESOCKTNOSUPPORT,
-    WSAEOPNOTSUPP => Errno::EOPNOTSUPP,
-    WSAEPFNOSUPPORT => Errno::EPFNOSUPPORT,
-    WSAEAFNOSUPPORT => Errno::EAFNOSUPPORT,
-    WSAEADDRINUSE => Errno::EADDRINUSE,
-    WSAEADDRNOTAVAIL => Errno::EADDRNOTAVAIL,
-    WSAENETDOWN => Errno::ENETDOWN,
-    WSAENETUNREACH => Errno::ENETUNREACH,
-    WSAENETRESET => Errno::ENETRESET,
-    WSAECONNABORTED => Errno::ECONNABORTED,
-    WSAECONNRESET => Errno::ECONNRESET,
-    WSAENOBUFS => Errno::ENOBUFS,
-    WSAEISCONN => Errno::EISCONN,
-    WSAENOTCONN => Errno::ENOTCONN,
-    WSAESHUTDOWN => Errno::ESHUTDOWN,
-    WSAETOOMANYREFS => Errno::ETOOMANYREFS,
-#    WSAETIMEDOUT => Errno::ETIMEDOUT,
-    WSAECONNREFUSED => Errno::ECONNREFUSED,
-    WSAELOOP => Errno::ELOOP,
-    WSAENAMETOOLONG => Errno::ENAMETOOLONG,
-    WSAEHOSTDOWN => Errno::EHOSTDOWN,
-    WSAEHOSTUNREACH => Errno::EHOSTUNREACH,
-#    WSAEPROCLIM => Errno::EPROCLIM,
-#    WSAENOTEMPTY => Errno::ENOTEMPTY,
-    WSAEUSERS => Errno::EUSERS,
-    WSAEDQUOT => Errno::EDQUOT,
-    WSAESTALE => Errno::ESTALE,
-    WSAEREMOTE => Errno::EREMOTE
-  }
-
-  module_function :create
 end

data/lib/mixlib/shellout/windows/core_ext.rb

@@ -0,0 +1,385 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2011, 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'win32/process'
+require 'windows/handle'
+require 'windows/process'
+require 'windows/synchronize'
+
+# Override module Windows::Process.CreateProcess to fix bug when
+# using both app_name and command_line
+#
+module Windows
+  module Process
+    API.new('CreateProcess', 'SPPPLLLPPP', 'B')
+  end
+end
+
+#
+# Override Win32::Process.create to take a proper environment hash
+# so that variables can contain semicolons
+# (submitted patch to owner)
+#
+module Process
+  def create(args)
+    unless args.kind_of?(Hash)
+      raise TypeError, 'Expecting hash-style keyword arguments'
+    end
+
+    valid_keys = %w/
+      app_name command_line inherit creation_flags cwd environment
+      startup_info thread_inherit process_inherit close_handles with_logon
+      domain password
+    /
+
+    valid_si_keys = %/
+      startf_flags desktop title x y x_size y_size x_count_chars
+      y_count_chars fill_attribute sw_flags stdin stdout stderr
+    /
+
+    # Set default values
+    hash = {
+      'app_name'       => nil,
+      'creation_flags' => 0,
+      'close_handles'  => true
+    }
+
+    # Validate the keys, and convert symbols and case to lowercase strings.
+    args.each{ |key, val|
+      key = key.to_s.downcase
+      unless valid_keys.include?(key)
+        raise ArgumentError, "invalid key '#{key}'"
+      end
+      hash[key] = val
+    }
+
+    si_hash = {}
+
+    # If the startup_info key is present, validate its subkeys
+    if hash['startup_info']
+      hash['startup_info'].each{ |key, val|
+        key = key.to_s.downcase
+        unless valid_si_keys.include?(key)
+          raise ArgumentError, "invalid startup_info key '#{key}'"
+        end
+        si_hash[key] = val
+      }
+    end
+
+    # The +command_line+ key is mandatory unless the +app_name+ key
+    # is specified.
+    unless hash['command_line']
+      if hash['app_name']
+        hash['command_line'] = hash['app_name']
+        hash['app_name'] = nil
+      else
+        raise ArgumentError, 'command_line or app_name must be specified'
+      end
+    end
+
+    # The environment string should be passed as an array of A=B paths, or
+    # as a string of ';' separated paths.
+    if hash['environment']
+      env = hash['environment']
+      if !env.respond_to?(:join)
+        # Backwards compat for ; separated paths
+        env = hash['environment'].split(File::PATH_SEPARATOR)
+      end
+      # The argument format is a series of null-terminated strings, with an additional null terminator.
+      env = env.map { |e| e + "\0" }.join("") + "\0"
+      if hash['with_logon']
+        env = env.multi_to_wide(e)
+      end
+      env = [env].pack('p*').unpack('L').first
+    else
+      env = nil
+    end
+
+    startinfo = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+    startinfo = startinfo.pack('LLLLLLLLLLLLSSLLLL')
+    procinfo  = [0,0,0,0].pack('LLLL')
+
+    # Process SECURITY_ATTRIBUTE structure
+    process_security = 0
+    if hash['process_inherit']
+      process_security = [0,0,0].pack('LLL')
+      process_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
+      process_security[8,4] = [1].pack('L')  # TRUE
+    end
+
+    # Thread SECURITY_ATTRIBUTE structure
+    thread_security = 0
+    if hash['thread_inherit']
+      thread_security = [0,0,0].pack('LLL')
+      thread_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
+      thread_security[8,4] = [1].pack('L')  # TRUE
+    end
+
+    # Automatically handle stdin, stdout and stderr as either IO objects
+    # or file descriptors.  This won't work for StringIO, however.
+    ['stdin', 'stdout', 'stderr'].each{ |io|
+      if si_hash[io]
+        if si_hash[io].respond_to?(:fileno)
+          handle = get_osfhandle(si_hash[io].fileno)
+        else
+          handle = get_osfhandle(si_hash[io])
+        end
+
+        if handle == INVALID_HANDLE_VALUE
+          raise Error, get_last_error
+        end
+
+        # Most implementations of Ruby on Windows create inheritable
+        # handles by default, but some do not. RF bug #26988.
+        bool = SetHandleInformation(
+          handle,
+          HANDLE_FLAG_INHERIT,
+          HANDLE_FLAG_INHERIT
+        )
+
+        raise Error, get_last_error unless bool
+
+        si_hash[io] = handle
+        si_hash['startf_flags'] ||= 0
+        si_hash['startf_flags'] |= STARTF_USESTDHANDLES
+        hash['inherit'] = true
+      end
+    }
+
+    # The bytes not covered here are reserved (null)
+    unless si_hash.empty?
+      startinfo[0,4]  = [startinfo.size].pack('L')
+      startinfo[8,4]  = [si_hash['desktop']].pack('p*') if si_hash['desktop']
+      startinfo[12,4] = [si_hash['title']].pack('p*') if si_hash['title']
+      startinfo[16,4] = [si_hash['x']].pack('L') if si_hash['x']
+      startinfo[20,4] = [si_hash['y']].pack('L') if si_hash['y']
+      startinfo[24,4] = [si_hash['x_size']].pack('L') if si_hash['x_size']
+      startinfo[28,4] = [si_hash['y_size']].pack('L') if si_hash['y_size']
+      startinfo[32,4] = [si_hash['x_count_chars']].pack('L') if si_hash['x_count_chars']
+      startinfo[36,4] = [si_hash['y_count_chars']].pack('L') if si_hash['y_count_chars']
+      startinfo[40,4] = [si_hash['fill_attribute']].pack('L') if si_hash['fill_attribute']
+      startinfo[44,4] = [si_hash['startf_flags']].pack('L') if si_hash['startf_flags']
+      startinfo[48,2] = [si_hash['sw_flags']].pack('S') if si_hash['sw_flags']
+      startinfo[56,4] = [si_hash['stdin']].pack('L') if si_hash['stdin']
+      startinfo[60,4] = [si_hash['stdout']].pack('L') if si_hash['stdout']
+      startinfo[64,4] = [si_hash['stderr']].pack('L') if si_hash['stderr']
+    end
+
+    if hash['with_logon']
+      logon  = multi_to_wide(hash['with_logon'])
+      domain = multi_to_wide(hash['domain'])
+      app    = hash['app_name'].nil? ? nil : multi_to_wide(hash['app_name'])
+      cmd    = hash['command_line'].nil? ? nil : multi_to_wide(hash['command_line'])
+      cwd    = multi_to_wide(hash['cwd'])
+      passwd = multi_to_wide(hash['password'])
+
+      hash['creation_flags'] |= CREATE_UNICODE_ENVIRONMENT
+
+      process_ran = CreateProcessWithLogonW(
+        logon,                  # User
+        domain,                 # Domain
+        passwd,                 # Password
+        LOGON_WITH_PROFILE,     # Logon flags
+        app,                    # App name
+        cmd,                    # Command line
+        hash['creation_flags'], # Creation flags
+        env,                    # Environment
+        cwd,                    # Working directory
+        startinfo,              # Startup Info
+        procinfo                # Process Info
+      )
+    else
+      process_ran = CreateProcess(
+        hash['app_name'],       # App name
+        hash['command_line'],   # Command line
+        process_security,       # Process attributes
+        thread_security,        # Thread attributes
+        hash['inherit'],        # Inherit handles?
+        hash['creation_flags'], # Creation flags
+        env,                    # Environment
+        hash['cwd'],            # Working directory
+        startinfo,              # Startup Info
+        procinfo                # Process Info
+      )
+    end
+
+    # TODO: Close stdin, stdout and stderr handles in the si_hash unless
+    # they're pointing to one of the standard handles already. [Maybe]
+    if !process_ran
+      raise_last_error("CreateProcess()")
+    end
+
+    # Automatically close the process and thread handles in the
+    # PROCESS_INFORMATION struct unless explicitly told not to.
+    if hash['close_handles']
+      CloseHandle(procinfo[0,4].unpack('L').first)
+      CloseHandle(procinfo[4,4].unpack('L').first)
+    end
+
+    ProcessInfo.new(
+      procinfo[0,4].unpack('L').first, # hProcess
+      procinfo[4,4].unpack('L').first, # hThread
+      procinfo[8,4].unpack('L').first, # hProcessId
+      procinfo[12,4].unpack('L').first # hThreadId
+    )
+  end
+
+  def self.raise_last_error(operation)
+    error_string = "#{operation} failed: #{get_last_error}"
+    last_error_code = GetLastError()
+    if ERROR_CODE_MAP.has_key?(last_error_code)
+      raise ERROR_CODE_MAP[last_error_code], error_string
+    else
+      raise Error, error_string
+    end
+  end
+
+  # List from ruby/win32/win32.c
+  ERROR_CODE_MAP = {
+    ERROR_INVALID_FUNCTION => Errno::EINVAL,
+    ERROR_FILE_NOT_FOUND => Errno::ENOENT,
+    ERROR_PATH_NOT_FOUND => Errno::ENOENT,
+    ERROR_TOO_MANY_OPEN_FILES => Errno::EMFILE,
+    ERROR_ACCESS_DENIED => Errno::EACCES,
+    ERROR_INVALID_HANDLE => Errno::EBADF,
+    ERROR_ARENA_TRASHED => Errno::ENOMEM,
+    ERROR_NOT_ENOUGH_MEMORY => Errno::ENOMEM,
+    ERROR_INVALID_BLOCK => Errno::ENOMEM,
+    ERROR_BAD_ENVIRONMENT => Errno::E2BIG,
+    ERROR_BAD_FORMAT => Errno::ENOEXEC,
+    ERROR_INVALID_ACCESS => Errno::EINVAL,
+    ERROR_INVALID_DATA => Errno::EINVAL,
+    ERROR_INVALID_DRIVE => Errno::ENOENT,
+    ERROR_CURRENT_DIRECTORY => Errno::EACCES,
+    ERROR_NOT_SAME_DEVICE => Errno::EXDEV,
+    ERROR_NO_MORE_FILES => Errno::ENOENT,
+    ERROR_WRITE_PROTECT => Errno::EROFS,
+    ERROR_BAD_UNIT => Errno::ENODEV,
+    ERROR_NOT_READY => Errno::ENXIO,
+    ERROR_BAD_COMMAND => Errno::EACCES,
+    ERROR_CRC => Errno::EACCES,
+    ERROR_BAD_LENGTH => Errno::EACCES,
+    ERROR_SEEK => Errno::EIO,
+    ERROR_NOT_DOS_DISK => Errno::EACCES,
+    ERROR_SECTOR_NOT_FOUND => Errno::EACCES,
+    ERROR_OUT_OF_PAPER => Errno::EACCES,
+    ERROR_WRITE_FAULT => Errno::EIO,
+    ERROR_READ_FAULT => Errno::EIO,
+    ERROR_GEN_FAILURE => Errno::EACCES,
+    ERROR_LOCK_VIOLATION => Errno::EACCES,
+    ERROR_SHARING_VIOLATION => Errno::EACCES,
+    ERROR_WRONG_DISK => Errno::EACCES,
+    ERROR_SHARING_BUFFER_EXCEEDED => Errno::EACCES,
+#    ERROR_BAD_NETPATH => Errno::ENOENT,
+#    ERROR_NETWORK_ACCESS_DENIED => Errno::EACCES,
+#    ERROR_BAD_NET_NAME => Errno::ENOENT,
+    ERROR_FILE_EXISTS => Errno::EEXIST,
+    ERROR_CANNOT_MAKE => Errno::EACCES,
+    ERROR_FAIL_I24 => Errno::EACCES,
+    ERROR_INVALID_PARAMETER => Errno::EINVAL,
+    ERROR_NO_PROC_SLOTS => Errno::EAGAIN,
+    ERROR_DRIVE_LOCKED => Errno::EACCES,
+    ERROR_BROKEN_PIPE => Errno::EPIPE,
+    ERROR_DISK_FULL => Errno::ENOSPC,
+    ERROR_INVALID_TARGET_HANDLE => Errno::EBADF,
+    ERROR_INVALID_HANDLE => Errno::EINVAL,
+    ERROR_WAIT_NO_CHILDREN => Errno::ECHILD,
+    ERROR_CHILD_NOT_COMPLETE => Errno::ECHILD,
+    ERROR_DIRECT_ACCESS_HANDLE => Errno::EBADF,
+    ERROR_NEGATIVE_SEEK => Errno::EINVAL,
+    ERROR_SEEK_ON_DEVICE => Errno::EACCES,
+    ERROR_DIR_NOT_EMPTY => Errno::ENOTEMPTY,
+#    ERROR_DIRECTORY => Errno::ENOTDIR,
+    ERROR_NOT_LOCKED => Errno::EACCES,
+    ERROR_BAD_PATHNAME => Errno::ENOENT,
+    ERROR_MAX_THRDS_REACHED => Errno::EAGAIN,
+#    ERROR_LOCK_FAILED => Errno::EACCES,
+    ERROR_ALREADY_EXISTS => Errno::EEXIST,
+    ERROR_INVALID_STARTING_CODESEG => Errno::ENOEXEC,
+    ERROR_INVALID_STACKSEG => Errno::ENOEXEC,
+    ERROR_INVALID_MODULETYPE => Errno::ENOEXEC,
+    ERROR_INVALID_EXE_SIGNATURE => Errno::ENOEXEC,
+    ERROR_EXE_MARKED_INVALID => Errno::ENOEXEC,
+    ERROR_BAD_EXE_FORMAT => Errno::ENOEXEC,
+    ERROR_ITERATED_DATA_EXCEEDS_64k => Errno::ENOEXEC,
+    ERROR_INVALID_MINALLOCSIZE => Errno::ENOEXEC,
+    ERROR_DYNLINK_FROM_INVALID_RING => Errno::ENOEXEC,
+    ERROR_IOPL_NOT_ENABLED => Errno::ENOEXEC,
+    ERROR_INVALID_SEGDPL => Errno::ENOEXEC,
+    ERROR_AUTODATASEG_EXCEEDS_64k => Errno::ENOEXEC,
+    ERROR_RING2SEG_MUST_BE_MOVABLE => Errno::ENOEXEC,
+    ERROR_RELOC_CHAIN_XEEDS_SEGLIM => Errno::ENOEXEC,
+    ERROR_INFLOOP_IN_RELOC_CHAIN => Errno::ENOEXEC,
+    ERROR_FILENAME_EXCED_RANGE => Errno::ENOENT,
+    ERROR_NESTING_NOT_ALLOWED => Errno::EAGAIN,
+#    ERROR_PIPE_LOCAL => Errno::EPIPE,
+    ERROR_BAD_PIPE => Errno::EPIPE,
+    ERROR_PIPE_BUSY => Errno::EAGAIN,
+    ERROR_NO_DATA => Errno::EPIPE,
+    ERROR_PIPE_NOT_CONNECTED => Errno::EPIPE,
+    ERROR_OPERATION_ABORTED => Errno::EINTR,
+#    ERROR_NOT_ENOUGH_QUOTA => Errno::ENOMEM,
+    ERROR_MOD_NOT_FOUND => Errno::ENOENT,
+    WSAEINTR => Errno::EINTR,
+    WSAEBADF => Errno::EBADF,
+#    WSAEACCES => Errno::EACCES,
+    WSAEFAULT => Errno::EFAULT,
+    WSAEINVAL => Errno::EINVAL,
+    WSAEMFILE => Errno::EMFILE,
+    WSAEWOULDBLOCK => Errno::EWOULDBLOCK,
+    WSAEINPROGRESS => Errno::EINPROGRESS,
+    WSAEALREADY => Errno::EALREADY,
+    WSAENOTSOCK => Errno::ENOTSOCK,
+    WSAEDESTADDRREQ => Errno::EDESTADDRREQ,
+    WSAEMSGSIZE => Errno::EMSGSIZE,
+    WSAEPROTOTYPE => Errno::EPROTOTYPE,
+    WSAENOPROTOOPT => Errno::ENOPROTOOPT,
+    WSAEPROTONOSUPPORT => Errno::EPROTONOSUPPORT,
+    WSAESOCKTNOSUPPORT => Errno::ESOCKTNOSUPPORT,
+    WSAEOPNOTSUPP => Errno::EOPNOTSUPP,
+    WSAEPFNOSUPPORT => Errno::EPFNOSUPPORT,
+    WSAEAFNOSUPPORT => Errno::EAFNOSUPPORT,
+    WSAEADDRINUSE => Errno::EADDRINUSE,
+    WSAEADDRNOTAVAIL => Errno::EADDRNOTAVAIL,
+    WSAENETDOWN => Errno::ENETDOWN,
+    WSAENETUNREACH => Errno::ENETUNREACH,
+    WSAENETRESET => Errno::ENETRESET,
+    WSAECONNABORTED => Errno::ECONNABORTED,
+    WSAECONNRESET => Errno::ECONNRESET,
+    WSAENOBUFS => Errno::ENOBUFS,
+    WSAEISCONN => Errno::EISCONN,
+    WSAENOTCONN => Errno::ENOTCONN,
+    WSAESHUTDOWN => Errno::ESHUTDOWN,
+    WSAETOOMANYREFS => Errno::ETOOMANYREFS,
+#    WSAETIMEDOUT => Errno::ETIMEDOUT,
+    WSAECONNREFUSED => Errno::ECONNREFUSED,
+    WSAELOOP => Errno::ELOOP,
+    WSAENAMETOOLONG => Errno::ENAMETOOLONG,
+    WSAEHOSTDOWN => Errno::EHOSTDOWN,
+    WSAEHOSTUNREACH => Errno::EHOSTUNREACH,
+#    WSAEPROCLIM => Errno::EPROCLIM,
+#    WSAENOTEMPTY => Errno::ENOTEMPTY,
+    WSAEUSERS => Errno::EUSERS,
+    WSAEDQUOT => Errno::EDQUOT,
+    WSAESTALE => Errno::ESTALE,
+    WSAEREMOTE => Errno::EREMOTE
+  }
+
+  module_function :create
+end

metadata

@@ -1,82 +1,76 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mixlib-shellout
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 1.1.0
   prerelease: 
-  version: 1.0.0
 platform: x86-mingw32
-authors: 
+authors:
 - Opscode
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-02-28 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-08-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &11516480 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: win32-process
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *11516480
+- !ruby/object:Gem::Dependency
+  name: win32-process
+  requirement: &11586780 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.6.5
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *11586780
 description: Run external commands on Unix or Windows
 email: info@opscode.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
 - LICENSE
-files: 
+files:
 - LICENSE
 - README.md
+- lib/mixlib/shellout.rb
+- lib/mixlib/shellout/windows/core_ext.rb
 - lib/mixlib/shellout/exceptions.rb
-- lib/mixlib/shellout/unix.rb
 - lib/mixlib/shellout/version.rb
+- lib/mixlib/shellout/unix.rb
 - lib/mixlib/shellout/windows.rb
-- lib/mixlib/shellout.rb
 homepage: http://wiki.opscode.com/
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Run external commands on Unix or Windows
 test_files: []
-