guard 0.8.8 → 0.9.0

data/lib/guard/ui.rb

@@ -56,7 +56,7 @@ module Guard
       def debug(message, options = { })
         unless ENV['GUARD_ENV'] == 'test'
           reset_line if options[:reset]
-          STDERR.puts color("DEBUG (#{Time.now.strftime('%T')}): ", :yellow) + message if ::Guard.options && ::Guard.options[:debug]
+          STDERR.puts color("DEBUG (#{Time.now.strftime('%T')}): ", :yellow) + message if ::Guard.options && ::Guard.options[:verbose]
         end
       end
 
@@ -119,7 +119,7 @@ module Guard
       #
       #   color('Hello World', :red, :bright)
       #
-      # @param [String] the text to colorize
+      # @param [String] text the text to colorize
       # @param [Array] color_options the color options
       #
       def color(text, *color_options)

data/lib/guard/version.rb

@@ -1,6 +1,6 @@
 module Guard
   unless defined? Guard::VERSION
     # The current gem version of Guard
-    VERSION = '0.8.8'
+    VERSION = '0.9.0'
   end
 end

data/lib/guard/watcher.rb

@@ -99,7 +99,7 @@ module Guard
 
     # Executes a watcher action.
     #
-    # @param [String, MatchData] the matched path or the match from the Regex
+    # @param [String, MatchData] matches the matched path or the match from the Regex
     # @return [String] the final paths
     #
     def call_action(matches)

data/lib/vendor/darwin/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake"
+

