fsevents 0.3.4 → 0.3.8

package/.travis.yml

@@ -0,0 +1,24 @@
+language: objective-c
+
+env:
+  - NODE_VERSION="v0.10"
+  - NODE_VERSION="v0.12"
+  - NODE_VERSION="iojs-v1.0"
+  - NODE_VERSION="iojs-v2.0"
+
+before_install:
+  - echo $TRAVIS_OS_NAME
+  - export PATH=./node_modules/.bin/:$PATH
+  - rm -rf ~/.nvm && git clone --depth 1 https://github.com/creationix/nvm.git ~/.nvm
+  - source ~/.nvm/nvm.sh
+  - nvm install $NODE_VERSION
+  - nvm use $NODE_VERSION
+  - node --version
+  - npm --version
+  - nvm --version
+
+install:
+  - npm install
+
+script:
+  - npm test

package/Readme.md

@@ -2,14 +2,14 @@
 ## Native Access to Mac OS-X FSEvents
 
  * [Node.js](http://nodejs.org/)
- * [Github repo](https://github.com/pipobscure/fsevents.git)
- * [Module Site](https://github.com/pipobscure/fsevents)
+ * [Github repo](https://github.com/strongloop/fsevents.git)
+ * [Module Site](https://github.com/strongloop/fsevents)
  * [NPM Page](https://npmjs.org/package/fsevents)
 
 ## Installation
 
 	$ npm install -g node-gyp
-	$	git clone https://github.com/pipobscure/fsevents.git fsevents
+	$	git clone https://github.com/strongloop/fsevents.git fsevents
 	$ cd fsevents
 	$ node-gyp configure build
 
@@ -40,7 +40,7 @@ watcher.stop()  // To end observation
 
 All events except *fsevent* take an *info* object as the second parameter of the callback. The structure of this object is:
 
-```json
+```js
 {
   "event": "<event-type>",
   "id": <eventi-id>,

package/fsevents.cc

@@ -10,12 +10,13 @@
 #include "CoreFoundation/CoreFoundation.h"
 #include "CoreServices/CoreServices.h"
 #include <iostream>
+#include <vector>
 
 #include "src/storage.cc"
 namespace fse {
   class FSEvents : public node::ObjectWrap {
   public:
-    FSEvents(const char *path, NanCallback *handler);
+    FSEvents(const char *path, Nan::Callback *handler);
     ~FSEvents();
 
     // locking.cc
@@ -40,12 +41,12 @@ namespace fse {
     void threadStop();
 
     // methods.cc - internal
-    NanCallback *handler;
+    Nan::Callback *handler;
     void emitEvent(const char *path, UInt32 flags, UInt64 id);
 
     // Common
     CFArrayRef paths;
-    CFMutableArrayRef events;
+    std::vector<fse_event*> events;
     static void Initialize(v8::Handle<v8::Object> exports);
 
     // methods.cc - exposed
@@ -58,10 +59,9 @@ namespace fse {
 
 using namespace fse;
 
-FSEvents::FSEvents(const char *path, NanCallback *handler): handler(handler) {
+FSEvents::FSEvents(const char *path, Nan::Callback *handler): handler(handler) {
   CFStringRef dirs[] = { CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8) };
   paths = CFArrayCreate(NULL, (const void **)&dirs, 1, NULL);
-  events = CFArrayCreateMutable(NULL, 0,  &FSEventArrayCallBacks);
   threadloop = NULL;
   lockingStart();
 }
@@ -72,7 +72,6 @@ FSEvents::~FSEvents() {
   handler = NULL;
 
   CFRelease(paths);
-  CFRelease(events);
 }
 
 #ifndef kFSEventStreamEventFlagItemCreated
@@ -86,15 +85,18 @@ FSEvents::~FSEvents() {
 #include "src/methods.cc"
 
 void FSEvents::Initialize(v8::Handle<v8::Object> exports) {
-  v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(FSEvents::New);
-  tpl->SetClassName(NanNew<v8::String>("FSEvents"));
+  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(FSEvents::New);
+  tpl->SetClassName(Nan::New<v8::String>("FSEvents").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-  NODE_SET_PROTOTYPE_METHOD(tpl, "stop", FSEvents::Stop);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "start", FSEvents::Start);
-
-  exports->Set(NanNew<v8::String>("Constants"), Constants());
-  exports->Set(NanNew<v8::String>("FSEvents"), tpl->GetFunction());
+  tpl->PrototypeTemplate()->Set(
+           Nan::New<v8::String>("start").ToLocalChecked(),
+           Nan::New<v8::FunctionTemplate>(FSEvents::Start)->GetFunction());
+  tpl->PrototypeTemplate()->Set(
+           Nan::New<v8::String>("stop").ToLocalChecked(),
+           Nan::New<v8::FunctionTemplate>(FSEvents::Stop)->GetFunction());
+  exports->Set(Nan::New<v8::String>("Constants").ToLocalChecked(), Constants());
+  exports->Set(Nan::New<v8::String>("FSEvents").ToLocalChecked(),
+               tpl->GetFunction());
 }
 
 NODE_MODULE(fse, FSEvents::Initialize)

package/fsevents.js

@@ -29,13 +29,15 @@ module.exports.getInfo = getInfo;
 module.exports.FSEvents = Native.FSEvents;
 module.exports.Constants = Native.Constants;
 
+var defer = global.setImmediate || process.nextTick;
+
 function watch(path) {
   var fse = new FSEvents(String(path || ''), handler);
   EventEmitter.call(fse);
   return fse;
 
   function handler(path, flags, id) {
-    (global.setImmediate || process.nextTick)(function() {
+    defer(function() {
       fse.emit('fsevent', path, flags, id);
       var info = getInfo(path, flags);
       info.id = id;
@@ -54,16 +56,14 @@ function watch(path) {
 }
 
 function proxies(ctor, target) {
-  for (var key in target.prototype) {
-    if (typeof target.prototype[key] !== 'function') {
-      continue;
-    }
-
+  Object.keys(target.prototype).filter(function(key) {
+    return typeof target.prototype[key] === 'function';
+  }).forEach(function(key) {
     ctor.prototype[key] = function() {
       this._impl[key].apply(this._impl, arguments);
       return this;
     }
-  }
+  });
 }
 
 function getFileType(flags) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "fsevents",
-  "version": "0.3.4",
+  "version": "0.3.8",
   "description": "Native Access to Mac OS-X FSEvents",
   "main": "fsevents.js",
   "dependencies": {
-    "nan": "~1.5.0"
+    "nan": "^2.0.2"
   },
   "os": [
     "darwin"
@@ -13,12 +13,11 @@
     "node": ">=0.8.0"
   },
   "scripts": {
-    "install": "node-gyp rebuild",
-    "test": "export PATH=$PATH:`pwd`/node_nodules/.bin/ && tap ./test"
+    "test": "tap ./test"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pipobscure/fsevents.git"
+    "url": "https://github.com/strongloop/fsevents.git"
   },
   "keywords": [
     "fsevents",
@@ -26,11 +25,10 @@
   ],
   "author": "Philipp Dunkel <pip@pipobscure.com>",
   "license": "MIT",
-  "gypfile": true,
   "bugs": {
-    "url": "https://github.com/pipobscure/fsevents/issues"
+    "url": "https://github.com/strongloop/fsevents/issues"
   },
-  "homepage": "https://github.com/pipobscure/fsevents",
+  "homepage": "https://github.com/strongloop/fsevents",
   "devDependencies": {
     "tap": "~0.4.8"
   }

package/src/async.cc

@@ -12,14 +12,16 @@ void async_propagate(uv_async_t *async) {
   char pathbuf[1024];
   const char *pathptr = NULL;
   fse->lock();
-  cnt = CFArrayGetCount(fse->events);
+  cnt = fse->events.size();
   for (idx=0; idx<cnt; idx++) {
-    event = (fse_event *)CFArrayGetValueAtIndex(fse->events, idx);
+    event = fse->events.at(idx);
+    if (event == NULL) continue;
     pathptr = CFStringGetCStringPtr(event->path, kCFStringEncodingUTF8);
     if (!pathptr) CFStringGetCString(event->path, pathbuf, 1024, kCFStringEncodingUTF8);
     fse->emitEvent(pathptr ? pathptr : pathbuf, event->flags, event->id);
+    delete event;
   }
-  if (cnt>0) CFArrayRemoveAllValues(fse->events);
+  if (cnt>0) fse->events.clear();
   fse->unlock();
 }
 

package/src/constants.cc

@@ -85,27 +85,26 @@
 #endif
 
 static v8::Local<v8::Object> Constants() {
-  NanEscapableScope();
-  v8::Local<v8::Object> object = NanNew<v8::Object>();
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagNone"), NanNew<v8::Integer>(kFSEventStreamEventFlagNone));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagMustScanSubDirs"), NanNew<v8::Integer>(kFSEventStreamEventFlagMustScanSubDirs));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagUserDropped"), NanNew<v8::Integer>(kFSEventStreamEventFlagUserDropped));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagKernelDropped"), NanNew<v8::Integer>(kFSEventStreamEventFlagKernelDropped));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagEventIdsWrapped"), NanNew<v8::Integer>(kFSEventStreamEventFlagEventIdsWrapped));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagHistoryDone"), NanNew<v8::Integer>(kFSEventStreamEventFlagHistoryDone));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagRootChanged"), NanNew<v8::Integer>(kFSEventStreamEventFlagRootChanged));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagMount"), NanNew<v8::Integer>(kFSEventStreamEventFlagMount));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagUnmount"), NanNew<v8::Integer>(kFSEventStreamEventFlagUnmount));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemCreated"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemCreated));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemRemoved"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemRemoved));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemInodeMetaMod"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemInodeMetaMod));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemRenamed"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemRenamed));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemModified"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemModified));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemFinderInfoMod"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemFinderInfoMod));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemChangeOwner"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemChangeOwner));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemXattrMod"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemXattrMod));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemIsFile"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemIsFile));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemIsDir"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemIsDir));
-  object->Set(NanNew<v8::String>("kFSEventStreamEventFlagItemIsSymlink"), NanNew<v8::Integer>(kFSEventStreamEventFlagItemIsSymlink));
-  return NanEscapeScope(object);
+  v8::Local<v8::Object> object = Nan::New<v8::Object>();
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagNone").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagNone));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagMustScanSubDirs").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagMustScanSubDirs));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagUserDropped").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagUserDropped));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagKernelDropped").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagKernelDropped));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagEventIdsWrapped").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagEventIdsWrapped));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagHistoryDone").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagHistoryDone));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagRootChanged").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagRootChanged));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagMount").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagMount));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagUnmount").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagUnmount));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemCreated").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemCreated));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemRemoved").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemRemoved));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemInodeMetaMod").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemInodeMetaMod));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemRenamed").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemRenamed));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemModified").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemModified));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemFinderInfoMod").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemFinderInfoMod));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemChangeOwner").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemChangeOwner));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemXattrMod").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemXattrMod));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemIsFile").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemIsFile));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemIsDir").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemIsDir));
+  object->Set(Nan::New<v8::String>("kFSEventStreamEventFlagItemIsSymlink").ToLocalChecked(), Nan::New<v8::Integer>(kFSEventStreamEventFlagItemIsSymlink));
+  return object;
 }

