terrapin 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fe1ba61cb02d982ac5535ff8423186dcb045c9de
-  data.tar.gz: d1eae833ed7b0041442275d6a005188c4300a5fa
+SHA256:
+  metadata.gz: 63194360423231cdc4e8a9d8029d6a13cefb7adaf18393e9c440c5bd78d9cda9
+  data.tar.gz: df7766c516b75cf3e4a3cdc9e34db75f71b445401412f2fa0d56731642bcf62a
 SHA512:
-  metadata.gz: d8d2a8e41b0f12e41062cfcbbacaa7abcc9e2d02519ffe27214a4ffaa93c5c0243b681066fa76e59c66e13dd2f8abf87258644b5cf421c7e66e47118434c764d
-  data.tar.gz: 3e3e8d27c8a9e569fe99b30a09baacbe05a7dae3a260b36470453bcaaa7303f685a6868d84304d6e1afd55661ead32b31d89f3d4debf01bd7b31c67379ac47b0
+  metadata.gz: 605061255a57c1565265f4b80c14fe246cdaea034c17148ac499022e6cbe34612551c455d506429c8ba5b071449a2d0b4137140757135b3a2c983af404bb0514
+  data.tar.gz: a609c3fb7fbca55d3382a8c8f41c93de29761aa19221a2768100e80107afe789d6984f46945b48eadea49def31a59bf7eab1812304fb66c1add37784f489e263

data/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+on:
+  - push
+  - pull_request
+
+jobs:
+  build:
+    name: Ruby ${{ matrix.ruby }}
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - jruby-9.4.1.0
+          - "2.7"
+          - "3.0"
+          - "3.1"
+          - "3.2"
+
+    runs-on: 'ubuntu-latest'
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Setup project
+        run: bundle install
+      - name: Run test
+        run: bundle exec rake

data/.travis.yml

@@ -2,5 +2,8 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.5
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
   - jruby-19mode
-  - rbx-2

data/Gemfile

@@ -1,7 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-platforms :ruby do
-  gem "posix-spawn"
-end

data/NEWS.md

@@ -1,3 +1,8 @@
+New for 1.0.0:
+
+* Terrapin::CommandLine::PosixRunner was removed. You can replace any usage of this with Terrapin::CommandLine::ProcessRunner, which uses Ruby’s builtin Process.spawn.
+* Moved CI from Travis to GH Actions.
+
 New for 0.6.0:
 
 * Rename the project to Terrapin

data/README.md

@@ -105,11 +105,11 @@ line.command # => "lolwut", but it looks in /opt/bin for it.
 You can even give it a bunch of places to look:
 
 ```ruby
-    FileUtils.rm("/opt/bin/lolwut")
-    File.open('/usr/local/bin/lolwut') {|f| f.write('echo Hello') }
-    Terrapin::CommandLine.path = ["/opt/bin", "/usr/local/bin"]
-    line = Terrapin::CommandLine.new("lolwut")
-    line.run # => prints 'Hello', because it searches the path
+FileUtils.rm("/opt/bin/lolwut")
+File.open('/usr/local/bin/lolwut') { |f| f.write('echo Hello') }
+Terrapin::CommandLine.path = ["/opt/bin", "/usr/local/bin"]
+line = Terrapin::CommandLine.new("lolwut")
+line.run # => prints 'Hello', because it searches the path
 ```
 
 Or just put it in the command:
@@ -145,23 +145,18 @@ second argument of `new`. Terrapin assumes that you will not be manually
 passing user-generated data to that argument and will be using it as a template
 for your command line's structure.
 
-## POSIX Spawn
+## Runners
 
