sidekiq-statsd 0.1.0

data/vendor/ruby/1.9.1/gems/guard-1.8.0/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2013 Thibaud Guillaume-Gentil
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.

data/vendor/ruby/1.9.1/gems/guard-1.8.0/README.md

@@ -0,0 +1,1000 @@
+Guard [![Gem Version](https://badge.fury.io/rb/guard.png)](http://badge.fury.io/rb/guard) [![Build Status](https://travis-ci.org/guard/guard.png?branch=master)](https://travis-ci.org/guard/guard) [![Dependency Status](https://gemnasium.com/guard/guard.png)](https://gemnasium.com/guard/guard) [![Code Climate](https://codeclimate.com/github/guard/guard.png)](https://codeclimate.com/github/guard/guard) [![Coverage Status](https://coveralls.io/repos/guard/guard/badge.png?branch=master)](https://coveralls.io/r/guard/guard)
+=====
+
+<img src="http://img515.imageshack.us/img515/1358/guardicon.png" alt="Guard Icon" align="right" />
+Guard is a command line tool to easily handle events on file system modifications.
+
+This document contains a lot of information, please take your time and read these instructions carefully. If you have
+any questions about the Guard usage or want to share some information with the Guard community, please go to one of
+the following places:
+
+* [Google+ community](https://plus.google.com/u/1/communities/110022199336250745477)
+* [Google group](http://groups.google.com/group/guard-dev)
+* [StackOverflow](http://stackoverflow.com/questions/tagged/guard)
+* IRC channel `#guard` (irc.freenode.net) for chatting
+
+Information on advanced topics like creating your own Guard plugin, programatic use of Guard, hooks and callbacks and
+more can be found in the [Guard wiki](https://github.com/guard/guard/wiki).
+
+Before you file an issue, make sure you have read the _[file an issue](#file-an-issue)_ section that contains some
+important information.
+
+Features
+--------
+
+* File system changes handled by our awesome [Listen](https://github.com/guard/listen) gem.
+* Support for visual system notifications.
+* Huge eco-system with [more than 190](https://rubygems.org/search?query=guard-) guard plugins.
+* Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, REE and the latest versions of JRuby & Rubinius.
+
+Screencast
+----------
+
+Two nice introduction screen casts to Guard are available that helps you get started:
+
+* [Guard is Your Best Friend](http://net.tutsplus.com/tutorials/tools-and-tips/guard-is-your-best-friend) on Net Tuts+
+* [Guard](http://railscasts.com/episodes/264-guard) on RailsCast
+
+Installation
+------------
+
+The simplest way to install Guard is to use [Bundler](http://gembundler.com/).
+
+Add Guard to your `Gemfile`:
+
+```ruby
+group :development do
+  gem 'guard'
+end
+```
+
+and install it by running Bundler:
+
+```bash
+$ bundle
+```
+
+Generate an empty `Guardfile` with:
+
+```bash
+$ guard init
+```
+
+**It's important that you always run Guard through Bundler to avoid errors.** If you're getting sick of typing
+`bundle exec` all the time, try the [Rubygems Bundler](https://github.com/mpapis/rubygems-bundler).
+
+If you are on Mac OS X and have problems with either Guard not reacting to file changes or Pry behaving strange, then
+you should [add proper Readline support to Ruby on Mac OS X](https://github.com/guard/guard/wiki/Add-proper-Readline-support-to-Ruby-on-Mac-OS-X).
+
+## Efficient Filesystem Handling
+
+Various operating systems are willing to notify you of changes to files, but the API to register/receive updates varies
+(see [rb-fsevent](https://github.com/thibaudgg/rb-fsevent) for OS X, [rb-inotify](https://github.com/nex3/rb-inotify)
+for Linux, and [rb-fchange](https://github.com/stereobooster/rb-fchange) for Windows). If you do not supply one of the
+supported gems for these methods, Guard will fall back to polling, and give you a warning about it doing so.
+
+A challenge arises when trying to make these dependencies work with [Bundler](http://gembundler.com/). If you simply put
+one of these dependencies into you `Gemfile`, even if it is conditional on a platform match, the platform-specific gem
+will end up in the `Gemfile.lock`, and developers will thrash the file back and forth.
+
+There is a good solution. All three gems will successfully, quietly install on all three operating systems, and
+`guard/listen` will only pull in the one you need. This is a more proper `Gemfile`:
+
+```Ruby
+group :development do
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+end
+```
+
+If you're using Windows and at least Ruby 1.9.2, then [Windows Directory Monitor](https://github.com/Maher4Ever/wdm) is
+more efficient than using `rb-fchange`.
+
+```Ruby
+group :development do
+  gem 'wdm', :platforms => [:mswin, :mingw], :require => false
+end
+```
+
+## Windows Colors
+
+If you want colors in your terminal, you'll have to add the [win32console](https://rubygems.org/gems/win32console) gem
+to your `Gemfile` and install it with Bundler:
+
+```ruby
+group :development do
+  gem 'win32console'
+end
+```
+
+## Interrupt handling
+
+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.
+
+## System notifications
+
+You can configure Guard to make use of the following system notification libraries:
+
+#### Ruby GNTP
+
+* Runs on Mac OS X, Linux and Windows
+* Supports [Growl](http://growl.info/) version >= 1.3, [Growl for Linux](http://mattn.github.com/growl-for-linux/),
+  [Growl for Windows](http://www.growlforwindows.com/gfw/default.aspx) and
+  [Snarl](https://sites.google.com/site/snarlapp/home)
+
+The [ruby_gntp](https://rubygems.org/gems/ruby_gntp) gem sends system notifications over the network with the
+[Growl Notification Transport Protocol](http://www.growlforwindows.com/gfw/help/gntp.aspx) and supports local and
+remote notifications. To have the images be displayed, you have to use `127.0.0.1` instead of `localhost` in your GTNP
+configuration.
+
+Guard supports multiple notification channels for customizing each notification type. For Growl on Mac OS X you need
+to have at least version 1.3 installed.
+
+To use `ruby_gntp` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'ruby_gntp'
+end
+```
+
+#### Growl
+
+* Runs on Mac OS X
+* Supports all [Growl](http://growl.info/) versions
+
+The [growl](https://rubygems.org/gems/growl) gem is compatible with all versions of Growl and uses a command line tool
+[growlnotify](http://growl.info/extras.php#growlnotify) that must be separately downloaded and installed. The version of
+the command line tool must match your Growl version. The `growl` gem does **not** support multiple notification
+channels.
+
+You have to download the installer for `growlnotify` from the [Growl download section](http://growl.info/downloads).
+
+To use `growl` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'growl'
+end
+```
+
+#### Libnotify
+
+* Runs on Linux, FreeBSD, OpenBSD and Solaris
+* Supports [Libnotify](http://developer.gnome.org/libnotify/)
+
+The [libnotify](https://rubygems.org/gems/libnotify) gem supports the Gnome libnotify notification daemon, but it can be
+used on other window managers as well. You have to install the `libnotify-bin` package with your favorite package
+manager.
+
+To use `libnotify` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'libnotify'
+end
+```
+
+If you are unable to build the `libnotify` gem on your system, Guard
+also has a built in notifier - `notifysend` - that shells out to the
+`notify-send` utility that comes with `libnotify-bin`.
+
+#### Notifu
+
+* Runs on Windows
+* Supports [Notifu](http://www.paralint.com/projects/notifu/)
+
+The [rb-notifu](https://rubygems.org/gems/rb-notifu) gem supports Windows system tray notifications.
+
+To use `rb-notifu` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'rb-notifu'
+end
+```
+
+#### GrowlNotify
+
+* Runs on Mac OS X
+* Supports [Growl](http://growl.info/) version >= 1.3
+* Doesn't support JRuby and MacRuby.
+* Doesn't work when forking, e.g. with [Spork](https://github.com/sporkrb/spork).
+
+The [growl_notify](https://rubygems.org/gems/growl_notify) gem uses AppleScript to send Growl notifications.
+The gem needs a native C extension to make use of AppleScript and does not run on JRuby and MacRuby.
+
+Guard supports multiple notification channels for customizing each notification type and you need to have at least
+Growl version 1.3 installed.
+
+To use `growl_notify` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'growl_notify'
+end
+```
+
+#### Terminal Notifier
+
+* Runs on Mac OS X 10.8 only
+
+The [terminal-notifier-guard](https://github.com/Springest/terminal-notifier-guard) sends notifications to the OS X
+Notification Center.
+
+To use `terminal-notifier-guard` you have to add it to your `Gemfile` and run bundler:
+
+```ruby
+group :development do
+  gem 'terminal-notifier-guard'
+end
+```
+
+#### Terminal Title
+
+* Runs in every terminal supporting XTerm escape sequences to set the window title.
+
+#### Emacs
+
+* Runs on any platform with Emacs + emacsclient (http://www.emacswiki.org/emacs/EmacsClient)
+
+#### TMux
+
+* To use TMux notifications, you have to start Guard within a [TMux](http://tmux.sourceforge.net/) session.
+
+The TMux notifier will color the background of the left part of the
+status bar indicating the status of the notifications. Optionally you
+can set `:display_message => true` to display the Guard notification as
+'display-message' notification.
+
+The way these messages are formatted is configurable.
+
+```ruby
+# Guardfile
+notification :tmux,
+  :display_message => true,
+  :timeout => 5, # in seconds
+  :default_message_format => '%s >> %s',
+  # the first %s will show the title, the second the message
+  # Alternately you can also configure *success_message_format*,
+  # *pending_message_format*, *failed_message_format*
+  :line_separator => ' > ', # since we are single line we need a separator
+  :color_location => 'status-left-bg' # to customize which tmux element will change color
+```
+
+The result will be for RSpec using example above
+
+    RSpec >> 15 test, 0 failures > in 0.002 sec
+
+You can use nice powerline chars here if you have that configured.
+
+You can get the message history by using `Ctrl+b ~` (where `Ctrl+b` is your key to activate TMux).
+
+#### File
+
+* You can also have Guard write notifications to a file. Each notification will
+  overwrite the file. This allows other commands to be run based on the status
+  of other guard commands.
+
+Example:
+
+```ruby
+# Guardfile
+notification :file, path: '.guard_result'
+
+guard :shell do
+  watch '.guard_result' do
+    if File.read('.guard_result').lines.first.strip == 'failed'
+      # ...
+    end
+  end
+end
+```
+
+Configuration:
+
+```ruby
+# Guardfile
+notification :file,
+  :path => '.guard_result', # Required, no default
+  :format => "result: %s\ntitle: %s\nmessage: %s\n" # Default: "%s\n%s\n%s\n"
+```
+
+Add Guard plugins
+-----------------
+
+Guard is now ready to use and you should add some Guard plugins for your specific use. Start exploring the many Guard
+plugins available by browsing the [Guard organization](https://github.com/guard) on GitHub or by searching for `guard-`
+on [RubyGems](https://rubygems.org/search?utf8=%E2%9C%93&query=guard-).
+
+When you have found a Guard plugin of your interest, add it to your `Gemfile`:
+
+```ruby
+group :development do
+  gem '<guard-plugin-name>'
+end
+```
+
+See the init section of the Guard usage below to see how to install the supplied plugin template that you can install and
+to suit your needs.
+
+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
+$ guard help
+```
+
+To request more detailed help on a specific task is simple: just appending the task name to the help task.
+For example, to get help for the `start` task, simply run:
+
+```bash
+$ 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
+$ guard init
+```
+
+You can also specify the name of an installed plugin to only get that plugin template
+in the generated Guardfile:
+
+```bash
+$ guard init <guard-name>
+```
+
+You can also specify the names of multiple plugins to only get those plugin templates
+in the generated Guardfile:
+
+```bash
+$ 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
+$ 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
+$ guard init --bare
+$ guard init -b # shortcut
+```
+
+### Start
+
+Just launch Guard inside your Ruby or Rails project with:
+
+```bash
+$ 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
+$ guard --clear
+$ guard -c # shortcut
+```
+
+You can add the following snippet to your `~/.guardrc` to have the clear option always be enabled:
+
+```
+Guard.options[:clear] = true
+```
+
+#### `-n`/`--notify` option
+
+System notifications can be disabled:
+
+```bash
+$ guard --notify false
+$ 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
+$ guard --group group_name another_group_name
+$ guard -g group_name another_group_name # shortcut
+```
+
+See the Guardfile DSL below for creating groups.
+
+#### `-P`/`--plugins` option
+
+Scope Guard to certain plugins on start:
+
+```bash
+$ guard --plugins plugin_name another_plugin_name
+$ guard -P plugin_name another_plugin_name # shortcut
+```
+
+#### `-d`/`--debug` option
+
+Guard can display debug information which can be very usefull for plugins
+developers with:
+
+```bash
+$ guard --debug
+$ guard -d # shortcut
+```
+
+#### `-w`/`--watchdir` option
+
+Guard can watch any directory instead of the current directory:
+
+```bash
+$ guard --watchdir ~/your/fancy/project
+$ guard -w ~/your/fancy/project # shortcut
+```
+
+#### `-G`/`--guardfile` option
+
+Guard can use a `Guardfile` not located in the current directory:
+
+```bash
+$ guard --guardfile ~/.your_global_guardfile
+$ guard -G ~/.your_global_guardfile # shortcut
+```
+
+#### `-i`/`--no-interactions` option
+
+Turn off completely any Guard terminal interactions with:
+
+```bash
+$ guard start -i
+$ 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
+$ guard start -B
+$ guard start --no-bundler-warning
+```
+
+#### `-l`/`--latency` option
+
+Overwrite Listen's default latency, useful when your hard-drive / system is slow.
+
+```bash
+$ guard start -l 1.5
+$ guard start --latency 1.5
+```
+
+#### `-p`/`--force-polling` option
+
+Force Listen polling listener usage.
+
+```bash
+$ guard start -p
+$ guard start --force-polling
+```
+
+### List
+
+You can list the available plugins with the `list` task:
+
+```bash
+$ 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
+$ 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#shared-configurations).
+
+Interactions
+------------
+
+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).
+
+#### 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.2/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.2/Regexp.html#method-i-match).
+
+You can also launch any arbitrary command in the supplied block:
+
+```ruby
+guard :shell do
+  watch('.*') { `git status` }
+end
+```
+
+### 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 to be run can be specified with the Guard DSL option `--group` (or `-g`):
+
+```bash
+$ guard -g specs
+```
+
+Guard plugins that don't belong to a group are considered global and are always run.
+
+Another neat use of groups is to group dependant 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.
+
+### notification
+
+If you don't specify any notification configuration in your `Guardfile`, Guard goes through the list of available
+notifiers and takes the first that is 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 :growl_notify, :sticky => true, :priority => 0
+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`, `.git`, `.svn`, `log`, `tmp`, `vendor`](https://github.com/guard/listen/blob/master/lib/listen/directory_record.rb#L14)
+are ignored.
+
+Please note that method only accept regexps. More on the
+[Listen README](https://github.com/guard/listen#the-patterns-for-filtering-and-ignoring-paths).
+
+To append to the default ignored files and directories, use the `ignore` method:
+
+```ruby
+ignore %r{^ignored/path/}, /public/
+```
+
+To _replace_ to default ignored files and directories, use the `ignore!` method:
+
+```ruby
+ignore! /data/
+```
+
+### filter
+
+The `filter` method allows you to focus by filtering files and directories without having to specify them by hand in the
+`watch` method. E.g. if you are watching multiple directories but only interested in changes to the Ruby files, then use
+the `filter` method.
+
+Please note that method only accept regexps. More on the
+[Listen README](https://github.com/guard/listen#the-patterns-for-filtering-and-ignoring-paths).
+
+```ruby
+filter /\.txt$/, /.*\.zip/
+```
+
+To _replace_ any existing filter, use the `filter!` method:
+
+```ruby
+filter /\.js$/
+```
+
+### 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.
+
+### Example
+
+```ruby
+ignore %r{^ignored/path/}, /public/
+filter /\.txt$/, /.*\.zip/
+
+notification :growl_notify
+notification :gntp, :host => '192.168.1.5'
+
+group :backend do
+  guard :bundler do
+    watch('Gemfile')
+  end
+
+  guard :rspec, :cli => '--color --format doc' do
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/(.+)\.rb$})         { |m| "spec/lib/#{m[1]}_spec.rb" }
+    watch(%r{^spec/models/.+\.rb$})   { ["spec/models", "spec/acceptance"] }
+    watch(%r{^spec/.+\.rb$})          { `say hello` }
+    watch('spec/spec_helper.rb')      { "spec" }
+  end
+end
+
+group :frontend do
+  guard :coffeescript, :output => 'public/javascripts/compiled' do
+    watch(%r{^app/coffeescripts/.+\.coffee$})
+  end
+
+  guard :livereload do
+    watch(%r{^app/.+\.(erb|haml)$})
+  end
+end
+```
+
+Shared configurations
+---------------------
+
+You may optionally place a `.Guardfile` in your home directory to use it across multiple projects. It's evaluated when
+you have no `Guardfile` in your current directory.
+
+If a `.guard.rb` is found in your home directory, it will be appended to the `Guardfile` in your current directory.
+This can be used for tasks you want guard to handle but other users probably don't.
+
+For example, indexing your source tree with [Ctags](http://ctags.sourceforge.net):
+
+```ruby
+guard :shell do
+  watch(%r{^(?:app|lib)/.+\.rb$}) { `ctags -R` }
+end
+```
+
+File an issue
+-------------
+
+You can report bugs and feature requests to [GitHub Issues](https://github.com/guard/guard/issues).
+
+**Please don't ask question in the issue tracker**, instead ask them at one of our other places:
+
+* [Google+ community](https://plus.google.com/u/1/communities/110022199336250745477)
+* [Google group](http://groups.google.com/group/guard-dev)
+* [StackOverflow](http://stackoverflow.com/questions/tagged/guard)
+* IRC channel `#guard` (irc.freenode.net) for chatting
+
+Try to figure out where the issue belongs to: Is it an issue with Guard itself or with a Guard plugin you're
+using?
+
+When you file a bug, please try to follow these simple rules if applicable:
+
+* Make sure you've read the README carefully.
+* Make sure you run Guard with `bundle exec` first.
+* Add debug information to the issue by running Guard with the `--debug` option.
+* Add your `Guardfile` and `Gemfile` to the issue.
+* Provide information about your environment:
+  * Your current versions of your OS, Ruby, Rubygems and Bundler.
+  * Shared project folder with services like Dropbox, NFS, etc.
+* Make sure that the issue is reproducible with your description.
+
+**It's most likely that your bug gets resolved faster if you provide as much information as possible!**
+
+Development
+-----------
+
+* Documentation hosted at [RubyDoc](http://rubydoc.info/github/guard/guard/master/frames).
+* Source hosted at [GitHub](https://github.com/guard/guard).
+
+Pull requests are very welcome! Please try to follow these simple rules if applicable:
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well tested. All specs must pass on [Travis CI](https://travis-ci.org/guard/guard).
+* Update the [Yard](http://yardoc.org/) documentation.
+* Update the [README](https://github.com/guard/guard/blob/master/README.md).
+* Update the [CHANGELOG](https://github.com/guard/guard/blob/master/CHANGELOG.md) for noteworthy changes (don't forget to run `bundle exec pimpmychangelog` and watch the magic happen)!
+* Please **do not change** the version number.
+
+For questions please join us in our [Google group](http://groups.google.com/group/guard-dev) or on
+`#guard` (irc.freenode.net).
+
+### Open Commit Bit
+
+Guard has an open commit bit policy: Anyone with an accepted pull request gets added as a repository collaborator.
+Please try to follow these simple rules:
+
+* Commit directly onto the master branch only for typos, improvements to the readme and documentation (please add
+  `[ci skip]` to the commit message).
+* Create a feature branch and open a pull-request early for any new features to get feedback.
+* Make sure you adhere to the general pull request rules above.
+
+### Author
+
+[Thibaud Guillaume-Gentil](https://github.com/thibaudgg) ([@thibaudgg](http://twitter.com/thibaudgg))
+
+### Core Team
+
+* [Maher Sallam](https://github.com/Maher4Ever) ([@mahersalam](http://twitter.com/mahersalam))
+* [Michael Kessler](https://github.com/netzpirat) ([@netzpirat](http://twitter.com/netzpirat), [mksoft.ch](https://mksoft.ch))
+* [Rémy Coutable](https://github.com/rymai) ([@rymai](http://twitter.com/rymai), [rymai.me](http://rymai.me))
+* [Thibaud Guillaume-Gentil](https://github.com/thibaudgg) ([@thibaudgg](http://twitter.com/thibaudgg), [thibaud.me](http://thibaud.me/))
+
+### Contributors
+
+[https://github.com/guard/guard/contributors](https://github.com/guard/guard/contributors)