rb-fsevent-legacy 0.1.0

data/Gemfile

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

data/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/README.rdoc

@@ -0,0 +1,51 @@
+= rb-fsevent
+
+Very simple & usable Mac OSX FSEvents API
+
+- RubyCocoa not required!
+- Signals are working (really) -- I don't know if they are or not.
+- Tested on MRI 1.8.7 & 1.9.2, JRuby 1.6.3
+- Tested on 10.5.8
+- Works on PowerPC
+
+== Install
+
+    gem install rb-fsevent-legacy
+
+== Usage
+
+=== Singular path
+
+    require 'rb-fsevent-legacy'
+
+    fsevent = FSEvent.new(Dir.pwd)
+
+    #some changes happen here, other program code, etcj
+
+    fsevent.events do |e|
+      puts "Detected change inside: #{e.event_path}"
+    end
+
+=== Multiple paths
+
+    require 'rb-fsevent'
+
+    paths = ['/tmp/path/one', '/tmp/path/two', Dir.pwd]
+
+    fsevent = FSEvent.new
+    fsevent.add_paths(paths)
+    fsevent.watch do |e|
+      puts "Detected change inside: #{e.event_path}"
+    end
+
+    #some things happen
+
+    fsevent.events.collect { |e| e.event_path }
+
+=== Threads
+    
+  The native stream runs in it's own (isolated) CoreFoundation thread, which is started as soon as the gem
+  is loaded and it terminated when the program stops.  You may check for changes as often as you like in 
+  ruby loop, or from an additional Ruby thread.
+
+

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rake/clean'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+file "lib/rb-fsevent-legacy/fs_native_stream.bundle" => Dir.glob("ext/rb-fsevent-legacy/*{.rb,.c}") do
+  Dir.chdir("ext/rb-fsevent-legacy") do
+    ruby "extconf.rb"
+    sh "make"
+  end
+  cp "ext/rb-fsevent-legacy/fs_native_stream.bundle", "lib/rb-fsevent-legacy/fs_native_stream.bundle"
+end
+
+task :spec => "lib/rb-fsevent-legacy/fs_native_stream.bundle"
+
+CLEAN.include('ext/**/*{.o,.log,.bundle}')
+CLEAN.include('ext/**/Makefile')
+CLOBBER.include('lib/**/*.bundle')
+
+namespace(:spec) do
+  desc "Run all specs on multiple ruby versions (requires rbenv)"
+  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
+  desc "run all specs with rcov"
+  RSpec::Core::RakeTask.new(:coverage) do |t|
+    t.rcov = true
+    t.rcov_opts =  %q[--exclude "spec"]
+    t.verbose = true
+  end
+end

data/ext/rb-fsevent-legacy/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+if RUBY_PLATFORM.downcase.include?("darwin")
+  with_ldflags($LDFLAGS + ' -framework Foundation') { true }
+  with_ldflags($LDFLAGS + ' -framework CoreServices') { true }
+else
+  raise "Compiling this for something other than OSX doesn't make sense."
+end
+
+$CFLAGS="-g -O0 -pipe -fno-common"
+
+create_makefile("rb-fsevent-legacy/fs_native_stream")

data/ext/rb-fsevent-legacy/fs_native_stream.c

