awesome_spawn 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2377955010be58dc1a2612d2293c2b423721fbdc
-  data.tar.gz: 294a70bb931c7eda8f4ae676f9635202679175b3
+SHA256:
+  metadata.gz: 5dff33751b72552d7d01e1bfa6e024881148c8d64e309daaa2504107aa6b28f9
+  data.tar.gz: 2d10fb491e209ba595dc1e8eb3751901d45ec427ddc56e3b3108606350881dab
 SHA512:
-  metadata.gz: 0c3671bcf020eb3c28750fcfdd67f19387100bf43064f9e1359f2bf690d7e984b7eceaa33d8ea198e47b42ecb01c27eae89f73c7f3bde5ef7aab915c4192d7ab
-  data.tar.gz: 1c512c6c1a18ca52bf255f1626b281f38c94c74ef17c9dae8bf220c0617ac36ff024f6d08ea0589790d583b532c9613f0b65d20a2ae573dbecf274c0e7168fcf
+  metadata.gz: 9b2ab733dc7226ac633d416500a8ddcec2d44a835431645560997acf3621636ad94286eb6431e92fdad88212ec151ad0046371d6c05006eed2d8dcd6e9bf1164
+  data.tar.gz: f4754e31a144048fc5988a664d997da432ac7af5883234ffd7ee4e205d620eab9e715d7980cdb6668f1a28f369cfffeb798867a56186be2a45222bb18387b263

data/lib/awesome_spawn.rb

@@ -62,6 +62,7 @@ module AwesomeSpawn
   # @option options [Hash,Array] :params The command line parameters. See
   #   {#build_command_line} for how to specify params.
   # @option options [String] :in_data Data to be passed on stdin.
+  # @option options [Boolean] :combined_output Combine STDOUT/STDERR streams from run command
   # @option options [Hash<String,String>] :env Additional environment variables for sub process
   #
   # @raise [NoSuchFileError] if the `command` is not found
@@ -100,8 +101,10 @@ module AwesomeSpawn
 
     if command_result.failure?
       message = CommandResultError.default_message(command, command_result.exit_status)
+      error = command_result.error.nil? || command_result.error.empty? ? command_result.output : command_result.error
+
       logger.error("AwesomeSpawn: #{message}")
-      logger.error("AwesomeSpawn: #{command_result.error}")
+      logger.error("AwesomeSpawn: #{error}")
       raise CommandResultError.new(message, command_result)
     end
 
@@ -116,7 +119,13 @@ module AwesomeSpawn
   private
 
   def launch(env, command, spawn_options)
-    output, error, status = Open3.capture3(env, command, spawn_options)
+    capture2e = spawn_options.delete(:combined_output)
+    if capture2e
+      output, status = Open3.capture2e(env, command, spawn_options)
+      error          = ""
+    else
+      output, error, status = Open3.capture3(env, command, spawn_options)
+    end
     return output, error, status && status.exitstatus
   end
 

data/lib/awesome_spawn/command_line_builder.rb

@@ -12,7 +12,7 @@ module AwesomeSpawn
     #
     #   - `{:k => "value"}`              generates `-k value`
     #   - `[[:k, "value"]]`              generates `-k value`
-    #   - `{:k => "value"}`              generates `-k=value`
+    #   - `{:k= => "value"}`             generates `-k=value`
     #   - `[[:k=, "value"]]`             generates `-k=value` <br /><br />
     #
     #   - `{:key => "value"}`            generates `--key value`

data/lib/awesome_spawn/command_result_error.rb

@@ -8,6 +8,7 @@ module AwesomeSpawn
     attr_reader :result
 
     def initialize(message, result)
+      message += " error was: #{result.error}" if !result.nil? && !result.error.empty?
       super(message)
       @result = result
     end

data/lib/awesome_spawn/spec_helper.rb

@@ -11,11 +11,11 @@ module AwesomeSpawn
       allow(Open3).to receive(:capture3).and_call_original
     end
 
-    def stub_good_run
+    def stub_good_run(command, options = {})
       stub_run(:good, :run, command, options)
     end
 
