guard-puma 0.4.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ba3c0c0435df8f3c4ebc9383ae9afbd92bd2f41d
-  data.tar.gz: c89ab9b1313f04b420a8ac8be2dc6a2b685f9440
+SHA256:
+  metadata.gz: c4882d80d8bb73e013141fc821e88c95a5cf8cf2c2cb1597de1d266951dda350
+  data.tar.gz: db041e9db3a6612ad08c77d10c40245675e41b4022366e36ac2a23b6390cc4a5
 SHA512:
-  metadata.gz: f3bf2e82c1da9bdfc4ae1d78244455642b5a07f242f0af7f4998b121492214b5322d5094b9f21b538575d04d2599a93c813055d7a07e614e98f07bce176aa60a
-  data.tar.gz: 073f9b90a53e4aed7fd27c282d63b50ff82f54e57fec7d6579a5446d24dd539648630d0a66f99bc16f88f47ad61f27ec6c35c9a96f431bc676b00aaa8e2ec9f9
+  metadata.gz: 742d39e52c73797a1bfae1d5744a3744a0ee13672ca5c950aa610739614f6647db02153935e72b264c53719aac2a0d1b3992dc5bad5545c48b802c4c0868d94f
+  data.tar.gz: f4e46ba7c2cfdbfb9726bcbf23099456efe4a22cc30b7424f27edaf21dc86a08bd7647e9a463ed99b9dfb302f341914054be89c0800f5c804cb487c42e522d73

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.travis.yml

@@ -1,10 +1,15 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.2.5
-  - 2.3.1
+  - 2.5.5
+  - 2.6.3
+  - 2.7.0-preview1
   - rbx
-  - jruby-9.1.5.0
+  - jruby-9.2.2.0
+env:
+- PUMA_VERSION="~> 5.0"
+- PUMA_VERSION="~> 4.0"
 matrix:
   allow_failures:
     - rvm: rbx
+    - rvm: 2.7.0-preview1

data/CHANGES.md

@@ -1,5 +1,32 @@
 # Changes
 
