Merge pull request #495 from kkoopa/nan2

Nan2

.travis.yml

+sudo: false
 language: cpp
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    packages:
+    - g++-4.8
 
 # http://docs.travis-ci.com/user/multi-os/
 os:
@@ -17,6 +24,7 @@ env:
    - NODE_VERSION="0.12.7" # ABI 14
    - NODE_VERSION="iojs-1.8.4" # ABI 43
    - NODE_VERSION="iojs-2.3.4" # ABI 44
+   - NODE_VERSION="iojs-3.1.0" # ABI 45
    - NODE_WEBKIT="0.8.6" TARGET_ARCH="ia32"
    - NODE_WEBKIT="0.8.6" TARGET_ARCH="x64"
    - NODE_WEBKIT="0.10.5" TARGET_ARCH="ia32"
@@ -31,6 +39,7 @@ matrix:
       os: osx
 
 before_install:
+- if [[ $TRAVIS_OS_NAME == "linux" ]]; then export CXX=g++-4.8; fi
 # check if tag exists and matches package.json
 - scripts/validate_tag.sh
 - echo $NODE_VERSION

appveyor.yml

@@ -28,6 +28,12 @@ environment:
     - nodejs_version: 2.0.0
       platform: x86
       msvs_toolset: 12
+    - nodejs_version: 3.1.0
+      platform: x64
+      msvs_toolset: 12
+    - nodejs_version: 3.1.0
+      platform: x86
+      msvs_toolset: 12
     # custom visual studio 2015 builds
     - nodejs_version: 0.10.40
       platform: x86

package.json

