Skip to content
This repository
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 347 lines (242 sloc) 9.062 kb

Guard Build Status

Guard is a command line tool that easily handle events on files modifications.

If you have any questions/issues please join us on our Google group or on #guard (irc.freenode.net).

Features

Install

Install the gem:

$ gem install guard

Add it to your Gemfile (inside the test group):

gem 'guard'

Generate an empty Guardfile with:

$ guard init

You may optionally place this Guardfile in your home directory to use it across multiple projects.

Add the guards you need to your Guardfile (see the existing guards below).

On Mac OS X

Install the rb-fsevent gem for FSEvent support:

$ gem install rb-fsevent

Install the Growl gem if you want notification support:

$ gem install growl

And add it to you Gemfile:

gem 'growl'

On Linux

Install the rb-inotify gem for inotify support:

$ gem install rb-inotify

Install the Libnotify gem if you want notification support:

$ gem install libnotify

And add it to you Gemfile:

gem 'libnotify'

On Windows

Install the rb-fchange gem for Directory Change Notification support:

$ gem install rb-fchange

Usage

Just launch Guard inside your Ruby / Rails project with:

$ guard [start]

or if you use Bundler, to run the Guard executable specific to your bundle:

$ 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 one.

Command line options

Shell can be cleared after each change with:

$ guard --clear
$ guard -c # shortcut

Notifications (growl/libnotify) can be disabled with:

$ guard --notify false
$ guard -n f # shortcut

Notifications can also be disabled globally by setting a GUARD_NOTIFY environment variable to false

The guards to start can be specified by group (see the Guardfile DSL below) specifying the --group (or -g) option:

$ guard --group group_name another_group_name
$ guard -g group_name another_group_name # shortcut

Options list is available with:

$ guard help [TASK]

Signal handlers

Signal handlers are used to interact with Guard:

  • Ctrl-C - Calls each guard's stop method, in the same order they are declared in the Guardfile, and then quits Guard itself.
  • Ctrl-\ - Calls each guard's run_all method, in the same order they are declared in the Guardfile.
  • Ctrl-Z - Calls each guard's reload method, in the same order they are declared in the Guardfile.

You can read more about configure the signal keyboard shortcuts on the wiki.

Available Guards

Available Guards list (on the wiki now)

Add a guard to your Guardfile

Add it to your Gemfile (inside the test group):

gem '<guard-name>'

Insert default guard's definition to your Guardfile by running this command:

$ guard init <guard-name>

You are good to go!

Guardfile DSL

The Guardfile DSL consists of just three simple methods: guard, watch & group.

Required:

  • The guard method allows you to add a guard with an optional hash of options.
  • The watch method allows you to define which files are supervised by this guard. An optional block can be added to overwrite the paths sent to the run_on_change guard method or to launch any arbitrary command.

Optional:

  • The group method allows you to group several guards together. Groups to be run can be specified with the Guard DSL option --group (or -g). This comes in handy especially when you have a huge Guardfile and want to focus your development on a certain part.

Example:

group 'backend' do
  guard 'bundler' do
    watch('Gemfile')
  end

  guard 'rspec', :cli => '--color --format doc' do
    # Regexp watch patterns are matched with Regexp#match
    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` }

    # String watch patterns are matched with simple '=='
    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

The Guardfile DSL can also be used in a programmatic fashion by calling directly Guard::Dsl.evaluate_guardfile. Available options are as follow:

  • :guardfile - The path to a valid Guardfile.
  • :guardfile_contents - A string representing the content of a valid Guardfile

Without any options given, Guard will look for a Guardfile in your current directory and if it does not find one, it will look in your $HOME directory for one.

For instance, you could use it as follow:

gem 'guard'
require 'guard'

Guard.setup

Guard::Dsl.evaluate_guardfile(:guardfile => '/Your/Custom/Path/To/A/Valid/Guardfile')
# or
Guard::Dsl.evaluate_guardfile(:guardfile_contents => "
  guard 'rspec' do
    watch(%r{^spec/.+_spec\.rb})
  end
")

Create a new guard

Creating a new guard is very easy, just create a new gem (bundle gem if you use Bundler) with this basic structure:

lib/
  guard/
    guard-name/
      templates/
        Guardfile (needed for guard init <guard-name>)
    guard-name.rb

Guard::GuardName (in lib/guard/guard-name.rb) must inherit from Guard::Guard and should overwrite at least one of the five basic Guard::Guard instance methods. Example:

require 'guard'
require 'guard/guard'

module Guard
  class GuardName < Guard

    def initialize(watchers=[], options={})
      super
      # init stuff here, thx!
    end

    # =================
    # = Guard methods =
    # =================

    # If one of those methods raise an exception, the Guard::GuardName instance
    # will be removed from the active guards.

    # Called once when Guard starts
    # Please override initialize method to init stuff
    def start
      true
    end

    # Called on Ctrl-C signal (when Guard quits)
    def stop
      true
    end

    # Called on Ctrl-Z signal
    # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
    def reload
      true
    end

    # Called on Ctrl-\ signal
    # This method should be principally used for long action like running all specs/tests/...
    def run_all
      true
    end

    # Called on file(s) modifications
    def run_on_change(paths)
      true
    end

  end
end

Please take a look at the existing guards' source code (see the list above) for more concrete example.

Alternatively, a new guard can be added inline to a Guardfile with this basic structure:

require 'guard/guard'

module ::Guard
  class InlineGuard < ::Guard::Guard
    def run_all
      true
    end

    def run_on_change(paths)
      true
    end
  end
end

Development

Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change you make. Please do not change the version in your pull-request.

Author

Thibaud Guillaume-Gentil

Contributors

https://github.com/guard/guard/contributors

Something went wrong with that request. Please try again.