@@ -0,0 +1,442 @@
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreServices/CoreServices.h>
+
+#include <ruby.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+#define COMPILED_AT __DATE__ " " __TIME__
+
+static VALUE cFSEventSystemStream;
+
+typedef struct cFSEventEventType {
+  char * path;
+  long eventFlags;
+  unsigned int long eventId;
+} cFSEventEvent;
+
+typedef struct cFSEventSystemStreamType {
+  cFSEventEvent *events; // pointer to an arry of events
+  int numEvents;
+  double latency;
+  VALUE path;
+  VALUE running;
+  FSEventStreamRef native_stream;
+} cFSEventSystemStreamType;
+
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_t FSEventThread;
+int semaphore = 0;
+
+CFRunLoopRef FSEventRunLoop;
+int timer_passes;
+VALUE last_events;
+VALUE rbFSEventModule;
+
+void *fs_rb_cf_allocate(CFIndex size, CFOptionFlags hint, void *info);
+void *fs_rb_cf_reallocate(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info);
+void  fs_rb_cf_deallocate(void *ptr, void *info);
+void  fs_callback( const FSEventStreamRef streamRef, void *callbackInfo, size_t numEvents, void *eventPaths,
+                  const FSEventStreamEventFlags eventFlags[],
+                  const FSEventStreamEventId eventIds[]);
+static VALUE fs_init(VALUE self, VALUE directory, VALUE latency);
+void *fs_runloop();
+
+// We need to create a custom allocator so that we place nice with
+// ruby's GC and allocation practices
+static CFAllocatorRef rb_CFAllocator(void) {
+  static CFAllocatorRef allocator = NULL;
+  if(!allocator) {
+    CFAllocatorContext context = {
+      0, // CFIndex Version - always 0
+      NULL, // void * to context info
+      NULL, // retain callback insn't necessary
+      NULL, // release callback isn't necessary
+      NULL, // a callback which returns a description based on info, so NULL here too.
+      fs_rb_cf_allocate,   // core foundation allocation functions which play nice
+      fs_rb_cf_reallocate, // with the ruby gc
+      fs_rb_cf_deallocate,
+      NULL // the preferred size allocater
+    };
+    allocator = CFAllocatorCreate(NULL, &context);
+  }
+  return allocator;
+}
+
+void * fs_rb_cf_allocate(CFIndex size, CFOptionFlags hint, void *info){
+  // hint and info are always going to bu null in our case.
+  // okay, so the size here is an int of BYTES.  ruby's ALLOC_N macro
+  // requires that we allocate by pointer type.  I think this
+  // is fairly cross platform - but I'm not sure.
+  ALLOC_N(char,size);
+}
+void * fs_rb_cf_reallocate(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info){
+  // hint and info are always going to bu null in our case.
+  REALLOC_N(ptr, char, newsize);
+}
+
+void fs_rb_cf_deallocate(void *ptr, void *info){
+  xfree(ptr);
+}
+
+//function prototypes
+//
+
+// AND GO.
+//
+void fs_timer(){
+#ifdef DEBUG
+    printf("Timer Fire\n");
+#endif
+  pthread_mutex_lock(&mutex);
+  timer_passes++;
+  pthread_mutex_unlock(&mutex);
+}
+
+// so OSX doesn't actually have posix semaphores, and i can't make
+// named sempahore work, so implement our own, rather stupid
+// version of them.
+void fs_wait_for_unlock(){
+  int deadlock = 0;
+  // really, it should never wait that long
+  while(semaphore < 0 && deadlock < 32767) { deadlock++; }
+  pthread_mutex_lock(&mutex);
+  semaphore = -1;
+  pthread_mutex_unlock(&mutex);
+}
+
+void fs_unlock(){
+  pthread_mutex_lock(&mutex);
+  semaphore = 0;
+  pthread_mutex_unlock(&mutex);
+}
+
+void fs_callback(
+    __attribute__((unused)) const FSEventStreamRef streamRef,
+    void *callbackInfo, 
+    size_t numEvents,
+    void *eventPaths,
+    const FSEventStreamEventFlags eventFlags[],
+    const FSEventStreamEventId eventIds[]){
+  
+  // this is actually running on our pthread.
+  // ruby is not NOT pthread aware or safe, we we
+  // lockout everything that could happen from
+  // calling ruby in this thread.
+
+  // this is only going to do anything
+  // if there's data corruption, in which case we probably
+  // want to bail out anyway.
+  
+  // the situation is shutting down, so we don't really care
+  if(FSEventRunLoop == false){
+#ifdef DEBUG
+    printf("CoreFoundation callback stopped\n");
+#endif
+    return;
+  }
+  
+  pthread_mutex_lock(&mutex);
+
+#ifdef DEBUG
+    printf("CoreFoundation callback enter for stream <#FSEvent::NativeStream 0x%x>\n", (VALUE)callbackInfo * 2);fflush(stdout);
+#endif
+    // we do object allocation here in another thread
+    // so mutex it incase the GC is running
+    rb_gc_disable();
+    
+    int start_dex;
+    char **paths = eventPaths;
+    // #define REALLOC_N(var,type,n) (var)=(type*)xrealloc((char*)(var),sizeof(type)*(n)) 
+    // make a new FSEvent ruby object
+    cFSEventSystemStreamType *obj;
+    Check_Type((VALUE)callbackInfo, T_DATA);
+    obj = (cFSEventSystemStreamType *)DATA_PTR((VALUE)callbackInfo);
+    
+    if(obj->numEvents > 0){
+#ifdef DEBUG
+      printf("Adding %d to %d existing events\n", numEvents, obj->numEvents);
+#endif
+      start_dex = obj->numEvents;
+      obj->numEvents = obj->numEvents + numEvents;
+    } else {
+      start_dex = 0;
+      obj->numEvents = numEvents;
+    }
+    
+    // just always do realloc - since it will act as an malloc
+    // if we've already nulled the pointer
+#ifdef DEBUG
+      printf("Allocating for %d events\n", obj->numEvents);
+#endif
+    cFSEventEvent *old = obj->events; // yes, i want to store the address.
+    obj->events = (cFSEventEvent *)realloc(obj->events, sizeof(cFSEventEvent) * (int)obj->numEvents);
+    
+    
+    if(obj->events == NULL){
+      rb_bug("Couldn't malloc events from secondary watch thread");
+    }
+
+    int i,j;
+    
+    for(i = start_dex, j = 0; j < numEvents; i++, j++){
+      obj->events[i].path = malloc(strlen(paths[j])+1);
+      if(obj->events[i].path == NULL){
+        rb_bug("Couldn't malloc path from secondary watch thread");
+      }
+      strcpy(obj->events[i].path,paths[j]);
+      obj->events[i].eventFlags = eventFlags[i];
+      obj->events[i].eventId = eventIds[i];
+    }
+    rb_gc_enable();
+    
+#ifdef DEBUG
+    printf("CoreFoundation callback exited\n");
+#endif
+
+  pthread_mutex_unlock(&mutex);
+}
+
+static VALUE fs_timer_events(VALUE self){
+#ifdef DEBUG
+  printf("Timer value retrieved\n"); fflush(stdout);
+#endif
+
+  VALUE timer;
+  pthread_mutex_lock(&mutex);
+  timer = INT2FIX(timer_passes);
+  pthread_mutex_unlock(&mutex);
+  return timer;
+}
+
+static VALUE fs_events(VALUE self) {
+  // this should be running on the main ruby thread
+  pthread_mutex_lock(&mutex);
+#ifdef DEBUG
+    printf("Ruby thread event enter for <#FSEvent::NativeStream 0x%x>\n",(VALUE)self * 2); fflush(stdout);
+#endif
+
+    cFSEventSystemStreamType *obj;
+    // DataGetStruct(self,cFSEventSystemStreamType,obj);
+    Check_Type(self, T_DATA);
+    obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+
+    if(obj->numEvents == 0){
+#ifdef DEBUG
+      printf("Ruby thread event break\n"); fflush(stdout);
+#endif
+      pthread_mutex_unlock(&mutex);
+      return Qnil;
+    }
+ 
+    volatile VALUE FSEvent = rb_const_get(rbFSEventModule,rb_intern("Event"));
+  
+    if(rb_block_given_p()) {
+      int len = obj->numEvents;
+      int i;
+#ifdef DEBUG
+      printf("Yielding %d values\n",obj->numEvents);
+#endif
+      for(i=0;i<len;i++){
+        volatile VALUE fs_event = rb_funcall(FSEvent,rb_intern("new"),0);
+        rb_funcall(fs_event,rb_intern("event_id="),1,ULL2NUM(obj->events[i].eventId));
+        rb_funcall(fs_event,rb_intern("event_path="),1,rb_str_new2(obj->events[i].path));
+        rb_funcall(fs_event,rb_intern("event_flags="),1,LONG2NUM(obj->events[i].eventFlags));
+        
+#ifdef DEBUG
+        printf("Ruby thread event yield\n"); fflush(stdout);
+#endif
+
+        rb_yield(fs_event);
+      }
+      
+      // delete all of the events
+      obj->numEvents = 0;
+      free(obj->events);
+      obj->events = NULL;
+    }
+#ifdef DEBUG
+        printf("Ruby thread event exit\n"); fflush(stdout);
+#endif
+
+  pthread_mutex_unlock(&mutex);
+  return Qnil;
+}
+
+static VALUE fs_running(VALUE self){
+  cFSEventSystemStreamType *obj;
+  Check_Type(self, T_DATA);
+  obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+  return (VALUE)obj->running;
+}
+
+static VALUE fs_path(VALUE self){
+  cFSEventSystemStreamType *obj;
+  Check_Type(self, T_DATA);
+  obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+  return (VALUE)obj->path;
+}
+
+// create a new FS Event Stream
+FSEventStreamRef fs_new_stream(char *dir, VALUE *self) {
+  // always runs on the ruby thread.
+  //
+  cFSEventSystemStreamType *obj;
+  Check_Type(self, T_DATA);
+  obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+
+  CFStringRef mypath = CFStringCreateWithCString(NULL,dir,CFStringGetSystemEncoding());
+  CFArrayRef paths = CFArrayCreate(NULL, (const void **)&mypath, 1, NULL);
+  FSEventStreamContext context = {0,self,NULL,NULL,NULL};
+  FSEventStreamRef stream;
+  CFAbsoluteTime latency = obj->latency;
+  
+  stream = FSEventStreamCreate(
+      rb_CFAllocator(),  // use the customer corefoundation allocator...
+      (FSEventStreamCallback)&fs_callback,
+      &context,
+      paths,
+      kFSEventStreamEventIdSinceNow, //allow to replace with a meaningufl "since"
+      latency,
+      kFSEventStreamCreateFlagNone //look this up
+    );
+  return stream;
+}
+
+static void fs_free(cFSEventSystemStreamType *me){
+  //unconditionally free unprocessed events
+#ifdef DEBUG
+  printf("GC Free for native stream\n"); fflush(stdout);
+#endif
+ 
+  pthread_mutex_lock(&mutex);
+    if(me->running == Qtrue){
+
+#ifdef DEBUG
+      printf("Discarding %d events.\n",me->numEvents); fflush(stdout);
+#endif
+      // we only get called from ruby's GC - but it's possible
+      // for this object to be GCd after the runloop itself has been
+      // so check for that situation
+      FSEventStreamFlushSync(me->native_stream);
+      FSEventStreamStop(me->native_stream);
+      FSEventStreamInvalidate(me->native_stream);
+    }
+  free(me->events);
+  FSEventStreamRelease(me->native_stream);
+  xfree(me);
+  pthread_mutex_unlock(&mutex);
+}
+
+static void fs_mark(cFSEventSystemStreamType *me){
+#ifdef DEBUG
+  printf("GC Mark for native stream\n"); fflush(stdout);
+#endif
+  
+  rb_gc_mark(me->path);
+  rb_gc_mark(me->running); // i think that's extraneous - but mark it just to be safe.
+}
+
+static VALUE fs_stop(VALUE self){
+#ifdef DEBUG
+  printf("Native stream stopping #<FSEvent::NativeStream 0x%x>\n",self * 2); fflush(stdout);
+#endif
+  
+  cFSEventSystemStreamType *obj;
+  Check_Type(self, T_DATA);
+  obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+
+  if(obj->running == Qfalse){
+    VALUE excp = rb_const_get(rb_cObject,rb_intern("RuntimeError"));
+    rb_raise(excp, "native stream watcher was stopped twice");
+  }
+
+  FSEventStreamFlushSync(obj->native_stream);
+  FSEventStreamStop(obj->native_stream);
+  FSEventStreamInvalidate(obj->native_stream);
+  obj->running = Qfalse;
+ 
+  return obj->running;
+}
+
+static VALUE fs_alloc(VALUE klass){
+  // create and assign an empty eventstream.
+#ifdef DEBUG
+  printf("GC Alloc for native stream\n"); fflush(stdout);
+#endif
+  cFSEventSystemStreamType *obj;
+  return Data_Make_Struct(klass,cFSEventSystemStreamType,fs_mark,fs_free,obj);
+}
+
+static VALUE fs_init(VALUE self, VALUE directory, VALUE latency) {
+  char *dir;
+  cFSEventSystemStreamType *obj;
+  /* obj, type, sval */
+  //DataGetStruct(self,cFSEventSystemStreamType,obj);
+  Check_Type(self, T_DATA);
+  obj = (cFSEventSystemStreamType *)DATA_PTR(self);
+  
+  dir = RSTRING_PTR(StringValue(directory));
+  obj->latency = NUM2DBL(latency);
+  obj->native_stream = fs_new_stream(dir,(VALUE *)self);
+  obj->events = NULL; 
+  obj->path = directory;
+  obj->numEvents = 0;
+  
+  
+  FSEventStreamScheduleWithRunLoop(obj->native_stream, FSEventRunLoop, kCFRunLoopDefaultMode);
+  FSEventStreamStart(obj->native_stream);
+
+  obj->running = Qtrue;
+
+  return self;
+}
+
+void *fs_runloop() {
+  FSEventRunLoop = CFRunLoopGetCurrent();
+  // create a one second timer to keep the event loop running even
+  // if we haven't actually added an FSEventStream yet.
+  CFRunLoopTimerRef timer = CFRunLoopTimerCreate(
+      NULL,
+      (CFAbsoluteTime)0,
+      (CFTimeInterval)1.0, //why not.
+      0,
+      0,
+      &fs_timer,
+      NULL
+      );
+  CFRunLoopAddTimer(FSEventRunLoop,timer,kCFRunLoopCommonModes);
+#ifdef DEBUG
+  printf("Starting CFRunLoop\n"); fflush(stdout);
+#endif
+  // this will not get set until the runloop terminates
+  // when it will show the reason for termination
+  CFRunLoopRun();
+  FSEventRunLoop = false;
+
+  // do we need to do any cleanup from our thread?
+}
+
+static void fs_stoploop(VALUE dummy) {
+#ifdef DEBUG
+  printf("Stopping CFRunLoop\n"); fflush(stdout);
+#endif
+  CFRunLoopStop(FSEventRunLoop);
+}
+
+void Init_fs_native_stream(){
+  rbFSEventModule = rb_const_get(rb_cObject,rb_intern("FSEvent"));
+  cFSEventSystemStream = rb_define_class_under(rbFSEventModule, "NativeStream", rb_cObject);
+  rb_define_alloc_func(cFSEventSystemStream,fs_alloc);
+  rb_define_method(cFSEventSystemStream,"initialize",fs_init,2);
+  rb_define_method(cFSEventSystemStream,"events",fs_events,0);
+  rb_define_method(cFSEventSystemStream,"path",fs_path,0);
+  rb_define_method(cFSEventSystemStream,"running?",fs_running,0);
+  rb_define_method(cFSEventSystemStream,"stop",fs_stop,0);
+  
+  rb_define_singleton_method(cFSEventSystemStream,"timer_events",fs_timer_events,0);
+
+  // we create a new pthread that we manage
+  pthread_create(&FSEventThread,NULL,&fs_runloop,NULL);
+  rb_set_end_proc(fs_stoploop,0);
+}