@@ -37,7 +37,7 @@
         "url": "git://github.com/mapbox/node-sqlite3.git"
     },
     "dependencies": {
-        "nan": "~1.8.4",
+        "nan": "~2.0.5",
         "node-pre-gyp": "~0.6.9"
     },
     "bundledDependencies": [

src/database.h

@@ -2,70 +2,69 @@
 #ifndef NODE_SQLITE3_SRC_DATABASE_H
 #define NODE_SQLITE3_SRC_DATABASE_H
 
-#include <node.h>
 
 #include <string>
 #include <queue>
 
 #include <sqlite3.h>
-#include "nan.h"
+#include <nan.h>
+
 #include "async.h"
 
 using namespace v8;
-using namespace node;
 
 namespace node_sqlite3 {
 
 class Database;
 
 
-class Database : public ObjectWrap {
+class Database : public Nan::ObjectWrap {
 public:
-    static Persistent<FunctionTemplate> constructor_template;
-    static void Init(Handle<Object> target);
+    static Nan::Persistent<FunctionTemplate> constructor_template;
+    static NAN_MODULE_INIT(Init);
 
-    static inline bool HasInstance(Handle<Value> val) {
-        NanScope();
+    static inline bool HasInstance(Local<Value> val) {
+        Nan::HandleScope scope;
         if (!val->IsObject()) return false;
-        Local<Object> obj = val->ToObject();
-        return NanNew(constructor_template)->HasInstance(obj);
+        Local<Object> obj = val.As<Object>();
+        return Nan::New(constructor_template)->HasInstance(obj);
     }
 
     struct Baton {
         uv_work_t request;
         Database* db;
-        Persistent<Function> callback;
+        Nan::Persistent<Function> callback;
         int status;
         std::string message;
 
-        Baton(Database* db_, Handle<Function> cb_) :
+        Baton(Database* db_, Local<Function> cb_) :
                 db(db_), status(SQLITE_OK) {
             db->Ref();
             request.data = this;
-            NanAssignPersistent(callback, cb_);
+            callback.Reset(cb_);
         }
         virtual ~Baton() {
             db->Unref();
-            NanDisposePersistent(callback);
+            callback.Reset();
         }
     };
 
     struct OpenBaton : Baton {
         std::string filename;
         int mode;
-        OpenBaton(Database* db_, Handle<Function> cb_, const char* filename_, int mode_) :
+        OpenBaton(Database* db_, Local<Function> cb_, const char* filename_, int mode_) :
             Baton(db_, cb_), filename(filename_), mode(mode_) {}
     };
 
     struct ExecBaton : Baton {
         std::string sql;
-        ExecBaton(Database* db_, Handle<Function> cb_, const char* sql_) :
+        ExecBaton(Database* db_, Local<Function> cb_, const char* sql_) :
             Baton(db_, cb_), sql(sql_) {}
     };
 
     struct LoadExtensionBaton : Baton {
         std::string filename;
-        LoadExtensionBaton(Database* db_, Handle<Function> cb_, const char* filename_) :
+        LoadExtensionBaton(Database* db_, Local<Function> cb_, const char* filename_) :
             Baton(db_, cb_), filename(filename_) {}
     };
 
@@ -101,7 +100,7 @@ public:
     friend class Statement;
 
 protected:
-    Database() : ObjectWrap(),
+    Database() : Nan::ObjectWrap(),
         _handle(NULL),
         open(false),
         locked(false),

src/macros.h

@@ -6,104 +6,107 @@ const char* sqlite_authorizer_string(int type);
 
 
 #define REQUIRE_ARGUMENTS(n)                                                   \
-    if (args.Length() < (n)) {                                                 \
-        return NanThrowTypeError("Expected " #n "arguments");                  \
+    if (info.Length() < (n)) {                                                 \
+        return Nan::ThrowTypeError("Expected " #n "arguments");                \
     }
 
 
 #define REQUIRE_ARGUMENT_EXTERNAL(i, var)                                      \
-    if (args.Length() <= (i) || !args[i]->IsExternal()) {                      \
-        return NanThrowTypeError("Argument " #i " invalid");                   \
+    if (info.Length() <= (i) || !info[i]->IsExternal()) {                      \
+        return Nan::ThrowTypeError("Argument " #i " invalid");                 \
     }                                                                          \
-    Local<External> var = Local<External>::Cast(args[i]);
+    Local<External> var = Local<External>::Cast(info[i]);
 
 
 #define REQUIRE_ARGUMENT_FUNCTION(i, var)                                      \
-    if (args.Length() <= (i) || !args[i]->IsFunction()) {                      \
-        return NanThrowTypeError("Argument " #i " must be a function");        \
+    if (info.Length() <= (i) || !info[i]->IsFunction()) {                      \
+        return Nan::ThrowTypeError("Argument " #i " must be a function");      \
     }                                                                          \
-    Local<Function> var = Local<Function>::Cast(args[i]);
+    Local<Function> var = Local<Function>::Cast(info[i]);
 
 
 #define REQUIRE_ARGUMENT_STRING(i, var)                                        \
-    if (args.Length() <= (i) || !args[i]->IsString()) {                        \
-        return NanThrowTypeError("Argument " #i " must be a string");          \
+    if (info.Length() <= (i) || !info[i]->IsString()) {                        \
+        return Nan::ThrowTypeError("Argument " #i " must be a string");        \
     }                                                                          \
-    String::Utf8Value var(args[i]->ToString());
+    Nan::Utf8String var(info[i]);
 
 
 #define OPTIONAL_ARGUMENT_FUNCTION(i, var)                                     \
     Local<Function> var;                                                       \
-    if (args.Length() > i && !args[i]->IsUndefined()) {                        \
-        if (!args[i]->IsFunction()) {                                          \
-            return NanThrowTypeError("Argument " #i " must be a function");    \
+    if (info.Length() > i && !info[i]->IsUndefined()) {                        \
+        if (!info[i]->IsFunction()) {                                          \
+            return Nan::ThrowTypeError("Argument " #i " must be a function");  \
         }                                                                      \
-        var = Local<Function>::Cast(args[i]);                                  \
+        var = Local<Function>::Cast(info[i]);                                  \
     }
 
 
 #define OPTIONAL_ARGUMENT_INTEGER(i, var, default)                             \
     int var;                                                                   \
-    if (args.Length() <= (i)) {                                                \
+    if (info.Length() <= (i)) {                                                \
         var = (default);                                                       \
     }                                                                          \
-    else if (args[i]->IsInt32()) {                                             \
-        var = args[i]->Int32Value();                                           \
+    else if (info[i]->IsInt32()) {                                             \
+        var = Nan::To<int32_t>(info[i]).FromJust();                            \
     }                                                                          \
     else {                                                                     \
-        return NanThrowTypeError("Argument " #i " must be an integer");        \
+        return Nan::ThrowTypeError("Argument " #i " must be an integer");      \
     }
 
 
 #define DEFINE_CONSTANT_INTEGER(target, constant, name)                        \
-    (target)->ForceSet(                                                        \
-        NanNew(#name),                                                         \
-        NanNew<Integer>(constant),                                             \
+    Nan::ForceSet(target,                                                      \
+        Nan::New(#name).ToLocalChecked(),                                      \
+        Nan::New<Integer>(constant),                                           \
         static_cast<PropertyAttribute>(ReadOnly | DontDelete)                  \
     );
 
 #define DEFINE_CONSTANT_STRING(target, constant, name)                         \
-    (target)->ForceSet(                                                        \
-        NanNew(#name),                                                         \
-        NanNew(constant),                                                      \
+    Nan::ForceSet(target,                                                      \
+        Nan::New(#name).ToLocalChecked(),                                      \
+        Nan::New(constant).ToLocalChecked(),                                   \
         static_cast<PropertyAttribute>(ReadOnly | DontDelete)                  \
     );
 
 
 #define NODE_SET_GETTER(target, name, function)                                \
-    (target)->InstanceTemplate()                                               \
-        ->SetAccessor(NanNew(name), (function));
+    Nan::SetAccessor((target)->InstanceTemplate(),                             \
+        Nan::New(name).ToLocalChecked(), (function));
 
 #define GET_STRING(source, name, property)                                     \
-    String::Utf8Value name((source)->Get(NanNew(property)));
+    Nan::Utf8String name(Nan::Get(source,                                      \
+        Nan::New(prop).ToLocalChecked()).ToLocalChecked());
 
-#define GET_INTEGER(source, name, property)                                    \
-    int name = (source)->Get(NanNew(property))->Int32Value();
+#define GET_INTEGER(source, name, prop)                                        \
+    int name = Nan::To<int>(Nan::Get(source,                                   \
+        Nan::New(property).ToLocalChecked()).ToLocalChecked()).FromJust();
 
 #define EXCEPTION(msg, errno, name)                                            \
     Local<Value> name = Exception::Error(                                      \
         String::Concat(                                                        \
             String::Concat(                                                    \
-                NanNew(sqlite_code_string(errno)),                             \
-                NanNew(": ")                                                   \
+                Nan::New(sqlite_code_string(errno)).ToLocalChecked(),          \
+                Nan::New(": ").ToLocalChecked()                                \
             ),                                                                 \
             (msg)                                                              \
         )                                                                      \
     );                                                                         \
-    Local<Object> name ##_obj = name->ToObject();                              \
-    name ##_obj->Set(NanNew("errno"), NanNew<Integer>(errno));                 \
-    name ##_obj->Set(NanNew("code"),                                           \
-        NanNew(sqlite_code_string(errno)));
+    Local<Object> name ##_obj = name.As<Object>();                             \
+    Nan::Set(name ##_obj, Nan::New("errno").ToLocalChecked(), Nan::New(errno));\
+    Nan::Set(name ##_obj, Nan::New("code").ToLocalChecked(),                   \
+        Nan::New(sqlite_code_string(errno)).ToLocalChecked());
 
 
 #define EMIT_EVENT(obj, argc, argv)                                            \
     TRY_CATCH_CALL((obj),                                                      \
-        Local<Function>::Cast((obj)->Get(NanNew("emit"))),                     \
+        Nan::Get(obj,                                                          \
+            Nan::New("emit").ToLocalChecked()).ToLocalChecked().As<Function>(),\
         argc, argv                                                             \
     );
 
 #define TRY_CATCH_CALL(context, callback, argc, argv)                          \
-    NanMakeCallback((context), (callback), (argc), (argv))
+    Nan::MakeCallback((context), (callback), (argc), (argv))
 
 #define WORK_DEFINITION(name)                                                  \
     static NAN_METHOD(name);                                                   \
@@ -120,7 +123,8 @@ const char* sqlite_authorizer_string(int type);
     baton->stmt->locked = true;                                                \
     baton->stmt->db->pending++;                                                \
     int status = uv_queue_work(uv_default_loop(),                              \
-        &baton->request, Work_##type, (uv_after_work_cb)Work_After##type);                       \
+        &baton->request,                                                       \
+        Work_##type, reinterpret_cast<uv_after_work_cb>(Work_After##type));    \
     assert(status == 0);
 
 #define STATEMENT_INIT(type)                                                   \

src/node_sqlite3.cc

-#include <node.h>
-#include <node_buffer.h>
-
 #include <stdint.h>
 #include <sstream>
 #include <cstring>
@@ -15,8 +12,9 @@ using namespace node_sqlite3;
 
 namespace {
 
-void RegisterModule(v8::Handle<Object> target) {
-    NanScope();
+NAN_MODULE_INIT(RegisterModule) {
+    Nan::HandleScope scope;
+
     Database::Init(target);
     Statement::Init(target);
 

src/statement.h

 #ifndef NODE_SQLITE3_SRC_STATEMENT_H
 #define NODE_SQLITE3_SRC_STATEMENT_H
 
-#include <node.h>
 
 #include "database.h"
 #include "threading.h"
@@ -13,7 +12,7 @@
 #include <vector>
 
 #include <sqlite3.h>
-#include "nan.h"
+#include <nan.h>
 
 using namespace v8;
 using namespace node;
@@ -72,23 +71,23 @@ typedef Row Parameters;
 
 
 
-class Statement : public ObjectWrap {
+class Statement : public Nan::ObjectWrap {
 public:
-    static Persistent<FunctionTemplate> constructor_template;
+    static Nan::Persistent<FunctionTemplate> constructor_template;
 
-    static void Init(Handle<Object> target);
+    static NAN_MODULE_INIT(Init);
     static NAN_METHOD(New);
 
     struct Baton {
         uv_work_t request;
         Statement* stmt;
-        Persistent<Function> callback;
+        Nan::Persistent<Function> callback;
         Parameters parameters;
 
-        Baton(Statement* stmt_, Handle<Function> cb_) : stmt(stmt_) {
+        Baton(Statement* stmt_, Local<Function> cb_) : stmt(stmt_) {
             stmt->Ref();
             request.data = this;
-            NanAssignPersistent(callback, cb_);
+            callback.Reset(cb_);
         }
         virtual ~Baton() {
             for (unsigned int i = 0; i < parameters.size(); i++) {
@@ -96,25 +95,25 @@ public:
                 DELETE_FIELD(field);
             }
             stmt->Unref();
-            NanDisposePersistent(callback);
+            callback.Reset();
         }
     };
 
     struct RowBaton : Baton {
-        RowBaton(Statement* stmt_, Handle<Function> cb_) :
+        RowBaton(Statement* stmt_, Local<Function> cb_) :
             Baton(stmt_, cb_) {}
         Row row;
     };
 
     struct RunBaton : Baton {
-        RunBaton(Statement* stmt_, Handle<Function> cb_) :
+        RunBaton(Statement* stmt_, Local<Function> cb_) :
             Baton(stmt_, cb_), inserted_id(0), changes(0) {}
         sqlite3_int64 inserted_id;
         int changes;
     };
 
     struct RowsBaton : Baton {
-        RowsBaton(Statement* stmt_, Handle<Function> cb_) :
+        RowsBaton(Statement* stmt_, Local<Function> cb_) :
             Baton(stmt_, cb_) {}
         Rows rows;
     };
@@ -122,20 +121,20 @@ public:
     struct Async;
 
     struct EachBaton : Baton {
-        Persistent<Function> completed;
+        Nan::Persistent<Function> completed;
         Async* async; // Isn't deleted when the baton is deleted.
 
-        EachBaton(Statement* stmt_, Handle<Function> cb_) :
+        EachBaton(Statement* stmt_, Local<Function> cb_) :
             Baton(stmt_, cb_) {}
         virtual ~EachBaton() {
-            NanDisposePersistent(completed);
+            completed.Reset();
         }
     };
 
     struct PrepareBaton : Database::Baton {
         Statement* stmt;
         std::string sql;
-        PrepareBaton(Database* db_, Handle<Function> cb_, Statement* stmt_) :
+        PrepareBaton(Database* db_, Local<Function> cb_, Statement* stmt_) :
             Baton(db_, cb_), stmt(stmt_) {
             stmt->Ref();
         }
@@ -167,8 +166,8 @@ public:
 
         // Store the callbacks here because we don't have
         // access to the baton in the async callback.
-        Persistent<Function> item_cb;
-        Persistent<Function> completed_cb;
+        Nan::Persistent<Function> item_cb;
+        Nan::Persistent<Function> completed_cb;
 
         Async(Statement* st, uv_async_cb async_cb) :
                 stmt(st), completed(false), retrieved(0) {
@@ -180,13 +179,13 @@ public:
 
         ~Async() {
             stmt->Unref();
-            NanDisposePersistent(item_cb);
-            NanDisposePersistent(completed_cb);
+            item_cb.Reset();
+            completed_cb.Reset();
             NODE_SQLITE3_MUTEX_DESTROY
         }
     };
 
-    Statement(Database* db_) : ObjectWrap(),
+    Statement(Database* db_) : Nan::ObjectWrap(),
             db(db_),
             _handle(NULL),
             status(SQLITE_OK),
@@ -220,8 +219,8 @@ protected:
     static void Finalize(Baton* baton);
     void Finalize();
 
-    template <class T> inline Values::Field* BindParameter(const Handle<Value> source, T pos);
-    template <class T> T* Bind(_NAN_METHOD_ARGS, int start = 0, int end = -1);
+    template <class T> inline Values::Field* BindParameter(const Local<Value> source, T pos);
+    template <class T> T* Bind(Nan::NAN_METHOD_ARGS_TYPE info, int start = 0, int end = -1);
     bool Bind(const Parameters &parameters);
 
     static void GetRow(Row* row, sqlite3_stmt* stmt);

test/unicode.test.js

 var sqlite3 = require('..');
 var assert = require('assert');
 
-function randomString() {
-    var str = '';
-    for (var i = Math.random() * 300; i > 0; i--) {
-        str += String.fromCharCode(Math.floor(Math.random() * 65536));
+describe('unicode', function() {
+    var first_values = [],
+        trailing_values = [],
+        chars = [],
+        subranges = new Array(2),
+        len = subranges.length,
+        db,
+        i;
+
+    before(function(done) { db = new sqlite3.Database(':memory:', done); });
+
+    for (i = 0x20; i < 0x80; i++) {
+        first_values.push(i);
+    }
+
+    for (i = 0xc2; i < 0xf0; i++) {
+        first_values.push(i);
+    }
+
+    for (i = 0x80; i < 0xc0; i++) {
+        trailing_values.push(i);
+    }
+
+    for (i = 0; i < len; i++) {
+        subranges[i] = [];
+    }
+
+    for (i = 0xa0; i < 0xc0; i++) {
+        subranges[0].push(i);
+    }
+
+    for (i = 0x80; i < 0xa0; i++) {
+        subranges[1].push(i);
     }
+
+    function random_choice(arr) {
+        return arr[Math.random() * arr.length | 0];
+    }
+
+    function random_utf8() {
+        var first = random_choice(first_values);
+
+        if (first < 0x80) {
+            return String.fromCharCode(first);
+        } else if (first < 0xe0) {
+            return String.fromCharCode((first & 0x1f) << 0x6 | random_choice(trailing_values) & 0x3f);
+        } else if (first == 0xe0) {
+             return String.fromCharCode(((first & 0xf) << 0xc) | ((random_choice(subranges[0]) & 0x3f) << 6) | random_choice(trailing_values) & 0x3f);
+        } else if (first == 0xed) {
+            return String.fromCharCode(((first & 0xf) << 0xc) | ((random_choice(subranges[1]) & 0x3f) << 6) | random_choice(trailing_values) & 0x3f);
+        } else if (first < 0xf0) {
+            return String.fromCharCode(((first & 0xf) << 0xc) | ((random_choice(trailing_values) & 0x3f) << 6) | random_choice(trailing_values) & 0x3f);
+        }
+    }
+
+    function randomString() {
+        var str = '',
+        i;
+
+        for (i = Math.random() * 300; i > 0; i--) {
+            str += random_utf8();
+        }
+
         return str;
-}
+    }
 
-describe('unicode', function() {
-    var db;
-    before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         // Generate random data.
     var data = [];