diff --git a/.gitignore b/.gitignore
index 5c0401e..5d58655 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.vagrant
 node_modules
 build
 .lock-*
diff --git a/LICENSE b/LICENSE
index 8e65a7c..ab229c4 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-# Copyright 2010 Camilo Aguilar. All rights reserved.
+# Copyright 2015 Camilo Aguilar. All rights reserved.
 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
diff --git a/Vagrantfile b/Vagrantfile
new file mode 100644
index 0000000..4ea07ef
--- /dev/null
+++ b/Vagrantfile
@@ -0,0 +1,24 @@
+$script = <<SCRIPT
+sudo apt-get install -y build-essential
+curl -sL https://deb.nodesource.com/setup_0.12 | sudo bash -
+# curl -sL https://deb.nodesource.com/setup_0.10 | sudo bash -
+# curl -sL https://deb.nodesource.com/setup_iojs_1.x | sudo bash -
+ sudo apt-get install -y nodejs
+# sudo apt-get install -y iojs
+sudo npm install -g node-gyp
+SCRIPT
+
+Vagrant.configure("2") do |config|
+	config.vm.box = "ubuntu/trusty64"
+	config.vm.box_check_update = false
+
+	config.vm.hostname = "inotify.local"
+
+	config.vm.provider "virtualbox" do |vb|
+		vb.gui = false
+		vb.memory = 1024
+		vb.cpus = 1
+	end
+
+	config.vm.provision "shell", inline: $script
+end
diff --git a/binding.gyp b/binding.gyp
index 499c4a9..392da49 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -1,11 +1,14 @@
 {
-  'targets': [
-    {
-      'target_name': 'inotify',
-      'sources': [
-        'src/bindings.cc',
-        'src/node_inotify.cc'
-      ],
-    }
-  ]
+	'targets': [
+		{
+			'target_name': 'inotify',
+			'sources': [
+				'src/bindings.cc',
+				'src/node_inotify.cc'
+			],
+			"include_dirs" : [
+				"<!(node -e \"require('nan')\")"
+			]
+		}
+	]
 }
diff --git a/package.json b/package.json
index 1c95e8d..6ade612 100644
--- a/package.json
+++ b/package.json
@@ -1,14 +1,26 @@
-{   "name" : "inotify",
-    "version": "1.2.1",
-    "author": "Camilo Aguilar <camilo@cloudescape.com>",
-    "email": "camilo@cloudescape.com",
-    "keywords": ["inotify", "watch", "monitor", "watch files", "watch directories"],
-    "description" : "inotify bindings for v8 javascript engine",
-    "repository": {
-            "type": "git",
-            "url": "http://github.com/c4milo/node-inotify"
-     },
-    "engines": {"node": ">=0.8"},
-    "main" : "inotify"
+{
+  "name": "inotify",
+  "version": "1.3.0",
+  "author": "Camilo Aguilar <camilo.aguilar@gmail.com>",
+  "email": "camilo.aguilar@gmail.com",
+  "keywords": [
+    "inotify",
+    "watch",
+    "monitor",
+    "watch files",
+    "watch directories"
+  ],
+  "license": "MIT",
+  "description": "inotify bindings for v8 javascript engine",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/c4milo/node-inotify"
+  },
+  "engines": {
+    "node": ">=0.8"
+  },
+  "main": "inotify",
+  "dependencies": {
+    "nan": "^1.8.4"
+  }
 }
-
diff --git a/src/bindings.cc b/src/bindings.cc
index 61c9e83..bbde8f6 100644
--- a/src/bindings.cc
+++ b/src/bindings.cc
@@ -1,4 +1,4 @@
-// Copyright 2010, Camilo Aguilar. Cloudescape, LLC.
+// Copyright 2015, Camilo Aguilar
 #include "bindings.h"
 
 /* size of the event structure, not counting name */