-    def stub_bad_run
+    def stub_bad_run(command, options = {})
       stub_run(:bad, :run, command, options)
     end
 
@@ -30,15 +30,14 @@ module AwesomeSpawn
     private
 
     def stub_run(mode, method, command, options)
-      output = options[:output] || ""
-      error  = options[:error]  || (mode == :bad ? "Failure" : "")
-      exit_status = options[:exit_status] || (mode == :bad ? 1 : 0)
+      options = options.dup
+      output = options.delete(:output) || ""
+      error  = options.delete(:error)  || (mode == :bad ? "Failure" : "")
+      exit_status = options.delete(:exit_status) || (mode == :bad ? 1 : 0)
 
-      params = options[:params]
-      command_line = AwesomeSpawn.build_command_line(command, params)
+      command_line = AwesomeSpawn.build_command_line(command, options[:params])
 
-      args = [command]
-      args << {:params => params} if params
+      args = [command, options]
 
       result = CommandResult.new(command_line, output, error, exit_status)
       if method == :run! && mode == :bad

data/lib/awesome_spawn/version.rb

@@ -1,3 +1,3 @@
 module AwesomeSpawn
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: awesome_spawn
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Jason Frey
@@ -11,22 +11,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-22 00:00:00.000000000 Z
+date: 2020-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +80,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
 - ".yardopts"
 - LICENSE.txt
 - README.md
@@ -92,12 +91,6 @@ files:
 - lib/awesome_spawn/null_logger.rb
 - lib/awesome_spawn/spec_helper.rb
 - lib/awesome_spawn/version.rb
-- spec/awesome_spawn_spec.rb
-- spec/command_line_builder_spec.rb
-- spec/command_result_error_spec.rb
-- spec/command_result_spec.rb
-- spec/no_such_file_error_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/ManageIQ/awesome_spawn
 licenses:
 - MIT