package/src/methods.cc

@@ -5,44 +5,38 @@
 
 void FSEvents::emitEvent(const char *path, UInt32 flags, UInt64 id) {
   if (!handler) return;
-  NanScope();
+  Nan::HandleScope handle_scope;
   v8::Local<v8::Value> argv[] = {
-    NanNew<v8::String>(path),
-    NanNew<v8::Number>(flags),
-    NanNew<v8::Number>(id)
+    Nan::New<v8::String>(path).ToLocalChecked(),
+    Nan::New<v8::Number>(flags),
+    Nan::New<v8::Number>(id)
   };
   handler->Call(3, argv);
 }
 
 NAN_METHOD(FSEvents::New) {
-  NanScope();
-
-  NanUtf8String *path = new NanUtf8String(args[0]);
-  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
+  Nan::Utf8String *path = new Nan::Utf8String(info[0]);
+  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
 
   FSEvents *fse = new FSEvents(**path, callback);
-  fse->Wrap(args.This());
+  fse->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 NAN_METHOD(FSEvents::Stop) {
-  NanScope();
-
-  FSEvents* fse = node::ObjectWrap::Unwrap<FSEvents>(args.This());
+  FSEvents* fse = node::ObjectWrap::Unwrap<FSEvents>(info.This());
 
   fse->threadStop();
   fse->asyncStop();
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 NAN_METHOD(FSEvents::Start) {
-  NanScope();
-
-  FSEvents* fse = node::ObjectWrap::Unwrap<FSEvents>(args.This());
+  FSEvents* fse = node::ObjectWrap::Unwrap<FSEvents>(info.This());
   fse->asyncStart();
   fse->threadStart();
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }

package/src/storage.cc

@@ -7,23 +7,21 @@ struct fse_event {
   UInt64 id;
   UInt32 flags;
   CFStringRef path;
-};
-typedef struct fse_event fse_event;
+  
+  fse_event(CFStringRef eventPath, UInt32 eventFlag, UInt64 eventId) {
+    this->path = eventPath;
+    this->flags = eventFlag;
+    this->id = eventId;
+    if (this->path != NULL)
+      CFRetain(this->path);
+  }
+  
+  ~fse_event() {
+    if (this->path != NULL)
+      CFRelease(this->path);
+  }
 
-const void * FSEventRetain(CFAllocatorRef allocator, const void * ptr) {
-  fse_event * orig = (fse_event * ) ptr;
-  fse_event * copy = (fse_event * ) CFAllocatorAllocate(allocator, sizeof(fse_event), 0);
-  copy->id = orig->id;
-  copy->flags = orig->flags;
-  copy->path = orig->path;
-  CFRetain(copy->path);
-  return copy;
-}
-void FSEventRelease(CFAllocatorRef allocator, const void * ptr) {
-  fse_event * evt = (fse_event * ) ptr;
-  CFRelease(evt->path);
-  CFAllocatorDeallocate(allocator, evt);
-}
-const CFArrayCallBacks FSEventArrayCallBacks = {
-  0, FSEventRetain, FSEventRelease, 0, 0
+private:
+  fse_event(const fse_event&);
+  void operator=(const fse_event&);
 };

package/src/thread.cc

@@ -37,12 +37,13 @@ void HandleStreamEvents(ConstFSEventStreamRef stream, void *ctx, size_t numEvent
   FSEvents * fse = (FSEvents *)ctx;
   size_t idx;
   fse->lock();
-  fse_event event;
   for (idx=0; idx < numEvents; idx++) {
-    event.path = (CFStringRef)CFArrayGetValueAtIndex((CFArrayRef)eventPaths, idx);
-    event.flags = eventFlags[idx];
-    event.id = eventIds[idx];
-    CFArrayAppendValue(fse->events, &event);
+    fse_event *event = new fse_event(
+        (CFStringRef)CFArrayGetValueAtIndex((CFArrayRef)eventPaths, idx),
+        eventFlags[idx],
+        eventIds[idx]
+      );
+    fse->events.push_back(event);
   }
   fse->asyncTrigger();
   fse->unlock();

package/test/function.js

@@ -43,6 +43,9 @@ test('functionality testing', function(t) {
     t.ok(name === info.path, 'matched path');
     switch (info.event) {
       case 'created':
+      case 'modified':
+        // NOTE(bajtos) The recent versions apparently report `modified` event
+        // instead of `created`.
         t.ok(path.basename(name) === 'created-fsevent', 'file created: ' + path.basename(name));
         break;
       case 'moved-out':
@@ -54,6 +57,9 @@ test('functionality testing', function(t) {
       case 'deleted':
         t.ok(path.basename(name) === 'moved-fsevent', 'file deleted: ' + path.basename(name));
         break;
+      default:
+        t.ok(false, 'Uknown event type: ' + info.event);
+        break;
     }
   });
 
@@ -63,7 +69,7 @@ test('functionality testing', function(t) {
     fs.writeFileSync(__dirname + '/temp/created-fsevent', 'created-fsevent');
 
     console.error("===========================================================================");
-  }, 5000);
+  }, 500);
   setTimeout(function() {
     console.error("===========================================================================");
     console.error("\trenameSync(__dirname + '/temp/created-fsevent', __dirname + '/temp/moved-fsevent');");
@@ -71,17 +77,17 @@ test('functionality testing', function(t) {
 
     console.error("===========================================================================");
 
-  }, 10000);
+  }, 1000);
   setTimeout(function() {
     console.error("===========================================================================");
     console.error("\tunlinkSync(__dirname + '/temp/moved-fsevent');");
     fs.unlinkSync(__dirname + '/temp/moved-fsevent');
     console.error("===========================================================================");
-  }, 15000);
+  }, 1500);
   setTimeout(function() {
     console.error("===========================================================================");
     console.error("\trmdirSync(__dirname + '/temp');");
     fs.rmdirSync(__dirname + '/temp');
     console.error("===========================================================================");
-  }, 20000);
+  }, 2000);
 });