guard 1.0.0 → 1.0.1

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

@@ -0,0 +1,160 @@
+#include <getopt.h>
+#include "cli.h"
+
+const char* cli_info_purpose = "A flexible command-line interface for the FSEvents API";
+const char* cli_info_usage = "Usage: fsevent_watch [OPTIONS]... [PATHS]...";
+const char* cli_info_help[] = {
+  "  -h, --help                you're looking at it",
+  "  -V, --version             print version number and exit",
+  "  -s, --since-when=EventID  fire historical events since ID",
+  "  -l, --latency=seconds     latency period (default='0.5')",
+  "  -n, --no-defer            enable no-defer latency modifier",
+  "  -r, --watch-root          watch for when the root path has changed",
+  // "  -i, --ignore-self         ignore current process",
+  "  -F, --file-events         provide file level event data",
+  "  -f, --format=name         output format (classic, niw, \n"
+  "                                           tnetstring, otnetstring)",
+  0
+};
+
+static void default_args (struct cli_info* args_info)
+{
+  args_info->since_when_arg     = kFSEventStreamEventIdSinceNow;
+  args_info->latency_arg        = 0.5;
+  args_info->no_defer_flag      = false;
+  args_info->watch_root_flag    = false;
+  args_info->ignore_self_flag   = false;
+  args_info->file_events_flag   = false;
+  args_info->format_arg         = kFSEventWatchOutputFormatClassic;
+}
+
+static void cli_parser_release (struct cli_info* args_info)
+{
+  unsigned int i;
+
+  for (i=0; i < args_info->inputs_num; ++i) {
+    free(args_info->inputs[i]);
+  }
+
+  if (args_info->inputs_num) {
+    free(args_info->inputs);
+  }
+
+  args_info->inputs_num = 0;
+}
+
+void cli_parser_init (struct cli_info* args_info)
+{
+  default_args(args_info);
+
+  args_info->inputs = 0;
+  args_info->inputs_num = 0;
+}
+
+void cli_parser_free (struct cli_info* args_info)
+{
+  cli_parser_release(args_info);
+}
+
+void cli_print_version (void)
+{
+  printf("%s %s\n", CLI_NAME, CLI_VERSION);
+#ifdef COMPILED_AT
+  printf("Compiled %s\n", COMPILED_AT);
+#endif
+}
+
+void cli_print_help (void)
+{
+  cli_print_version();
+
+  printf("\n%s\n", cli_info_purpose);
+  printf("\n%s\n", cli_info_usage);
+  printf("\n");
+
+  int i = 0;
+  while (cli_info_help[i]) {
+    printf("%s\n", cli_info_help[i++]);
+  }
+}
+
+int cli_parser (int argc, const char** argv, struct cli_info* args_info)
+{
+  static struct option longopts[] = {
+    { "help",         no_argument,        NULL, 'h' },
+    { "version",      no_argument,        NULL, 'V' },
+    { "since-when",   required_argument,  NULL, 's' },
+    { "latency",      required_argument,  NULL, 'l' },
+    { "no-defer",     no_argument,        NULL, 'n' },
+    { "watch-root",   no_argument,        NULL, 'r' },
+    { "ignore-self",  no_argument,        NULL, 'i' },
+    { "file-events",  no_argument,        NULL, 'F' },
+    { "format",       required_argument,  NULL, 'f' },
+    { 0, 0, 0, 0 }
+  };
+
+  const char* shortopts = "hVs:l:nriFf:";
+
+  int c = -1;
+
+  while ((c = getopt_long(argc, (char * const*)argv, shortopts, longopts, NULL)) != -1) {
+    switch(c) {
+    case 's': // since-when
+      args_info->since_when_arg = strtoull(optarg, NULL, 0);
+      break;
+    case 'l': // latency
+      args_info->latency_arg = strtod(optarg, NULL);
+      break;
+    case 'n': // no-defer
+      args_info->no_defer_flag = true;
+      break;
+    case 'r': // watch-root
+      args_info->watch_root_flag = true;
+      break;
+    case 'i': // ignore-self
+      args_info->ignore_self_flag = true;
+      break;
+    case 'F': // file-events
+      args_info->file_events_flag = true;
+      break;
+    case 'f': // format
+      if (strcmp(optarg, "classic") == 0) {
+        args_info->format_arg = kFSEventWatchOutputFormatClassic;
+      } else if (strcmp(optarg, "niw") == 0) {
+        args_info->format_arg = kFSEventWatchOutputFormatNIW;
+      } else if (strcmp(optarg, "tnetstring") == 0) {
+        args_info->format_arg = kFSEventWatchOutputFormatTNetstring;
+      } else if (strcmp(optarg, "otnetstring") == 0) {
+        args_info->format_arg = kFSEventWatchOutputFormatOTNetstring;
+      } else {
+        fprintf(stderr, "Unknown output format: %s\n", optarg);
+        exit(EXIT_FAILURE);
+      }
+      break;
+    case 'V': // version
+      cli_print_version();
+      exit(EXIT_SUCCESS);
+      break;
+    case 'h': // help
+    case '?': // invalid option
+    case ':': // missing argument
+      cli_print_help();
+      exit((c == 'h') ? EXIT_SUCCESS : EXIT_FAILURE);
+      break;
+    }
+  }
+
+  if (optind < argc) {
+    int i = 0;
+    args_info->inputs_num = (unsigned int)(argc - optind);
+    args_info->inputs =
+      (char**)(malloc ((args_info->inputs_num)*sizeof(char*)));
+    while (optind < argc)
+      if (argv[optind++] != argv[0]) {
+        args_info->inputs[i++] = strdup(argv[optind-1]);
+      }
+  }
+
+  return EXIT_SUCCESS;
+}
+

