joshbuddy-guard 0.10.0

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;
+}

data/lib/vendor/darwin/lib/rb-fsevent.rb

@@ -0,0 +1,2 @@
+require 'rb-fsevent/fsevent'
+require 'rb-fsevent/version'

data/lib/vendor/darwin/lib/rb-fsevent/fsevent.rb

@@ -0,0 +1,105 @@
+class FSEvent
+  class << self
+    class_eval <<-END
+      def root_path
+        "#{File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..'))}"
+      end
+    END
+    class_eval <<-END
+      def watcher_path
+        "#{File.join(FSEvent.root_path, 'bin', 'fsevent_watch_guard')}"
+      end
+    END
+  end
+
+  attr_reader :paths, :callback
+
+  def watch(watch_paths, options=nil, &block)
+    @paths      = watch_paths.kind_of?(Array) ? watch_paths : [watch_paths]
+    @callback   = block
+
+    if options.kind_of?(Hash)
+      @options  = parse_options(options)
+    elsif options.kind_of?(Array)
+      @options  = options
+    else
+      @options  = []
+    end
+  end
+
+  def run
+    @running = true
+    # please note the use of IO::select() here, as it is used specifically to
+    # preserve correct signal handling behavior in ruby 1.8.
+    while @running && IO::select([pipe], nil, nil, nil)
+      if line = pipe.readline
+        modified_dir_paths = line.split(":").select { |dir| dir != "\n" }
+        callback.call(modified_dir_paths)
+      end
+    end
+  rescue Interrupt, IOError
+  ensure
+    stop
+  end
+
+  def stop
+    if pipe
+      Process.kill("KILL", pipe.pid)
+      pipe.close
+    end
+  rescue IOError
+  ensure
+    @pipe = @running = nil
+  end
+
+  if RUBY_VERSION < '1.9'
+    def pipe
+      @pipe ||= IO.popen("#{self.class.watcher_path} #{options_string} #{shellescaped_paths}")
+    end
+
+    private
+
+    def options_string
+      @options.join(' ')
+    end
+
+    def shellescaped_paths
+      @paths.map {|path| shellescape(path)}.join(' ')
+    end
+
+    # for Ruby 1.8.6  support
+    def shellescape(str)
+      # An empty argument will be skipped, so return empty quotes.
+      return "''" if str.empty?
+
+      str = str.dup
+
+      # Process as a single byte sequence because not all shell
+      # implementations are multibyte aware.
+      str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+      # A LF cannot be escaped with a backslash because a backslash + LF
+      # combo is regarded as line continuation and simply ignored.
+      str.gsub!(/\n/, "'\n'")
+
+      return str
+    end
+  else
+    def pipe
+      @pipe ||= IO.popen([self.class.watcher_path] + @options + @paths)
+    end
+  end
+
+  private
+
+  def parse_options(options={})
+    opts = []
+    opts.concat(['--since-when', options[:since_when]]) if options[:since_when]
+    opts.concat(['--latency', options[:latency]]) if options[:latency]
+    opts.push('--no-defer') if options[:no_defer]
+    opts.push('--watch-root') if options[:watch_root]
+    # ruby 1.9's IO.popen(array-of-stuff) syntax requires all items to be strings
+    opts.map {|opt| "#{opt}"}
+  end
+
+end

data/lib/vendor/darwin/lib/rb-fsevent/version.rb

@@ -0,0 +1,3 @@
+class FSEvent
+  VERSION = "0.4.3.1"
+end

data/lib/vendor/darwin/rb-fsevent.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rb-fsevent/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rb-fsevent"
+  s.version     = FSEvent::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Thibaud Guillaume-Gentil', 'Travis Tilley']
+  s.email       = ['thibaud@thibaud.me', 'ttilley@gmail.com']
+  s.homepage    = "http://rubygems.org/gems/rb-fsevent"
+  s.summary     = "Very simple & usable FSEvents API"
+  s.description = "FSEvents API with Signals catching (without RubyCocoa)"
+
+  s.rubyforge_project = "rb-fsevent"
+
+  s.add_development_dependency  'bundler',     '~> 1.0.10'
+  s.add_development_dependency  'rspec',       '~> 2.5.0'
+  s.add_development_dependency  'guard-rspec', '~> 0.1.9'
+
+  s.files        = Dir.glob('{lib,ext}/**/*') + %w[LICENSE README.rdoc]
+  s.extensions   = ['ext/extconf.rb']
+  s.require_path = 'lib'
+end

data/lib/vendor/darwin/spec/rb-fsevent/fsevent_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe FSEvent do
+
+  before(:each) do
+    @results = []
+    @fsevent = FSEvent.new
+    @fsevent.watch @fixture_path.to_s, {:latency => 0.5} do |paths|
+      @results += paths
+    end
+  end
+
+  it "should have a watcher_path that resolves to an executable file" do
+    File.exists?(FSEvent.watcher_path).should be_true
+    File.executable?(FSEvent.watcher_path).should be_true
+  end
+
+  it "should work with path with an apostrophe" do
+    custom_path = @fixture_path.join("custom 'path")
+    file = custom_path.join("newfile.rb").to_s
+    File.delete file if File.exists? file
+    @fsevent.watch custom_path.to_s do |paths|
+      @results += paths
+    end
+    @fsevent.paths.should == ["#{custom_path}"]
+    run
+    FileUtils.touch file
+    stop
+    File.delete file
+    @results.should == [custom_path.to_s + '/']
+  end
+
+  it "should catch new file" do
+    file = @fixture_path.join("newfile.rb")
+    File.delete file if File.exists? file
+    run
+    FileUtils.touch file
+    stop
+    File.delete file
+    @results.should == [@fixture_path.to_s + '/']
+  end
+
+  it "should catch file update" do
+    file = @fixture_path.join("folder1/file1.txt")
+    File.exists?(file).should be_true
+    run
+    FileUtils.touch file
+    stop
+    @results.should == [@fixture_path.join("folder1/").to_s]
+  end
+
+  it "should catch files update" do
+    file1 = @fixture_path.join("folder1/file1.txt")
+    file2 = @fixture_path.join("folder1/folder2/file2.txt")
+    File.exists?(file1).should be_true
+    File.exists?(file2).should be_true
+    run
+    FileUtils.touch file1
+    FileUtils.touch file2
+    stop
+    @results.should == [@fixture_path.join("folder1/").to_s, @fixture_path.join("folder1/folder2/").to_s]
+  end
+
+  def run
+    sleep 1
+    Thread.new { @fsevent.run }
+    sleep 1
+  end
+
+  def stop
+    sleep 1
+    @fsevent.stop
+  end
+
+end

data/lib/vendor/darwin/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+require 'rb-fsevent'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  
+  config.before(:each) do
+    @fixture_path = Pathname.new(File.expand_path('../fixtures/', __FILE__))
+  end
+  
+  config.before(:all) do
+    system "cd ext; ruby extconf.rb"
+    puts "fsevent_watch compiled"
+  end
+  
+  config.after(:all) do
+    gem_root = Pathname.new(File.expand_path('../../', __FILE__))
+    system "rm -rf #{gem_root.join('bin')}"
+    system "rm #{gem_root.join('ext/Makefile')}"
+  end
+  
+end