+## 0.7.0
+
+* Add MIT license identifier in gemspec. Via #45
+* Remove support for MRI 2.2|3 and bump other versions
+
+## 0.6.0
+
+* Bump puma to 4.0
+
+## 0.5.2
+
+* Default config to `-` instead of `nil`. Fixes #38
+
+## 0.5.1
+
+* Detect and use `config/puma.rb` if present
+
+## 0.5.0
+
+* Add `:pumactl` option
+* Add `:restart_timeout` option
+* Don't stop Puma if it was not started by Guard
+* Don't notify about start when no start
+* Improve `guard-compat` using (https://github.com/guard/guard-compat#migrating-your-api-calls)
+* Remove unused `pry` dependency
+* Update versions of dependencies
+
 ## 0.4.1
 
 * Improve notifications. Via #30

data/README.md

@@ -1,6 +1,5 @@
 # Guard::Puma
 [![Build Status](https://secure.travis-ci.org/jc00ke/guard-puma.png)](http://travis-ci.org/jc00ke/guard-puma)
-[![Dependency Status](https://gemnasium.com/jc00ke/guard-puma.png?travis)](https://gemnasium.com/jc00ke/guard-puma)
 
 Restart Puma when some files change
 
@@ -33,17 +32,21 @@ end
 
 * `:port` is the port number to run on (default `4000`)
 * `:environment` is the environment to use (default `development`)
-* `:start_on_start` will start the server when starting Guard (default `true`)
+* `:start_on_start` will start the server when starting Guard and stop the server when reloading/stopping Guard (default `true`)
 * `:force_run` kills any process that's holding open the listen port before attempting to (re)start Puma (default `false`).
 * `:daemon` runs the server as a daemon, without any output to the terminal that ran `guard` (default `false`).
 * `:quiet` runs the server in quiet mode, suppressing output (default `true`).
 * `:debugger` runs the server with the debugger enabled (default `false`). Required ruby-debug gem.
 * `:timeout` waits this number of seconds when restarting the Puma server before reporting there's a problem (default `20`).
+* `:restart_timeout` waits this number of seconds before the next restarting the Puma server (default `1`).
 * `:config` is the path to the Puma config file (optional)
 * `:bind` is URI to bind to (tcp:// and unix:// only) (optional)
 * `:control_token` is the token to use as authentication for the control server(optional)
 * `:control_port` is the port to use for the control server(optional)
 * `:threads` is the min:max number of threads to use. Defaults to 0:16 (optional)
+* `:pumactl` manages the server via `pumactl` executable instead of `puma` (default `false`)
+    * Incompatible with options such as `port`, `environment`, `daemon`, `bind`, `threads`
+    * Use with `config` option is preferred.
 * `:notifications` is the list of notification types that will be sent. Defaults to `[:restarting, :restarted, :not_restarted, :stopped]` (optional)
 
 ## Contributing

data/guard-puma.gemspec

@@ -6,6 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["jesse@jc00ke.com"]
   gem.summary       = %q{Restart puma when files change }
   gem.homepage      = "https://github.com/jc00ke/guard-puma"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -15,9 +16,8 @@ Gem::Specification.new do |gem|
   gem.version       = Guard::PumaVersion::VERSION
   gem.add_dependency              "guard", "~> 2.14"
   gem.add_dependency              "guard-compat", "~> 1.2"
-  gem.add_dependency              "puma", "~> 3.6"
-  gem.add_development_dependency  "rake", "~> 10.4"
-  gem.add_development_dependency  "rspec", "~> 3.5.0"
-  gem.add_development_dependency  "guard-rspec", "~> 4.7.0"
-  gem.add_development_dependency  "pry"
+  gem.add_dependency              "puma", ENV["PUMA_VERSION"] || [">= 4.0", "< 6"]
+  gem.add_development_dependency  "rake", "~> 12"
+  gem.add_development_dependency  "rspec", "~> 3.7"
+  gem.add_development_dependency  "guard-rspec", "~> 4.7"
 end

data/lib/guard/puma.rb

@@ -1,9 +1,6 @@
-require "guard"
-require "guard/plugin"
-require "guard/puma/runner"
-require "rbconfig"
-require "guard/puma/version"
-require "guard/compat/plugin"
+require 'guard/compat/plugin'
+require_relative 'puma/runner'
+require_relative 'puma/version'
 
 module Guard
   class Puma < Plugin
@@ -14,11 +11,13 @@ module Guard
     end
 
     DEFAULT_OPTIONS = {
+      :pumactl => false,
       :port => 4000,
       :environment => default_env,
       :start_on_start => true,
       :force_run => false,
       :timeout => 20,
+      :restart_timeout => 1,
       :debugger => false,
       :notifications => %i[restarting restarted not_restarted stopped]
     }
@@ -28,35 +27,54 @@ module Guard
       @options = DEFAULT_OPTIONS.merge(options)
       @options[:port] = nil if @options.key?(:config)
       @runner = ::Guard::PumaRunner.new(@options)
+      @last_restarted = Time.now
     end
 
     def start
+      return unless options[:start_on_start]
       server = options[:server] ? "#{options[:server]} and " : ""
-      UI.info "Puma starting#{port_text} in #{server}#{options[:environment]} environment."
-      runner.start if options[:start_on_start]
+      Compat::UI.info(
+        "Puma starting#{port_text} in #{server}#{options[:environment]} environment."
+      )
+      runner.start
     end
 
     def reload
-      UI.info "Restarting Puma..."
+      return if (Time.now - @last_restarted) < options[:restart_timeout]
+      @last_restarted = Time.now
+      Compat::UI.info "Restarting Puma..."
       if options[:notifications].include?(:restarting)
-        Notifier.notify("Puma restarting#{port_text} in #{options[:environment]} environment...", :title => "Restarting Puma...", :image => :pending)
+        Compat::UI.notify(
+          "Puma restarting#{port_text} in #{options[:environment]} environment...",
+          title: "Restarting Puma...", image: :pending
+        )
       end
       if runner.restart
-        UI.info "Puma restarted"
+        Compat::UI.info "Puma restarted"
         if options[:notifications].include?(:restarted)
-          Notifier.notify("Puma restarted#{port_text}.", :title => "Puma restarted!", :image => :success)
+          Compat::UI.notify(
+            "Puma restarted#{port_text}.",
+            title: "Puma restarted!", image: :success
+          )
         end
       else
-        UI.info "Puma NOT restarted, check your log files."
+        Compat::UI.info "Puma NOT restarted, check your log files."
         if options[:notifications].include?(:not_restarted)
-          Notifier.notify("Puma NOT restarted, check your log files.", :title => "Puma NOT restarted!", :image => :failed)
+          Compat::UI.notify(
+            "Puma NOT restarted, check your log files.",
+            title: "Puma NOT restarted!", image: :failed
+          )
         end
       end
     end
 
     def stop
+      return unless options[:start_on_start]
       if options[:notifications].include?(:stopped)
-        Notifier.notify("Until next time...", :title => "Puma shutting down.", :image => :pending)
+        Compat::UI.notify(
+          "Until next time...",
+          title: "Puma shutting down.", image: :pending
+        )
       end
       runner.halt
     end

data/lib/guard/puma/runner.rb

@@ -6,49 +6,50 @@ module Guard
 
     MAX_WAIT_COUNT = 20
 
-    attr_reader :options, :control_url, :control_token, :cmd_opts
+    attr_reader :options, :control_url, :control_token, :cmd_opts, :pumactl
 
     def initialize(options)
       @control_token = options.delete(:control_token) { |_| ::Puma::Configuration.random_token }
-      @control = "localhost"
       @control_port = (options.delete(:control_port) || '9293')
-      @control_url = "#{@control}:#{@control_port}"
+      @control_url = "localhost:#{@control_port}"
       @quiet = options.delete(:quiet) { true }
+      @pumactl = options.delete(:pumactl) { false }
       @options = options
 
-      puma_options = if options[:config]
-        {
-          '--config' => options[:config],
-          '--control-token' => @control_token,
-          '--control' => "tcp://#{@control_url}",
-          '--environment' => options[:environment]
-        }
+      puma_options = {
+        puma_options_key(:config) => options.fetch(:config, "-"),
+        puma_options_key(:control_token) => @control_token,
+        puma_options_key(:control_url) => "tcp://#{@control_url}"
+      }
+      if options[:config]
+        puma_options['--config'] = options[:config]
+      elsif default_config_file_exists?
+        puma_options['--config'] = DEFAULT_CONFIG_FILE_PATH
       else
-        {
-          '--port' => options[:port],
-          '--control-token' => @control_token,
-          '--control' => "tcp://#{@control_url}",
-          '--environment' => options[:environment]
-        }
-      end
-      [:bind, :threads].each do |opt|
-        puma_options["--#{opt}"] = options[opt] if options[opt]
+        puma_options['--port'] = options[:port]
       end
+      %i[bind threads environment]
+        .select { |opt| options[opt] }
+        .each do |opt|
+          if pumactl
+            Compat::UI.warning(
+              "`#{opt}` option is not compatible with `pumactl` option"
+            )
+          else
+            puma_options["--#{opt}"] = options[opt]
+          end
+        end
       puma_options = puma_options.to_a.flatten
-      puma_options << '-q' if @quiet
+      puma_options << '--quiet' if @quiet
       @cmd_opts = puma_options.join ' '
     end
 
     def start
-      if in_windows_cmd?
-        Kernel.system windows_start_cmd
-      else
-        Kernel.system nix_start_cmd
-      end
+      Kernel.system build_command('start')
     end
 
     def halt
-      Net::HTTP.get build_uri('halt')
+      run_puma_command!('halt')
       # server may not have been stopped correctly, but we are halting so who cares.
       return true
     end
@@ -68,8 +69,36 @@ module Guard
 
     private
 
+    DEFAULT_CONFIG_FILE_PATH = "config/puma.rb".freeze
+
+    PUMA_OPTIONS_KEYS_BY_PUMACTL = {
+      true => {
+        config:      '--config-file',
+        control_url: '--control-url'
+      }.freeze,
+      false => {
+        config:      '--config',
+        control_url: '--control-url',
+      }.freeze
+    }.freeze
+
+    private_constant :PUMA_OPTIONS_KEYS_BY_PUMACTL
+
+    def default_config_file_exists?
+      File.exist?(DEFAULT_CONFIG_FILE_PATH)
+    end
+
+    def puma_options_key(key)
+      keys = PUMA_OPTIONS_KEYS_BY_PUMACTL[@pumactl]
+      keys.fetch(key) { |k| "--#{k.to_s.tr('_', '-')}" }
+    end
+
     def run_puma_command!(cmd)
-      Net::HTTP.get build_uri(cmd)
+      if pumactl
+        Kernel.system build_command(cmd)
+      else
+        Net::HTTP.get build_uri(cmd)
+      end
       return true
     rescue Errno::ECONNREFUSED => e
       # server may not have been started correctly.
@@ -80,12 +109,22 @@ module Guard
       URI "http://#{control_url}/#{cmd}?token=#{control_token}"
     end
 
-    def nix_start_cmd
-      %{sh -c 'cd #{Dir.pwd} && puma #{cmd_opts} &'}
+    def build_command(cmd)
+      puma_cmd = "#{pumactl ? 'pumactl' : 'puma'} #{cmd_opts} #{cmd if pumactl}"
+      background = cmd == 'start'
+      if in_windows_cmd?
+        windows_cmd(puma_cmd, background)
+      else
+        nix_cmd(puma_cmd, background)
+      end
+    end
+
+    def nix_cmd(puma_cmd, background = false)
+      %(sh -c 'cd #{Dir.pwd} && #{puma_cmd} #{'&' if background}')
     end
 
-    def windows_start_cmd
-      %{cd "#{Dir.pwd}" && start "" /B cmd /C "puma #{cmd_opts}"}
+    def windows_cmd(puma_cmd, background = false)
+      %(cd "#{Dir.pwd}" && #{'start "" /B' if background} cmd /C "#{puma_cmd}")
     end
 
     def in_windows_cmd?

data/lib/guard/puma/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module PumaVersion
-    VERSION = "0.4.1"
+    VERSION = "0.7.0"
   end
 end

data/spec/lib/guard/puma/runner_spec.rb

@@ -1,54 +1,85 @@
 require 'spec_helper'
 require 'guard/puma/runner'
-require 'pry'
 
 describe Guard::PumaRunner do
   let(:runner) { Guard::PumaRunner.new(options) }
   let(:environment) { 'development' }
   let(:port) { 4000 }
 
-  let(:default_options) { { :environment => environment, :port => port } }
+  let(:default_options) { { environment: environment, port: port } }
   let(:options) { default_options }
 
   describe "#initialize" do
     it "sets options" do
       expect(runner.options).to eq(options)
     end
+
+    it "sets the command options" do
+      runner = described_class.new(options.merge(control_token: "abc"))
+      expect(runner.cmd_opts).to include("--config - ")
+      expect(runner.cmd_opts).to include("--control-token abc")
+      expect(runner.cmd_opts).to include("--control-url tcp://localhost:9293")
+      expect(runner.cmd_opts).to include("--port 4000")
+      expect(runner.cmd_opts).to include("--environment development")
+      expect(runner.cmd_opts).to include("--quiet")
+    end
   end
 
-  %w(halt restart).each do |cmd|
+  %w[halt restart].each do |cmd|
     describe cmd do
-      before do
-        allow(runner).to receive(:build_uri).with(cmd).and_return(uri)
+      context "without pumactl" do
+        let(:options) { { pumactl: false } }
+
+        let(:uri) {
+          URI(
+            "http://#{runner.control_url}/#{cmd}?token=#{runner.control_token}"
+          )
+        }
+
+        it "#{cmd}s" do
+          expect(Net::HTTP).to receive(:get).with(uri).once
+          runner.public_send(cmd)
+        end
       end
-      let(:uri) { URI("http://#{runner.control_url}/#{cmd}?token=#{runner.control_token}") }
-      it "#{cmd}s" do
-        expect(Net::HTTP).to receive(:get).with(uri).once
-        runner.send(cmd.intern)
+
+      context "with pumactl" do
+        let(:options) { { pumactl: true } }
+
+        before do
+          allow(runner).to receive(:in_windows_cmd?).and_return(false)
+        end
+
+        let(:command) {
+          %(sh -c 'cd #{Dir.pwd} && pumactl #{runner.cmd_opts} #{cmd} ')
+        }
+
+        it "#{cmd}s" do
+          expect(Kernel).to receive(:system).with(command).once
+          runner.public_send(cmd)
+        end
       end
     end
   end
 
-  describe '#start' do
+  describe "#start" do
     context "when on Windows" do
       before do
         allow(runner).to receive(:in_windows_cmd?).and_return(true)
-        allow(runner).to receive(:windows_start_cmd).and_return("echo 'windows'")
       end
 
       it "runs the Windows command" do
-        expect(Kernel).to receive(:system).with("echo 'windows'")
+        expect(Kernel).to receive(:system).with(%r{cmd /C ".+"})
         runner.start
       end
     end
 
     context "when on *nix" do
       before do
-        allow(runner).to receive(:nix_start_cmd).and_return("echo 'nix'")
+        allow(runner).to receive(:in_windows_cmd?).and_return(false)
       end
 
       it "runs the *nix command" do
-        expect(Kernel).to receive(:system).with("echo 'nix'")
+        expect(Kernel).to receive(:system).with(/sh -c '.+'/)
         runner.start
       end
     end
@@ -69,45 +100,138 @@ describe Guard::PumaRunner do
     let(:command) { runner.start }
 
     context "with config" do
-      let(:options) {{ :config => path }}
       let(:path) { "/tmp/elephants" }
       let(:environment) { "special_dev" }
-      it "adds path to command" do
-        expect(runner.cmd_opts).to match("--config #{path}")
-      end
 
-      context "and additional options" do
-        let(:options) {{ :config => path, :port => "4000", quiet: false, :environment => environment }}
+      context "without pumactl but with a default config file" do
+        let(:options) { { pumactl: false } }
+
         it "assumes options are set in config" do
+          allow_any_instance_of(Guard::PumaRunner).
+            to receive(:default_config_file_exists?).
+            and_return(true)
+          expect(runner.cmd_opts).to match("--config config/puma.rb")
+        end
+      end
+
+      context "without pumactl" do
+        let(:options) { { config: path, pumactl: false } }
+
+        it "adds path to command" do
           expect(runner.cmd_opts).to match("--config #{path}")
-          expect(runner.cmd_opts).to match(/--control-token [0-9a-f]{10,}/)
-          expect(runner.cmd_opts).to match("--control tcp")
-          expect(runner.cmd_opts).to match("--environment #{environment}")
+        end
+
+        context "and additional options" do
+          let(:options) {
+            {
+              config: path, port: "4000",
+              quiet: false, environment: environment
+            }
+          }
+
+          it "assumes options are set in config" do
+            expect(runner.cmd_opts).to match("--config #{path}")
+            expect(runner.cmd_opts).to match(/--control-token [0-9a-f]{10,}/)
+            expect(runner.cmd_opts).to match("--control-url tcp")
+            expect(runner.cmd_opts).to match("--environment #{environment}")
+          end
+        end
+      end
+
+      context "with pumactl" do
+        let(:options) { { config: path, pumactl: true } }
+
+        it "adds path to command" do
+          expect(runner.cmd_opts).to match("--config-file #{path}")
+        end
+
+        context "and additional options" do
+          let(:options) {
+            {
+              pumactl: true,
+              config: path, port: "4000",
+              quiet: false
+            }
+          }
+
+          it "assumes options are set in config" do
+            expect(runner.cmd_opts).to match("--config-file #{path}")
+            expect(runner.cmd_opts).to match(/--control-token [0-9a-f]{10,}/)
+            expect(runner.cmd_opts).to match("--control-url tcp")
+          end
         end
       end
     end
 
     context "with bind" do
-      let(:options) {{ :bind => uri }}
       let(:uri) { "tcp://foo" }
-      it "adds uri option to command" do
-        expect(runner.cmd_opts).to match("--bind #{uri}")
+
+      context "without pumactl" do
+        let(:options) { { pumactl: false, bind: uri } }
+
+        it "adds uri option to command" do
+          expect(runner.cmd_opts).to match("--bind #{uri}")
+        end
+      end
+
+      context "with pumactl" do
+        let(:options) { { pumactl: true, bind: uri } }
+
+        it "raises ArgumentError about incompatible options" do
+          expect(Guard::Compat::UI).to receive(:warning).with(/bind.+pumactl/)
+          runner.cmd_opts
+        end
       end
     end
 
     context "with control_token" do
-      let(:options) {{ :control_token => token }}
       let(:token) { "imma-token" }
+      let(:options) { { control_token: token } }
+
       it "adds token to command" do
         expect(runner.cmd_opts).to match(/--control-token #{token}/)
       end
     end
 
     context "with threads" do
-      let(:options) {{ :threads => threads }}
       let(:threads) { "13:42" }
-      it "adds path to command" do
-        expect(runner.cmd_opts).to match("--threads #{threads}")
+
+      context "without pumactl" do
+        let(:options) { { pumactl: false, threads: threads } }
+
+        it "adds threads option to command" do
+          expect(runner.cmd_opts).to match("--threads #{threads}")
+        end
+      end
+
+      context "with pumactl" do
+        let(:options) { { pumactl: true, threads: threads } }
+
+        it "raises ArgumentError about incompatible options" do
+          expect(Guard::Compat::UI).to receive(:warning).with(/threads.+pumactl/)
+          runner.cmd_opts
+        end
+      end
+    end
+
+    context "with environment" do
+      let(:environment) { "development" }
+
+      context "without pumactl" do
+        let(:options) { { pumactl: false, environment: environment } }
+
+        it "adds environment option to command" do
+          expect(runner.cmd_opts).to match("--environment #{environment}")
+        end
+      end
+
+      context "with pumactl" do
+        let(:options) { { pumactl: true, environment: environment } }
+
+        it "warns about incompatible options" do
+          expect(Guard::Compat::UI).to receive(:warning).with(/environment.+pumactl/)
+          runner.cmd_opts
+        end
       end
     end
   end

data/spec/lib/guard/puma_spec.rb

@@ -57,19 +57,20 @@ describe Guard::Puma do
   end
 
   describe '#start' do
-
-    context 'start on start' do
+    context "start on start" do
       it "runs startup" do
-        expect(guard).to receive(:start).once
+        expect(guard.runner).to receive(:start).once
+        expect(Guard::Compat::UI).to receive(:info).with(/Puma starting/)
         guard.start
       end
     end
 
-    context 'no start on start' do
-      let(:options) { { :start_on_start => false } }
+    context "no start on start" do
+      let(:options) { { start_on_start: false } }
 
-      it "shows the right message and not run startup" do
-        expect(guard.runner).to receive(:start).never
+      it "doesn't show the message and not run startup" do
+        expect(guard.runner).not_to receive(:start)
+        expect(Guard::Compat::UI).not_to receive(:info).with(/Puma starting/)
         guard.start
       end
     end
@@ -81,42 +82,45 @@ describe Guard::Puma do
 
       context "when no config option set" do
         it "contains port" do
-          expect(Guard::UI).to receive(:info).with(/starting on port 4000/)
+          expect(Guard::Compat::UI).to receive(:info)
+            .with(/starting on port 4000/)
           guard.start
         end
       end
 
       context "when config option set" do
-        let(:options) { { :config => 'config.rb' } }
+        let(:options) { { config: 'config.rb' } }
 
         it "doesn't contain port" do
-          expect(Guard::UI).to receive(:info).with(/starting/)
+          expect(Guard::Compat::UI).to receive(:info).with(/starting/)
           guard.start
         end
       end
     end
   end
 
-  describe '#reload' do
+  describe "#reload" do
+    let(:zero_restart_timeout) { { restart_timeout: 0 } }
+    let(:options) { zero_restart_timeout }
 
     before do
-      expect(Guard::UI).to receive(:info).with('Restarting Puma...')
-      expect(Guard::UI).to receive(:info).with('Puma restarted')
       allow(guard.runner).to receive(:restart).and_return(true)
+      allow_any_instance_of(Guard::PumaRunner).to receive(:halt)
     end
 
-    let(:runner_stub) { allow_any_instance_of(Guard::PumaRunner).to receive(:halt) }
-
     context "with default options" do
       it "restarts and show the message" do
-        expect(Guard::Notifier).to receive(:notify).with(
+        expect(Guard::Compat::UI).to receive(:info).with('Restarting Puma...')
+        expect(Guard::Compat::UI).to receive(:info).with('Puma restarted')
+
+        expect(Guard::Compat::UI).to receive(:notify).with(
           /restarting on port 4000/,
-          hash_including(:title => "Restarting Puma...", :image => :pending)
+          hash_including(title: "Restarting Puma...", image: :pending)
         )
 
-        expect(Guard::Notifier).to receive(:notify).with(
+        expect(Guard::Compat::UI).to receive(:notify).with(
           "Puma restarted on port 4000.",
-          hash_including(:title => "Puma restarted!", :image => :success)
+          hash_including(title: "Puma restarted!", image: :success)
         )
 
         guard.reload
@@ -124,17 +128,20 @@ describe Guard::Puma do
     end
 
     context "with config option set" do
-      let(:options) { { :config => "config.rb" } }
+      let(:options) { { config: "config.rb" }.merge!(zero_restart_timeout) }
 
       it "restarts and show the message" do
-        expect(Guard::Notifier).to receive(:notify).with(
+        expect(Guard::Compat::UI).to receive(:info).with('Restarting Puma...')
+        expect(Guard::Compat::UI).to receive(:info).with('Puma restarted')
+
+        expect(Guard::Compat::UI).to receive(:notify).with(
           /restarting/,
-          hash_including(:title => "Restarting Puma...", :image => :pending)
+          hash_including(title: "Restarting Puma...", image: :pending)
         )
 
-        expect(Guard::Notifier).to receive(:notify).with(
+        expect(Guard::Compat::UI).to receive(:notify).with(
           "Puma restarted.",
-          hash_including(:title => "Puma restarted!", :image => :success)
+          hash_including(title: "Puma restarted!", image: :success)
         )
 
         guard.reload
@@ -142,49 +149,95 @@ describe Guard::Puma do
     end
 
     context "with custom :notifications option" do
-      let(:options) { { :notifications => [:restarted] } }
+      let(:options) {
+        { notifications: [:restarted] }.merge!(zero_restart_timeout)
+      }
 
       it "restarts and show the message only about restarted" do
-        expect(Guard::Notifier).not_to receive(:notify).with(/restarting/)
-        expect(Guard::Notifier).to receive(:notify).with(/restarted/, kind_of(Hash))
+        allow(Guard::Compat::UI).to receive(:info)
+
+        expect(Guard::Compat::UI).not_to receive(:notify).with(/restarting/)
+        expect(Guard::Compat::UI).to receive(:notify)
+          .with(/restarted/, kind_of(Hash))
 
         guard.reload
       end
     end
 
     context "with empty :notifications option" do
-      let(:options) { { :notifications => [] } }
+      let(:options) { { notifications: [] }.merge!(zero_restart_timeout) }
 
       it "restarts and doesn't show the message" do
-        expect(Guard::Notifier).not_to receive(:notify)
+        allow(Guard::Compat::UI).to receive(:info)
+
+        expect(Guard::Compat::UI).not_to receive(:notify)
 
         guard.reload
       end
     end
 
+    context "with :restart_timeout option" do
+      let(:restart_timeout) { 1.0 }
+      let(:options) { { restart_timeout: restart_timeout } }
+
+      before { sleep restart_timeout }
+
+      it "doesn't restarts during restart timeout" do
+        allow(Guard::Compat::UI).to receive(:info)
+        allow(Guard::Compat::UI).to receive(:notify)
+
+        expect(guard.runner).to receive(:restart).twice
+
+        guard.reload
+        sleep restart_timeout / 2
+        guard.reload
+        sleep restart_timeout
+        guard.reload
+      end
+    end
   end
 
-  describe '#stop' do
+  describe "#stop" do
     context "with default options" do
       it "stops correctly with notification" do
-        expect(Guard::Notifier).to receive(:notify).with('Until next time...', anything)
+        expect(Guard::Compat::UI).to receive(:notify)
+          .with('Until next time...', anything)
         expect(guard.runner).to receive(:halt).once
         guard.stop
       end
     end
 
     context "with custom :notifications option" do
-      let(:options) { { :notifications => [] } }
+      let(:options) { { notifications: [] } }
 
       it "stops correctly without notification" do
-        expect(Guard::Notifier).not_to receive(:notify)
+        expect(Guard::Compat::UI).not_to receive(:notify)
         expect(guard.runner).to receive(:halt).once
         guard.stop
       end
     end
+
+    context "start on start" do
+      it "stops correctly with notification" do
+        expect(guard.runner).to receive(:halt).once
+        expect(Guard::Compat::UI).to receive(:notify)
+          .with('Until next time...', anything)
+        guard.stop
+      end
+    end
+
+    context "no start on start" do
+      let(:options) { { start_on_start: false } }
+
+      it "doesn't show the message and doesn't halt" do
+        expect(guard.runner).not_to receive(:halt)
+        expect(Guard::Compat::UI).not_to receive(:notify)
+        guard.stop
+      end
+    end
   end
 
-  describe '#run_on_changes' do
+  describe "#run_on_changes" do
     it "reloads on change" do
       expect(guard).to receive(:reload).once
       guard.run_on_changes([])

data/spec/spec_helper.rb

@@ -11,4 +11,5 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.mock_with :rspec
+  config.color = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard-puma
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Jesse Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-13 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -42,72 +42,64 @@ dependencies:
   name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '12'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.7.0
+        version: '4.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.7.0
-- !ruby/object:Gem::Dependency
-  name: pry
-  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'
+        version: '4.7'
 description: 
 email:
 - jesse@jc00ke.com
@@ -115,6 +107,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".editorconfig"
 - ".gitignore"
 - ".travis.yml"
 - CHANGES.md
@@ -132,7 +125,8 @@ files:
 - spec/lib/guard/puma_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jc00ke/guard-puma
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -149,8 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Restart puma when files change