data/lib/vendor/darwin/ext/fsevent_watch/fsevent_watch/cli.h

@@ -0,0 +1,45 @@
+#ifndef CLI_H
+#define CLI_H
+
+#ifndef CLI_NAME
+#define CLI_NAME "fsevent_watch"
+#endif /* CLI_NAME */
+
+#ifndef PROJECT_VERSION
+#error "PROJECT_VERSION not set"
+#endif /* PROJECT_VERSION */
+
+#ifndef CLI_VERSION
+#define _str(s) #s
+#define _xstr(s) _str(s)
+#define CLI_VERSION _xstr(PROJECT_VERSION)
+#endif /* CLI_VERSION */
+
+#include "common.h"
+
+struct cli_info {
+  UInt64 since_when_arg;
+  double latency_arg;
+  bool no_defer_flag;
+  bool watch_root_flag;
+  bool ignore_self_flag;
+  bool file_events_flag;
+  enum FSEventWatchOutputFormat format_arg;
+
+  char** inputs;
+  unsigned inputs_num;
+};
+
+extern const char* cli_info_purpose;
+extern const char* cli_info_usage;
+extern const char* cli_info_help[];
+
+void cli_print_help(void);
+void cli_print_version(void);
+
+int cli_parser (int argc, const char** argv, struct cli_info* args_info);
+void cli_parser_init (struct cli_info* args_info);
+void cli_parser_free (struct cli_info* args_info);
+
+
+#endif /* CLI_H */

data/lib/vendor/darwin/ext/fsevent_watch/fsevent_watch/common.h

@@ -0,0 +1,34 @@
+#ifndef fsevent_watch_common_h
+#define fsevent_watch_common_h
+
+#include <CoreFoundation/CoreFoundation.h>
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+#endif
+
+#include <CoreServices/CoreServices.h>
+#include <unistd.h>
+#include "compat.h"
+#include "TSICTString.h"
+
+#define COMPILED_AT __DATE__ " " __TIME__
+
+#define FLAG_CHECK(flags, flag) ((flags) & (flag))
+
+#define FPRINTF_FLAG_CHECK(flags, flag, msg, fd)  \
+  do {                                            \
+    if (FLAG_CHECK(flags, flag)) {                \
+      fprintf(fd, "%s", msg "\n"); } }            \
+  while (0)
+
+#define FLAG_CHECK_STDERR(flags, flag, msg)       \
+  FPRINTF_FLAG_CHECK(flags, flag, msg, stderr)
+
+enum FSEventWatchOutputFormat {
+  kFSEventWatchOutputFormatClassic,
+  kFSEventWatchOutputFormatNIW,
+  kFSEventWatchOutputFormatTNetstring,
+  kFSEventWatchOutputFormatOTNetstring
+};
+
+#endif /* fsevent_watch_common_h */

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

