guard 2.10.4 → 2.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6fc0ad2fbda04c8ee81a66a51ab6bb8a084e1424
-  data.tar.gz: 3da8cfbf2e1014f8c0ac1bf16669514537474dd9
+  metadata.gz: df6dd8c3a8afddbe828bc11ed09f1586ebd6a5fa
+  data.tar.gz: 64d5137c8119bdc11273ba20aa3592e228dbaf3b
 SHA512:
-  metadata.gz: 36a8be8f123f47f11d4051d502f5063fd4afea3e1c1d8305cfae527d6763338b7cd01b4411361b765283de0e90462f27b9a6707a1a33591f0ca9dfb69e5f4076
-  data.tar.gz: 338cd2c5a62a03bc7a922398537b98decf56c1543e304c04cd3b60e54c6efc9b69e395d6b6bb36429bc55af3c5adcf09a69696b87da035d52cad0fd61d3454b7
+  metadata.gz: 19e7f4548e9b3d36560ce126b8bc3df6a95ac789d82a9bf811c00f88f9fae2f9b2c7dff248b73a8f70a1785471fde1dd28932486e13497cc9715270412431a25
+  data.tar.gz: 5893cb11c600e01bb7e999255696ce081a62389abd2d20ac5031131f03aa82f7d990e837c5dd3676d699391c99e6791a2bff7f03f0c153713e1926e45ae01972

data/README.md

@@ -120,63 +120,7 @@ Usage
 
 Guard is run from the command line. Please open your terminal and go to your project work directory.
 