@@ -117,16 +110,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: AwesomeSpawn is a module that provides some useful features over Ruby's Kernel.spawn.
-test_files:
-- spec/awesome_spawn_spec.rb
-- spec/command_line_builder_spec.rb
-- spec/command_result_error_spec.rb
-- spec/command_result_spec.rb
-- spec/no_such_file_error_spec.rb
-- spec/spec_helper.rb
-- ".rspec"
+test_files: []

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/spec/awesome_spawn_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'pathname' # For Pathname specific specs
-
-describe AwesomeSpawn do
-  subject { described_class }
-
-  shared_examples_for "parses" do
-    it "supports no options" do
-      allow(subject).to receive(:launch).with({}, "true", {}).and_return(["", "", 0])
-      subject.send(run_method, "true")
-    end
-
-    it "supports option :params and :env" do
-      allow(subject).to receive(:launch).with({"VAR" => "x"}, "true --user bob", {}).and_return(["", "", 0])
-      subject.send(run_method, "true", :params => {:user => "bob"}, :env => {"VAR" => "x"})
-    end
-
-    it "wont modify passed in options" do
-      options      = {:params => {:user => "bob"}}
-      orig_options = options.dup
-      allow(subject).to receive(:launch).with({}, "true --user bob", {}).and_return(["", "", 0])
-      subject.send(run_method, "true", options)
-      expect(orig_options).to eq(options)
-    end
-
-    it "wont modify passed in options[:params]" do
-      params      = {:user => "bob"}
-      orig_params = params.dup
-      allow(subject).to receive(:launch).with({}, "true --user bob", {}).and_return(["", "", 0])
-      subject.send(run_method, "true", :params => params)
-      expect(orig_params).to eq(params)
-    end
-
-    it "warns about option :in" do
-      expect do
-        subject.send(run_method, "true", :in => "/dev/null")
-      end.to raise_error(ArgumentError, "options cannot contain :in")
-    end
-
-    it "warns about option :out" do
-      expect do
-        subject.send(run_method, "true", :out => "/dev/null")
-      end.to raise_error(ArgumentError, "options cannot contain :out")
-    end
-
-    it "warns about option :err" do
-      expect do
-        subject.send(run_method, "true", :err => "/dev/null")
-      end.to raise_error(ArgumentError, "options cannot contain :err")
-    end
-
-    it "warns about option :err when in an array" do
-      expect do
-        subject.send(run_method, "true", [:err, :out, 3] => "/dev/null")
-      end.to raise_error(ArgumentError, "options cannot contain :err, :out")
-    end
-  end
-
-  shared_examples_for "executes" do
-    before do
-      # Re-enable actual spawning just for these specs.
-      enable_spawning
-    end
-
-    it "runs command" do
-      expect(subject.send(run_method, "true")).to be_kind_of AwesomeSpawn::CommandResult
-    end
-
-    it "detects bad commands" do
-      expect do
-        subject.send(run_method, "XXXXX --user=bob")
-      end.to raise_error(AwesomeSpawn::NoSuchFileError, "No such file or directory - XXXXX")
-    end
-
-    describe "parameters" do
-      it "changes directory" do
-        result = subject.send(run_method, "pwd", :chdir => "..")
-        expect(result.exit_status).to  eq(0)
-        expect(result.output.chomp).to eq(File.expand_path("..", Dir.pwd))
-      end
-
-      it "passes input" do
-        result = subject.send(run_method, "cat", :in_data => "line1\nline2")
-        expect(result.exit_status).to eq(0)
-        expect(result.output).to      eq("line1\nline2")
-      end
-
-      it "sets environment" do
-        result = subject.send(run_method, "echo ${ABC}", :env => {"ABC" => "yay!"})
-        expect(result.exit_status).to eq(0)
-        expect(result.output).to      eq("yay!\n")
-      end
-    end
-
-    describe "result" do
-      it "contains #command_line" do
-        expect(subject.send(run_method, "echo", :params => %w(x)).command_line).to eq("echo x")
-      end
-
-      it "contains #exit_status" do
-        expect(subject.send(run_method, "true").exit_status).to eq(0)
-      end
-
-      it "contains #output" do
-        expect(subject.send(run_method, "echo \"Hello World\"").output).to eq("Hello World\n")
-      end
-
-      it "contains #output when output redirected to stderr)" do
-        expect(subject.send(run_method, "echo \"Hello World\" >&2").output).to eq("")
-      end
-
-      it "contains #error when no error" do
-        expect(subject.send(run_method, "echo", :params => ["Hello World"]).error).to eq("")
-      end
-
-      it "contains #error" do
-        expect(subject.send(run_method, "echo \"Hello World\" >&2").error).to eq("Hello World\n")
-      end
-    end
-  end
-
-  shared_examples_for "executes with failures" do
-    context "result with a bad command" do
-      before do
-        # Re-enable actual spawning just for these specs.
-        enable_spawning
-      end
-
-      it "contains #command_line" do
-        expect(subject.send(run_method, "echo x && false").command_line).to eq("echo x && false")
-      end
-
-      it "contains #exit_status" do
-        expect(subject.send(run_method, "false").exit_status).to eq(1)
-      end
-
-      it "contains #output" do
-        expect(subject.send(run_method, "echo 'bad' && false").output).to eq("bad\n")
-      end
-
-      it "contains #error" do
-        expect(subject.send(run_method, "echo 'bad' >&2 && false").error).to eq("bad\n")
-      end
-    end
-  end
-
-  describe ".build_command_line" do
-    it "supports no parameters" do
-      expect(subject.build_command_line("cmd")).to eq("cmd")
-    end
-
-    it "supports single long parameter" do
-      expect(subject.build_command_line("cmd", :status => true)).to eq("cmd --status true")
-    end
-
-    it "supports multiple long parameters" do
-      expect(subject.build_command_line("cmd", :status => true, :fast => false)).to eq("cmd --status true --fast false")
-    end
-  end
-
-  describe ".run" do
-    let(:run_method) { "run" }
-    include_examples "parses"
-    include_examples "executes"
-    include_examples "executes with failures"
-  end
-
-  describe ".run!" do
-    let(:run_method) { "run!" }
-    include_examples "parses"
-    include_examples "executes"
-
-    it "raises errors on failure" do
-      expect { subject.send(run_method, "false") }.to raise_error do |error|
-        expect(error).to be_kind_of AwesomeSpawn::CommandResultError
-        expect(error.result).to be_kind_of AwesomeSpawn::CommandResult
-      end
-    end
-  end
-end