@@ -0,0 +1,20 @@
+#include "compat.h"
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 1060
+FSEventStreamCreateFlags  kFSEventStreamCreateFlagIgnoreSelf        = 0x00000008;
+#endif
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 1070
+FSEventStreamCreateFlags  kFSEventStreamCreateFlagFileEvents        = 0x00000010;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemCreated        = 0x00000100;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemRemoved        = 0x00000200;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemInodeMetaMod   = 0x00000400;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemRenamed        = 0x00000800;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemModified       = 0x00001000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemFinderInfoMod  = 0x00002000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemChangeOwner    = 0x00004000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemXattrMod       = 0x00008000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemIsFile         = 0x00010000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemIsDir          = 0x00020000;
+FSEventStreamEventFlags   kFSEventStreamEventFlagItemIsSymlink      = 0x00040000;
+#endif

data/lib/vendor/darwin/ext/fsevent_watch/fsevent_watch/compat.h

@@ -0,0 +1,40 @@
+/**
+ * @headerfile compat.h
+ * FSEventStream flag compatibility shim
+ *
+ * In order to compile a binary against an older SDK yet still support the
+ * features present in later OS releases, we need to define any missing enum
+ * constants not present in the older SDK. This allows us to safely defer
+ * feature detection to runtime (and avoid recompilation).
+ */
+
+
+#ifndef fsevent_watch_compat_h
+#define fsevent_watch_compat_h
+
+#ifndef __CORESERVICES__
+#include <CoreServices/CoreServices.h>
+#endif // __CORESERVICES__
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 1060
+// ignoring events originating from the current process introduced in 10.6
+extern FSEventStreamCreateFlags kFSEventStreamCreateFlagIgnoreSelf;
+#endif
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 1070
+// file-level events introduced in 10.7
+extern FSEventStreamCreateFlags kFSEventStreamCreateFlagFileEvents;
+extern FSEventStreamEventFlags  kFSEventStreamEventFlagItemCreated,
+                                kFSEventStreamEventFlagItemRemoved,
+                                kFSEventStreamEventFlagItemInodeMetaMod,
+                                kFSEventStreamEventFlagItemRenamed,
+                                kFSEventStreamEventFlagItemModified,
+                                kFSEventStreamEventFlagItemFinderInfoMod,
+                                kFSEventStreamEventFlagItemChangeOwner,
+                                kFSEventStreamEventFlagItemXattrMod,
+                                kFSEventStreamEventFlagItemIsFile,
+                                kFSEventStreamEventFlagItemIsDir,
+                                kFSEventStreamEventFlagItemIsSymlink;
+#endif
+
+#endif // fsevent_watch_compat_h

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

