terrapin 0.6.0 → 1.1.1

data/spec/terrapin/command_line_spec.rb

@@ -6,37 +6,49 @@ describe Terrapin::CommandLine do
     on_unix! # Assume we're on unix unless otherwise specified.
   end
 
+  describe ".new" do
+    it "treats nil params as blank" do
+      cmd =  Terrapin::CommandLine.new("echo", nil)
+      expect(cmd.run).to eq("\n")
+    end
+
+    it "raises when given nil options" do
+      expect { Terrapin::CommandLine.new("echo", "", nil) }
+        .to raise_error(ArgumentError)
+    end
+  end
+
   it "takes a command and parameters and produces a Bash command line" do
     cmd = Terrapin::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    cmd.command.should == "convert a.jpg b.png"
+    expect(cmd.command).to eq("convert a.jpg b.png")
   end
 
   it "specifies the $PATH where the command can be found on unix" do
     Terrapin::CommandLine.path = ["/path/to/command/dir", "/"]
     cmd = Terrapin::CommandLine.new("ls")
-    cmd.command.should == "PATH=/path/to/command/dir:/:$PATH; ls"
+    expect(cmd.command).to eq("PATH=/path/to/command/dir:/:$PATH; ls")
   end
 
   it "specifies the %PATH% where the command can be found on windows" do
     on_windows!
     Terrapin::CommandLine.path = ['C:\system32', 'D:\\']
     cmd = Terrapin::CommandLine.new("dir")
-    cmd.command.should == 'SET PATH=C:\system32;D:\;%PATH% & dir'
+    expect(cmd.command).to eq('SET PATH=C:\system32;D:\;%PATH% & dir')
   end
 
   it "specifies more than one path where the command can be found" do
     Terrapin::CommandLine.path = ["/path/to/command/dir", "/some/other/path"]
     cmd = Terrapin::CommandLine.new("ruby", "-e 'puts ENV[%{PATH}]'")
     output = cmd.run
-    output.should match(%r{/path/to/command/dir})
-    output.should match(%r{/some/other/path})
+    expect(output).to match(%r{/path/to/command/dir})
+    expect(output).to match(%r{/some/other/path})
   end
 
   it "temporarily changes specified environment variables" do
     Terrapin::CommandLine.environment['TEST'] = 'Hello, world!'
     cmd = Terrapin::CommandLine.new("ruby", "-e 'puts ENV[%{TEST}]'")
     output = cmd.run
-    output.should match(%r{Hello, world!})
+    expect(output).to match(%r{Hello, world!})
   end
 
   it 'changes environment variables for the command line' do
@@ -45,13 +57,13 @@ describe Terrapin::CommandLine do
                                    "-e 'puts ENV[%{TEST}]'",
                                    :environment => {'TEST' => 'Hej hej'})
     output = cmd.run
-    output.should match(%r{Hej hej})
+    expect(output).to match(%r{Hej hej})
   end
 
   it 'passes the existing environment variables through to the runner' do
     command = Terrapin::CommandLine.new('echo', '$HOME')
     output = command.run
-    output.chomp.should_not == ''
+    expect(output.chomp).not_to eq('')
   end
 
   it "can interpolate quoted variables into the command line's parameters" do
@@ -60,7 +72,7 @@ describe Terrapin::CommandLine do
                                    :swallow_stderr => false)
 
     command_string = cmd.command(:one => "a.jpg", :two => "b.png")
-    command_string.should == "convert 'a.jpg' 'b.png'"
+    expect(command_string).to eq("convert 'a.jpg' 'b.png'")
   end
 
   it 'does not over-interpolate in a command line' do
@@ -69,17 +81,17 @@ describe Terrapin::CommandLine do
                                    :swallow_stderr => false)
 
     command_string = cmd.command(:hell => "a.jpg", :two => "b.png", :hello => "c.tiff")