data/lib/rb-fsevent-legacy/event.rb

@@ -0,0 +1,17 @@
+module FSEvent
+  class Event
+    #an ACTUAL filesystem event
+    attr_accessor :event_path, :event_flags, :event_id
+
+    def to_s 
+      "#<%s:0x%x event_path='%s' event_flags='%s' event_id='%s'>" \
+        % [self.class, self.object_id.abs * 2,self.event_path, self.event_flags, self.event_id]
+    end
+
+    def event_flag
+      # honestly, since this is the legacy system i'm not sure this is
+      # ever anything but zero. so lazily do nothing until i know otherwise
+      # break out the event flags into the something meaningful
+    end
+  end
+end

data/lib/rb-fsevent-legacy/stream.rb

@@ -0,0 +1,108 @@
+module FSEvent
+  class Stream
+    class << self
+      def running?
+        if NativeStream.timer_events > 0 then true end
+      end
+    end
+
+    #the callback recieves FSEvent objects which describe the events
+    def initialize(path = nil, latency = 1.0)
+      unless path.nil?
+        @streams = [NativeStream.new(path,Float(latency))]
+      else
+        @streams = []
+      end
+      @run = false;
+    end
+
+    def latency
+      @latency || 1.0
+    end
+
+    def latency= val
+      @latency = Float(val)
+    end
+
+    def watch path = nil, &block
+      @streams.push(NativeStream.new(path,self.latency)) unless path.nil?
+      @call_block = block
+      self
+    end
+    
+    def empty
+      @streams.each { |s| s.stop }.delete_if { |s| not s.running? }
+    end
+
+    def paths
+      @streams.collect { |s| s.path }
+    end
+
+    def add_paths paths
+      paths.each do |p|
+        self.add_path p
+      end
+    end
+
+    def add_path path
+      @streams.push(NativeStream.new(path,self.latency))
+    end
+
+    def status
+      status = @streams.collect do |s|
+        s.running?
+      end
+    end
+
+    def running?
+      status = @streams.collect { |s| s.running? }
+      if not status.include? true
+        false
+      elsif not status.include? false
+        true
+      else
+        raise StandardError, "native streams are in mixed states"
+      end
+    end
+
+    def killall
+      @streams.each do |s|
+        s.stop
+      end
+    end
+
+    def streams
+      @streams
+    end
+
+    def events
+      events = []
+      @streams.each do |s|
+        s.events do |e|
+          if block_given?
+            events << (yield e)
+          else
+            events << e
+          end
+        end
+      end
+      events.compact
+    end
+
+    def run 
+      @run = true
+      while @run do 
+        self.events do |e|
+          if @call_block
+            @call_block.call(e)
+          end
+        end
+        sleep 1
+      end
+    end
+
+    def stop
+      @run = false
+    end
+  end
+end