-You can potentially increase performance by installing [the posix-spawn
-gem](https://rubygems.org/gems/posix-spawn). This gem can keep your
-application's heap from being copied when forking command line
-processes. For applications with large heaps the gain can be
-significant. To include `posix-spawn`, simply add it to your `Gemfile` or,
-if you don't use bundler, install the gem.
+Terrapin will choose from among a couple different ways of running commands.
+The simplest is `Process.spawn`, which is also the default. Terrapin can also just use [backticks], so if for some reason you'd prefer that, you can ask Terrapin to use that:
 
-## Runners
+```ruby
+Terrapin::CommandLine.runner = Terrapin::CommandLine::BackticksRunner.new
+```
+
+And if you really want to, you can define your own Runner, though I can't imagine why you would.
 
-Terrapin will attempt to choose from among 3 different ways of running commands.
-The simplest is using backticks, and is the default in 1.8. In Ruby 1.9, it
-will attempt to use `Process.spawn`. And, as mentioned above, if the
-`posix-spawn` gem is installed, it will attempt to use that. If for some reason
-one of the `.spawn` runners don't work for you, you can override them manually
-by setting a new runner, like so:
+[backticks]: https://ruby-doc.org/3.2.1/Kernel.html#method-i-60
 
 ```ruby
 Terrapin::CommandLine.runner = Terrapin::CommandLine::BackticksRunner.new

data/lib/terrapin/command_line/runners.rb

@@ -2,6 +2,5 @@
 
 require 'terrapin/command_line/runners/backticks_runner'
 require 'terrapin/command_line/runners/process_runner'
-require 'terrapin/command_line/runners/posix_runner'
 require 'terrapin/command_line/runners/popen_runner'
 require 'terrapin/command_line/runners/fake_runner'

data/lib/terrapin/command_line.rb

@@ -38,7 +38,7 @@ module Terrapin
       private
 
       def best_runner
-        [PosixRunner, ProcessRunner, BackticksRunner].detect do |runner|
+        [ProcessRunner, BackticksRunner].detect do |runner|
           runner.supported?
         end.new
       end
@@ -49,15 +49,20 @@ module Terrapin
     attr_reader :exit_status, :runner
 
     def initialize(binary, params = "", options = {})
-      @binary            = binary.dup
-      @params            = params.dup
-      @options           = options.dup
-      @runner            = @options.delete(:runner) || self.class.runner
-      @logger            = @options.delete(:logger) || self.class.logger
-      @swallow_stderr    = @options.delete(:swallow_stderr)
+      if options.nil?
+        raise ArgumentError, "3rd argument to CommandLine.new should be a" \
+          "hash of values that will be interpolated into the command line"
+      end
+
+      @options = options.dup
+      @binary = binary.dup
+      @params = params.to_s.dup
+      @runner = @options.delete(:runner) || self.class.runner
+      @logger = @options.delete(:logger) || self.class.logger
+      @swallow_stderr = @options.delete(:swallow_stderr)
       @expected_outcodes = @options.delete(:expected_outcodes) || [0]
-      @environment       = @options.delete(:environment) || {}
-      @runner_options    = @options.delete(:runner_options) || {}
+      @environment = @options.delete(:environment) || {}
+      @runner_options = @options.delete(:runner_options) || {}
     end
 
     def command(interpolations = {})

data/lib/terrapin/version.rb

@@ -1,4 +1,4 @@
 # coding: UTF-8
 module Terrapin
-  VERSION = "0.6.0".freeze
+  VERSION = "1.0.0".freeze
 end

data/spec/spec_helper.rb

@@ -1,6 +1,4 @@
 require 'rspec'
-require 'mocha/api'
-require 'bourne'
 require 'terrapin'
 require 'timeout'
 require 'tempfile'
@@ -14,10 +12,8 @@ begin; require 'active_support/buffered_logger'; rescue LoadError; end
 Dir[File.dirname(__FILE__) + "/support/**.rb"].each{|support_file| require support_file }
 
 RSpec.configure do |config|
-  config.mock_with :mocha
   config.include WithExitstatus
   config.include StubOS
-  config.include UnsettingExitstatus
 end
 
 def best_logger

data/spec/support/nonblocking_examples.rb

@@ -5,8 +5,8 @@ shared_examples_for "a command that does not block" do
 
     Timeout.timeout(5) do
       output = subject.call("cat '#{garbage_file.path}'")
-      $?.exitstatus.should == 0
-      output.output.length.should == 10 * 1024 * 1024
+      expect($?.exitstatus).to eq(0)
+      expect(output.output.length).to eq(10 * 1024 * 1024)
     end
 
     garbage_file.close

data/spec/support/stub_os.rb

@@ -1,25 +1,25 @@
 module StubOS
   def on_windows!
     stub_os('mswin')
-    Terrapin::OS.stubs(:path_separator).returns(";")
+    allow(Terrapin::OS).to receive(:path_separator).and_return(";")
   end
 
   def on_unix!
     stub_os('darwin11.0.0')
-    Terrapin::OS.stubs(:path_separator).returns(":")
+    allow(Terrapin::OS).to receive(:path_separator).and_return(":")
   end
 
   def on_mingw!
     stub_os('mingw')
-    Terrapin::OS.stubs(:path_separator).returns(";")
+    allow(Terrapin::OS).to receive(:path_separator).and_return(";")
   end
 
   def on_java!
-    Terrapin::OS.stubs(:arch).returns("universal-java1.7")
+    allow(Terrapin::OS).to receive(:arch).and_return("universal-java1.7")
   end
 
   def stub_os(host_string)
     # http://blog.emptyway.com/2009/11/03/proper-way-to-detect-windows-platform-in-ruby/
-    RbConfig::CONFIG.stubs(:[]).with('host_os').returns(host_string)
+    allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return(host_string)
   end
 end

data/spec/terrapin/command_line/runners/backticks_runner_spec.rb

@@ -16,9 +16,9 @@ describe Terrapin::CommandLine::BackticksRunner do
 
     it 'sets the exitstatus when a command completes' do
       subject.call("ruby -e 'exit 0'")
-      $?.exitstatus.should == 0
+      expect($?.exitstatus).to eq(0)
       subject.call("ruby -e 'exit 5'")
-      $?.exitstatus.should == 5
+      expect($?.exitstatus).to eq(5)
     end
   end
 end

data/spec/terrapin/command_line/runners/fake_runner_spec.rb

@@ -4,19 +4,19 @@ describe Terrapin::CommandLine::FakeRunner do
   it 'records commands' do
     subject.call("some command", :environment)
     subject.call("other command", :other_environment)
-    subject.commands.should eq [["some command", :environment], ["other command", :other_environment]]
+    expect(subject.commands).to eq [["some command", :environment], ["other command", :other_environment]]
   end
 
   it 'can tell if a command was run' do
     subject.call("some command", :environment)
     subject.call("other command", :other_environment)
-    subject.ran?("some command").should eq true
-    subject.ran?("no command").should eq false
+    expect(subject.ran?("some command")).to eq true
+    expect(subject.ran?("no command")).to eq false
   end
 
   it 'can tell if a command was run even if shell options were set' do
     subject.call("something 2>/dev/null", :environment)
-    subject.ran?("something").should eq true
+    expect(subject.ran?("something")).to eq true
   end
 
 end

data/spec/terrapin/command_line/runners/popen_runner_spec.rb

@@ -16,9 +16,9 @@ describe Terrapin::CommandLine::PopenRunner do
 
     it 'sets the exitstatus when a command completes' do
       subject.call("ruby -e 'exit 0'")
-      $?.exitstatus.should == 0
+      expect($?.exitstatus).to eq(0)
       subject.call("ruby -e 'exit 5'")
-      $?.exitstatus.should == 5
+      expect($?.exitstatus).to eq(5)
     end
   end
 end

data/spec/terrapin/command_line/runners/process_runner_spec.rb

@@ -21,9 +21,9 @@ describe Terrapin::CommandLine::ProcessRunner do
 
     it 'sets the exitstatus when a command completes' do
       subject.call("ruby -e 'exit 0'")
-      $?.exitstatus.should == 0
+      expect($?.exitstatus).to eq(0)
       subject.call("ruby -e 'exit 5'")
-      $?.exitstatus.should == 5
+      expect($?.exitstatus).to eq(5)
     end
 
     it "runs the command it's given and allows access to stderr afterwards" do

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,14 +40,14 @@ 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
 
@@ -78,7 +66,6 @@ describe 'When running an executable in the supplemental path' do
   [
     Terrapin::CommandLine::BackticksRunner,
     Terrapin::CommandLine::PopenRunner,
-    Terrapin::CommandLine::PosixRunner,
     Terrapin::CommandLine::ProcessRunner
   ].each do |runner_class|
     if runner_class.supported?

data/terrapin.gemspec

@@ -1,28 +1,24 @@
 $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")
 end
-

metadata

@@ -1,57 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: terrapin
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Jon Yurek
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-02 00:00:00.000000000 Z
+date: 2023-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
   requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.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'
-- !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: bourne
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -59,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -126,6 +92,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".travis.yml"
 - GOALS
@@ -142,7 +109,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 +118,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 +133,7 @@ homepage: https://github.com/thoughtbot/terrapin
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -184,26 +148,8 @@ 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.4.10
+signing_key:
 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/lib/terrapin/command_line/runners/posix_runner.rb

@@ -1,49 +0,0 @@
-# coding: UTF-8
-
-module Terrapin
-  class CommandLine
-    class PosixRunner
-      def self.available?
-        return @available unless @available.nil?
-
-        @available = posix_spawn_gem_available?
-      end
-
-      def self.supported?
-        available? && !OS.java?
-      end
-
-      def supported?
-        self.class.supported?
-      end
-
-      def call(command, env = {}, options = {})
-        pipe = MultiPipe.new
-        pid = spawn(env, command, options.merge(pipe.pipe_options))
-        pipe.read_and_then do
-          waitpid(pid)
-        end
-        pipe.output
-      end
-
-      private
-
-      def spawn(*args)
-        POSIX::Spawn.spawn(*args)
-      end
-
-      def waitpid(pid)
-        Process.waitpid(pid)
-      end
-
-      def self.posix_spawn_gem_available?
-        require 'posix/spawn'
-        true
-      rescue LoadError
-        false
-      end
-
-      private_class_method :posix_spawn_gem_available?
-    end
-  end
-end

data/spec/support/unsetting_exitstatus.rb

@@ -1,7 +0,0 @@
-module UnsettingExitstatus
-  def assuming_no_processes_have_been_run
-    class << $?
-      undef_method :exitstatus
-    end
-  end
-end

data/spec/terrapin/command_line/runners/posix_runner_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Terrapin::CommandLine::PosixRunner do
-  if Terrapin::CommandLine::PosixRunner.supported?
-    it_behaves_like 'a command that does not block'
-
-    it 'runs the command given and captures the output' do
-      output = subject.call("echo hello")
-      expect(output).to have_output "hello\n"
-    end
-
-    it 'runs the command given and captures the error output' do
-      output = subject.call("echo hello 1>&2")
-      expect(output).to have_error_output "hello\n"
-    end
-
-    it 'modifies the environment and runs the command given' do
-      output = subject.call("echo $yes", {"yes" => "no"})
-      expect(output).to have_output "no\n"
-    end
-
-    it 'sets the exitstatus when a command completes' do
-      subject.call("ruby -e 'exit 0'")
-      $?.exitstatus.should == 0
-      subject.call("ruby -e 'exit 5'")
-      $?.exitstatus.should == 5
-    end
-
-    it "runs the command it's given and allows access to stderr afterwards" do
-      cmd = Terrapin::CommandLine.new(
-        "ruby",
-        "-e '$stdout.puts %{hello}; $stderr.puts %{goodbye}'",
-        :swallow_stderr => false
-      )
-      cmd.run
-      expect(cmd.command_output).to eq "hello\n"
-      expect(cmd.command_error_output).to eq "goodbye\n"
-    end
-  end
-end