dante 0.1.5 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aa7b32fa2eed7d038ee4835edd3155967b25f62360ba553c1f153004c8ccf0f6
+  data.tar.gz: 8e4d92c8ade70fd93d399744324de5205dbdb8c9f3b4c25a4b2445d0857a56d8
+SHA512:
+  metadata.gz: 97423c3af18736da37830316eee8ade12cf3d1205ec158a70743a65ceb99e9df9f6268ff7e3946aa66808e93eb7c2c38550ee647c8dff874dd796aa4b815fa7c
+  data.tar.gz: 30d083e38a48c5a6d64c9a0af91a441c577199b833c38176d0bc4f470b1fd7a2861d6fa95f998c9f690203e6e039f1670abc73939db5c0fcc7b383112eee48b4

data/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4', '4.0']
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake test
+    - name: Run the user and group switching tests as root
+      run: sudo -E env "PATH=$PATH" bundle exec ruby -Ilib -Itest test/user_switch_test.rb

data/.github/workflows/release.yml

@@ -0,0 +1,210 @@
+# Publishes a dante release to rubygems.org with trusted publishing, gated by the "release"
+# environment: the owner approves each publish.
+#
+# Usual path: merge the release PR (the version in lib/dante/version.rb and the CHANGELOG.md heading
+# stamped with the date, e.g. "## 0.3.0 (2026-11-01)"), then "Run workflow" on master with the
+# version. build checks the version, that the changelog's first heading is that version with a date,
+# and the branch, and builds the gem reproducibly; publish waits for approval, pushes the gem with
+# short-lived trusted-publishing credentials, then creates the tag vX.Y.Z on the built commit. Pushing
+# a vX.Y.Z tag on a master commit runs the same checks. "Re-run failed jobs" (not "Re-run all jobs",
+# which rebuilds) resumes a release that stopped partway.
+# If the gem is pushed but the tag step keeps failing, push the tag by hand at the built commit: that
+# tag push's run skips the push (same sum).
+#
+# Dry run: tick dry_run to check the wiring. Everything runs except the changelog checks, the tag and
+# the push; the credential exchange fails unless the trusted publisher is set up.
+#
+# The "release" environment's protection rules are the ONLY gate on publishing (required reviewer, no
+# admin bypass, deployments only from master and v*.*.* tags): RubyGems trusts any run of this file
+# that uses that environment, and a branch or tag can carry its own modified copy of it. The trusted
+# publisher on rubygems.org must name the environment. Before approving a deployment, check
+# who started the run, the event, that the commit is the release PR's merge commit, and the build
+# log's "is on master" line. Reject any run you won't approve: a waiting run blocks the next one.
+# A deployment rule for X.Y-stable lets anyone with write access create such a branch carrying its own
+# copy of this file: add one only for a maintenance release, and remove it after.
+
+name: release
+run-name: release ${{ inputs.version || github.ref_name }}${{ inputs.dry_run && ' (dry run)' || '' }}
+
+on:
+  push:
+    tags: ['v[0-9]+.[0-9]+.[0-9]+']
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release (already in the version file of this branch), e.g. 1.2.0'
+        required: true
+        type: string
+      dry_run:
+        description: 'Dry run: check, build and exchange credentials, but create no tag and push nothing'
+        required: false
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  build:
+    if: github.repository == 'nesquena/dante'
+    runs-on: ubuntu-latest
+    env:
+      TRUNK: master
+      TAG_PREFIX: v
+      GEMS: 'dante:.'
+      VERSION_FILE: lib/dante/version.rb
+      CHANGELOG: CHANGELOG.md
+      CHANGELOG_HEADING: '^## '
+      CHANGELOG_TOP: '^## ([0-9]+\.[0-9]+\.[0-9]+)( |$)'
+    outputs:
+      version: ${{ steps.check.outputs.version }}
+      tag: ${{ steps.check.outputs.tag }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+          submodules: true
+          persist-credentials: false
+      - uses: ruby/setup-ruby@de492cf36cbab201753d720ce4f4e336cd688c94 # v1.336.0
+        with:
+          ruby-version: '3.3'
+      - name: Check the version
+        id: check
+        shell: bash -eo pipefail {0}
+        env:
+          INPUT_VERSION: ${{ inputs.version }}
+          DRY_RUN: ${{ inputs.dry_run }}
+        run: |
+          if [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
+            version="$INPUT_VERSION"
+            [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::the version input is not a plain version like 1.2.3"; exit 1; }
+            case "$GITHUB_REF" in
+              "refs/heads/$TRUNK"|"refs/heads/${version%.*}-stable") ;;
+              *) echo "::error::run this on $TRUNK or ${version%.*}-stable, not $GITHUB_REF"; exit 1 ;;
+            esac
+            tag="$TAG_PREFIX$version"
+            tagged=$(git ls-remote origin "refs/tags/$tag*" | awk -v t="refs/tags/$tag" '$2 == t || $2 == t "^{}" { print $1 }')
+            [ -z "$tagged" ] || echo "$tagged" | grep -qx "$GITHUB_SHA" ||
+              { echo "::error::tag $tag already exists at another commit"; exit 1; }
+          else
+            tag="$GITHUB_REF_NAME"
+            version="${tag#"$TAG_PREFIX"}"
+            [[ "$tag" == "$TAG_PREFIX"* && "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::tag $tag is not ${TAG_PREFIX}X.Y.Z"; exit 1; }
+          fi
+          file_version=$(ruby -e 'puts File.binread(ENV["VERSION_FILE"])[/\bVERSION\s*=\s*["\x27]([^"\x27]+)/, 1]')
+          [ "$version" = "$file_version" ] || { echo "::error::version $version but $VERSION_FILE says $file_version"; exit 1; }
+          if [ "$DRY_RUN" = true ]; then
+            echo "::warning::dry run: not checking $CHANGELOG"
+          else
+            heading=$(grep -m1 -E "$CHANGELOG_HEADING" "$CHANGELOG") || { echo "::error::$CHANGELOG has no heading matching '$CHANGELOG_HEADING'"; exit 1; }
+            top=$(echo "$heading" | sed -nE "s/$CHANGELOG_TOP.*/\1/p")
+            [ "$top" = "$version" ] || { echo "::error::$CHANGELOG starts with '$heading', not release $version: merge the release PR first, and nothing after it"; exit 1; }
+            rest="${heading#*"$version"}"
+            [[ "$rest" =~ (19|20)[0-9][0-9] ]] && ! echo "$rest" | grep -qiwE 'unreleased|tbd|tba' ||
+              { echo "::error::$CHANGELOG's '$heading' isn't stamped with a date yet"; exit 1; }
+          fi
+          series="${version%.*}-stable"
+          on=""
+          for b in "$series" "$TRUNK"; do
+            git merge-base --is-ancestor "$GITHUB_SHA" "refs/remotes/origin/$b" 2>/dev/null && on="$b"
+          done
+          [ -n "$on" ] || { echo "::error::$version ($GITHUB_SHA) is not on $TRUNK or $series"; exit 1; }
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "$version ($GITHUB_SHA) is on $on"
+      - name: Build the gems
+        shell: bash -eo pipefail {0}
+        env:
+          VERSION: ${{ steps.check.outputs.version }}
+        run: |
+          SOURCE_DATE_EPOCH=$(git log -1 --format=%ct "$GITHUB_SHA"); export SOURCE_DATE_EPOCH
+          mkdir dist
+          for spec in $GEMS; do
+            g="${spec%%:*}"; dir="${spec#*:}"; [ "$dir" = "$spec" ] && dir=.
+            out="$GITHUB_WORKSPACE/dist/$g-$VERSION.gem"
+            (cd "$dir" && gem build "$g.gemspec" --output "$out")
+            [ "$(gem spec "$out" name)" = "--- $g" ] && [ "$(gem spec "$out" version | sed -n 's/^version: //p')" = "$VERSION" ] ||
+              { echo "::error::$out is not $g $VERSION:"; gem spec "$out" name; gem spec "$out" version; exit 1; }
+            echo "$g" >> dist/ORDER
+          done
+          echo "SOURCE_DATE_EPOCH=$SOURCE_DATE_EPOCH (ruby $(ruby -e 'print RUBY_VERSION'), rubygems $(gem -v))"
+          (cd dist && sha256sum *.gem > SHA256SUMS && cat ORDER SHA256SUMS)
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: gems-${{ steps.check.outputs.version }}
+          path: dist/
+          if-no-files-found: error
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      contents: write   # creates the tag on a dispatched release
+      id-token: write   # the RubyGems trusted-publishing exchange
+    steps:
+      - name: Refuse a stale run (the tag is somewhere else)
+        shell: bash -eo pipefail {0}
+        env:
+          TAG: ${{ needs.build.outputs.tag }}
+        run: |
+          tagged=$(git ls-remote "https://github.com/$GITHUB_REPOSITORY" "refs/tags/$TAG*" |
+            awk -v t="refs/tags/$TAG" '$2 == t || $2 == t "^{}" { print $1 }')
+          if [ -z "$tagged" ] && [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
+            echo "tag $TAG will be created at $GITHUB_SHA"
+          else
+            echo "$tagged" | grep -qx "$GITHUB_SHA" || { echo "::error::tag $TAG is not at $GITHUB_SHA (now: ${tagged:-gone}); this run is stale"; exit 1; }
+          fi
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          name: gems-${{ needs.build.outputs.version }}
+          path: dist
+      - name: Check the sums
+        working-directory: dist
+        run: sha256sum -c SHA256SUMS
+      - uses: ruby/setup-ruby@de492cf36cbab201753d720ce4f4e336cd688c94 # v1.336.0
+        with:
+          ruby-version: '3.3'
+      - uses: rubygems/configure-rubygems-credentials@dc5a8d8553e6ee01fc26761a49e99e733d17954a # v2.1.0
+      - name: Dry run ends here
+        if: inputs.dry_run
+        run: echo "Credentials exchange succeeded, so the trusted publisher works. No tag created, nothing pushed."
+      - name: Push the gems
+        if: ${{ !inputs.dry_run }}
+        shell: bash -eo pipefail {0}
+        working-directory: dist
+        env:
+          VERSION: ${{ needs.build.outputs.version }}
+        run: |
+          while read -r g; do
+            sum=$(sha256sum "$g-$VERSION.gem" | cut -d' ' -f1)
+            published=$(curl -fsS "https://rubygems.org/api/v1/versions/$g.json" 2>/dev/null |
+              ruby -rjson -e 'b = $stdin.read; v = (b.empty? ? [] : JSON.parse(b)).find { |x| x["number"] == ENV["VERSION"] && x["platform"] == "ruby" }; print v ? v["sha"].to_s : ""' || true)
+            if [ -z "$published" ]; then
+              gem push "$g-$VERSION.gem" </dev/null
+            elif [ "$published" = "$sum" ]; then
+              echo "$g $VERSION is already on rubygems.org with this sum; skipping"
+            else
+              echo "::error::$g $VERSION is already on rubygems.org with sha256 $published, not this build's $sum"; exit 1
+            fi
+          done < ORDER
+      - name: Create the tag
+        if: github.event_name == 'workflow_dispatch' && !inputs.dry_run
+        shell: bash -eo pipefail {0}
+        env:
+          TAG: ${{ needs.build.outputs.tag }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          tagged=$(git ls-remote "https://github.com/$GITHUB_REPOSITORY" "refs/tags/$TAG*" |
+            awk -v t="refs/tags/$TAG" '$2 == t || $2 == t "^{}" { print $1 }')
+          if [ -z "$tagged" ]; then
+            gh api "repos/$GITHUB_REPOSITORY/git/refs" -f ref="refs/tags/$TAG" -f sha="$GITHUB_SHA"
+          elif echo "$tagged" | grep -qx "$GITHUB_SHA"; then
+            echo "tag $TAG is already at $GITHUB_SHA"
+          else
+            echo "::error::tag $TAG is not at $GITHUB_SHA (now: $tagged)"; exit 1
+          fi

data/CHANGELOG.md

@@ -0,0 +1,96 @@
+# Changelog
+
+## 0.3.0 (2026-10-31)
+
+Changes since 0.2.0:
+
+- **Ruby 2.7 or newer is now required** (the gemspec declares it). Stay on 0.2.0 for older Rubies. (#21, @nesquena)
+- **New `-f`/`--force` option** (`:force => true`): when a stop's SIGTERM does not stop the daemon within 5 seconds,
+  dante sends SIGKILL. (#13, @hayesgm)
+- **Changed: stopping keeps the pid file until the daemon has stopped.** `-k`/`stop` used to delete the pid file
+  before signalling; it now deletes it only once the daemon has exited, and keeps it (and says "Failed to kill
+  daemonized process") when the daemon survives. The log line is now "Sent SIGTERM to PID: ..." instead of
+  "Stopped PID: ...": update anything that matches the old text. (#13, @hayesgm)
+- **Changed: user and group switching as root** (`-u`, `-G`, `:user`, `:group`). Everything is looked up before
+  anything changes. `-u` now takes the user's primary group (or the `-G` group) and the user's own supplementary
+  groups; before, the daemon kept gid 0 and root's supplementary groups. `-G` alone leaves only that group. If your
+  daemon relied on root's groups, add the user to the groups it needs or pass `-G`. Where root may not change its
+  groups (a restricted capability set, or a user namespace that denies setgroups), `-u` now fails at startup with
+  `Errno::EPERM`, as `su` does. A non-root process changes only what it was given, as before. (#22, @nesquena)
+- **Changed: the daemon keeps the caller's umask** instead of setting it to 0000, so new files are 644 and
+  directories 755 under umask 022 (they were 666 and 777). If the daemon must create world-writable files, set
+  `File.umask` in the startup block. The log file stays 0644. (#22, @nesquena)
+- **Changed: a daemon now counts as started only if it is still running 1 second after it was forked**, so
+  `-d` takes up to a second longer. A daemon that exits at once (its startup block raised, or returned) is now
+  reported as "Daemonized process couldn't be started", `daemonize` returns false, and the pid file it left is
+  removed; before, it could be reported as started, and its stale pid stayed in the pid file. The exit status of
+  your executable doesn't change (dante doesn't set it): to act on a failed start, check what `execute` returns.
+  (#24, @nesquena)
+- **Changed: the process between the caller and the daemon no longer runs the program's `at_exit` handlers**; it
+  leaves with `exit!`, as Ruby's `Process.daemon` does. They used to run in the two intermediate processes right
+  after the fork, so a cleanup handler (stripe-ruby-mock's `kill_server`, say) ran there too. Handlers still run in
+  the caller and in the daemon; nothing to do unless you relied on that extra run. (#24, @nesquena)
+- Fixed: output redirection when the standard streams are sockets (Spring, Zeus): output now goes to the log
+  instead of raising `can't change access mode`. Reported by @antonfefilov in #20. (#22, @nesquena)
+- Fixed: a pid file naming another user's process no longer crashes with `Errno::EPERM`: starting prints "Process
+  is already started", and `-k` reports that it could not stop the process and keeps the pid file. (#22, @nesquena)
+- Fixed: `-k` on another user's process gives up at once (in about 0.2 seconds) instead of waiting 5 seconds, or
+  10 with `--force`, for a process it cannot signal. (#24, @nesquena)
+- Fixed: an empty pid file (left by a crash between creating and writing it), or one holding 0 or a negative
+  number, counts as no daemon. Before, starting refused with "Process is already started", and `-k` sent SIGTERM
+  to its own process group, killing itself and the processes started alongside it. A number too large for a pid
+  counts as no daemon too, where it raised `RangeError`. (#24, @nesquena)
+- Fixed: daemonizing from a program that ignores SIGCHLD (`trap('CHLD', 'IGNORE')`) raised `Errno::ECHILD`; it now
+  reports whether the daemon started. (#24, @nesquena)
+- Fixed: INT and TERM are handled before the pid file is written, so a `-k` right after start goes through
+  dante's handler. (#22, @nesquena)
+- The gemspec now declares the MIT license and points its homepage at github.com/nesquena/dante, and the
+  deprecated `rubyforge_project` setting is gone. (#27, @nesquena)
+- Development: the test suite is reliable on current Ruby and minitest (mocha is no longer needed), `rake` runs
+  it, and GitHub Actions runs it on Ruby 2.7 to 4.0. Reported by @balasankarc in #19. (#21, #23, @nesquena)
+
+## 0.2.0 (2013-12-04)
+
+- A `verify_options_hook` to validate options; daemon mode logs to `/var/log/<name>.log` by default; a log file
+  given in the foreground is used. (#7, #9, #10, @rkatti)
+- The daemonizing process reaps its child, leaving no zombie. (#5, @jonigata)
+
+## 0.1.5 (2012-06-21)
+
+- Fixes for `kill_pid`, `interrupt` and `log`. (@mckern)
+
+## 0.1.4 (2012-06-20)
+
+- Fixed user and group switching and log redirection; cleaner shutdown message. (#1, @mckern)
+
+## 0.1.3 (2012-01-30)
+
+- `-l`/`--log`: a log file for the daemon's output.
+
+## 0.1.2 (2011-12-06)
+
+- `daemon_running?` and `daemon_stopped?` are public.
+
+## 0.1.1 (2011-12-06)
+
+- Better handling of the debug option.
+
+## 0.1.0 (2011-12-06)
+
+- A more robust runner: stops and starts are checked, and `restart` is added.
+
+## 0.0.4 (2011-11-30)
+
+- Stopping sends INT instead of KILL. (@joshbuddy)
+
+## 0.0.3 (2011-11-30)
+
+- Cleaner process stopping.
+
+## 0.0.2 (2011-11-28)
+
+- Custom options (`with_options`), a custom banner, and options passed to the startup block.
+
+## 0.0.1 (2011-11-21)
+
+- First release.

data/Gemfile

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

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Miso
+Copyright (c) 2011-2026 Nathan Esquenazi
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -65,12 +65,28 @@ This gives your binary several useful things for free:
 
 will start the app undaemonized in the terminal, handling trapping and stopping the process.
 
+```
+./bin/myapp -l /var/log/myapp.log
+```
+
+will start the app undaemonized in the terminal and redirect all stdout and stderr to the specified logfile.
+
 ```
 ./bin/myapp -p 8080 -d -P /var/run/myapp.pid -l /var/log/myapp.log
 ```
 
-will daemonize and start the process, storing the pid in the specified pid file.
-All stdout and stderr will be redirected to the specified logfile.
+will daemonize and start the process, storing the pid in the specified pid file. It reports the daemon as
+started once the daemon has kept running for a second, and as not started if it exits before then.
+All stdout and stderr will be redirected to the specified logfile. If no logfile is specified in daemon mode then all 
+stdout and stderr will be directed to /var/log/<myapp name>.log.
+
+```
+./bin/myapp -d -u nobody -G nogroup
+```
+
+will switch to the user nobody before starting, with the group given by `-G`. When started as root, the group
+defaults to the user's primary group, and the process takes on the user's supplementary groups (plus the `-G`
+group, if given).
 
 ```
 ./bin/myapp -k -P /var/run/myapp.pid
@@ -104,6 +120,10 @@ runner.with_options do |opts|
     options[:test] = test
   end
 end
+# Create validation hook for options
+runner.verify_options_hook = lambda { |opts|
+  raise Exception.new("Must supply test parameter") if opts[:test].nil?
+}
 # Parse command-line options and execute the process
 runner.execute do |opts|
   # opts: host, pid_path, port, daemonize, user, group
@@ -170,4 +190,4 @@ and that's all. Of course now you can also easily daemonize as well as start/sto
 
 ## Copyright
 
-Copyright © 2011 Nathan Esquenazi. See [LICENSE](https://github.com/bazaarlabs/dante/blob/master/LICENSE) for details.
+Copyright © 2011-2026 Nathan Esquenazi. See [LICENSE](https://github.com/nesquena/dante/blob/master/LICENSE) for details.

data/Rakefile

@@ -2,14 +2,22 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 # require 'yard'
 
-task :test do
-  Rake::TestTask.new do |t|
-    t.libs.push "lib"
-    t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
-    t.verbose = true
-  end
+TEST_FILES = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = TEST_FILES
+  t.verbose = true
+end
+
+# Rake::TestTask treats an empty file list as a passing run of nothing.
+task :test_files_present do
+  abort "No test files match test/**/*_test.rb" if TEST_FILES.empty?
 end
+task :test => :test_files_present
+
+task :default => :test
 
 # task :doc do
 #  YARD::CLI::Yardoc.new.run
-# end
+# end

data/dante.gemspec

@@ -7,18 +7,17 @@ Gem::Specification.new do |s|
   s.version     = Dante::VERSION
   s.authors     = ["Nathan Esquenazi"]
   s.email       = ["nesquena@gmail.com"]
-  s.homepage    = "https://github.com/bazaarlabs/dante"
+  s.homepage    = "https://github.com/nesquena/dante"
   s.summary     = %q{Turn any process into a demon}
   s.description = %q{Turn any process into a demon.}
-
-  s.rubyforge_project = "dante"
+  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.require_paths = ["lib"]
+  s.required_ruby_version = '>= 2.7'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
-  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'minitest', '>= 5.0'
 end