@@ -8,325 +8,313 @@
 #define BUF_LEN        (1024 * (EVENT_SIZE + 16))
 
 namespace NodeInotify {
-    static Persistent<String> path_sym;
-    static Persistent<String> watch_for_sym;
-    static Persistent<String> callback_sym;
-    static Persistent<String> persistent_sym;
-    static Persistent<String> watch_sym;
-    static Persistent<String> mask_sym;
-    static Persistent<String> cookie_sym;
-    static Persistent<String> name_sym;
-
-    void Inotify::Initialize(Handle<Object> target) {
-        Local<FunctionTemplate> t = FunctionTemplate::New(Inotify::New);
-
-        t->InstanceTemplate()->SetInternalFieldCount(1);
-
-        NODE_SET_PROTOTYPE_METHOD(t, "addWatch",
-                                      Inotify::AddWatch);
-        NODE_SET_PROTOTYPE_METHOD(t, "removeWatch",
-                                      Inotify::RemoveWatch);
-        NODE_SET_PROTOTYPE_METHOD(t, "close",
-                                      Inotify::Close);
-
-        //Constants initialization
-        NODE_DEFINE_CONSTANT(t, IN_ACCESS); //File was accessed (read)
-        NODE_DEFINE_CONSTANT(t, IN_ATTRIB); //Metadata changed, e.g., permissions, timestamps,
-                                                      //extended attributes, link count (since Linux 2.6.25),
-                                                      //UID, GID, etc.
-        NODE_DEFINE_CONSTANT(t, IN_CLOSE_WRITE); //File opened for writing was closed
-        NODE_DEFINE_CONSTANT(t, IN_CLOSE_NOWRITE); //File not opened for writing was closed
-        NODE_DEFINE_CONSTANT(t, IN_CREATE); //File/directory created in watched directory
-        NODE_DEFINE_CONSTANT(t, IN_DELETE); //File/directory deleted from watched directory
-        NODE_DEFINE_CONSTANT(t, IN_DELETE_SELF); //Watched file/directory was itself deleted
-        NODE_DEFINE_CONSTANT(t, IN_MODIFY); //File was modified
-        NODE_DEFINE_CONSTANT(t, IN_MOVE_SELF); //Watched file/directory was itself moved
-        NODE_DEFINE_CONSTANT(t, IN_MOVED_FROM); //File moved out of watched directory
-        NODE_DEFINE_CONSTANT(t, IN_MOVED_TO); //File moved into watched directory
-        NODE_DEFINE_CONSTANT(t, IN_OPEN); //File was opened
-        NODE_DEFINE_CONSTANT(t, IN_IGNORED); // Watch was removed explicitly (inotify.watch.rm) or
-                                                       //automatically (file was deleted, or file system was
-                                                        //unmounted)
-        NODE_DEFINE_CONSTANT(t, IN_ISDIR); //Subject of this event is a directory
-        NODE_DEFINE_CONSTANT(t, IN_Q_OVERFLOW); //Event queue overflowed (wd is -1 for this event)
-        NODE_DEFINE_CONSTANT(t, IN_UNMOUNT); //File system containing watched object was unmounted
-        NODE_DEFINE_CONSTANT(t, IN_ALL_EVENTS);
-
-        NODE_DEFINE_CONSTANT(t, IN_ONLYDIR); // Only watch the path if it is a directory.
-        NODE_DEFINE_CONSTANT(t, IN_DONT_FOLLOW); // Do not follow a sym link
-        NODE_DEFINE_CONSTANT(t, IN_ONESHOT); // Only send event once
-        NODE_DEFINE_CONSTANT(t, IN_MASK_ADD); //Add (OR) events to watch mask for this pathname if it
-                                                        //already exists (instead of replacing mask).
-
-        NODE_DEFINE_CONSTANT(t, IN_CLOSE); // (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)  Close
-        NODE_DEFINE_CONSTANT(t, IN_MOVE);  //  (IN_MOVED_FROM | IN_MOVED_TO)  Moves
-
-        path_sym        = NODE_PSYMBOL("path");
-        watch_for_sym   = NODE_PSYMBOL("watch_for");
-        callback_sym    = NODE_PSYMBOL("callback");
-        persistent_sym  = NODE_PSYMBOL("persistent");
-
-        watch_sym       = NODE_PSYMBOL("watch");
-        mask_sym        = NODE_PSYMBOL("mask");
-        cookie_sym      = NODE_PSYMBOL("cookie");
-        name_sym        = NODE_PSYMBOL("name");
-
-        Local<ObjectTemplate> object_tmpl = t->InstanceTemplate();
-        object_tmpl->SetAccessor(persistent_sym, Inotify::GetPersistent);
-
-        t->SetClassName(String::NewSymbol("Inotify"));
-        target->Set(String::NewSymbol("Inotify"), t->GetFunction());
-    }
-
-    Inotify::Inotify() : ObjectWrap() {
-        //ev_init(&read_watcher, Inotify::Callback);
-        read_watcher = new uv_poll_t;
-        read_watcher->data = this;  //preserving my reference to use it inside Inotify::Callback
-        //uv_poll_init(uv_default_loop(), &read_watcher, Inotify::Callback);
-        persistent = true;
-        poll_stopped = 0;
-    }
-
-    Inotify::Inotify(bool nonpersistent) : ObjectWrap() {
-        read_watcher = new uv_poll_t;
-        read_watcher->data = this; //preserving my reference so that we can use it inside Inotify::Callback
-        //ev_init(&read_watcher, Inotify::Callback);
-        persistent = nonpersistent;
-        poll_stopped = 0;
-    }
-
-    Inotify::~Inotify() {
-        if(!persistent) {
-            //ev_ref(EV_DEFAULT_UC);
-            uv_ref((uv_handle_t *) read_watcher);
-        }
-        //ev_io_stop(EV_DEFAULT_UC_ &read_watcher);
-
-        // if Inotify::Close() was already called we do not need to
-        // stop polling again thus it causes fail of assertion test
-        StopPolling();
-
-        //assert(!uv_is_pending(&read_watcher));
-    }
-
-    Handle<Value> Inotify::New(const Arguments& args) {
-        HandleScope scope;
-
-        Inotify *inotify = NULL;
-        if(args.Length() == 1 && args[0]->IsBoolean()) {
-            inotify = new Inotify(args[0]->IsTrue());
-        } else {
-            inotify = new Inotify();
-        }
-
- 	inotify->fd = inotify_init();
-
-        if(inotify->fd == -1) {
-            ThrowException(String::New(strerror(errno)));
-            return Null();
-        }
-	
-	int flags = fcntl(inotify->fd, F_GETFL);
-	if(flags == -1) {
-	    flags = 0;
+	void Inotify::Initialize(Handle<Object> exports) {
+		Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
+		t->SetClassName(NanNew<String>("Inotify"));
+		t->InstanceTemplate()->SetInternalFieldCount(1);
+
+		NODE_SET_PROTOTYPE_METHOD(t, "addWatch", Inotify::AddWatch);
+		NODE_SET_PROTOTYPE_METHOD(t, "removeWatch", Inotify::RemoveWatch);
+		NODE_SET_PROTOTYPE_METHOD(t, "close", Inotify::Close);
+
+		Local<ObjectTemplate> object_tmpl = t->InstanceTemplate();
+		object_tmpl->SetAccessor(NanNew<String>("persistent"), Inotify::GetPersistent);
+
+		Local<Function> fn = t->GetFunction();
+		exports->Set(NanNew<String>("Inotify"), fn);
+
+		// Constants initialization
+		NODE_DEFINE_CONSTANT(fn, IN_ACCESS); //File was accessed (read)
+		NODE_DEFINE_CONSTANT(fn, IN_ATTRIB); //Metadata changed, e.g., permissions, timestamps,
+													  //extended attributes, link count (since Linux 2.6.25),
+													  //UID, GID, etc.
+		NODE_DEFINE_CONSTANT(fn, IN_CLOSE_WRITE); //File opened for writing was closed
+		NODE_DEFINE_CONSTANT(fn, IN_CLOSE_NOWRITE); //File not opened for writing was closed
+		NODE_DEFINE_CONSTANT(fn, IN_CREATE); //File/directory created in watched directory
+		NODE_DEFINE_CONSTANT(fn, IN_DELETE); //File/directory deleted from watched directory
+		NODE_DEFINE_CONSTANT(fn, IN_DELETE_SELF); //Watched file/directory was itself deleted
+		NODE_DEFINE_CONSTANT(fn, IN_MODIFY); //File was modified
+		NODE_DEFINE_CONSTANT(fn, IN_MOVE_SELF); //Watched file/directory was itself moved
+		NODE_DEFINE_CONSTANT(fn, IN_MOVED_FROM); //File moved out of watched directory
+		NODE_DEFINE_CONSTANT(fn, IN_MOVED_TO); //File moved into watched directory
+		NODE_DEFINE_CONSTANT(fn, IN_OPEN); //File was opened
+		NODE_DEFINE_CONSTANT(fn, IN_IGNORED);// Watch was removed explicitly (inotify.watch.rm) or
+											// automatically (file was deleted, or file system was
+											// unmounted)
+		NODE_DEFINE_CONSTANT(fn, IN_ISDIR); //Subject of this event is a directory
+		NODE_DEFINE_CONSTANT(fn, IN_Q_OVERFLOW); //Event queue overflowed (wd is -1 for this event)
+		NODE_DEFINE_CONSTANT(fn, IN_UNMOUNT); //File system containing watched object was unmounted
+		NODE_DEFINE_CONSTANT(fn, IN_ALL_EVENTS);
+
+		NODE_DEFINE_CONSTANT(fn, IN_ONLYDIR); // Only watch the path if it is a directory.
+		NODE_DEFINE_CONSTANT(fn, IN_DONT_FOLLOW); // Do not follow a sym link
+		NODE_DEFINE_CONSTANT(fn, IN_ONESHOT); // Only send event once
+		NODE_DEFINE_CONSTANT(fn, IN_MASK_ADD); //Add (OR) events to watch mask for this pathname if it
+											// already exists (instead of replacing mask).
+
+		NODE_DEFINE_CONSTANT(fn, IN_CLOSE); // (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)  Close
+		NODE_DEFINE_CONSTANT(fn, IN_MOVE);  //  (IN_MOVED_FROM | IN_MOVED_TO)  Moves
 	}
 
-	fcntl(inotify->fd, F_SETFL, flags | O_NONBLOCK);
-
-        //ev_io_set(&inotify->read_watcher, inotify->fd, EV_READ);
-        //ev_io_start(EV_DEFAULT_UC_ &inotify->read_watcher);
-        uv_poll_init(uv_default_loop(), inotify->read_watcher, inotify->fd);
-        uv_poll_start(inotify->read_watcher, UV_READABLE, Inotify::Callback); 
-
-	
-        Local<Object> obj = args.This();
-        inotify->Wrap(obj);
-
-        if(!inotify->persistent) {
-            //ev_unref(EV_DEFAULT_UC);
-            uv_unref((uv_handle_t *) inotify->read_watcher);
-        }
-        /**
- 	 * Increment object references to avoid be GCed while
-   	 * we are waiting for events in the inotify file descriptor.
-         * Also, the object is not weak anymore. 
-	 */
-        inotify->Ref();
-
-        return scope.Close(obj);
-    }
-
-    Handle<Value> Inotify::AddWatch(const Arguments& args) {
-        HandleScope scope;
-        uint32_t mask = 0;
-        int watch_descriptor = 0;
-
-        if(args.Length() < 1 || !args[0]->IsObject()) {
-            return ThrowException(Exception::TypeError(
-            String::New("You must specify an object as first argument")));
-        }
-
-        Local<Object> args_ = args[0]->ToObject();
-
-        if(!args_->Has(path_sym)) {
-            return ThrowException(Exception::TypeError(
-            String::New("You must specify a path to watch for events")));
-        }
-
-        if(!args_->Has(callback_sym) ||
-            !args_->Get(callback_sym)->IsFunction()) {
-            return ThrowException(Exception::TypeError(
-            String::New("You must specify a callback function")));
-        }
-
-        if(!args_->Has(watch_for_sym)) {
-            mask |= IN_ALL_EVENTS;
-        } else {
-            if(!args_->Get(watch_for_sym)->IsInt32()) {
-                return ThrowException(Exception::TypeError(
-                String::New("You must specify OR'ed set of events")));
-            }
-            mask |= args_->Get(watch_for_sym)->Int32Value();
-            if(mask == 0) {
-                return ThrowException(Exception::TypeError(
-                String::New("You must specify OR'ed set of events")));
-            }
-       }
-
-        String::Utf8Value path(args_->Get(path_sym));
-
-        Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
-
-        /* add watch */
-        watch_descriptor = inotify_add_watch(inotify->fd, (const char *) *path, mask);
-
-        Local<Integer> descriptor = Integer::New(watch_descriptor);
-
-        //Local<Function> callback = Local<Function>::Cast(args_->Get(callback_sym));
-        inotify->handle_->Set(descriptor, args_->Get(callback_sym));
-
-        return scope.Close(descriptor);
-    }
-
-    Handle<Value> Inotify::RemoveWatch(const Arguments& args) {
-        HandleScope scope;
-        uint32_t watch = 0;
-        int ret = -1;
-
-        if(args.Length() == 0 || !args[0]->IsInt32()) {
-            return ThrowException(Exception::TypeError(
-            String::New("You must specify a valid watcher descriptor as argument")));
-        }
-        watch = args[0]->Int32Value();
-
-        Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
-
-        ret = inotify_rm_watch(inotify->fd, watch);
-        if(ret == -1) {
-            ThrowException(String::New(strerror(errno)));
-            return False();
-        }
-
-        return True();
-    }
-
-    void Inotify::on_handle_close(uv_handle_t* handle) {
-        assert(!uv_is_active(handle));
-        delete handle;
-    }
-    
-    Handle<Value> Inotify::Close(const Arguments& args) {
-        HandleScope scope;
-        int ret = -1;
-
-        Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
-        ret = close(inotify->fd);
-
-        if(ret == -1) {
-            ThrowException(String::New(strerror(errno)));
-            return False();
-        }
-
-        if(!inotify->persistent) {
-            //ev_ref(EV_DEFAULT_UC);
-            uv_ref((uv_handle_t *) inotify->read_watcher);
-        }
-
-        //ev_io_stop(EV_DEFAULT_UC_ &inotify->read_watcher);
-        inotify->StopPolling();
-	
-        /*Eliminating reference created inside of Inotify::New.
-        The object is also weak again.
-        Now v8 can do its stuff and GC the object.
-        */
-        inotify->Unref();
-
-        return True();
-    }
-
-    void Inotify::Callback(uv_poll_t *watcher, int status, int revents) {
-        HandleScope scope;
-
-        Inotify *inotify = static_cast<Inotify*>(watcher->data);
-        assert(watcher == inotify->read_watcher);
-
-        char buffer[BUF_LEN];
-
-        //int length = read(inotify->fd, buffer, BUF_LEN);
-
-        Local<Value> argv[1];
-        TryCatch try_catch;
-
-        int i = 0;
-	int sz = 0;
-        while ((sz = read(inotify->fd, buffer, BUF_LEN)) > 0) {
-	  struct inotify_event *event;
-	  for (i = 0; i <= (sz-EVENT_SIZE); i += (EVENT_SIZE + event->len)) {
-            event = (struct inotify_event *) &buffer[i];
-
-            Local<Object> obj = Object::New();
-            obj->Set(watch_sym, Integer::New(event->wd));
-            obj->Set(mask_sym, Integer::New(event->mask));
-            obj->Set(cookie_sym, Integer::New(event->cookie));
-
-            if(event->len) {
-                obj->Set(name_sym, String::New(event->name));
-            }
-            argv[0] = obj;
-
-            inotify->Ref();
-            Local<Value> callback_ = inotify->handle_->Get(Integer::New(event->wd));
-            Local<Function> callback = Local<Function>::Cast(callback_);
-
-            callback->Call(inotify->handle_, 1, argv);
-            inotify->Unref();
-
-            if(event->mask & IN_IGNORED) {
-                //deleting callback because the watch was removed
-                Local<Value> wd = Integer::New(event->wd);
-                inotify->handle_->Delete(wd->ToString());
-            }
-
-            if (try_catch.HasCaught()) {
-                FatalException(try_catch);
-            }
-	  }
+	Inotify::Inotify() : ObjectWrap() {
+		//ev_init(&read_watcher, Inotify::Callback);
+		read_watcher = new uv_poll_t;
+		read_watcher->data = this;  //preserving my reference to use it inside Inotify::Callback
+		//uv_poll_init(uv_default_loop(), &read_watcher, Inotify::Callback);
+		persistent = true;
+		poll_stopped = 0;
 	}
-    }
 
-    Handle<Value> Inotify::GetPersistent(Local<String> property,
-                                        const AccessorInfo& info) {
-        Inotify *inotify = ObjectWrap::Unwrap<Inotify>(info.This());
+	Inotify::Inotify(bool nonpersistent) : ObjectWrap() {
+		read_watcher = new uv_poll_t;
+		read_watcher->data = this; //preserving my reference so that we can use it inside Inotify::Callback
+		//ev_init(&read_watcher, Inotify::Callback);
+		persistent = nonpersistent;
+		poll_stopped = 0;
+	}
+
+	Inotify::~Inotify() {
+		if(!persistent) {
+			//ev_ref(EV_DEFAULT_UC);
+			uv_ref((uv_handle_t *) read_watcher);
+		}
+		//ev_io_stop(EV_DEFAULT_UC_ &read_watcher);
+
+		// if Inotify::Close() was already called we do not need to
+		// stop polling again thus it causes fail of assertion test
+		StopPolling();
+
+		//assert(!uv_is_pending(&read_watcher));
+	}
+
+	NAN_METHOD(Inotify::New) {
+		NanScope();
+
+		Inotify *inotify = NULL;
+		if(args.Length() == 1 && args[0]->IsBoolean()) {
+			inotify = new Inotify(args[0]->IsTrue());
+		} else {
+			inotify = new Inotify();
+		}
+
+		inotify->fd = inotify_init();
+
+		if(inotify->fd == -1) {
+			NanThrowError(NanNew<String>(strerror(errno)));
+			NanReturnValue(NanNull());
+		}
+
+		int flags = fcntl(inotify->fd, F_GETFL);
+		if(flags == -1) {
+			flags = 0;
+		}
+
+		fcntl(inotify->fd, F_SETFL, flags | O_NONBLOCK);
+
+		//ev_io_set(&inotify->read_watcher, inotify->fd, EV_READ);
+		//ev_io_start(EV_DEFAULT_UC_ &inotify->read_watcher);
+		uv_poll_init(uv_default_loop(), inotify->read_watcher, inotify->fd);
+		uv_poll_start(inotify->read_watcher, UV_READABLE, Inotify::Callback);
+
+
+		Local<Object> obj = args.This();
+		inotify->Wrap(obj);
+
+		if(!inotify->persistent) {
+			//ev_unref(EV_DEFAULT_UC);
+			uv_unref((uv_handle_t *) inotify->read_watcher);
+		}
+		/**
+		* Increment object references to avoid be GCed while
+		* we are waiting for events in the inotify file descriptor.
+		* Also, the object is not weak anymore.
+		*/
+		inotify->Ref();
+
+		NanReturnValue(obj);
+	}
+
+	NAN_METHOD(Inotify::AddWatch) {
+		NanScope();
+		uint32_t mask = 0;
+		int watch_descriptor = 0;
+
+		if(args.Length() < 1 || !args[0]->IsObject()) {
+			return NanThrowTypeError("You must specify an object as first argument");
+		}
+
+		Local<Object> args_ = args[0]->ToObject();
+
+		Local<String> path_sym = NanNew<String>("path");
+		if (!args_->Has(path_sym)) {
+			return NanThrowTypeError("You must specify a path to watch for events");
+		}
+
+		Local<String> callback_sym = NanNew<String>("callback");
+		if (!args_->Has(callback_sym) ||
+			!args_->Get(callback_sym)->IsFunction()) {
+			return NanThrowTypeError("You must specify a callback function");
+		}
+
+		Local<String> watch_for_sym = NanNew<String>("watch_for");
+		if (!args_->Has(watch_for_sym)) {
+			mask |= IN_ALL_EVENTS;
+		} else {
+			if (!args_->Get(watch_for_sym)->IsInt32()) {
+				return NanThrowTypeError("You must specify OR'ed set of events");
+			}
+			mask |= args_->Get(watch_for_sym)->Int32Value();
+			if (mask == 0) {
+				return NanThrowTypeError("You must specify OR'ed set of events");
+			}
+	   }
+
+		String::Utf8Value path(args_->Get(path_sym));
+
+		Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
+
+		/* add watch */
+		watch_descriptor = inotify_add_watch(inotify->fd, (const char *) *path, mask);
+
+		Local<Integer> descriptor = NanNew<Integer>(watch_descriptor);
+
+		//Local<Function> callback = Local<Function>::Cast(args_->Get(callback_sym));
+		#if NODE_VERSION_AT_LEAST(0, 11, 0)
+		inotify->handle()->Set(descriptor, args_->Get(callback_sym));
+		#else
+		inotify->handle_->Set(descriptor, args_->Get(callback_sym));
+		#endif
+
+		NanReturnValue(descriptor);
+	}
+
+	NAN_METHOD(Inotify::RemoveWatch) {
+		NanScope();
+		uint32_t watch = 0;
+		int ret = -1;
+
+		if(args.Length() == 0 || !args[0]->IsInt32()) {
+			return NanThrowTypeError("You must specify a valid watcher descriptor as argument");
+		}
+		watch = args[0]->Int32Value();
+
+		Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
+
+		ret = inotify_rm_watch(inotify->fd, watch);
+		if(ret == -1) {
+			NanThrowError(NanNew<String>(strerror(errno)));
+			NanReturnValue(NanFalse());
+		}
+
+		NanReturnValue(NanTrue());
+	}
+
+	void Inotify::on_handle_close(uv_handle_t* handle) {
+		assert(!uv_is_active(handle));
+		delete handle;
+	}
+
+	NAN_METHOD(Inotify::Close) {
+		NanScope();
+		int ret = -1;
+
+		Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
+		ret = close(inotify->fd);
+
+		if (ret == -1) {
+			NanThrowError(NanNew<String>(strerror(errno)));
+			NanReturnValue(NanFalse());
+		}
+
+		if (!inotify->persistent) {
+			//ev_ref(EV_DEFAULT_UC);
+			uv_ref((uv_handle_t *) inotify->read_watcher);
+		}
+
+		//ev_io_stop(EV_DEFAULT_UC_ &inotify->read_watcher);
+		inotify->StopPolling();
+
+		/*Eliminating reference created inside of Inotify::New.
+		The object is also weak again.
+		Now v8 can do its stuff and GC the object.
+		*/
+		inotify->Unref();
+
+		NanReturnValue(NanTrue());
+	}
+
+	void Inotify::Callback(uv_poll_t *watcher, int status, int revents) {
+		NanScope();
+
+		Inotify *inotify = static_cast<Inotify*>(watcher->data);
+		assert(watcher == inotify->read_watcher);
+
+		char buffer[BUF_LEN];
+
+		//int length = read(inotify->fd, buffer, BUF_LEN);
 
-        return inotify->persistent ? True() : False();
-     }
+		Local<Value> argv[1];
+		TryCatch try_catch;
 
-    void Inotify::StopPolling() {
-        if (!poll_stopped) {
-            uv_poll_stop(read_watcher);
-            uv_close((uv_handle_t *) read_watcher, Inotify::on_handle_close);
-            poll_stopped = 1;
-        }
-    }
+		int sz = 0;
+		while ((sz = read(inotify->fd, buffer, BUF_LEN)) > 0) {
+			struct inotify_event *event;
+			for (unsigned int i = 0; i <= (sz-EVENT_SIZE); i += (EVENT_SIZE + event->len)) {
+				event = (struct inotify_event *) &buffer[i];
 
+				Local<Object> obj = NanNew<Object>();
+				obj->Set(NanNew<String>("watch"), NanNew<Integer>(event->wd));
+				obj->Set(NanNew<String>("mask"), NanNew<Integer>(event->mask));
+				obj->Set(NanNew<String>("cookie"), NanNew<Integer>(event->cookie));
+
+				if(event->len) {
+					obj->Set(NanNew<String>("name"), NanNew<String>(event->name));
+				}
+				argv[0] = obj;
+
+				inotify->Ref();
+
+				#if NODE_VERSION_AT_LEAST(0, 11, 0)
+				Local<Object> handle = inotify->handle();
+				#else
+				Persistent<Object> handle = inotify->handle_;
+				#endif
+
+				Local<Value> callback_ = handle->Get(NanNew<Integer>(event->wd));
+				Local<Function> callback = Local<Function>::Cast(callback_);
+
+				callback->Call(handle, 1, argv);
+				inotify->Unref();
+
+				if(event->mask & IN_IGNORED) {
+					//deleting callback because the watch was removed
+					Local<Value> wd = NanNew<Integer>(event->wd);
+					handle->Delete(wd->ToString());
+				}
+
+				if (try_catch.HasCaught()) {
+					FatalException(try_catch);
+				}
+			} // for
+		} // while
+	}
+
+	NAN_GETTER(Inotify::GetPersistent) {
+		NanScope();
+		Inotify *inotify = ObjectWrap::Unwrap<Inotify>(args.This());
+
+		if (inotify->persistent) {
+			NanReturnValue(NanTrue());
+		}
+
+		NanReturnValue(NanFalse());
+	 }
+
+	void Inotify::StopPolling() {
+		if (!poll_stopped) {
+			uv_poll_stop(read_watcher);
+			uv_close((uv_handle_t *) read_watcher, Inotify::on_handle_close);
+			poll_stopped = 1;
+		}
+	}
 }//namespace NodeInotify
diff --git a/src/bindings.h b/src/bindings.h
index 646fafb..f4e4b6c 100644
--- a/src/bindings.h
+++ b/src/bindings.h
@@ -1,33 +1,33 @@
-// Copyright 2010, Camilo Aguilar. Cloudescape, LLC.
+// Copyright 2015, Camilo Aguilar.
 #ifndef SRC_BINDINGS_H_
 #define SRC_BINDINGS_H_
 #include "node_inotify.h"
 
 namespace NodeInotify {
 
-    class Inotify : public ObjectWrap {
-        public:
-            static void Initialize(Handle<Object> target);
+	class Inotify : public ObjectWrap {
+		public:
+			static void Initialize(Handle<Object> target);
 
-            Inotify();
-            Inotify(bool nonpersistent);
-            virtual ~Inotify();
-        protected:
-            static Handle<Value> New(const Arguments& args);
-            static Handle<Value> AddWatch(const Arguments& args);
-            static Handle<Value> RemoveWatch(const Arguments& args);
-            static Handle<Value> Close(const Arguments& args);
-            static Handle<Value> GetPersistent(Local<String> property,
-                                             const AccessorInfo& info);
-        private:
-            int fd;
-            uv_poll_t* read_watcher;
-            bool persistent;
-            char poll_stopped;
-            void StopPolling();
-            static void Callback(uv_poll_t* watcher, int status, int revents);
-            static void on_handle_close(uv_handle_t* handle);
-    };
+			Inotify();
+			Inotify(bool nonpersistent);
+			virtual ~Inotify();
+		protected:
+			static NAN_METHOD(New);
+			static NAN_METHOD(AddWatch);
+			static NAN_METHOD(RemoveWatch);
+			static NAN_METHOD(Close);
+			static NAN_GETTER(GetPersistent);
+
+		private:
+			int fd;
+			uv_poll_t* read_watcher;
+			bool persistent;
+			char poll_stopped;
+			void StopPolling();
+			static void Callback(uv_poll_t* watcher, int status, int revents);
+			static void on_handle_close(uv_handle_t* handle);
+	};
 
 }  //namespace NodeInotify
 
diff --git a/src/node_inotify.cc b/src/node_inotify.cc
index a41a4e4..927210a 100644
--- a/src/node_inotify.cc
+++ b/src/node_inotify.cc
@@ -1,25 +1,25 @@
-// Copyright 2010, Camilo Aguilar. Cloudescape, LLC.
+// Copyright 2015, Camilo Aguilar.
 #include "bindings.h"
 
 namespace NodeInotify {
-    void InitializeInotify(Handle<Object> target) {
-        HandleScope scope;
+    void InitializeInotify(Handle<Object> exports) {
+        NanScope();
 
-        Inotify::Initialize(target);
+        Inotify::Initialize(exports);
 
-        target->Set(String::NewSymbol("version"),
-                    String::New(NODE_INOTIFY_VERSION));
+        exports->Set(NanNew<String>("version"),
+                    NanNew<String>(NODE_INOTIFY_VERSION));
 
         Handle<ObjectTemplate> global = ObjectTemplate::New();
-        Handle<Context> context = Context::New(NULL, global);
+        Handle<Context> context = NanNew<Context>(reinterpret_cast<ExtensionConfiguration *>(NULL), global);
         Context::Scope context_scope(context);
 
-        context->Global()->Set(String::NewSymbol("Inotify"), target);
+        context->Global()->Set(NanNew<String>("Inotify"), exports);
     }
 
-    extern "C" void init (Handle<Object> target) {
-        HandleScope scope;
-        InitializeInotify(target);
+    extern "C" void init (Handle<Object> exports) {
+        NanScope();
+        InitializeInotify(exports);
     }
 } //namespace NodeInotify
 
diff --git a/src/node_inotify.h b/src/node_inotify.h
index 126ecba..477d981 100644
--- a/src/node_inotify.h
+++ b/src/node_inotify.h
@@ -3,6 +3,7 @@
 #define SRC_NODE_INOTIFY_H_
 
 #include <node.h>
+#include <node_version.h>
 #include <node_object_wrap.h>
 #include <sys/inotify.h>
 #include <sys/select.h>
@@ -10,7 +11,8 @@
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
-#define NODE_INOTIFY_VERSION "1.2.1"
+#include "nan.h"
+#define NODE_INOTIFY_VERSION "1.3.0"
 
 using namespace v8;
 using namespace node;