-    command_string.should == "convert 'a.jpg' 'b.png' 'c.tiff'"
+    expect(command_string).to eq("convert 'a.jpg' 'b.png' 'c.tiff'")
   end
 
   it "interpolates when running a command" do
     command = Terrapin::CommandLine.new("echo", ":hello_world")
-    command.run(:hello_world => "Hello, world").should match(/Hello, world/)
+    expect(command.run(:hello_world => "Hello, world")).to match(/Hello, world/)
   end
 
   it "interpolates any Array arguments when running a command" do
     command = Terrapin::CommandLine.new("echo", "Hello :worlds and :dwarfs")
-    command.command(:worlds => %w[mercury venus earth], :dwarfs => "pluto").should == "echo Hello 'mercury' 'venus' 'earth' and 'pluto'"
+    expect(command.command(:worlds => %w[mercury venus earth], :dwarfs => "pluto")).to eq("echo Hello 'mercury' 'venus' 'earth' and 'pluto'")
   end
 
   it "quotes command line options differently if we're on windows" do
@@ -88,7 +100,7 @@ describe Terrapin::CommandLine do
                                    ":one :{two}",
                                    :swallow_stderr => false)
     command_string = cmd.command(:one => "a.jpg", :two => "b.png")
-    command_string.should == 'convert "a.jpg" "b.png"'
+    expect(command_string).to eq('convert "a.jpg" "b.png"')
   end
 
   it "can quote and interpolate dangerous variables" do
@@ -96,12 +108,12 @@ describe Terrapin::CommandLine do
                                    ":one :two",
                                    :swallow_stderr => false)
     command_string = cmd.command(:one => "`rm -rf`.jpg", :two => "ha'ha.png'")
-    command_string.should == "convert '`rm -rf`.jpg' 'ha'\\''ha.png'\\'''"
+    expect(command_string).to eq("convert '`rm -rf`.jpg' 'ha'\\''ha.png'\\'''")
   end
 
   it 'cannot recursively introduce a place where user-supplied commands can run' do
     cmd = Terrapin::CommandLine.new('convert', ':foo :bar')
-    cmd.command(:foo => ':bar', :bar => '`rm -rf`').should == 'convert \':bar\' \'`rm -rf`\''
+    expect(cmd.command(:foo => ':bar', :bar => '`rm -rf`')).to eq('convert \':bar\' \'`rm -rf`\'')
   end
 
   it "can quote and interpolate dangerous variables even on windows" do
@@ -110,7 +122,7 @@ describe Terrapin::CommandLine do
                                    ":one :two",
                                    :swallow_stderr => false)
     command_string = cmd.command(:one => "`rm -rf`.jpg", :two => "ha'ha.png")
-    command_string.should == %{convert "`rm -rf`.jpg" "ha'ha.png"}
+    expect(command_string).to eq(%{convert "`rm -rf`.jpg" "ha'ha.png"})
   end
 
   it "quotes blank values into the command line's parameters" do
@@ -118,18 +130,18 @@ describe Terrapin::CommandLine do
                                    "-X POST -d :data :url",
                                    :swallow_stderr => false)
     command_string = cmd.command(:data => "", :url => "http://localhost:9000")
-    command_string.should == "curl -X POST -d '' 'http://localhost:9000'"
+    expect(command_string).to eq("curl -X POST -d '' 'http://localhost:9000'")
   end
 
   it "allows colons in parameters" do
     cmd = Terrapin::CommandLine.new("convert", "'a.jpg' xc:black 'b.jpg'", :swallow_stderr => false)
-    cmd.command.should == "convert 'a.jpg' xc:black 'b.jpg'"
+    expect(cmd.command).to eq("convert 'a.jpg' xc:black 'b.jpg'")
   end
 
   it 'handles symbols in user supplied values' do
     cmd = Terrapin::CommandLine.new("echo", ":foo")
     command_string = cmd.command(:foo => :bar)
-    command_string.should == "echo 'bar'"
+    expect(command_string).to eq("echo 'bar'")
   end
 
   it "can redirect stderr to the bit bucket if requested" do