data/lib/vendor/darwin/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at http://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r(^spec/(.*)_spec.rb))
+  watch(%r(^lib/(.*)\.rb))        { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')    { "spec" }
+end

data/lib/vendor/darwin/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 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/lib/vendor/darwin/README.rdoc

@@ -0,0 +1,254 @@
+= rb-fsevent
+
+Very simple & usable Mac OSX FSEvents API
+
+- RubyCocoa not required!
+- Signals are working (really)
+- Tested on MRI 1.8.7 & 1.9.2
+- Tested on JRuby 1.6.3
+
+== Install
+
+    gem install rb-fsevent
+
+== Usage
+
+=== Singular path
+
+    require 'rb-fsevent'
+
+    fsevent = FSEvent.new
+    fsevent.watch Dir.pwd do |directories|
+      puts "Detected change inside: #{directories.inspect}"
+    end
+    fsevent.run
+
+=== Multiple paths
+
+    require 'rb-fsevent'
+
+    paths = ['/tmp/path/one', '/tmp/path/two', Dir.pwd]
+
+    fsevent = FSEvent.new
+    fsevent.watch paths do |directories|
+      puts "Detected change inside: #{directories.inspect}"
+    end
+    fsevent.run
+
+=== Multiple paths and additional options as a Hash
+
+    require 'rb-fsevent'
+
+    paths = ['/tmp/path/one', '/tmp/path/two', Dir.pwd]
+    options = {:latency => 1.5, :no_defer => true }
+
+    fsevent = FSEvent.new
+    fsevent.watch paths, options do |directories|
+      puts "Detected change inside: #{directories.inspect}"
+    end
+    fsevent.run
+
+=== Multiple paths and additional options as an Array
+
+    require 'rb-fsevent'
+
+    paths = ['/tmp/path/one', '/tmp/path/two', Dir.pwd]
+    options = ['--latency', 1.5, '--no-defer']
+
+    fsevent = FSEvent.new
+    fsevent.watch paths, options do |directories|
+      puts "Detected change inside: #{directories.inspect}"
+    end
+    fsevent.run
+
+== Options
+
+When defining options using a hash or hash-like object, it gets checked for validity and converted to the appropriate fsevent_watch commandline arguments array when the FSEvent class is instantiated. This is obviously the safest and preferred method of passing in options.
+
+You may, however, choose to pass in an array of commandline arguments as your options value and it will be passed on, unmodified, to the fsevent_watch binary when called.
+
+So far, the following options are supported...
+
+- :latency => 0.5 # in seconds
+- :no_defer => true
+- :watch_root => true
+- :since_when => 18446744073709551615 # an FSEventStreamEventId
+
+=== Latency
+
+The :latency parameter determines how long the service should wait after the first event before passing that information along to the client. If your latency is set to 4 seconds, and 300 changes occur in the first three, then the callback will be fired only once. If latency is set to 0.1 in the exact same scenario, you will see that callback fire somewhere closer to between 25 and 30 times.
+
+Setting a higher latency value allows for more effective temporal coalescing, resulting in fewer callbacks and greater overall efficiency... at the cost of apparent responsiveness. Setting this to a reasonably high value (and NOT setting :no_defer) is particularly well suited for background, daemon, or batch processing applications.
+
+Implementation note: It appears that FSEvents will only coalesce events from a maximum of 32 distinct subpaths, making the above completely accurate only when events are to fewer than 32 subpaths. Creating 300 files in one directory, for example, or 30 files in 10 subdirectories, but not 300 files within 300 subdirectories. In the latter case, you may receive 31 callbacks in one go after the latency period. As this appears to be an implementation detail, the number could potentially differ across OS revisions. It is entirely possible that this number is somehow configurable, but I have not yet discovered an accepted method of doing so.
+
+=== NoDefer
+
+The :no_defer option changes the behavior of the latency parameter completely. Rather than waiting for $latency period of time before sending along events in an attempt to coalesce a potential deluge ahead of time, that first event is sent along to the client immediately and is followed by a $latency period of silence before sending along any additional events that occurred within that period.
+
+This behavior is particularly useful for interactive applications where that feeling of apparent responsiveness is most important, but you still don't want to get overwhelmed by a series of events that occur in rapid succession.
+
+=== WatchRoot
+
+The :watch_root option allows for catching the scenario where you start watching "~/src/demo_project" and either it is later renamed to "~/src/awesome_sauce_3000" or the path changes in such a manner that the original directory is now at "~/clients/foo/iteration4/demo_project".
+
+Unfortunately, while this behavior is somewhat supported in the fsevent_watch binary built as part of this project, support for passing across detailed metadata is not (yet). As a result, you would not receive the appropriate RootChanged event and be able to react appropriately. Also, since the C code doesn't open watched directories and retain that file descriptor as part of path-specific callback metadata, we are unable to issue an F_GETPATH fcntl() to determine the directory's new path.
+
+Please do not use this option until proper support is added in an upcoming (planned) release.
+
+=== SinceWhen
+
+The FSEventStreamEventId passed in to :since_when is used as a base for reacting to historic events. Unfortunately, not only is the metadata for transitioning from historic to live events not currently passed along, but it is incorrectly passed as a change event on the root path, and only per-host event streams are currently supported. When using per-host event streams, the event IDs are not guaranteed to be unique or contiguous when shared volumes (firewire/USB/net/etc) are used on multiple macs.
+
+Please do not use this option until proper support is added in an upcoming (planned) release, unless it's acceptable for you to receive that one fake event that's handled incorrectly when events transition from historical to live. Even in that scenario, there's no metadata available for determining the FSEventStreamEventId of the last received event.
+
+WARNING: passing in 0 as the parameter to :since_when will return events for every directory modified since "the beginning of time".
+
+== Debugging output
+
+If the gem is installed with the environment variable FWDEBUG set to the string "true", then fsevent_watch will be built with its various DEBUG sections defined, and the output to STDERR is truly verbose (and hopefully helpful in debugging your application and not just fsevent_watch itself). If enough people find this to be directly useful when developing code that makes use of rb-fsevent, then it wouldn't be hard to clean this up and make it a feature enabled by a commandline argument instead. Until somebody files an issue, however, I will assume otherwise.
+
+    append_path called for: /tmp/moo/cow/
+      resolved path to: /private/tmp/moo/cow
+
+    config.sinceWhen    18446744073709551615
+    config.latency      0.300000
+    config.flags        00000000
+    config.paths
+      /private/tmp/moo/cow
+
+    FSEventStreamRef @ 0x100108540:
+       allocator = 0x7fff705a4ee0
+       callback = 0x10000151e
+       context = {0, 0x0, 0x0, 0x0, 0x0}
+       numPathsToWatch = 1
+       pathsToWatch = 0x7fff705a4ee0
+            pathsToWatch[0] = '/private/tmp/moo/cow'
+       latestEventId = -1
+       latency = 300000 (microseconds)
+       flags = 0x00000000
+       runLoop = 0x0
+       runLoopMode = 0x0
+
+
+    FSEventStreamCallback fired!
+      numEvents: 32
+      event path: /private/tmp/moo/cow/1/a/
+      event flags: 00000000
+      event ID: 1023767
+      event path: /private/tmp/moo/cow/1/b/
+      event flags: 00000000
+      event ID: 1023782
+      event path: /private/tmp/moo/cow/1/c/
+      event flags: 00000000
+      event ID: 1023797
+      event path: /private/tmp/moo/cow/1/d/
+      event flags: 00000000
+      event ID: 1023812
+      event path: /private/tmp/moo/cow/1/e/
+      event flags: 00000000
+      event ID: 1023827
+      event path: /private/tmp/moo/cow/1/f/
+      event flags: 00000000
+      event ID: 1023842
+      event path: /private/tmp/moo/cow/1/g/
+      event flags: 00000000
+      event ID: 1023857
+      event path: /private/tmp/moo/cow/1/h/
+      event flags: 00000000
+      event ID: 1023872
+      event path: /private/tmp/moo/cow/1/i/
+      event flags: 00000000
+      event ID: 1023887
+      event path: /private/tmp/moo/cow/1/j/
+      event flags: 00000000
+      event ID: 1023902
+      event path: /private/tmp/moo/cow/1/k/
+      event flags: 00000000
+      event ID: 1023917
+      event path: /private/tmp/moo/cow/1/l/
+      event flags: 00000000
+      event ID: 1023932
+      event path: /private/tmp/moo/cow/1/m/
+      event flags: 00000000
+      event ID: 1023947
+      event path: /private/tmp/moo/cow/1/n/
+      event flags: 00000000
+      event ID: 1023962
+      event path: /private/tmp/moo/cow/1/o/
+      event flags: 00000000
+      event ID: 1023977
+      event path: /private/tmp/moo/cow/1/p/
+      event flags: 00000000
+      event ID: 1023992
+      event path: /private/tmp/moo/cow/1/q/
+      event flags: 00000000
+      event ID: 1024007
+      event path: /private/tmp/moo/cow/1/r/
+      event flags: 00000000
+      event ID: 1024022
+      event path: /private/tmp/moo/cow/1/s/
+      event flags: 00000000
+      event ID: 1024037
+      event path: /private/tmp/moo/cow/1/t/
+      event flags: 00000000
+      event ID: 1024052
+      event path: /private/tmp/moo/cow/1/u/
+      event flags: 00000000
+      event ID: 1024067
+      event path: /private/tmp/moo/cow/1/v/
+      event flags: 00000000
+      event ID: 1024082
+      event path: /private/tmp/moo/cow/1/w/
+      event flags: 00000000
+      event ID: 1024097
+      event path: /private/tmp/moo/cow/1/x/
+      event flags: 00000000
+      event ID: 1024112
+      event path: /private/tmp/moo/cow/1/y/
+      event flags: 00000000
+      event ID: 1024127
+      event path: /private/tmp/moo/cow/1/z/
+      event flags: 00000000
+      event ID: 1024142
+      event path: /private/tmp/moo/cow/1/
+      event flags: 00000000
+      event ID: 1024145
+      event path: /private/tmp/moo/cow/2/a/
+      event flags: 00000000
+      event ID: 1024160
+      event path: /private/tmp/moo/cow/2/b/
+      event flags: 00000000
+      event ID: 1024175
+      event path: /private/tmp/moo/cow/2/c/
+      event flags: 00000000
+      event ID: 1024190
+      event path: /private/tmp/moo/cow/2/d/
+      event flags: 00000000
+      event ID: 1024205
+      event path: /private/tmp/moo/cow/2/e/
+      event flags: 00000000
+      event ID: 1024220
+
+== Note about FFI
+
+rb-fsevent doesn't use {ruby-ffi}[http://github.com/ffi/ffi] anymore because it sadly doesn't allow for catching Signals. You can still see the code in the {ffi branch}[http://github.com/thibaudgg/rb-fsevent/tree/ffi].
+
+== Development
+
+- Source hosted at {GitHub}[http://github.com/thibaudgg/rb-fsevent]
+- Report issues/Questions/Feature requests on {GitHub Issues}[http://github.com/thibaudgg/rb-fsevent/issues]
+
+Pull requests are quite welcome! Please ensure that your commits are in a topic branch for each individual changeset than can be reasonably isolated. It is also important to ensure that your changes are well tested... whether that means new tests, modified tests, or fixing a scenario where the existing tests currently fail. If you have rvm and the required rubies currently installed, we have a helper task for running the testsuite in all of them:
+
+    rake spec:portability
+
+The list of tested RVM targets is currently:
+
+    %w[1.8.6 1.8.7 1.9.2 jruby-head]
+
+== Authors
+
+- {Thibaud Guillaume-Gentil}[http://github.com/thibaudgg]
+- {Travis Tilley}[http://github.com/ttilley]
+

data/lib/vendor/darwin/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace(:spec) do
+  desc "Run all specs on multiple ruby versions (requires rvm)"
+  task(:portability) do
+    %w[1.8.6 1.8.7 1.9.2 jruby-head].each do |version|
+      system <<-BASH
+        bash -c 'source ~/.rvm/scripts/rvm;
+                 rvm #{version};
+                 echo "--------- version #{version} ----------\n";
+                 bundle install;
+                 rake spec'
+      BASH
+    end
+  end
+end

data/lib/vendor/darwin/ext/extconf.rb

@@ -0,0 +1,61 @@
+# Workaround to make Rubygems believe it builds a native gem
+require 'mkmf'
+create_makefile('none')
+
+# TODO: determine whether we really need to be working around instead of with mkmf
+
+if `uname -s`.chomp != 'Darwin'
+  puts "Warning! Only Darwin (Mac OS X) systems are supported, nothing will be compiled"
+else
+  begin
+    xcode_path = %x[xcode-select -print-path].to_s.strip!
+  rescue Errno::ENOENT
+  end
+
+  raise "Could not find a suitable Xcode installation" unless xcode_path
+
+  gem_root       = File.expand_path(File.join('..'))
+  darwin_version = `uname -r`.to_i
+  sdk_version    = { 9 => '10.5', 10 => '10.6', 11 => '10.7' }[darwin_version]
+
+  raise "Only Darwin systems greater than 8 (Mac OS X 10.5+) are supported" unless sdk_version
+
+  core_flags = %W{
+    -isysroot #{xcode_path}/SDKs/MacOSX#{sdk_version}.sdk
+    -mmacosx-version-min=#{sdk_version} -mdynamic-no-pic -std=gnu99
+  }
+
+  cflags = core_flags + %w{-Os -pipe}
+
+  wflags = %w{
+    -Wmissing-prototypes -Wreturn-type -Wmissing-braces -Wparentheses -Wswitch
+    -Wunused-function -Wunused-label -Wunused-parameter -Wunused-variable
+    -Wunused-value -Wuninitialized -Wunknown-pragmas -Wshadow
+    -Wfour-char-constants -Wsign-compare -Wnewline-eof -Wconversion
+    -Wshorten-64-to-32 -Wglobal-constructors -pedantic
+  }
+
+  ldflags = %w{
+    -dead_strip -framework CoreServices
+  }
+
+  cc_opts = core_flags + ldflags
+
+  cc_opts += %w{
+    -D DEBUG=true
+  } if ENV['FWDEBUG'] == "true"
+  
+  cc_bin = `which clang || which gcc`.to_s.strip!
+
+  compile_command = "CFLAGS='#{cflags.join(' ')} #{wflags.join(' ')}' #{cc_bin} #{cc_opts.join(' ')} -o '#{gem_root}/bin/fsevent_watch' fsevent/fsevent_watch.c"
+
+  STDERR.puts(compile_command)
+
+  # Compile the actual fsevent_watch binary
+  system "mkdir -p #{File.join(gem_root, 'bin')}"
+  system compile_command
+
+  unless File.executable?("#{gem_root}/bin/fsevent_watch")
+    raise "Compilation of fsevent_watch failed (see README)"
+  end
+end

data/lib/vendor/darwin/ext/fsevent/fsevent_watch.c

@@ -0,0 +1,226 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <CoreServices/CoreServices.h>
+
+
+// Structure for storing metadata parsed from the commandline
+static struct {
+  FSEventStreamEventId        sinceWhen;
+  CFTimeInterval              latency;
+  FSEventStreamCreateFlags    flags;
+  CFMutableArrayRef           paths;
+} config = {
+  (UInt64) kFSEventStreamEventIdSinceNow,
+  (double) 0.3,
+  (UInt32) kFSEventStreamCreateFlagNone,
+  NULL
+};
+
+// Prototypes
+static void         append_path(const char *path);
+static inline void  parse_cli_settings(int argc, const char *argv[]);
+static void         callback(FSEventStreamRef streamRef,
+                             void *clientCallBackInfo,
+                             size_t numEvents,
+                             void *eventPaths,
+                             const FSEventStreamEventFlags eventFlags[],
+                             const FSEventStreamEventId eventIds[]);
+
+
+// Resolve a path and append it to the CLI settings structure
+// The FSEvents API will, internally, resolve paths using a similar scheme.
+// Performing this ahead of time makes things less confusing, IMHO.
+static void append_path(const char *path)
+{
+#ifdef DEBUG
+  fprintf(stderr, "\n");
+  fprintf(stderr, "append_path called for: %s\n", path);
+#endif
+
+  char fullPath[PATH_MAX];
+
+  if (realpath(path, fullPath) == NULL) {
+#ifdef DEBUG
+    fprintf(stderr, "  realpath not directly resolvable from path\n");
+#endif
+
+    if (path[0] != '/') {
+#ifdef DEBUG
+      fprintf(stderr, "  passed path is not absolute\n");
+#endif
+      size_t len;
+      getcwd(fullPath, sizeof(fullPath));
+#ifdef DEBUG
+      fprintf(stderr, "  result of getcwd: %s\n", fullPath);
+#endif
+      len = strlen(fullPath);
+      fullPath[len] = '/';
+      strlcpy(&fullPath[len + 1], path, sizeof(fullPath) - (len + 1));
+    } else {
+#ifdef DEBUG
+      fprintf(stderr, "  assuming path does not YET exist\n");
+#endif
+      strlcpy(fullPath, path, sizeof(fullPath));
+    }
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "  resolved path to: %s\n", fullPath);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  CFStringRef pathRef = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                  fullPath,
+                                                  kCFStringEncodingUTF8);
+  CFArrayAppendValue(config.paths, pathRef);
+  CFRelease(pathRef);
+}
+
+// Parse commandline settings
+static inline void parse_cli_settings(int argc, const char *argv[])
+{
+  config.paths = CFArrayCreateMutable(NULL,
+                                      (CFIndex)0,
+                                      &kCFTypeArrayCallBacks);
+
+  for (int i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--since-when") == 0) {
+      config.sinceWhen = strtoull(argv[++i], NULL, 0);
+    } else if (strcmp(argv[i], "--latency") == 0) {
+      config.latency = strtod(argv[++i], NULL);
+    } else if (strcmp(argv[i], "--no-defer") == 0) {
+      config.flags |= kFSEventStreamCreateFlagNoDefer;
+    } else if (strcmp(argv[i], "--watch-root") == 0) {
+      config.flags |= kFSEventStreamCreateFlagWatchRoot;
+    } else if (strcmp(argv[i], "--ignore-self") == 0) {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
+      config.flags |= kFSEventStreamCreateFlagIgnoreSelf;
+#else
+      fprintf(stderr, "MacOSX10.6.sdk is required for --ignore-self\n");
+#endif
+    } else {
+      append_path(argv[i]);
+    }
+  }
+
+  if (CFArrayGetCount(config.paths) == 0) {
+    append_path(".");
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "config.sinceWhen    %llu\n", config.sinceWhen);
+  fprintf(stderr, "config.latency      %f\n", config.latency);
+  fprintf(stderr, "config.flags        %#.8x\n", config.flags);
+  fprintf(stderr, "config.paths\n");
+
+  long numpaths = CFArrayGetCount(config.paths);
+
+  for (long i = 0; i < numpaths; i++) {
+    char path[PATH_MAX];
+    CFStringGetCString(CFArrayGetValueAtIndex(config.paths, i),
+                       path,
+                       PATH_MAX,
+                       kCFStringEncodingUTF8);
+    fprintf(stderr, "  %s\n", path);
+  }
+
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+}
+
+static void callback(FSEventStreamRef streamRef,
+                     void *clientCallBackInfo,
+                     size_t numEvents,
+                     void *eventPaths,
+                     const FSEventStreamEventFlags eventFlags[],
+                     const FSEventStreamEventId eventIds[])
+{
+  char **paths = eventPaths;
+
+#ifdef DEBUG
+  fprintf(stderr, "\n");
+  fprintf(stderr, "FSEventStreamCallback fired!\n");
+  fprintf(stderr, "  numEvents: %lu\n", numEvents);
+
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stderr, "  event path: %s\n", paths[i]);
+    fprintf(stderr, "  event flags: %#.8x\n", eventFlags[i]);
+    fprintf(stderr, "  event ID: %llu\n", eventIds[i]);
+  }
+
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stdout, "%s", paths[i]);
+    fprintf(stdout, ":");
+  }
+
+  fprintf(stdout, "\n");
+  fflush(stdout);
+}
+
+int main(int argc, const char *argv[])
+{
+  /*
+   * a subprocess will initially inherit the process group of its parent. the
+   * process group may have a control terminal associated with it, which would
+   * be the first tty device opened by the group leader. typically the group
+   * leader is your shell and the control terminal is your login device. a
+   * subset of signals triggered on the control terminal are sent to all members
+   * of the process group, in large part to facilitate sane and consistent
+   * cleanup (ex: control terminal was closed).
+   *
+   * so why the overly descriptive lecture style comment?
+   *   1. SIGINT and SIGQUIT are among the signals with this behavior
+   *   2. a number of applications gank the above for their own use
+   *   3. ruby's insanely useful "guard" is one of these applications
+   *   4. despite having some level of understanding of POSIX signals and a few
+   *      of the scenarios that might cause problems, i learned this one only
+   *      after reading ruby 1.9's process.c
+   *   5. if left completely undocumented, even slightly obscure bugfixes
+   *      may be removed as cruft by a future maintainer
+   *
+   * hindsight is 20/20 addition: if you're single-threaded and blocking on IO
+   * with a subprocess, then handlers for deferrable signals might not get run
+   * when you expect them to. In the case of Ruby 1.8, that means making use of
+   * IO::select, which will preserve correct signal handling behavior.
+   */
+  if (setpgid(0,0) < 0) {
+    fprintf(stderr, "Unable to set new process group.\n");
+    return 1;
+  }
+
+  parse_cli_settings(argc, argv);
+
+  FSEventStreamContext context = {0, NULL, NULL, NULL, NULL};
+  FSEventStreamRef stream;
+  stream = FSEventStreamCreate(kCFAllocatorDefault,
+                               (FSEventStreamCallback)&callback,
+                               &context,
+                               config.paths,
+                               config.sinceWhen,
+                               config.latency,
+                               config.flags);
+
+#ifdef DEBUG
+  FSEventStreamShow(stream);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  FSEventStreamScheduleWithRunLoop(stream,
+                                   CFRunLoopGetCurrent(),
+                                   kCFRunLoopDefaultMode);
+  FSEventStreamStart(stream);
+  CFRunLoopRun();
+  FSEventStreamFlushSync(stream);
+  FSEventStreamStop(stream);
+
+  return 0;
+}