-### Help
-
-You can always get help on the available tasks with the `help` task:
-
-```bash
-$ bundle exec guard help
-```
-
-Requesting more detailed help on a specific task is simple: just append the task name to the help task.
-For example, to get help for the `start` task, simply run:
-
-```bash
-$ bundle exec guard help start
-```
-
-### Init
-
-You can generate a Guardfile and have all installed plugins be automatically added into
-it by running the `init` task without any option:
-
-```bash
-$ bundle exec guard init
-```
-
-You can also specify the name of an installed plugin to only get that plugin template
-in the generated Guardfile:
-
-```bash
-$ bundle exec guard init <guard-name>
-```
-
-You can also specify the names of multiple plugins to only get those plugin templates
-in the generated Guardfile:
-
-```bash
-$ bundle exec guard init <guard1-name> <guard2-name>
-```
-
-You can also define your own templates in `~/.guard/templates/` which can be appended in the same way to your existing
-`Guardfile`:
-
-```bash
-$ bundle exec guard init <template-name>
-```
-
-**Note**: If you already have a `Guardfile` in the current directory, the `init` task can be used
-to append a supplied template from an installed plugin to your existing `Guardfile`.
-
-#### `-b`/`--bare` option
-
-You can generate an empty `Guardfile` by running the `init` task with the bare
-option:
-
-```bash
-$ bundle exec guard init --bare
-$ bundle exec guard init -b # shortcut
-```
+Look here for a full [list of Guard commands](https://github.com/guard/guard/wiki/List-of-Guard-Commands)
 
 ### Start
 
@@ -189,621 +133,16 @@ $ bundle exec guard
 Guard will look for a `Guardfile` in your current directory. If it does not find one, it will look in your `$HOME`
 directory for a `.Guardfile`.
 
-#### `-c`/`--clear` option
-
-The shell can be cleared after each change:
-
-```bash
-$ bundle exec guard --clear
-$ bundle exec guard -c # shortcut
-```
-
-You may prefer to enable clearing in all projects by addin the `clearing`
-statement (described below) in you `~/.guardrc` instead:
-
-```ruby
-clearing :on
-```
-
-#### `-n`/`--notify` option
-
-System notifications can be disabled:
-
-```bash
-$ bundle exec guard --notify false
-$ bundle exec guard -n f # shortcut
-```
-
-Notifications can also be disabled globally by setting a `GUARD_NOTIFY` environment variable to `false`.
-
-#### `-g`/`--group` option
-
-Scope Guard to certain plugin groups on start:
-
-```bash
-$ bundle exec guard --group group_name another_group_name
-$ bundle exec guard -g group_name another_group_name # shortcut
-```
-
-See the Guardfile DSL below for creating groups.
-
-#### `-P`/`--plugin` option
-
-Scope Guard to certain plugins on start:
-
-```bash
-$ bundle exec guard --plugin plugin_name another_plugin_name
-$ bundle exec guard -P plugin_name another_plugin_name # shortcut
-```
-
-#### `-d`/`--debug` option
-
-Guard can display debug information (useful for plugin
-developers) with:
-
-```bash
-$ bundle exec guard --debug
-$ bundle exec guard -d # shortcut
-```
-
-#### `-w`/`--watchdir` option
-
-Guard can watch any number of directories instead of only the current directory:
-
-```bash
-$ bundle exec guard --watchdir source/files # watch a subdirectory of your project
-$ bundle exec guard -w source/files # shortcut
-$ bundle exec guard -w sources/foo assets/foo ./config # multiple directories
-
-$ bundle exec guard -w /fancy/project # path outside project - watch out! (see below)
-```
-*NOTE: this option is only meant for ignoring subdirectories in the CURRENT
-directory - by selecting which ones to actually track.*
-
-If your watched directories are outside the current one, or if `--watchdirs` isn't working
-as you expect, be sure to read: [Correctly using watchdirs](https://github.com/guard/guard/wiki/Correctly-using-the---watchdir-option)
-
-You may find it more convenient to use the `directories` statement (described
-below) in your Guardfile
-
-
-#### `-G`/`--guardfile` option
-
-Guard can use a `Guardfile` not located in the current directory:
-
-```bash
-$ bundle exec guard --guardfile ~/.your_global_guardfile
-$ bundle exec guard -G ~/.your_global_guardfile # shortcut
-```
-*TIP: set `BUNDLER_GEMFILE` environment variable to point to your Gemfile if it isn't in the current directory or the current Gemfile doesn't include all your favorite plugins*
-
-#### `-i`/`--no-interactions` option
-
-Turn off completely any Guard terminal interactions with:
-
-```bash
-$ bundle exec guard start -i
-$ bundle exec guard start --no-interactions
-```
-
-#### `-B`/`--no-bundler-warning` option
-
-Skip Bundler warning when a Gemfile exists in the project directory but Guard is not run with Bundler.
-
-```bash
-$ bundle exec guard start -B
-$ bundle exec guard start --no-bundler-warning
-```
-
-#### `-l`/`--latency` option
-
-Overwrite Listen's default latency, useful when your hard-drive / system is slow.
-
-```bash
-$ bundle exec guard start -l 1.5
-$ bundle exec guard start --latency 1.5
-```
-
-*NOTE: this option is OS specific: while higher values may reduce CPU usage
-(and lower values may increase responsiveness) when in polling mode , it has no
-effect for optimized backends (except on Mac OS). If guard is not behaving as
-you want, you'll likely instead want to tweak the `--wait-for-delay` option
-below or use the `--watchdirs` option.*
-
-
-#### `-p`/`--force-polling` option
-
-Force Listen polling listener usage.
-
-```bash
-$ bundle exec guard start -p
-$ bundle exec guard start --force-polling
-```
-
-#### `-y`/`--wait-for-delay` option
-
-Overwrite Listen's default wait_for_delay, useful for kate-like editors through
-ssh access or when guard is annoyingly running tasks multiple times.
-
-```bash
-$ bundle exec guard start -y 1
-$ bundle exec guard start --wait-for-delay 1
-```
-
-#### `-o`/`--listen-on` option
-
-Use Listen's network functionality to receive file change events from the network. This is most useful for virtual machines (e.g. Vagrant) which have problems firing native filesystem events on the guest OS.
-
-##### Suggested use:
-
-On the host OS, you need to listen to filesystem events and forward them to your VM using the `listen` script:
-
-```bash
-$ listen -f 127.0.0.1:4000
-```
-
-Remember to configure your VM to forward the appropriate ports, e.g. in Vagrantfile:
-
-```ruby
-config.vm.network :forwarded_port, guest: 4000, host: 4000
-```
-
-Then, on your guest OS, listen to the network events but ensure you specify the *host* path
-
-```bash
-$ bundle exec guard -o '10.0.2.2:4000' -w '/projects/myproject'
-```
-
-### List
-
-You can list the available plugins with the `list` task:
-
-```bash
-$ bundle exec guard list
-+----------+--------------+
-| Plugin   | In Guardfile |
-+----------+--------------+
-| Compass  | ✘            |
-| Cucumber | ✘            |
-| Jammit   | ✘            |
-| Ronn     | ✔            |
-| Rspec    | ✔            |
-| Spork    | ✘            |
-| Yard     | ✘            |
-+----------+--------------+
-```
-
-### Show
-
-You can show the structure of the groups and their plugins with the `show` task:
-
-```bash
-$ bundle exec guard show
-+---------+--------+-----------------+----------------------------+
-| Group   | Plugin | Option          | Value                      |
-+---------+--------+-----------------+----------------------------+
-| Specs   | Rspec  | all_after_pass  | true                       |
-|         |        | all_on_start    | true                       |
-|         |        | cli             | "--fail-fast --format doc" |
-|         |        | focus_on_failed | false                      |
-|         |        | keep_failed     | true                       |
-|         |        | run_all         | {}                         |
-|         |        | spec_paths      | ["spec"]                   |
-+---------+--------+-----------------+----------------------------+
-| Docs    | Ronn   |                 |                            |
-+---------+--------+-----------------+----------------------------+
-```
-
-This shows the internal structure of the evaluated `Guardfile` or `.Guardfile`, with the `.guard.rb` file. You can
-read more about these files in the [shared configuration section](https://github.com/guard/guard/wiki/Shared-configurations).
-
-### Notifiers
-
-You can show the notifiers, their availablity and options with the `notifier` task:
-
-```bash
-$ bundle exec guard notifiers
-+-------------------+-----------+------+------------------------+-------------------+
-| Name              | Available | Used | Option                 | Value             |
-+-------------------+-----------+------+------------------------+-------------------+
-| gntp              | ✔         | ✘    | sticky                 | false             |
-+-------------------+-----------+------+------------------------+-------------------+
-| growl             | ✘         | ✘    | sticky                 | false             |
-|                   |           |      | priority               | 0                 |
-+-------------------+-----------+------+------------------------+-------------------+
-```
-
-This shows if a notifier is available on the current system, if it's being used and the
-current options (which reflects your custom options merged into the default options).
+Please look here to see all the [command line options for Guard](https://github.com/guard/guard/wiki/Command-line-options-for-Guard)
 
 Interactions
 ------------
+Please read how to [interact with Guard](https://github.com/guard/guard/wiki/Interacting-with-Guard) on the console and which [signals](https://github.com/guard/guard/wiki/Interacting-with-Guard#guard-signals) Guard accepts
 
-Guard shows a [Pry](http://pryrepl.org/) console whenever it has nothing to do and comes with some Guard specific Pry
-commands:
-
- * `↩`, `a`, `all`: Run all plugins.
- * `h`, `help`: Show help for all interactor commands.
- * `c`, `change`: Trigger a file change.
- * `n`, `notification`: Toggles the notifications.
- * `p`, `pause`: Toggles the file listener.
- * `r`, `reload`: Reload all plugins.
- * `o`, `scope`: Scope Guard actions to plugins or groups.
- * `s`, `show`: Show all Guard plugins.
- * `e`, `exit`: Stop all plugins and quit Guard
-
-The `all` and `reload` commands supports an optional scope, so you limit the Guard action to either a Guard plugin or
-a Guard group like:
-
-```bash
-[1]  guard(main)> all rspec
-[2]  guard(main)> all frontend
-```
-
-Remember, you can always use `help` on the Pry command line to see all available commands and `help <command>` for
-more detailed information. `help guard` will show all Guard related commands available
-
-Pry supports the Ruby built-in Readline, [rb-readline](https://github.com/luislavena/rb-readline) and
-[Coolline](https://github.com/Mon-Ouie/coolline). Just install the readline implementation of your choice by adding it
-to your `Gemfile`.
-
-You can also disable the interactions completely by running Guard with the `--no-interactions` option.
-
-### Customizations
-
-Further Guard specific customizations can be made in `~/.guardrc` that will be evaluated prior the Pry session is
-started (`~/.pryrc` is ignored). This allows you to make use of the Pry plugin architecture to provide custom commands
-and extend Guard for your own needs and distribute as a gem. Please have a look at the
-[Pry Wiki](https://github.com/pry/pry/wiki) for more information.
-
-### Signals
-
-You can also interact with Guard by sending POSIX signals to the Guard process (all but Windows and JRuby).
-
-If the Pry interactor is used, then `Ctrl-C` is delegated to Pry to exit continuation and `Ctrl-D` to exit Guard.
-Without interactor, `Ctrl-C` exits Guard and `Ctrl-D` is ignored.
-
-#### Pause watching
-
-```bash
-$ kill -USR1 <guard_pid>
-```
-
-#### Continue watching
-
-```bash
-$ kill -USR2 <guard_pid>
-```
 
 Guardfile DSL
 -------------
-
-The Guardfile DSL is evaluated as plain Ruby, so you can use normal Ruby code in your `Guardfile`.
-Guard itself provides the following DSL methods that can be used for configuration:
-
-### guard
-
-The `guard` method allows you to add a Guard plugin to your toolchain and configure it by passing the
-options after the name of the plugin:
-
-```ruby
-guard :coffeescript, input: 'coffeescripts', output: 'javascripts'
-```
-
-You can define the same plugin more than once:
-
-```ruby
-guard :coffeescript, input: 'coffeescripts', output: 'javascripts'
-guard :coffeescript, input: 'specs', output: 'specs'
-```
-
-### watch
-
-The `watch` method allows you to define which files are watched by a Guard:
-
-```ruby
-guard :bundler do
-  watch('Gemfile')
-end
-```
-
-String watch patterns are matched with [String#==](http://www.ruby-doc.org/core-1.9.3/String.html#method-i-3D-3D).
-You can also pass a regular expression to the watch method:
-
-```ruby
-guard :jessie do
-  watch(%r{^spec/.+(_spec|Spec)\.(js|coffee)})
-end
-```
-
-This instructs the jessie plugin to watch for file changes in the `spec` folder,
-but only for file names that ends with `_spec` or `Spec` and have a file type of `js` or `coffee`.
-
-You can easily test your watcher regular expressions with [Rubular](http://rubular.com/).
-
-When you add a block to the watch expression, you can modify the file name that has been
-detected before sending it to the plugin for processing:
-
-```ruby
-guard :rspec do
-  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
-end
-```
-
-In this example the regular expression capture group `(.+)` is used to transform a file change
-in the `lib` folder to its test case in the `spec` folder. Regular expression watch patterns
-are matched with [Regexp#match](http://www.ruby-doc.org/core-1.9.3/Regexp.html#method-i-match).
-
-You can also launch any arbitrary command in the supplied block:
-
-```ruby
-guard :shell do
-  watch(/.*/) { `git status` }
-end
-```
-
-*NOTE: Normally, most plugins expect the block to return a path or array of
-paths - i.e. other plugins would think the `git status` output here is a
-file path (which would cause an error), so this trick of returning the command
-output only works for `guard-shell` plugin and other plugins that support
-arbitrary results.*
-
-You can also define `watch`es outside of a `guard` plugin. This is useful to
-perform arbitrary Ruby logic (i.e. something project-specific).
-
-```ruby
-watch(/.*/) { |m| puts "#{m[0]} changed." }
-```
-
-### group
-
-The `group` method allows you to group several plugins together. This comes in handy especially when you
-have a huge `Guardfile` and want to focus your development on a certain part.
-
-```ruby
-group :specs do
-  guard :rspec do
-    watch(%r{^spec/.+_spec\.rb$})
-  end
-end
-
-group :docs do
-  guard :ronn do
-    watch(%r{^man/.+\.ronn?$})
-  end
-end
-```
-
-Groups can be nested, reopened and can take multiple names to assign its plugin to multiple groups:
-
-```ruby
-group :desktop do
-  guard 'livereload' do
-    watch(%r{desktop/.+\.html})
-  end
-
-  group :mobile do
-    guard 'livereload' do
-      watch(%r{mobile/.+\.html})
-    end
-  end
-end
-
-group :mobile, :desktop do
-  guard 'livereload' do
-    watch(%r{both/.+\.html})
-  end
-end
-```
-
-Groups to be run can be specified with the Guard DSL option `--group` (or `-g`):
-
-```bash
-$ bundle exec guard -g specs
-```
-
-Plugins that don't belong to a group are part of the `default` group.
-
-Another neat use of groups is to group dependent plugins and stop processing if one fails. In order
-to make this work, the group needs to have the `halt_on_fail` option enabled and the Guard plugin
-needs to throw `:task_has_failed` to indicate that the action was not successful.
-
-```ruby
-group :specs, halt_on_fail: true do
-  guard :rspec do
-    watch(/.../)
-  end
-
-  guard :cucumber do
-    watch(/.../)
-  end
-end
-```
-
-### scope
-
-The `scope` method allows you to define the default plugin or group scope for Guard, if not
-specified as command line option. Thus command line group and plugin scope takes precedence over
-the DSL scope configuration.
-
-You can define either a single plugin or group:
-
-```ruby
-scope plugin: :rspec
-scope group: :docs
-```
-
-or specify multiple plugins or groups.
-
-```ruby
-scope plugins: [:test, :jasmine]
-scope groups: [:docs, :frontend]
-```
-
-If you define both the plugin and group scope, the plugin scope has precedence. If you use both the
-plural and the singular option, the plural has precedence.
-
-**Please be sure to call the `scope` method after you've declared your Guard plugins!**
-
-### directories
-
-This option limits the directories watch to those given, which can improve
-responsiveness, performance and help reduce resource usage (CPU, memory) on
-larger projects.
-
-```ruby
-directories %w(app config lib spec features)
-```
-
-Note: The `--watchdir` option overrides this. (see `--watchdir` above for extra
-info).
-
-Note: Since recursion cannot be diabled on OSX, all other backends were made
-recursive - so if you want to watch selected directories AND files in the root
-directory of your project, move them to another directory and create symlinks
-back, e.g.
-
-```
-mkdir config
-mv Gemfile config
-ln -s config/Gemfile Gemfile
-```
-
-### clearing
-
-Guard can clear the screen before every action (which some people prefer).
-
-The this clearing behavior can be set to `:on` or `:off`:
-
-```ruby
-clearing :on
-```
-
-### notification
-
-If you don't specify any notification configuration in your `Guardfile`, Guard goes through the list of available
-notifiers and enables all that are available. If you specify your preferred library, auto detection will not take
-place:
-
-```ruby
-notification :growl
-```
-
-will select the `growl` gem for notifications. You can also set options for a notifier:
-
-```ruby
-notification :growl, sticky: true
-```
-
-Each notifier has a slightly different set of supported options:
-
-```ruby
-notification :growl, sticky: true, host: '192.168.1.5', password: 'secret'
-notification :gntp, sticky: true, host: '192.168.1.5', password: 'secret'
-notification :libnotify, timeout: 5, transient: true, append: false, urgency: :critical
-notification :notifu, time: 5, nosound: true, xp: true
-notification :emacs
-```
-
-It's possible to use more than one notifier. This allows you to configure different notifiers for different OS if your
-project is developed cross-platform or if you like to have local and remote notifications.
-
-Notifications can also be turned off in the `Guardfile`, in addition to setting the environment variable `GUARD_NOTIFY`
-or using the cli switch `-n`:
-
-```ruby
-notification :off
-```
-
-### interactor
-
-You can customize the Pry interactor history and RC file like:
-
-```ruby
-interactor guard_rc: '~/.my_guard-rc', history_file: '~/.my_guard_history_file'
-```
-
-If you do not need the Pry interactions with Guard at all, you can turn it off:
-
-```ruby
-interactor :off
-```
-
-### callback
-
-The `callback` method allows you to execute arbitrary code before or after any of the `start`, `stop`, `reload`,
-`run_all`, `run_on_changes`, `run_on_additions`, `run_on_modifications` and `run_on_removals` Guard plugins method.
-You can even insert more hooks inside these methods.
-
-```ruby
-guard :rspec do
-  watch(%r{^spec/.+_spec\.rb$})
-
-  callback(:start_begin) { `mate .` }
-end
-```
-
-Please see the [hooks and callbacks](https://github.com/guard/guard/wiki/Hooks-and-callbacks) page in the Guard wiki for
-more details.
-
-### ignore
-
-The `ignore` method can be used to exclude files and directories from the set of files being watched. Let's say you have
-used the `watch` method to monitor a directory, but you are not interested in changes happening to images, you could use
-the ignore method to exclude them.
-
-This comes in handy when you have large amounts of non-source data in you project. By default
-[`.rbx`, `.bundle`, `.DS_Store`, `.git`, `.hg` ,`.svn`, `bundle`, `log`, `tmp`, `vendor/bundle`](https://github.com/guard/listen/blob/master/lib/listen/silencer.rb#L5-L9)
-are ignored.
-
-*NOTE: this option mostly helps when irrelevant changes are triggering guard tasks (e.g. a task starts before the editor finished saving all the files). Also, while it can reduce CPU time and increase responsiveness when using polling, instead, using `--watchdirs` is recommended for such "tuning" (e.g. large projects)*
-
-Please note that method only accept regexps. See [Listen README](https://github.com/guard/listen#ignore--ignore).
-
-To append to the default ignored files and directories, use the `ignore` method:
-
-```ruby
-ignore %r{^ignored/path/}, /public/
-```
-
-To _replace_ any existing ignored files and directories, use the `ignore!` method:
-
-```ruby
-ignore! /data/
-```
-
-### filter
-
-Alias of the [ignore](https://github.com/guard/guard#ignore) method.
-
-### logger
-
-The `logger` method allows you to customize the [Lumberjack](https://github.com/bdurand/lumberjack) log output to your
-needs by specifying one or more options like:
-
-```ruby
-logger level:       :warn,
-       template:    '[:severity - :time - :progname] :message',
-       time_format: 'at %I:%M%p',
-       only:        [:rspec, :jasmine, 'coffeescript'],
-       except:      :jammit,
-       device:      'guard.log'
-```
-
-Log `:level` option must be either `:debug`, `:info`, `:warn` or `:error`. If Guard is started in debug mode, the log
-level will be automatically set to `:debug`.
-
-The `:template` option is a string which can have one or more of the following placeholders: `:time`, `:severity`,
-`:progname`, `:pid`, `:unit_of_work_id` and `:message`. A unit of work is assigned for each action Guard performs on
-multiple Guard plugin.
-
-The `:time_format` option directives are the same as Time#strftime or can be `:milliseconds`
-
-The `:only` and `:except` are either a string or a symbol, or an array of strings or symbols that matches the name of
-the Guard plugin name that sends the log message. They cannot be specified at the same time.
-
-By default the logger uses `$stderr` as device, but you can override this by supplying the `:device` option and set
-either an IO stream or a filename.
+For details on extending your `Guardfile` look at [Guardfile examples](https://github.com/guard/guard/wiki/Guardfile-examples) or look at a list of commands [Guardfile-DSL / Configuring-Guard](https://github.com/guard/guard/wiki/Guardfile-DSL---Configuring-Guard)
 
 Issues
 ------

data/lib/guard/internals/session.rb

@@ -72,8 +72,15 @@ module Guard
 
       def guardfile_scope(scope)
         opts = scope.dup
-        @guardfile_plugin_scope = Array(opts.delete(:plugins))
-        @guardfile_group_scope = Array(opts.delete(:groups))
+
+        groups = Array(opts.delete(:groups))
+        group = Array(opts.delete(:group))
+        @guardfile_group_scope = Array(groups) + Array(group)
+
+        plugins = Array(opts.delete(:plugins))
+        plugin = Array(opts.delete(:plugin))
+        @guardfile_plugin_scope = Array(plugins) + Array(plugin)
+
         fail "Unknown options: #{opts.inspect}" unless opts.empty?
       end
 

data/lib/guard/templates/Guardfile

@@ -7,13 +7,12 @@
 ## Uncomment to clear the screen before every task
 # clearing :on
 
-## Make Guard exit when config is changed so it can be restarted
-#
-## Note: if you want Guard to automatically start up again, run guard in a
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
 ## shell loop, e.g.:
-#
-#  $ while bundle exec guard; do echo "Restarting Guard..."; done
-#
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
 ## Note: if you are using the `directories` clause above and you are not
 ## watching the project directory ('.'), the you will want to move the Guardfile
 ## to a watched dir and symlink it back, e.g.
@@ -23,8 +22,3 @@
 #  $ ln -s config/Guardfile .
 #
 # and, you'll have to watch "config/Guardfile" instead of "Guardfile"
-#
-watch ("Guardfile") do
-  UI.info "Exiting because Guard must be restarted for changes to take effect"
-  exit 0
-end

data/lib/guard/version.rb

@@ -1,3 +1,3 @@
 module Guard
-  VERSION = "2.10.4"
+  VERSION = "2.10.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard
 version: !ruby/object:Gem::Version
-  version: 2.10.4
+  version: 2.10.5
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -197,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Guard keeps an eye on your file modifications