@@ -137,7 +149,7 @@ describe Terrapin::CommandLine do
                                    "a.jpg b.png",
                                    :swallow_stderr => true)
 
-    cmd.command.should == "convert a.jpg b.png 2>/dev/null"
+    expect(cmd.command).to eq("convert a.jpg b.png 2>/dev/null")
   end
 
   it "can redirect stderr to the bit bucket on windows" do
@@ -146,7 +158,7 @@ describe Terrapin::CommandLine do
                                    "a.jpg b.png",
                                    :swallow_stderr => true)
 
-    cmd.command.should == "convert a.jpg b.png 2>NUL"
+    expect(cmd.command).to eq("convert a.jpg b.png 2>NUL")
   end
 
   it "runs the command it's given and returns the output" do
@@ -163,33 +175,33 @@ describe Terrapin::CommandLine do
   it "colorizes the output to a tty" do
     logger = FakeLogger.new(:tty => true)
     Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
-    logger.entries.should include("\e[32mCommand\e[0m :: echo 'Logging!' 'bar'")
+    expect(logger.entries).to include("\e[32mCommand\e[0m :: echo 'Logging!' 'bar'")
   end
 
   it 'can still take something that does not respond to tty as a logger' do
     output_buffer = StringIO.new
     logger = best_logger.new(output_buffer)
-    logger.should_not respond_to(:tty?)
+    expect(logger).not_to respond_to(:tty?)
     Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
     output_buffer.rewind
-    output_buffer.read.should == "Command :: echo 'Logging!' 'bar'\n"
+    expect(output_buffer.read).to eq("Command :: echo 'Logging!' 'bar'\n")
   end
 
   it "logs the command to a supplied logger" do
     logger = FakeLogger.new
     Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
-    logger.entries.should include("Command :: echo 'Logging!' 'bar'")
+    expect(logger.entries).to include("Command :: echo 'Logging!' 'bar'")
   end
 
   it "logs the command to a default logger" do
     Terrapin::CommandLine.logger = FakeLogger.new
     Terrapin::CommandLine.new("echo", "'Logging!'").run
-    Terrapin::CommandLine.logger.entries.should include("Command :: echo 'Logging!'")
+    expect(Terrapin::CommandLine.logger.entries).to include("Command :: echo 'Logging!'")
   end
 
   it "is fine if no logger is supplied" do
     Terrapin::CommandLine.logger = nil
     cmd = Terrapin::CommandLine.new("echo", "'Logging!'", :logger => nil)
-    lambda { cmd.run }.should_not raise_error
+    expect { cmd.run }.not_to raise_error
   end
 end

data/spec/terrapin/errors_spec.rb

@@ -3,38 +3,36 @@ require 'spec_helper'
 describe "When an error happens" do
   it "raises a CommandLineError if the result code command isn't expected" do
     cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.stubs(:execute)
+    expect(cmd).to receive(:execute)
     with_exitstatus_returning(1) do
-      lambda { cmd.run }.should raise_error(Terrapin::CommandLineError)
+      expect { cmd.run }.to raise_error(Terrapin::CommandLineError)
     end
   end
 
   it "does not raise if the result code is expected, even if nonzero" do
     cmd = Terrapin::CommandLine.new("echo", "hello", expected_outcodes: [0, 1])
-    cmd.stubs(:execute)
+    expect(cmd).to receive(:execute)
     with_exitstatus_returning(1) do
-      lambda { cmd.run }.should_not raise_error
+      expect { cmd.run }.not_to raise_error
     end
   end
 
   it "adds command output to exception message if the result code is nonzero" do
     cmd = Terrapin::CommandLine.new("echo", "hello")
     error_output = "Error 315"
-    cmd.
-      stubs(:execute).
-      returns(Terrapin::CommandLine::Output.new("", error_output))
+    expect(cmd).to receive(:execute).and_return(Terrapin::CommandLine::Output.new("", error_output))
     with_exitstatus_returning(1) do
       begin
         cmd.run
       rescue Terrapin::ExitStatusError => e