data/spec/command_line_builder_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-
-describe AwesomeSpawn::CommandLineBuilder do
-  subject { described_class.new }
-
-  context "#build" do
-    def assert_params(params, expected_params)
-      expect(subject.build("true", params)).to eq "true #{expected_params}".strip
-    end
-
-    it "without params" do
-      expect(subject.build("true")).to eq "true"
-    end
-
-    it "with nil" do
-      expect(subject.build("true", nil)).to eq "true"
-    end
-
-    it "with empty" do
-      expect(subject.build("true", "")).to eq "true"
-    end
-
-    it "with empty" do
-      expect(subject.build("true", [])).to eq "true"
-    end
-
-    it "with Pathname command" do
-      actual = subject.build(Pathname.new("/usr/bin/ruby"))
-      expect(actual).to eq "/usr/bin/ruby"
-    end
-
-    it "with Pathname command and params" do
-      actual = subject.build(Pathname.new("/usr/bin/ruby"), "-v" => nil)
-      expect(actual).to eq "/usr/bin/ruby -v"
-    end
-
-    it "with Pathname in params" do
-      options = ["-d", Pathname.new("script.rb")]
-
-      actual = subject.build(Pathname.new("/usr/bin/ruby"), options)
-      expect(actual).to eq "/usr/bin/ruby -d script.rb"
-    end
-
-    context "with Hash" do
-      it "that is empty" do
-        assert_params({}, "")
-      end
-
-      it "with normal params" do
-        assert_params({"--user" => "bob"}, "--user bob")
-      end
-
-      it "with key with tailing '='" do
-        assert_params({"--user=" => "bob"}, "--user=bob")
-      end
-
-      it "with single letter symbol" do
-        assert_params({:a => "val"}, "-a val")
-      end
-
-      it "with single letter symbol" do
-        assert_params({:a= => "val"}, "-a=val")
-      end
-
-      it "with value requiring sanitization" do
-        assert_params({"--pass" => "P@$s w0rd%"}, "--pass P@\\$s\\ w0rd\\%")
-      end
-
-      it "with key requiring sanitization" do
-        assert_params({"--h&x0r=" => "xxx"}, "--h\\&x0r=xxx")
-      end
-
-      it "with key as Symbol" do
-        assert_params({:abc => "def"}, "--abc def")
-      end
-
-      it "with key as Symbol with tailing '='" do
-        assert_params({:abc= => "def"}, "--abc=def")
-      end
-
-      it "with key as Symbol with underscore" do
-        assert_params({:abc_def => "ghi"}, "--abc-def ghi")
-      end
-
-      it "with key as Symbol with underscore and tailing '='" do
-        assert_params({:abc_def= => "ghi"}, "--abc-def=ghi")
-      end
-
-      it "with key as nil" do
-        assert_params({nil => "def"}, "def")
-      end
-
-      it "with value as nil" do
-        assert_params({"--abc" => nil}, "--abc")
-      end
-
-      it "with key and value nil" do
-        assert_params({nil => nil}, "")
-      end
-
-      it "with key of '--'" do
-        assert_params({"--" => nil}, "--")
-      end
-
-      it "with value as Symbol" do
-        assert_params({"--abc" => :def}, "--abc def")
-      end
-
-      it "with value as Array" do
-        assert_params({"--abc" => ["def", "ghi"]}, "--abc def ghi")
-      end
-
-      it "with value as Fixnum" do
-        assert_params({"--abc" => 1}, "--abc 1")
-      end
-
-      it "with value as Fixnum Array" do
-        assert_params({"--abc" => [1, 2]}, "--abc 1 2")
-      end
-
-      it "with value as Range" do
-        assert_params({"--abc" => (1..4)}, "--abc 1 2 3 4")
-      end
-
-      it "with value as Pathname" do
-        assert_params({"--abc" => Pathname.new("/usr/bin/ruby")}, "--abc /usr/bin/ruby")
-      end
-    end
-
-    context "with associative Array" do
-      it "that is empty" do
-        assert_params([], "")
-      end
-
-      it "that is nested empty" do
-        assert_params([[]], "")
-      end
-
-      it "with normal params" do
-        assert_params([["--user", "bob"]], "--user bob")
-      end
-
-      it "with key with tailing '='" do
-        assert_params([["--user=", "bob"]], "--user=bob")
-      end
-
-      it "with value requiring sanitization" do
-        assert_params([["--pass", "P@$s w0rd%"]], "--pass P@\\$s\\ w0rd\\%")
-      end
-
-      it "with key requiring sanitization" do
-        assert_params([["--h&x0r=", "xxx"]], "--h\\&x0r=xxx")
-      end
-
-      it "with key as Symbol" do
-        assert_params([[:abc, "def"]], "--abc def")
-      end
-
-      it "with key as Symbol with tailing '='" do
-        assert_params([[:abc=, "def"]], "--abc=def")
-      end
-
-      it "with key as Symbol with underscore" do
-        assert_params([[:abc_def, "ghi"]], "--abc-def ghi")
-      end
-
-      it "with key as Symbol with underscore and tailing '='" do
-        assert_params([[:abc_def=, "ghi"]], "--abc-def=ghi")
-      end
-
-      it "with key as nil" do
-        assert_params([[nil, "def"]], "def")
-      end
-
-      it "with value as nil" do
-        assert_params([["--abc", nil]], "--abc")
-      end
-
-      it "with key and value nil" do
-        assert_params([[nil, nil]], "")
-      end
-
-      it "with key as nil and multiple values" do
-        assert_params([[nil, "def", "ghi"]], "def ghi")
-      end
-
-      it "with key of '--'" do
-        assert_params([["--", nil]], "--")
-      end
-
-      it "with key alone" do
-        assert_params([["--abc"]], "--abc")
-      end
-
-      it "with key as Symbol alone" do
-        assert_params([[:abc]], "--abc")
-      end
-
-      it "with key as a bareword" do
-        assert_params(["--abc"], "--abc")
-      end
-
-      it "with key as bareword Symbol" do
-        assert_params([:abc], "--abc")
-      end
-
-      it "with value as a bareword" do
-        assert_params(["abc"], "abc")
-      end
-
-      it "with entry as a nested Hash" do
-        assert_params([{:abc_def= => "ghi"}], "--abc-def=ghi")
-      end
-
-      it "with value as Symbol" do
-        assert_params([["--abc" => :def]], "--abc def")
-      end
-
-      it "with value as Array" do
-        assert_params([["--abc", ["def", "ghi"]]], "--abc def ghi")
-      end
-
-      it "with value as Array and extra nils" do
-        assert_params([["--abc", [nil, "def", nil, "ghi", nil]]], "--abc def ghi")
-      end
-
-      it "with value as flattened Array" do
-        assert_params([["--abc", "def", "ghi"]], "--abc def ghi")
-      end
-
-      it "with value as Fixnum" do
-        assert_params([["--abc", 1]], "--abc 1")
-      end
-
-      it "with value as Fixnum Array" do
-        assert_params([["--abc", [1, 2]]], "--abc 1 2")
-      end
-
-      it "with value as Range" do
-        assert_params([["--abc", (1..4)]], "--abc 1 2 3 4")
-      end
-
-      it "with value as Pathname" do
-        assert_params([["--abc", Pathname.new("/usr/bin/ruby")]], "--abc /usr/bin/ruby")
-      end
-
-      it "with duplicate keys" do
-        assert_params([["--abc", 1], ["--abc", 2]], "--abc 1 --abc 2")
-      end
-    end
-
-    context "with multiple params" do # real-world cases
-      let(:expected) { "log feature -E --oneline --grep abc" }
-
-      it "as full Hash" do
-        params = {"log" => nil, "feature" => nil, "-E" => nil, :oneline => nil, "--grep" => "abc"}
-        assert_params(params, expected)
-      end
-
-      it "as grouped Hash" do
-        params = {nil => ["log", "feature"], "-E" => nil, :oneline => nil, :grep => "abc"}
-        assert_params(params, expected)
-      end
-
-      it "as associative Array" do
-        params = [[nil, "log", "feature"], ["-E", nil], [:oneline, nil], [:grep, "abc"]]
-        assert_params(params, expected)
-      end
-
-      it "as associative Array without nil values" do
-        params = [["log", "feature"], ["-E"], [:oneline], [:grep, "abc"]]
-        assert_params(params, expected)
-      end
-
-      it "as mixed Array with barewords" do
-        params = ["log", "feature", "-E", :oneline, [:grep, "abc"]]
-        assert_params(params, expected)
-      end
-
-      it "as mixed Array" do
-        params = ["log", "feature", "-E", :oneline, :grep, "abc"]
-        assert_params(params, expected)
-      end
-
-      it "as mixed Array with nested Hashes" do
-        params = ["log", "feature", "-E", :oneline, {:grep => "abc"}]
-        assert_params(params, expected)
-      end
-    end
-  end
-end