data/lib/rb-fsevent-legacy/version.rb

@@ -0,0 +1,3 @@
+module FSEvent
+  VERSION = "0.1.0"
+end

data/lib/rb-fsevent-legacy.rb

@@ -0,0 +1,7 @@
+require "rb-fsevent-legacy/version"
+
+module FSEvent
+  require "rb-fsevent-legacy/stream"
+  require "rb-fsevent-legacy/event"
+  require "rb-fsevent-legacy/fs_native_stream"
+end

data/rb-fsevent-legacy.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rb-fsevent-legacy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rb-fsevent-legacy"
+  s.version     = FSEvent::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Stephen Prater']
+  s.email       = ['me@stephenprater.com']
+  s.homepage    = "http://github.com/stephenprater/rb-fsevents-legacy"
+  s.summary     = "Very simple & usable FSEvents API - it works on PowerPCs and 10.5.8"
+  s.description = "A legacy compatible version of an FSEvents API for Darwin."
+
+  s.rubyforge_project = "rb-fsevent-legacy"
+
+  s.add_development_dependency  'bundler',     '~> 1.0.10'
+  s.add_development_dependency  'rspec',       '~> 2.5.0'
+  s.add_development_dependency  'rcov'
+  s.add_development_dependency  'pry'
+
+  s.files         = `git ls-files`.split("\n")
+  s.extensions    = ['ext/rb-fsevent-legacy/extconf.rb']
+  s.require_paths = ['lib','ext']
+end
+

