shexecutor 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 610b8828b18a5c04454d349966788f26997f6f12
+  data.tar.gz: f9e6d63577e7acd0fb79001863c6f67a4f901e0e
+SHA512:
+  metadata.gz: b91c99fd12ce80faaf82636b2bb4f4b055ca803674eb5f6298442d7d7bb5f6462719a42c085a3a273f66198c8d9e5ef14ce5ece0586dda73b96dc7f67c32216b
+  data.tar.gz: ce988ff050c5e011268683556073f43c8b2ff55d393052675a3e509d734d03cbea3a141818a18389d1ee070ec4579c48a3fb7ad6bd0077f2d0418580f694d2e7

data/.gitignore

@@ -0,0 +1,4 @@
+*swp
+coverage
+*gem
+doc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shexecutor.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    shexecutor (0.0.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (4.0.5)
+      columnize (= 0.9.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.2)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    simplecov-rcov (0.2.3)
+      simplecov (>= 0.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  byebug
+  rake
+  rspec
+  shexecutor!
+  simplecov
+  simplecov-rcov

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,102 @@
+# SHExecutor
+
+SHExecutor is a convenience wrapper for executing shell commands from with-in a ruby process. It is intended to be used for the simple execution of shell commands or scripts that are not expected to generate GBs of output or require feeding via stdin.
+
+## It supports:
+- blocking indefinitely, on exit you can get status, stdout and stderr
+- blocking with timeout, on exit you can get status, stdout, stderr, timeout exception (then output streams are not available)
+- non-blocking, then you get no output streams, but status of the forked process
+- replacement, then you get a replaced process and none of the above
+
+## It is intended to support (future release):
+- redirecting of stderr and stdout, separately, to file, with the option to overwrite or append
+
+## It does not support:
+- streaming input to stdin
+- large stdout and stderr outputs that require real-time reading from the pipes
+
+## For any executor:
+- you can ask status, which will tell you "not executed", current status (e.g. run or sleep) and "no longer executing"
+- you can ask result, which gives you nil unless the process is no longer executing, in which case you get status (e.g. pid, exit code, sigints.)
+
+For a full description of status, please see Process::Status
+
+This gem is sponsored by Hetzner (Pty) Ltd - http://hetzner.co.za
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shexecutor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shexecutor
+
+## Usage
+
+###Blocking
+
+```
+iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => "/bin/echo", :params => ["hello world"]})
+iut.execute
+iut.flush
+puts "After execution status is: #{iut.status}"
+# "no longer executing"
+puts "out: #{iut.stdout} err: #{iut.stderr}"
+puts "#{iut.result.pid} success? #{iut.result.success?} with code #{iut.result.exitstatus}"
+puts "For more see: #{iut.result.methods}"
+```
+
+###Blocking with timeout
+
+```
+iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => "/bin/sleep", :params => ["2"]})
+iut.execute
+# Timeout::Error gets raised and the spawned process is killed
+```
+
+###Non-blocking
+
+```
+iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => "/bin/sleep", :params => ["1"]})
+iut.execute
+puts "Status: #{iut.status}"
+# "run" or "sleep"
+sleep 2
+puts "Status: #{iut.status}"
+# "no longer executing"
+```
+
+###Replacing
+
+```
+iut = SHExecutor::Executor.new({:replace => true, :application_path => "/bin/echo", :params => ["Your process has been assimilated"]})
+iut.execute
+```
+
+###stdout and stderr
+
+```
+iut.flush
+```
+
+  Remember to call iut.flush in order to stream stdout and stderr to the Executor object.
+
+  Note: calling flush will block if execute was called non-blocking, so wait until the execute has finished to preserve non-blocking behaviour.
+
+  Please send feedback and comments to the author at:
+
+  Ernst van Graan <ernst.van.graan@hetzner.co.za>
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/executor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/shexecutor/version.rb

@@ -0,0 +1,3 @@
+module SHExecutor
+  VERSION = "0.0.6"
+end

data/lib/shexecutor.rb

@@ -0,0 +1,132 @@
+require "shexecutor/version"
+require 'open3'
+
+module SHExecutor
+  @@default_options = {
+    :timeout => -1,
+    :protect_against_injection => true,
+    :stdout_path => nil,
+    :strerr_path => nil,
+    :append_stdout_path => true,
+    :append_stderr_path => true,
+    :replace => false,
+    :wait_for_completion => false
+  }
+
+  def self.default_options
+    @@default_options
+  end
+
+  class Executor
+    attr_accessor :options
+    attr_accessor :stdout
+    attr_accessor :stderr
+    attr_accessor :result
+    attr_accessor :pid
+
+    def initialize(options = ::SHExecutor::default_options)
+      # set default options
+      @options = ::SHExecutor::default_options.dup
+
+      # then apply specified options
+      options.each do |key, value|
+        @options[key] = value
+      end
+
+      @options
+    end
+
+    def status
+      return "not executed" if @result.nil?
+      return @result.status if @result.alive?
+      return "no longer executing" if not @result.alive?
+    end
+
+    def result
+      return nil if status != "no longer executing"
+      @result.value
+    end
+
+    def validate
+      errors = []
+      if (!@options[:application_path].nil? and @options[:application_path].strip != "")
+        if (File.exists?(@options[:application_path]))
+          errors << "Application path not executable" if !File.executable?(@options[:application_path])
+	else
+          errors << "Application path not found"
+	end
+
+       errors << "Suspected injection vulnerability due to space in application_path. Turn off strict checking if you are sure" if @options[:application_path].include?(" ")
+
+      else
+        errors << "No application path provided" if (@options[:application_path].nil?) or (@options[:application_path].strip == "")
+      end
+
+      raise ArgumentError.new(errors.join(',')) if errors.count > 0
+    end
+
+    def execute
+      @pid = nil
+      @stdout = nil
+      @stderr = nil
+      if (@options[:replace] == true)
+        replace_process
+      else
+        if (@options[:wait_for_completion])
+          if (@options[:timeout] <= 0)
+            block_process
+          else
+            block_process_with_timeout
+          end
+        else
+          fork_process
+        end
+      end
+    end
+
+    # Warning! This method will block if you are not blocking!
+    # Check status? before calling this to see if the process has completed if you do not want to block
+    def flush
+      #store output for inspection
+      @stdout = @stdout_stream.gets(nil)
+      @stderr = @stderr_stream.gets(nil)
+    end
+
+    private
+
+    def replace_process
+      validate
+      @options[:params].nil? ? exec(@options[:application_path]) : exec(@options[:application_path], *@options[:params]) 
+    end
+
+    def block_process
+      validate
+      @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
+      @result.value
+    end
+
+    def block_process_with_timeout
+      validate
+      @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
+      begin
+        Timeout.timeout(@options[:timeout]) do
+          @result.value
+        end
+      rescue Timeout::Error => ex
+        Process.kill 9, @result.pid
+        raise ex
+      end
+    end
+
+    def fork_process
+      validate
+      @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
+    end
+  end
+end
+
+#def redirect_all_output_to_file file
+#   log = File.new(file, "w+")
+#   STDOUT.reopen log;  STDERR.reopen log
+#   STDOUT.sync = true
+#end

data/shexecutor.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shexecutor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shexecutor"
+  spec.version       = SHExecutor::VERSION
+  spec.authors       = ["Ernst van Graan"]
+  spec.email         = ["ernst.van.graan@hetzner.co.za"]
+  spec.summary       = %q{Execute shell commands easily and securely}
+  spec.description   = %q{Implements process replacement, forking, protection from shell injection, and a variety of output options}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-rcov'
+  spec.add_development_dependency 'byebug'
+end

data/spec/executor_spec.rb

@@ -0,0 +1,306 @@
+require 'spec_helper'
+require 'shexecutor.rb'
+require 'tempfile'
+require 'mocks/kernel.rb'
+require 'mocks/result.rb'
+
+describe 'Executor' do
+  before :all do
+    @executable_file = Tempfile.new("testingargumenterror")
+    File.chmod(0744, @executable_file.path)
+    `echo "ls" >> #{@executable_file.path}`
+  end
+
+  context 'when initialized with no options' do
+    it 'should set default options' do
+      @iut = SHExecutor::Executor.new
+    end
+  end
+
+  context 'when initialized with options' do
+    it 'should remember the options' do
+      iut_options = {
+        :timeout => -1,
+        :protect_against_injection=>true,
+        :stdout_path => '/log/testlog',
+        :strerr_path => '/log/testlog',
+        :append_stdout_path => false,
+        :append_stderr_path => false,
+        :replace => false,
+        :wait_for_completion => true
+      }
+      @iut = SHExecutor::Executor.new(iut_options)
+      expect(@iut.options).to eq(iut_options)
+    end
+  end
+
+  context 'when initialized with some but not all options' do
+    it 'should remember the options provided and default the rest' do
+      expected_options = ::SHExecutor::default_options
+      expected_options[:wait_for_completion] = false
+      iut_options = {
+        :wait_for_completion => false
+      }
+      @iut = SHExecutor::Executor.new(iut_options)
+      expect(@iut.options).to eq(expected_options)
+    end
+  end
+
+  context 'when initialized with one or more invalid options' do
+    it 'validate should raise an ArgumentError' do
+      iut = SHExecutor::Executor.new({:application_path => nil})
+      expect{
+        iut.validate
+      }.to raise_error(ArgumentError, "No application path provided")
+      iut = SHExecutor::Executor.new({:application_path => ""})
+      expect{
+        iut.validate
+      }.to raise_error(ArgumentError, "No application path provided")
+      iut = SHExecutor::Executor.new({:application_path => "/kjsdfhgjkgsjk"})
+      expect{
+        iut.validate
+      }.to raise_error(ArgumentError, "Application path not found")
+      f = Tempfile.new("testingargumenterror")
+      iut = SHExecutor::Executor.new({:application_path => f.path})
+      expect{
+        iut.validate
+      }.to raise_error(ArgumentError, "Application path not executable")
+    end
+  end
+
+  context 'when initialized with valid options' do
+    it 'validate should not raise an exception' do
+      iut = SHExecutor::Executor.new({:application_path => @executable_file.path})
+      iut.validate
+    end
+  end
+
+  context "when asked to execute" do
+    it 'should clear stderr and stdout before execution' do
+      test_command = "/bin/echo"
+      test_params = ["Hello"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
+      iut.stdout = "stdout before"
+      iut.stderr = "error before"
+      iut.execute
+      iut.flush
+      expect(iut.stderr).to be_nil
+      expect(iut.stdout).to eq("Hello\n")
+    end
+  end
+
+  context 'when asked to execute, replacing the current process' do
+    it 'should use exec with the command and parameters specified' do
+      test_command = "/bin/ls"
+      test_params = ["/tmp/"]
+      iut = SHExecutor::Executor.new({:replace => true, :application_path => test_command, :params => test_params})
+      iut.execute
+      expect(Kernel::last_command).to eq(test_command)
+      expect(Kernel::last_params).to eq(*test_params)
+    end
+
+    it 'should use exec with the command if no parameters are specified' do
+      test_command = "/bin/ls"
+      iut = SHExecutor::Executor.new({:replace => true, :application_path => test_command})
+      iut.execute
+      expect(Kernel::last_command).to eq(test_command)
+      expect(Kernel::last_params).to be_nil
+    end
+
+    it 'should validate' do
+      iut = SHExecutor::Executor.new({:replace => true})
+      expect{
+        iut.execute
+      }.to raise_error(ArgumentError, "No application path provided")
+    end
+
+    it 'should not replace if replace is not true' do
+      iut = SHExecutor::Executor.new({:application_path => "/bin/ls", :replace => false})
+      Kernel::last_command = "not executed"
+      iut.execute
+      expect(Kernel::last_command).to eq("not executed")
+
+      iut = SHExecutor::Executor.new({:application_path => "/bin/ls", :replace => 'blah ignore this'})
+      iut.execute
+      expect(Kernel::last_command).to eq("not executed")
+    end
+  end
+
+  context 'when not waiting for completion' do
+    it 'should execute the command without blocking' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      before = Time.now
+      iut.execute
+      after = Time.now
+      expect(after - before).to be < 0.2
+    end
+
+    it 'should validate' do
+      iut = SHExecutor::Executor.new({:wait_for_completion => false})
+      expect{
+        iut.execute
+      }.to raise_error(ArgumentError, "No application path provided")
+    end
+  end
+
+  context 'when asking for the status of the executor' do
+    it 'should return "not executed" if execute has not been called' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      expect(iut.status).to eq("not executed")
+    end
+
+    it 'should return the current process status if the process is executing' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      iut.execute
+      status = iut.status
+      puts "status: #{status}"
+      running = ((status == "run") or (status == "sleep"))
+      expect(running).to eq(true)
+    end
+
+    it 'should return "no longer executing" if the process has stopped for what-ever reason' do
+      test_command = "/bin/echo"
+      test_params = ["I ran"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      iut.execute
+      sleep 1
+      expect(iut.status).to eq("no longer executing")
+    end
+  end
+
+  context 'when asking for the result of execution' do
+    it 'should return nil if the process has not executed yet' do
+      test_command = "/bin/sleep"
+      test_params = ["1"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      expect(iut.result).to be_nil
+    end
+
+    it 'should return nil if the process is still executing' do
+      test_command = "/bin/sleep"
+      test_params = ["1"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      iut.execute
+      expect(iut.result).to be_nil
+    end
+
+    it 'should return a Process::Status object if the process has executed, but is no longer, for what-ever reason' do
+      test_command = "/bin/sleep"
+      test_params = ["1"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => test_command, :params => test_params})
+      iut.execute 
+      sleep 2
+      expect(iut.result.class).to eq(Process::Status)
+    end
+  end
+
+  context 'when asked to execute and block' do
+    it 'should raise a TimeoutException if a timeout is specified and the forked process does not exit before' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => test_command, :params => test_params})
+      before = Time.now
+      expect {
+        iut.execute
+      }.to raise_error(Timeout::Error, "execution expired")
+      after = Time.now
+      expect(after - before).to be < 2
+    end
+
+    it 'should kill the subprocess when a TimeoutException is raised' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => test_command, :params => test_params})
+      expect(Process).to receive(:kill)
+      expect {
+        iut.execute
+      }.to raise_error(Timeout::Error, "execution expired")
+    end
+
+    it 'should use Open3::popen3 with the command and parameters specified' do
+      test_command = "/bin/ls"
+      test_params = ["/tmp/"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
+      stdin = stdout = stderr = StringIO.new
+      expect(Open3).to receive(:popen3).with(test_command, *test_params).and_return([stdin, stdout, stderr, Result.new(true)])
+      iut.execute
+    end
+
+    it 'should use Open3::popen3 with the command' do
+      test_command = "/bin/ls"
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command})
+      stdin = stdout = stderr = StringIO.new
+      expect(Open3).to receive(:popen3).with(test_command).and_return([stdin, stdout, stderr, Result.new(true)])
+      iut.execute
+    end
+
+    it 'should block until completion' do
+      test_command = "/bin/sleep"
+      test_params = ["2"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
+      before = Time.now
+      iut.execute
+      after = Time.now
+      expect(after - before).to be > 2
+    end
+
+    it 'should validate' do
+      iut = SHExecutor::Executor.new({:wait_for_completion => true})
+      expect{
+        iut.execute
+      }.to raise_error(ArgumentError, "No application path provided")
+    end
+  end
+
+  context 'when asked to redirect stdout to a file appending' do
+    it 'should append stdout to the file specified, and create it if it does not exist'
+  end
+
+  context 'when asked to redirect stdout to a file overwriting' do
+    it 'should delete if exists and create the specified file, then append stdout to it'
+  end
+
+  context 'when asked to redirect stdout' do
+    it 'should raise an exception if one of the file operations fails'
+  end
+
+  context 'when asked to redirect stderr to a file appending' do
+    it 'should append stderr to the file specified, and create it if it does not exist'
+  end
+
+  context 'when asked to redirect stderr to a file overwriting' do
+    it 'should delete if exists and create the specified file, then append stderr to it'
+  end
+
+  context 'when asked to redirect stderr' do
+    it 'should raise an exception if one of the file operations fails'
+  end
+
+  context 'when asked to flush' do
+    it 'should flush to its buffer for stderr' do
+      test_command = "/bin/echo"
+      test_params = ["hello world"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
+      iut.execute
+      iut.flush
+      expect(iut.stdout).to eq("hello world\n")
+      expect(iut.stderr).to be_nil
+    end
+
+    it 'should flush to its buffer for stdout' do
+      test_command = "/bin/ls"
+      test_params = ["/tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0"]
+      iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
+      iut.execute
+      iut.flush
+      expect(iut.stdout).to be_nil
+      expect(iut.stderr).to eq("ls: /tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0: No such file or directory\n")
+    end
+  end
+end

data/spec/mocks/kernel.rb

@@ -0,0 +1,22 @@
+module Kernel
+  @@last_command = nil
+  @@last_params = nil
+
+  def exec(cmd, params = nil)
+    @@last_command = cmd
+    @@last_params = params
+    puts "Kernel::exec('#{cmd}', '#{params}')"
+  end
+
+  def last_command=(command)
+    @@last_command = command
+  end
+
+  def last_command
+    @@last_command
+  end
+
+  def last_params
+    @@last_params
+  end
+end

data/spec/mocks/result.rb

@@ -0,0 +1,7 @@
+class Result
+  attr_accessor :value
+
+  def initialize(value)
+    @value = value
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rspec'
+require 'rspec/mocks'
+require 'tempfile'
+require 'simplecov'
+require 'simplecov-rcov'
+require 'byebug'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'executor'))
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start do
+  add_filter "/spec/"
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: shexecutor
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Ernst van Graan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Implements process replacement, forking, protection from shell injection,
+  and a variety of output options
+email:
+- ernst.van.graan@hetzner.co.za
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shexecutor.rb
+- lib/shexecutor/version.rb
+- shexecutor.gemspec
+- spec/executor_spec.rb
+- spec/mocks/kernel.rb
+- spec/mocks/result.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Execute shell commands easily and securely
+test_files:
+- spec/executor_spec.rb
+- spec/mocks/kernel.rb
+- spec/mocks/result.rb
+- spec/spec_helper.rb