@@ -0,0 +1,509 @@
+#include "common.h"
+#include "cli.h"
+
+// TODO: set on fire. cli.{h,c} handle both parsing and defaults, so there's
+//       no need to set those here. also, in order to scope metadata by path,
+//       each stream will need its own configuration... so this won't work as
+//       a global any more. In the end the goal is to make the output format
+//       able to declare not just that something happened and what flags were
+//       attached, but what path it was watching that caused those events (so
+//       that the path itself can be used for routing that information to the
+//       relevant callback).
+//
+// Structure for storing metadata parsed from the commandline
+static struct {
+  FSEventStreamEventId            sinceWhen;
+  CFTimeInterval                  latency;
+  FSEventStreamCreateFlags        flags;
+  CFMutableArrayRef               paths;
+  enum FSEventWatchOutputFormat   format;
+} config = {
+  (UInt64) kFSEventStreamEventIdSinceNow,
+  (double) 0.3,
+  (CFOptionFlags) kFSEventStreamCreateFlagNone,
+  NULL,
+  kFSEventWatchOutputFormatClassic
+};
+
+// 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
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+  
+#ifdef DEBUG
+  fprintf(stderr, "compiled against 10.6+, using CFURLCreateFileReferenceURL\n");
+#endif
+  
+  CFURLRef url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8*)path, (CFIndex)strlen(path), false);
+  CFURLRef placeholder = CFURLCopyAbsoluteURL(url);
+  CFRelease(url);
+  
+  CFMutableArrayRef imaginary = NULL;
+  
+  // if we don't have an existing url, spin until we get to a parent that
+  // does exist, saving any imaginary components for appending back later
+  while(!CFURLResourceIsReachable(placeholder, NULL)) {
+#ifdef DEBUG
+    fprintf(stderr, "path does not exist\n");
+#endif
+    
+    CFStringRef child;
+    
+    if (imaginary == NULL) {
+      imaginary = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+    }
+    
+    child = CFURLCopyLastPathComponent(placeholder);
+    CFArrayInsertValueAtIndex(imaginary, 0, child);
+    CFRelease(child);
+    
+    url = CFURLCreateCopyDeletingLastPathComponent(NULL, placeholder);
+    CFRelease(placeholder);
+    placeholder = url;
+    
+#ifdef DEBUG
+    fprintf(stderr, "parent: ");
+    CFShow(placeholder);
+#endif
+  }
+  
+#ifdef DEBUG
+  fprintf(stderr, "path exists\n");
+#endif
+  
+  // realpath() doesn't always return the correct case for a path, so this
+  // is a funky workaround that converts a path into a (volId/inodeId) pair
+  // and asks what the path should be for that. since it looks at the actual
+  // inode instead of returning the same case passed in like realpath()
+  // appears to do for HFS+, it should always be correct.
+  url = CFURLCreateFileReferenceURL(NULL, placeholder, NULL);
+  CFRelease(placeholder);
+  placeholder = CFURLCreateFilePathURL(NULL, url, NULL);
+  CFRelease(url);
+  
+#ifdef DEBUG
+  fprintf(stderr, "path resolved to: ");
+  CFShow(placeholder);
+#endif
+  
+  // if we stripped off any imaginary path components, append them back on
+  if (imaginary != NULL) {
+    CFIndex count = CFArrayGetCount(imaginary);
+    for (CFIndex i = 0; i<count; i++) {
+      CFStringRef component = CFArrayGetValueAtIndex(imaginary, i);
+#ifdef DEBUG
+      fprintf(stderr, "appending component: ");
+      CFShow(component);
+#endif
+      url = CFURLCreateCopyAppendingPathComponent(NULL, placeholder, component, false);
+      CFRelease(placeholder);
+      placeholder = url;
+    }
+    CFRelease(imaginary);
+  }
+  
+#ifdef DEBUG
+  fprintf(stderr, "result: ");
+  CFShow(placeholder);
+#endif
+  
+  CFStringRef cfPath = CFURLCopyFileSystemPath(placeholder, kCFURLPOSIXPathStyle);
+  CFArrayAppendValue(config.paths, cfPath);
+  CFRelease(cfPath);
+  CFRelease(placeholder);
+  
+#else
+  
+#ifdef DEBUG
+  fprintf(stderr, "compiled against 10.5, using realpath()\n");
+#endif
+  
+  char fullPath[PATH_MAX + 1];
+  
+  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");
+#endif
+  
+  CFStringRef pathRef = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                  fullPath,
+                                                  kCFStringEncodingUTF8);
+  CFArrayAppendValue(config.paths, pathRef);
+  CFRelease(pathRef);
+  
+#endif
+}
+
+// Parse commandline settings
+static inline void parse_cli_settings(int argc, const char* argv[])
+{
+  // runtime os version detection
+  SInt32 osMajorVersion, osMinorVersion;
+  if (!(Gestalt(gestaltSystemVersionMajor, &osMajorVersion) == noErr)) {
+    osMajorVersion = 0;
+  }
+  if (!(Gestalt(gestaltSystemVersionMinor, &osMinorVersion) == noErr)) {
+    osMinorVersion = 0;
+  }
+
+  if ((osMajorVersion == 10) & (osMinorVersion < 5)) {
+    fprintf(stderr, "The FSEvents API is unavailable on this version of macos!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  struct cli_info args_info;
+  cli_parser_init(&args_info);
+
+  if (cli_parser(argc, argv, &args_info) != 0) {
+    exit(EXIT_FAILURE);
+  }
+
+  config.paths = CFArrayCreateMutable(NULL,
+                                      (CFIndex)0,
+                                      &kCFTypeArrayCallBacks);
+
+  config.sinceWhen = args_info.since_when_arg;
+  config.latency = args_info.latency_arg;
+  config.format = args_info.format_arg;
+
+  if (args_info.no_defer_flag) {
+    config.flags |= kFSEventStreamCreateFlagNoDefer;
+  }
+  if (args_info.watch_root_flag) {
+    config.flags |= kFSEventStreamCreateFlagWatchRoot;
+  }
+
+  if (args_info.ignore_self_flag) {
+    if ((osMajorVersion == 10) & (osMinorVersion >= 6)) {
+      config.flags |= kFSEventStreamCreateFlagIgnoreSelf;
+    } else {
+      fprintf(stderr, "MacOSX 10.6 or later is required for --ignore-self\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  if (args_info.file_events_flag) {
+    if ((osMajorVersion == 10) & (osMinorVersion >= 7)) {
+      config.flags |= kFSEventStreamCreateFlagFileEvents;
+    } else {
+      fprintf(stderr, "MacOSX 10.7 or later required for --file-events\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  if (args_info.inputs_num == 0) {
+    append_path(".");
+  } else {
+    for (unsigned int i=0; i < args_info.inputs_num; ++i) {
+      append_path(args_info.inputs[i]);
+    }
+  }
+
+  cli_parser_free(&args_info);
+
+#ifdef DEBUG
+  fprintf(stderr, "config.sinceWhen    %llu\n", config.sinceWhen);
+  fprintf(stderr, "config.latency      %f\n", config.latency);
+
+// STFU clang
+#if __LP64__
+  fprintf(stderr, "config.flags        %#.8x\n", config.flags);
+#else
+  fprintf(stderr, "config.flags        %#.8lx\n", config.flags);
+#endif
+
+  FLAG_CHECK_STDERR(config.flags, kFSEventStreamCreateFlagUseCFTypes,
+                    "  Using CF instead of C types");
+  FLAG_CHECK_STDERR(config.flags, kFSEventStreamCreateFlagNoDefer,
+                    "  NoDefer latency modifier enabled");
+  FLAG_CHECK_STDERR(config.flags, kFSEventStreamCreateFlagWatchRoot,
+                    "  WatchRoot notifications enabled");
+  FLAG_CHECK_STDERR(config.flags, kFSEventStreamCreateFlagIgnoreSelf,
+                    "  IgnoreSelf enabled");
+  FLAG_CHECK_STDERR(config.flags, kFSEventStreamCreateFlagFileEvents,
+                    "  FileEvents enabled");
+
+  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");
+#endif
+}
+
+// original output format for rb-fsevent
+static void classic_output_format(size_t numEvents,
+                                  char** paths)
+{
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stdout, "%s:", paths[i]);
+  }
+  fprintf(stdout, "\n");
+}
+
+// output format used in the Yoshimasa Niwa branch of rb-fsevent
+static void niw_output_format(size_t numEvents,
+                              char** paths,
+                              const FSEventStreamEventFlags eventFlags[],
+                              const FSEventStreamEventId eventIds[])
+{
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stdout, "%lu:%llu:%s\n",
+            (unsigned long)eventFlags[i],
+            (unsigned long long)eventIds[i],
+            paths[i]);
+  }
+  fprintf(stdout, "\n");
+}
+
+static void tstring_output_format(size_t numEvents,
+                                  char** paths,
+                                  const FSEventStreamEventFlags eventFlags[],
+                                  const FSEventStreamEventId eventIds[],
+                                  TSITStringFormat format)
+{
+  CFMutableArrayRef events = CFArrayCreateMutable(kCFAllocatorDefault,
+                             0, &kCFTypeArrayCallBacks);
+
+  for (size_t i = 0; i < numEvents; i++) {
+    CFMutableDictionaryRef event = CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                   0,
+                                   &kCFTypeDictionaryKeyCallBacks,
+                                   &kCFTypeDictionaryValueCallBacks);
+
+    CFStringRef path = CFStringCreateWithBytes(kCFAllocatorDefault,
+                       (const UInt8*)paths[i],
+                       (CFIndex)strlen(paths[i]),
+                       kCFStringEncodingUTF8,
+                       false);
+    CFDictionarySetValue(event, CFSTR("path"), path);
+
+    CFNumberRef flags = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &eventFlags[i]);
+    CFDictionarySetValue(event, CFSTR("flags"), flags);
+
+    CFNumberRef ident = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongLongType, &eventIds[i]);
+    CFDictionarySetValue(event, CFSTR("id"), ident);
+
+    CFArrayAppendValue(events, event);
+
+    CFRelease(event);
+    CFRelease(path);
+    CFRelease(flags);
+    CFRelease(ident);
+  }
+
+  CFMutableDictionaryRef meta = CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                0,
+                                &kCFTypeDictionaryKeyCallBacks,
+                                &kCFTypeDictionaryValueCallBacks);
+  CFDictionarySetValue(meta, CFSTR("events"), events);
+
+  CFNumberRef num = CFNumberCreate(kCFAllocatorDefault, kCFNumberCFIndexType, &numEvents);
+  CFDictionarySetValue(meta, CFSTR("numEvents"), num);
+
+  CFDataRef data = TSICTStringCreateRenderedDataFromObjectWithFormat(meta, format);
+  fprintf(stdout, "%s", CFDataGetBytePtr(data));
+
+  CFRelease(events);
+  CFRelease(num);
+  CFRelease(meta);
+  CFRelease(data);
+}
+
+static void callback(__attribute__((unused)) FSEventStreamRef streamRef,
+                     __attribute__((unused)) 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, "\n");
+    fprintf(stderr, "  event ID: %llu\n", eventIds[i]);
+
+// STFU clang
+#if __LP64__
+    fprintf(stderr, "  event flags: %#.8x\n", eventFlags[i]);
+#else
+    fprintf(stderr, "  event flags: %#.8lx\n", eventFlags[i]);
+#endif
+
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagMustScanSubDirs,
+                      "    Recursive scanning of directory required");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagUserDropped,
+                      "    Buffering problem: events dropped user-side");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagKernelDropped,
+                      "    Buffering problem: events dropped kernel-side");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagEventIdsWrapped,
+                      "    Event IDs have wrapped");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagHistoryDone,
+                      "    All historical events have been processed");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagRootChanged,
+                      "    Root path has changed");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagMount,
+                      "    A new volume was mounted at this path");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagUnmount,
+                      "    A volume was unmounted from this path");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemCreated,
+                      "    Item created");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemRemoved,
+                      "    Item removed");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemInodeMetaMod,
+                      "    Item metadata modified");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemRenamed,
+                      "    Item renamed");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemModified,
+                      "    Item modified");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemFinderInfoMod,
+                      "    Item Finder Info modified");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemChangeOwner,
+                      "    Item changed ownership");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemXattrMod,
+                      "    Item extended attributes modified");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsFile,
+                      "    Item is a file");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsDir,
+                      "    Item is a directory");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsSymlink,
+                      "    Item is a symbolic link");
+
+    fprintf(stderr, "  event path: %s\n", paths[i]);
+    fprintf(stderr, "\n");
+  }
+
+  fprintf(stderr, "\n");
+#endif
+
+  if (config.format == kFSEventWatchOutputFormatClassic) {
+    classic_output_format(numEvents, paths);
+  } else if (config.format == kFSEventWatchOutputFormatNIW) {
+    niw_output_format(numEvents, paths, eventFlags, eventIds);
+  } else if (config.format == kFSEventWatchOutputFormatTNetstring) {
+    tstring_output_format(numEvents, paths, eventFlags, eventIds,
+                          kTSITStringFormatTNetstring);
+  } else if (config.format == kFSEventWatchOutputFormatOTNetstring) {
+    tstring_output_format(numEvents, paths, eventFlags, eventIds,
+                          kTSITStringFormatOTNetstring);
+  }
+
+  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");
+#endif
+
+  FSEventStreamScheduleWithRunLoop(stream,
+                                   CFRunLoopGetCurrent(),
+                                   kCFRunLoopDefaultMode);
+  FSEventStreamStart(stream);
+  CFRunLoopRun();
+  FSEventStreamFlushSync(stream);
+  FSEventStreamStop(stream);
+
+  return 0;
+}