-        e.message.should =~ /STDERR:\s+#{error_output}/
+        expect(e.message).to match(/STDERR:\s+#{error_output}/)
       end
     end
   end
 
   it 'passes the error message to the exception when command is not found' do
     cmd = Terrapin::CommandLine.new('test', '')
-    cmd.stubs(:execute).raises(Errno::ENOENT.new("not found"))
+    expect(cmd).to receive(:execute).and_raise(Errno::ENOENT.new("not found"))
     begin
       cmd.run
     rescue Terrapin::CommandNotFoundError => e
@@ -44,19 +42,18 @@ describe "When an error happens" do
 
   it "should keep result code in #exitstatus" do
     cmd = Terrapin::CommandLine.new("convert")
-    cmd.stubs(:execute).with("convert").returns(:correct_value)
+    expect(cmd).to receive(:execute).with("convert").and_return(:correct_value)
     with_exitstatus_returning(1) do
       cmd.run rescue nil
     end
-    cmd.exit_status.should == 1
+    expect(cmd.exit_status).to eq(1)
   end
 
   it "does not blow up if running the command errored before execution" do
-    assuming_no_processes_have_been_run
-    command = Terrapin::CommandLine.new("echo", ":hello_world")
-    command.stubs(:command).raises("An Error")
+    cmd = Terrapin::CommandLine.new("echo", ":hello_world")
+    expect(cmd).to receive(:command).and_raise("An Error")
 
-    lambda{ command.run }.should raise_error("An Error")
-    command.exit_status.should eq 0
+    expect{ cmd.run }.to raise_error("An Error")
+    expect(cmd.exit_status).to eq 0
   end
 end

data/spec/terrapin/os_detector_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Terrapin::OSDetector do
   it "detects that the system is unix" do
     on_unix!
-    Terrapin::OS.should be_unix
+    expect(Terrapin::OS).to be_unix
   end
 
   it "detects that the system is windows" do
     on_windows!
-    Terrapin::OS.should be_windows
+    expect(Terrapin::OS).to be_windows
   end
 
   it "detects that the system is windows (mingw)" do
     on_mingw!
-    Terrapin::OS.should be_windows
+    expect(Terrapin::OS).to be_windows
   end
 
   it "detects that the current Ruby is on Java" do
     on_java!
-    Terrapin::OS.should be_java
+    expect(Terrapin::OS).to be_java
   end
 end

data/spec/terrapin/runners_spec.rb

@@ -2,49 +2,37 @@ require 'spec_helper'
 
 describe "When picking a Runner" do
   it "uses the BackticksRunner by default" do
-    Terrapin::CommandLine::ProcessRunner.stubs(:supported?).returns(false)
-    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(false)
+    expect(Terrapin::CommandLine::ProcessRunner).to receive(:supported?).and_return(false)
 
     cmd = Terrapin::CommandLine.new("echo", "hello")
 
-    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+    expect(cmd.runner.class).to eq(Terrapin::CommandLine::BackticksRunner)
   end
 
   it "uses the ProcessRunner on 1.9 and it's available" do
-    Terrapin::CommandLine::ProcessRunner.stubs(:supported?).returns(true)
-    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(false)
+    expect(Terrapin::CommandLine::ProcessRunner).to receive(:supported?).and_return(true)
 
     cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.runner.class.should == Terrapin::CommandLine::ProcessRunner
+    expect(cmd.runner.class).to eq(Terrapin::CommandLine::ProcessRunner)
   end
 
-  it "uses the PosixRunner if the PosixRunner is available" do
-    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
-
-    cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.runner.class.should == Terrapin::CommandLine::PosixRunner
-  end
-
-  it "uses the BackticksRunner if the PosixRunner is available, but we told it to use Backticks all the time" do
-    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
+  it "uses the BackticksRunner if we told it to use Backticks all the time" do
     Terrapin::CommandLine.runner = Terrapin::CommandLine::BackticksRunner.new
 
     cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+    expect(cmd.runner.class).to eq(Terrapin::CommandLine::BackticksRunner)
   end
 
-  it "uses the BackticksRunner if the PosixRunner is available, but we told it to use Backticks" do
-    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
-
+  it "uses the BackticksRunner, if we told it to use Backticks" do
     cmd = Terrapin::CommandLine.new("echo", "hello", :runner => Terrapin::CommandLine::BackticksRunner.new)
-    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+    expect(cmd.runner.class).to eq(Terrapin::CommandLine::BackticksRunner)
   end
 
   it "can go into 'Fake' mode" do
     Terrapin::CommandLine.fake!
 
     cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.runner.class.should eq Terrapin::CommandLine::FakeRunner
+    expect(cmd.runner.class).to eq Terrapin::CommandLine::FakeRunner
   end
 
   it "can turn off Fake mode" do
@@ -52,43 +40,40 @@ describe "When picking a Runner" do
     Terrapin::CommandLine.unfake!
 
     cmd = Terrapin::CommandLine.new("echo", "hello")
-    cmd.runner.class.should_not eq Terrapin::CommandLine::FakeRunner
+    expect(cmd.runner.class).not_to eq Terrapin::CommandLine::FakeRunner
   end
 
   it "can use a FakeRunner even if not in Fake mode" do
     Terrapin::CommandLine.unfake!
 
     cmd = Terrapin::CommandLine.new("echo", "hello", :runner => Terrapin::CommandLine::FakeRunner.new)
-    cmd.runner.class.should eq Terrapin::CommandLine::FakeRunner
+    expect(cmd.runner.class).to eq Terrapin::CommandLine::FakeRunner
   end
 end
 
 describe 'When running an executable in the supplemental path' do
-  before do
-    path = Pathname.new(File.dirname(__FILE__)) + '..' + 'support'
-    File.open(path + 'ls', 'w'){|f| f.puts "#!/bin/sh\necho overridden-ls\n" }
-    FileUtils.chmod(0755, path + 'ls')
-    Terrapin::CommandLine.path = path
-  end
-
-  after do
-    FileUtils.rm_f("#{Terrapin::CommandLine.path}/ls")
-  end
-
   [
     Terrapin::CommandLine::BackticksRunner,
     Terrapin::CommandLine::PopenRunner,
-    Terrapin::CommandLine::PosixRunner,
     Terrapin::CommandLine::ProcessRunner
   ].each do |runner_class|
     if runner_class.supported?
       describe runner_class do
         describe '#run' do
           it 'finds the correct executable' do
+            path = Pathname.new(File.dirname(__FILE__)) + '..' + 'support'
+            File.open(path + 'ls', 'w'){|f| f.puts "#!/bin/sh\necho overridden-ls\n" }
+            FileUtils.chmod(0755, path + 'ls')
+            Terrapin::CommandLine.path = path
             Terrapin::CommandLine.runner = runner_class.new
             command = Terrapin::CommandLine.new('ls')
+
             result = command.run
+
             expect(result.strip).to eq('overridden-ls')
+
+          ensure
+            FileUtils.rm("#{Terrapin::CommandLine.path}/ls")
           end
         end
       end

data/terrapin.gemspec

@@ -1,28 +1,25 @@
 $LOAD_PATH.push File.expand_path("../lib", __FILE__)
-require 'terrapin/version'
+require "terrapin/version"
 
 Gem::Specification.new do |s|
-  s.name              = "terrapin"
-  s.version           = Terrapin::VERSION.dup
-  s.platform          = Gem::Platform::RUBY
-  s.author            = "Jon Yurek"
-  s.email             = "jyurek@thoughtbot.com"
-  s.homepage          = "https://github.com/thoughtbot/terrapin"
-  s.summary           = "Run shell commands safely, even with user-supplied values"
-  s.description       = "Run shell commands safely, even with user-supplied values"
-  s.license           = "MIT"
+  s.name = "terrapin"
+  s.version = Terrapin::VERSION.dup
+  s.platform = Gem::Platform::RUBY
+  s.author = "Jon Yurek"
+  s.email = "jyurek@thoughtbot.com"
+  s.homepage = "https://github.com/thoughtbot/terrapin"
+  s.summary = "Run shell commands safely, even with user-supplied values"
+  s.description = "Run shell commands safely, even with user-supplied values"
+  s.license = "MIT"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.files = `git ls-files`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('climate_control', '>= 0.0.3', '< 1.0')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('bourne')
-  s.add_development_dependency('mocha')
-  s.add_development_dependency('rake')
-  s.add_development_dependency('activesupport', ">= 3.0.0", "< 5.0")
-  s.add_development_dependency('pry')
+  s.add_dependency("climate_control")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("activesupport", ">= 3.0.0", "< 5.0")
+  s.add_development_dependency("pry")
+  s.add_development_dependency("logger")
 end
-

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: terrapin
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Jon Yurek
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -16,20 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -45,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bourne
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -59,21 +52,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -87,27 +86,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: pry
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -126,14 +105,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
+- ".github/workflows/dynamic-readme.yml"
+- ".github/workflows/dynamic-security.yml"
 - ".gitignore"
-- ".travis.yml"
+- CODEOWNERS
 - GOALS
 - Gemfile
 - LICENSE
 - NEWS.md
 - README.md
 - Rakefile
+- SECURITY.md
 - lib/terrapin.rb
 - lib/terrapin/command_line.rb
 - lib/terrapin/command_line/multi_pipe.rb
@@ -142,7 +125,6 @@ files:
 - lib/terrapin/command_line/runners/backticks_runner.rb
 - lib/terrapin/command_line/runners/fake_runner.rb
 - lib/terrapin/command_line/runners/popen_runner.rb
-- lib/terrapin/command_line/runners/posix_runner.rb
 - lib/terrapin/command_line/runners/process_runner.rb
 - lib/terrapin/exceptions.rb
 - lib/terrapin/os_detector.rb
@@ -152,13 +134,11 @@ files:
 - spec/support/have_output.rb
 - spec/support/nonblocking_examples.rb
 - spec/support/stub_os.rb
-- spec/support/unsetting_exitstatus.rb
 - spec/support/with_exitstatus.rb
 - spec/terrapin/command_line/output_spec.rb
 - spec/terrapin/command_line/runners/backticks_runner_spec.rb
 - spec/terrapin/command_line/runners/fake_runner_spec.rb
 - spec/terrapin/command_line/runners/popen_runner_spec.rb
-- spec/terrapin/command_line/runners/posix_runner_spec.rb
 - spec/terrapin/command_line/runners/process_runner_spec.rb
 - spec/terrapin/command_line_spec.rb
 - spec/terrapin/errors_spec.rb
@@ -169,7 +149,6 @@ homepage: https://github.com/thoughtbot/terrapin
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -184,26 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Run shell commands safely, even with user-supplied values
-test_files:
-- spec/spec_helper.rb
-- spec/support/fake_logger.rb
-- spec/support/have_output.rb
-- spec/support/nonblocking_examples.rb
-- spec/support/stub_os.rb
-- spec/support/unsetting_exitstatus.rb
-- spec/support/with_exitstatus.rb
-- spec/terrapin/command_line/output_spec.rb
-- spec/terrapin/command_line/runners/backticks_runner_spec.rb
-- spec/terrapin/command_line/runners/fake_runner_spec.rb
-- spec/terrapin/command_line/runners/popen_runner_spec.rb
-- spec/terrapin/command_line/runners/posix_runner_spec.rb
-- spec/terrapin/command_line/runners/process_runner_spec.rb
-- spec/terrapin/command_line_spec.rb
-- spec/terrapin/errors_spec.rb
-- spec/terrapin/os_detector_spec.rb
-- spec/terrapin/runners_spec.rb
+test_files: []

data/.travis.yml

@@ -1,6 +0,0 @@
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.5
-  - jruby-19mode
-  - rbx-2