data/spec/command_result_error_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe AwesomeSpawn::CommandResultError do
-  context "basic false command" do
-    before { enable_spawning }
-    subject do
-      begin
-        AwesomeSpawn.run!("false")
-      rescue => e
-        return e
-      end
-    end
-
-    it { expect(subject.message).to eq("false exit code: 1") }
-    it { expect(subject.result).to be_a_failure }
-  end
-
-  it ".default_message" do
-    expect(described_class.default_message("some message", 123)).to eq "some message exit code: 123"
-  end
-end

data/spec/command_result_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe AwesomeSpawn::CommandResult do
-  context "succeeding object" do
-    subject { described_class.new("aaa", "bbb", "ccc", 0) }
-
-    it "should set attributes" do
-      expect(subject.command_line).to eq("aaa")
-      expect(subject.output).to eq("bbb")
-      expect(subject.error).to eq("ccc")
-      expect(subject.exit_status).to eq(0)
-      expect(subject.inspect).to match(/^#<AwesomeSpawn::CommandResult:[0-9a-fx]+ @exit_status=0>$/)
-    end
-
-    it "should not display sensitive information" do
-      expect(subject.inspect).to_not include("aaa")
-      expect(subject.inspect).to_not include("bbb")
-      expect(subject.inspect).to_not include("ccc")
-    end
-
-    it { expect(subject).to be_a_success }
-    it { expect(subject).not_to be_a_failure }
-  end
-
-  context "failing object" do
-    subject { described_class.new("aaa", "bbb", "ccc", 1) }
-
-    it { expect(subject).not_to be_a_success }
-    it { expect(subject).to be_a_failure }
-  end
-
-  context "another failing object" do
-    subject { described_class.new("aaa", "bbb", "ccc", 100) }
-
-    it { expect(subject).not_to be_a_success }
-    it { expect(subject).to be_a_failure }
-  end
-end

data/spec/no_such_file_error_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe AwesomeSpawn::NoSuchFileError do
-  before do
-    enable_spawning
-  end
-
-  context "single word command" do
-    subject { caught_exception_for("falsey") }
-    it { expect(subject.message).to eq("No such file or directory - falsey") }
-    it { expect(subject.to_s).to eq("No such file or directory - falsey") }
-    it { expect(subject).to be_a(described_class) }
-  end
-
-  context "multi word command" do
-    subject { caught_exception_for("  flat   --arg 1 --arg 2") }
-    it { expect(subject.message).to eq("No such file or directory - flat") }
-    it { expect(subject.to_s).to eq("No such file or directory - flat") }
-    it { expect(subject).to be_a(described_class) }
-  end
-
-  def caught_exception_for(command)
-    AwesomeSpawn.run!(command)
-  rescue => e
-    return e
-  end
-end

data/spec/spec_helper.rb

@@ -1,30 +0,0 @@
-# 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
-
-require 'awesome_spawn/spec_helper'
-
-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'
-
-  include AwesomeSpawn::SpecHelper
-  config.before { disable_spawning }
-end
-
-begin
-  require 'coveralls'
-  Coveralls.wear!
-rescue LoadError
-end
-
-require 'awesome_spawn'