data/spec/rb-fsevent/fsevent_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe FSEvent do
+
+  it "should automatically start the FSEvent native thread" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    fsevent.running?.should be_true
+    fsevent.streams.length.should == 1
+    fsevent.killall
+  end
+
+  it "can start and stop native FSEvent watchers" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    fsevent.running?.should be_true
+    fsevent.streams.length.should == 1
+    fsevent.killall
+    fsevent.running?.should be_false
+   
+    file = @fixture_path.join("newfile#{rand(10).to_s}.rb")
+    FileUtils.touch file
+    sleep 0.2  
+
+    # that event should NOT show up because watcher is stopped 
+    fsevent.events do |e|
+      raise "event block called even though events should return an empty array"
+    end.should == [] 
+
+    event = FSEvent::Stream.new(@fixture_path,0.1)
+    event.running?.should be_true
+    
+    event.events.should == []
+    
+    event.killall
+  end
+
+  it "can only stop it once" do
+    fsevent = FSEvent::Stream.new(@fixture_path,0.1)
+    fsevent.killall
+    lambda { fsevent.killall }.should raise_error RuntimeError
+  end
+
+  it "has a long running thread timer" do
+    FSEvent::Stream.running?.should be_true
+    sleep 1  
+    FSEvent::NativeStream.timer_events.should > 1
+  end
+
+  it "shouldn't throw an error when it gets GC'd" do
+    #basically, if this doesn't throw a bus error it probably worked.
+    #you can ifdef the debugging output in the c-extension if you want
+    #to futz about with it.
+    local_event = FSEvent::Stream.new(@fixture_path,0.1)
+    local_event.running?.should be_true
+    local_event = nil
+    GC.start
+  end
+
+  it "should work with path with an apostrophe" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    custom_path = @fixture_path.join("custom 'path")
+    file = custom_path.join("newfile#{rand(10)}.rb").to_s
+    
+    fsevent.add_path custom_path
+    fsevent.paths.should include("#{custom_path}")
+    FileUtils.touch file
+    
+    sleep 0.2
+
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should include(custom_path.to_s + '/')
+
+    File.delete file
+    fsevent.killall
+  end
+
+  it "should catch new file" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    file = @fixture_path.join("newfile#{rand(10).to_s}.rb")
+    
+    FileUtils.touch file
+    sleep 0.2
+    File.delete file
+  
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should include(@fixture_path.to_s + '/')
+    fsevent.killall
+  end
+
+  it "should catch file update" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    file = @fixture_path.join("folder1/file1.txt")
+    File.exists?(file).should be_true
+    FileUtils.touch file
+    sleep 0.2
+
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should include(@fixture_path.join("folder1/").to_s)
+    fsevent.killall
+  end
+
+  it "should store events until called" do
+    fsevent = FSEvent::Stream.new(@fixture_path, 0.1)
+    file1 = @fixture_path.join("folder1/file3.txt")
+    file2 = @fixture_path.join("folder1/folder2/file2.txt")
+    File.exists?(file1).should be_true
+    File.exists?(file2).should be_true
+    FileUtils.touch file1
+    sleep 0.5 
+    FileUtils.touch file2
+    sleep 0.2 
+
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should == [@fixture_path.join("folder1/").to_s, @fixture_path.join("folder1/folder2/").to_s]
+    fsevent.killall
+  end
+
+  it "will run in a separate thread" do
+    fsevent = nil
+    t = Thread.new do
+      fsevent = FSEvent::Stream.new(@fixture_path,0.1)
+      fsevent.run
+    end
+
+    
+    file1 = @fixture_path.join("folder1/file1.txt")
+    file2 = @fixture_path.join("folder1/folder2/file2.txt")
+
+    FileUtils.touch file1
+
+    sleep 0.2
+
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should include(@fixture_path.join("folder1/").to_s)
+
+    FileUtils.touch file2
+    
+    sleep 0.2
+
+    fsevent.events.collect do |e|
+      e.event_path
+    end.should include(@fixture_path.join("folder1/folder2/").to_s)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'rb-fsevent-legacy'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  
+  config.before(:each) do
+    @fixture_path = Pathname.new(File.expand_path('../fixtures/', __FILE__))
+  end
+  
+  config.after(:all) do
+    gem_root = Pathname.new(File.expand_path('../../', __FILE__))
+    system "rm -rf #{gem_root.join('bin')}"
+  end
+  
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: rb-fsevent-legacy
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stephen Prater
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 0
+        - 10
+        version: 1.0.10
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: A legacy compatible version of an FSEvents API for Darwin.
+email: 
+- me@stephenprater.com
+executables: []
+
+extensions: 
+- ext/rb-fsevent-legacy/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- ext/rb-fsevent-legacy/extconf.rb
+- ext/rb-fsevent-legacy/fs_native_stream.c
+- lib/rb-fsevent-legacy.rb
+- lib/rb-fsevent-legacy/event.rb
+- lib/rb-fsevent-legacy/stream.rb
+- lib/rb-fsevent-legacy/version.rb
+- rb-fsevent-legacy.gemspec
+- spec/fixtures/folder1/file1.txt
+- spec/fixtures/folder1/file3.txt
+- spec/fixtures/folder1/folder2/file2.txt
+- spec/rb-fsevent/fsevent_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/stephenprater/rb-fsevents-legacy
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rb-fsevent-legacy
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Very simple & usable FSEvents API - it works on PowerPCs and 10.5.8
+test_files: []
+