[Pkg-javascript-commits] [node-leveldown] 01/04: add patch to update nan to 1.2.0
Andrew Kelley
andrewrk-guest at moszumanska.debian.org
Mon Jun 30 03:54:20 UTC 2014
This is an automated email from the git hooks/post-receive script.
andrewrk-guest pushed a commit to branch master
in repository node-leveldown.
commit 36f9e52e73dbcf85bfb5c9433dd96fe1721f1bec
Author: Andrew Kelley <superjoe30 at gmail.com>
Date: Mon Jun 30 03:10:23 2014 +0000
add patch to update nan to 1.2.0
---
debian/patches/series | 1 +
debian/patches/update-nan.patch | 658 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 659 insertions(+)
diff --git a/debian/patches/series b/debian/patches/series
index af72458..f024b07 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +1,2 @@
use-system-libs.patch
+update-nan.patch
diff --git a/debian/patches/update-nan.patch b/debian/patches/update-nan.patch
new file mode 100644
index 0000000..46944f8
--- /dev/null
+++ b/debian/patches/update-nan.patch
@@ -0,0 +1,658 @@
+Description: update nan to 1.2.0
+ leveldown 0.10.2 depends on nan 0.6.0 but 1.2.0 is in Debian. This patch
+ updates to the new version.
+Author: Andrew Kelley <superjoe30 at gmail.com>
+Bug: <url in upstream bugtracker>
+Bug-Debian: http://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: https://github.com/rvagg/node-leveldown/pull/115
+Last-Update: 2012-06-29
+--- node-leveldown-0.10.2.orig/package.json
++++ node-leveldown-0.10.2/package.json
+@@ -28,8 +28,9 @@
+ ],
+ "main": "index.js",
+ "dependencies": {
++ "abstract-leveldown": "^0.11.4",
+ "bindings": "~1.1.1",
+- "nan": "~0.6.0"
++ "nan": "^1.2.0"
+ },
+ "devDependencies": {
+ "tap": "~0.4.1",
+--- node-leveldown-0.10.2.orig/src/async.h
++++ node-leveldown-0.10.2/src/async.h
+@@ -22,14 +22,14 @@ public:
+ ) : NanAsyncWorker(callback), database(database) {
+ NanScope();
+ v8::Local<v8::Object> obj = v8::Object::New();
+- NanAssignPersistent(v8::Object, persistentHandle, obj);
++ NanAssignPersistent(persistentHandle, obj);
+ }
+
+ protected:
+ void SetStatus(leveldb::Status status) {
+ this->status = status;
+ if (!status.ok())
+- this->errmsg = strdup(status.ToString().c_str());
++ this->SetErrorMessage(status.ToString().c_str());
+ }
+ Database* database;
+ private:
+--- node-leveldown-0.10.2.orig/src/batch.cc
++++ node-leveldown-0.10.2/src/batch.cc
+@@ -30,8 +30,8 @@ leveldb::Status Batch::Write () {
+
+ void Batch::Init () {
+ v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(Batch::New);
+- NanAssignPersistent(v8::FunctionTemplate, batch_constructor, tpl);
+- tpl->SetClassName(NanSymbol("Batch"));
++ NanAssignPersistent(batch_constructor, tpl);
++ tpl->SetClassName(NanNew<v8::String>("Batch"));
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "put", Batch::Put);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "del", Batch::Del);
+@@ -49,7 +49,7 @@ NAN_METHOD(Batch::New) {
+ optionsObj = v8::Local<v8::Object>::Cast(args[1]);
+ }
+
+- bool sync = NanBooleanOptionValue(optionsObj, NanSymbol("sync"));
++ bool sync = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("sync"));
+
+ Batch* batch = new Batch(database, sync);
+ batch->Wrap(args.This());
+@@ -67,7 +67,7 @@ v8::Handle<v8::Value> Batch::NewInstance
+ v8::Local<v8::Object> instance;
+
+ v8::Local<v8::FunctionTemplate> constructorHandle =
+- NanPersistentToLocal(batch_constructor);
++ NanNew(batch_constructor);
+
+ if (optionsObj.IsEmpty()) {
+ v8::Handle<v8::Value> argv[1] = { database };
+@@ -165,7 +165,7 @@ NAN_METHOD(Batch::Write) {
+ BatchWriteWorker* worker = new BatchWriteWorker(batch, callback);
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("batch", _this);
++ worker->SaveToPersistent("batch", _this);
+ NanAsyncQueueWorker(worker);
+ } else {
+ LD_RUN_CALLBACK(v8::Local<v8::Function>::Cast(args[0]), 0, NULL);
+--- node-leveldown-0.10.2.orig/src/database.cc
++++ node-leveldown-0.10.2/src/database.cc
+@@ -130,8 +130,8 @@ NAN_METHOD(LevelDOWN) {
+
+ void Database::Init () {
+ v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(Database::New);
+- NanAssignPersistent(v8::FunctionTemplate, database_constructor, tpl);
+- tpl->SetClassName(NanSymbol("Database"));
++ NanAssignPersistent(database_constructor, tpl);
++ tpl->SetClassName(NanNew<v8::String>("Database"));
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "open", Database::Open);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "close", Database::Close);
+@@ -153,7 +153,7 @@ NAN_METHOD(Database::New) {
+ if (!args[0]->IsString())
+ return NanThrowError("constructor requires a location string argument");
+
+- char* location = NanFromV8String(args[0].As<v8::Object>(), Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
++ char* location = (char*)NanRawString(args[0], Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
+
+ Database* obj = new Database(location);
+ obj->Wrap(args.This());
+@@ -167,7 +167,7 @@ v8::Handle<v8::Value> Database::NewInsta
+ v8::Local<v8::Object> instance;
+
+ v8::Local<v8::FunctionTemplate> constructorHandle =
+- NanPersistentToLocal(database_constructor);
++ NanNew(database_constructor);
+
+ if (location.IsEmpty()) {
+ instance = constructorHandle->GetFunction()->NewInstance(0, NULL);
+@@ -186,37 +186,37 @@ NAN_METHOD(Database::Open) {
+
+ bool createIfMissing = NanBooleanOptionValue(
+ optionsObj
+- , NanSymbol("createIfMissing")
++ , NanNew<v8::String>("createIfMissing")
+ , true
+ );
+ bool errorIfExists =
+- NanBooleanOptionValue(optionsObj, NanSymbol("errorIfExists"));
++ NanBooleanOptionValue(optionsObj, NanNew<v8::String>("errorIfExists"));
+ bool compression =
+- NanBooleanOptionValue(optionsObj, NanSymbol("compression"), true);
++ NanBooleanOptionValue(optionsObj, NanNew<v8::String>("compression"), true);
+
+ uint32_t cacheSize = NanUInt32OptionValue(
+ optionsObj
+- , NanSymbol("cacheSize")
++ , NanNew<v8::String>("cacheSize")
+ , 8 << 20
+ );
+ uint32_t writeBufferSize = NanUInt32OptionValue(
+ optionsObj
+- , NanSymbol("writeBufferSize")
++ , NanNew<v8::String>("writeBufferSize")
+ , 4 << 20
+ );
+ uint32_t blockSize = NanUInt32OptionValue(
+ optionsObj
+- , NanSymbol("blockSize")
++ , NanNew<v8::String>("blockSize")
+ , 4096
+ );
+ uint32_t maxOpenFiles = NanUInt32OptionValue(
+ optionsObj
+- , NanSymbol("maxOpenFiles")
++ , NanNew<v8::String>("maxOpenFiles")
+ , 1000
+ );
+ uint32_t blockRestartInterval = NanUInt32OptionValue(
+ optionsObj
+- , NanSymbol("blockRestartInterval")
++ , NanNew<v8::String>("blockRestartInterval")
+ , 16
+ );
+
+@@ -234,7 +234,7 @@ NAN_METHOD(Database::Open) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+
+ NanReturnUndefined();
+@@ -251,7 +251,7 @@ NAN_METHOD(Database::Close) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+
+ if (!database->iterators.empty()) {
+ // yikes, we still have iterators open! naughty naughty.
+@@ -272,10 +272,10 @@ NAN_METHOD(Database::Close) {
+ // CloseWorker will be invoked
+
+ /*
+- v8::Local<v8::Object> localHandle = NanPersistentToLocal(it->second);
++ v8::Local<v8::Object> localHandle = NanNew(it->second);
+ leveldown::Iterator* iterator =
+ node::ObjectWrap::Unwrap<leveldown::Iterator>(localHandle->
+- Get(NanSymbol("iterator")).As<v8::Object>());
++ Get(NanNew<v8::String>("iterator")).As<v8::Object>());
+ */
+ leveldown::Iterator *iterator = it->second;
+
+@@ -314,7 +314,7 @@ NAN_METHOD(Database::Put) {
+ LD_STRING_OR_BUFFER_TO_SLICE(key, keyHandle, key)
+ LD_STRING_OR_BUFFER_TO_SLICE(value, valueHandle, value)
+
+- bool sync = NanBooleanOptionValue(optionsObj, NanSymbol("sync"));
++ bool sync = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("sync"));
+
+ WriteWorker* worker = new WriteWorker(
+ database
+@@ -327,7 +327,7 @@ NAN_METHOD(Database::Put) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+
+ NanReturnUndefined();
+@@ -343,8 +343,8 @@ NAN_METHOD(Database::Get) {
+ v8::Local<v8::Object> keyHandle = args[0].As<v8::Object>();
+ LD_STRING_OR_BUFFER_TO_SLICE(key, keyHandle, key)
+
+- bool asBuffer = NanBooleanOptionValue(optionsObj, NanSymbol("asBuffer"), true);
+- bool fillCache = NanBooleanOptionValue(optionsObj, NanSymbol("fillCache"), true);
++ bool asBuffer = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("asBuffer"), true);
++ bool fillCache = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("fillCache"), true);
+
+ ReadWorker* worker = new ReadWorker(
+ database
+@@ -356,7 +356,7 @@ NAN_METHOD(Database::Get) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+
+ NanReturnUndefined();
+@@ -372,7 +372,7 @@ NAN_METHOD(Database::Delete) {
+ v8::Local<v8::Object> keyHandle = args[0].As<v8::Object>();
+ LD_STRING_OR_BUFFER_TO_SLICE(key, keyHandle, key)
+
+- bool sync = NanBooleanOptionValue(optionsObj, NanSymbol("sync"));
++ bool sync = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("sync"));
+
+ DeleteWorker* worker = new DeleteWorker(
+ database
+@@ -383,7 +383,7 @@ NAN_METHOD(Database::Delete) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+
+ NanReturnUndefined();
+@@ -402,7 +402,7 @@ NAN_METHOD(Database::Batch) {
+
+ LD_METHOD_SETUP_COMMON(batch, 1, 2)
+
+- bool sync = NanBooleanOptionValue(optionsObj, NanSymbol("sync"));
++ bool sync = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("sync"));
+
+ v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(args[0]);
+
+@@ -415,12 +415,12 @@ NAN_METHOD(Database::Batch) {
+
+ v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(array->Get(i));
+
+- LD_CB_ERR_IF_NULL_OR_UNDEFINED(obj->Get(NanSymbol("type")), type)
++ LD_CB_ERR_IF_NULL_OR_UNDEFINED(obj->Get(NanNew<v8::String>("type")), type)
+
+- v8::Local<v8::Value> keyBuffer = obj->Get(NanSymbol("key"));
++ v8::Local<v8::Value> keyBuffer = obj->Get(NanNew<v8::String>("key"));
+ LD_CB_ERR_IF_NULL_OR_UNDEFINED(keyBuffer, key)
+
+- if (obj->Get(NanSymbol("type"))->StrictEquals(NanSymbol("del"))) {
++ if (obj->Get(NanNew<v8::String>("type"))->StrictEquals(NanNew<v8::String>("del"))) {
+ LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, key)
+
+ batch->Delete(key);
+@@ -428,8 +428,8 @@ NAN_METHOD(Database::Batch) {
+ hasData = true;
+
+ DisposeStringOrBufferFromSlice(keyBuffer, key);
+- } else if (obj->Get(NanSymbol("type"))->StrictEquals(NanSymbol("put"))) {
+- v8::Local<v8::Value> valueBuffer = obj->Get(NanSymbol("value"));
++ } else if (obj->Get(NanNew<v8::String>("type"))->StrictEquals(NanNew<v8::String>("put"))) {
++ v8::Local<v8::Value> valueBuffer = obj->Get(NanNew<v8::String>("value"));
+ LD_CB_ERR_IF_NULL_OR_UNDEFINED(valueBuffer, value)
+
+ LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, key)
+@@ -454,7 +454,7 @@ NAN_METHOD(Database::Batch) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+ } else {
+ LD_RUN_CALLBACK(callback, 0, NULL);
+@@ -497,7 +497,7 @@ NAN_METHOD(Database::ApproximateSize) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("database", _this);
++ worker->SaveToPersistent("database", _this);
+ NanAsyncQueueWorker(worker);
+
+ NanReturnUndefined();
+@@ -560,7 +560,7 @@ NAN_METHOD(Database::Iterator) {
+ // register our iterator
+ /*
+ v8::Local<v8::Object> obj = v8::Object::New();
+- obj->Set(NanSymbol("iterator"), iteratorHandle);
++ obj->Set(NanNew<v8::String>("iterator"), iteratorHandle);
+ v8::Persistent<v8::Object> persistent;
+ persistent.Reset(nan_isolate, obj);
+ database->iterators.insert(std::pair< uint32_t, v8::Persistent<v8::Object> & >
+--- node-leveldown-0.10.2.orig/src/database.h
++++ node-leveldown-0.10.2/src/database.h
+@@ -25,8 +25,8 @@ struct Reference {
+
+ Reference(v8::Local<v8::Value> obj, leveldb::Slice slice) : slice(slice) {
+ v8::Local<v8::Object> _obj = v8::Object::New();
+- _obj->Set(NanSymbol("obj"), obj);
+- NanAssignPersistent(v8::Object, handle, _obj);
++ _obj->Set(NanNew<v8::String>("obj"), obj);
++ NanAssignPersistent(handle, _obj);
+ };
+ };
+
+--- node-leveldown-0.10.2.orig/src/database_async.cc
++++ node-leveldown-0.10.2/src/database_async.cc
+@@ -86,7 +86,7 @@ IOWorker::IOWorker (
+ {
+ NanScope();
+
+- SavePersistent("key", keyHandle);
++ SaveToPersistent("key", keyHandle);
+ };
+
+ IOWorker::~IOWorker () {}
+@@ -114,7 +114,7 @@ ReadWorker::ReadWorker (
+
+ options = new leveldb::ReadOptions();
+ options->fill_cache = fillCache;
+- SavePersistent("key", keyHandle);
++ SaveToPersistent("key", keyHandle);
+ };
+
+ ReadWorker::~ReadWorker () {
+@@ -135,7 +135,7 @@ void ReadWorker::HandleOKCallback () {
+ returnValue = v8::String::New((char*)value.data(), value.size());
+ }
+ v8::Local<v8::Value> argv[] = {
+- NanNewLocal<v8::Value>(v8::Null())
++ NanNew(v8::Null())
+ , returnValue
+ };
+ callback->Call(2, argv);
+@@ -155,7 +155,7 @@ DeleteWorker::DeleteWorker (
+
+ options = new leveldb::WriteOptions();
+ options->sync = sync;
+- SavePersistent("key", keyHandle);
++ SaveToPersistent("key", keyHandle);
+ };
+
+ DeleteWorker::~DeleteWorker () {
+@@ -181,7 +181,7 @@ WriteWorker::WriteWorker (
+ {
+ NanScope();
+
+- SavePersistent("value", valueHandle);
++ SaveToPersistent("value", valueHandle);
+ };
+
+ WriteWorker::~WriteWorker () {}
+@@ -236,8 +236,8 @@ ApproximateSizeWorker::ApproximateSizeWo
+ {
+ NanScope();
+
+- SavePersistent("start", startHandle);
+- SavePersistent("end", endHandle);
++ SaveToPersistent("start", startHandle);
++ SaveToPersistent("end", endHandle);
+ };
+
+ ApproximateSizeWorker::~ApproximateSizeWorker () {}
+@@ -259,7 +259,7 @@ void ApproximateSizeWorker::HandleOKCall
+
+ v8::Local<v8::Value> returnValue = v8::Number::New((double) size);
+ v8::Local<v8::Value> argv[] = {
+- NanNewLocal<v8::Value>(v8::Null())
++ NanNew(v8::Null())
+ , returnValue
+ };
+ callback->Call(2, argv);
+--- node-leveldown-0.10.2.orig/src/iterator.cc
++++ node-leveldown-0.10.2/src/iterator.cc
+@@ -50,8 +50,8 @@ Iterator::Iterator (
+
+ v8::Local<v8::Object> obj = v8::Object::New();
+ if (!startHandle.IsEmpty())
+- obj->Set(NanSymbol("start"), startHandle);
+- NanAssignPersistent(v8::Object, persistentHandle, obj);
++ obj->Set(NanNew<v8::String>("start"), startHandle);
++ NanAssignPersistent(persistentHandle, obj);
+
+ options = new leveldb::ReadOptions();
+ options->fill_cache = fillCache;
+@@ -65,7 +65,7 @@ Iterator::Iterator (
+ Iterator::~Iterator () {
+ delete options;
+ if (!persistentHandle.IsEmpty())
+- NanDispose(persistentHandle);
++ NanDisposePersistent(persistentHandle);
+ if (start != NULL)
+ delete start;
+ if (end != NULL)
+@@ -201,7 +201,7 @@ NAN_METHOD(Iterator::Next) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("iterator", _this);
++ worker->SaveToPersistent("iterator", _this);
+ iterator->nexting = true;
+ NanAsyncQueueWorker(worker);
+
+@@ -228,7 +228,7 @@ NAN_METHOD(Iterator::End) {
+ );
+ // persist to prevent accidental GC
+ v8::Local<v8::Object> _this = args.This();
+- worker->SavePersistent("iterator", _this);
++ worker->SaveToPersistent("iterator", _this);
+ iterator->ended = true;
+
+ if (iterator->nexting) {
+@@ -244,8 +244,8 @@ NAN_METHOD(Iterator::End) {
+ void Iterator::Init () {
+ v8::Local<v8::FunctionTemplate> tpl =
+ v8::FunctionTemplate::New(Iterator::New);
+- NanAssignPersistent(v8::FunctionTemplate, iterator_constructor, tpl);
+- tpl->SetClassName(NanSymbol("Iterator"));
++ NanAssignPersistent(iterator_constructor, tpl);
++ tpl->SetClassName(NanNew<v8::String>("Iterator"));
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "next", Iterator::Next);
+ NODE_SET_PROTOTYPE_METHOD(tpl, "end", Iterator::End);
+@@ -261,7 +261,7 @@ v8::Local<v8::Object> Iterator::NewInsta
+
+ v8::Local<v8::Object> instance;
+ v8::Local<v8::FunctionTemplate> constructorHandle =
+- NanPersistentToLocal(iterator_constructor);
++ NanNew(iterator_constructor);
+
+ if (optionsObj.IsEmpty()) {
+ v8::Handle<v8::Value> argv[2] = { database, id };
+@@ -307,13 +307,13 @@ NAN_METHOD(Iterator::New) {
+ if (args.Length() > 1 && args[2]->IsObject()) {
+ optionsObj = v8::Local<v8::Object>::Cast(args[2]);
+
+- reverse = NanBooleanOptionValue(optionsObj, NanSymbol("reverse"));
++ reverse = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("reverse"));
+
+- if (optionsObj->Has(NanSymbol("start"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("start")))
+- || optionsObj->Get(NanSymbol("start"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("start"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("start")))
++ || optionsObj->Get(NanNew<v8::String>("start"))->IsString())) {
+
+- startHandle = optionsObj->Get(NanSymbol("start")).As<v8::Object>();
++ startHandle = optionsObj->Get(NanNew<v8::String>("start")).As<v8::Object>();
+
+ // ignore start if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(startHandle) > 0) {
+@@ -322,12 +322,12 @@ NAN_METHOD(Iterator::New) {
+ }
+ }
+
+- if (optionsObj->Has(NanSymbol("end"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("end")))
+- || optionsObj->Get(NanSymbol("end"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("end"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("end")))
++ || optionsObj->Get(NanNew<v8::String>("end"))->IsString())) {
+
+ v8::Local<v8::Value> endBuffer =
+- NanNewLocal<v8::Value>(optionsObj->Get(NanSymbol("end")));
++ NanNew(optionsObj->Get(NanNew<v8::String>("end")));
+
+ // ignore end if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(endBuffer) > 0) {
+@@ -336,17 +336,17 @@ NAN_METHOD(Iterator::New) {
+ }
+ }
+
+- if (!optionsObj.IsEmpty() && optionsObj->Has(NanSymbol("limit"))) {
++ if (!optionsObj.IsEmpty() && optionsObj->Has(NanNew<v8::String>("limit"))) {
+ limit = v8::Local<v8::Integer>::Cast(optionsObj->Get(
+- NanSymbol("limit")))->Value();
++ NanNew<v8::String>("limit")))->Value();
+ }
+
+- if (optionsObj->Has(NanSymbol("lt"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("lt")))
+- || optionsObj->Get(NanSymbol("lt"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("lt"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("lt")))
++ || optionsObj->Get(NanNew<v8::String>("lt"))->IsString())) {
+
+ v8::Local<v8::Value> ltBuffer =
+- NanNewLocal<v8::Value>(optionsObj->Get(NanSymbol("lt")));
++ NanNew(optionsObj->Get(NanNew<v8::String>("lt")));
+
+ // ignore end if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(ltBuffer) > 0) {
+@@ -357,12 +357,12 @@ NAN_METHOD(Iterator::New) {
+ }
+ }
+
+- if (optionsObj->Has(NanSymbol("lte"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("lte")))
+- || optionsObj->Get(NanSymbol("lte"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("lte"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("lte")))
++ || optionsObj->Get(NanNew<v8::String>("lte"))->IsString())) {
+
+ v8::Local<v8::Value> lteBuffer =
+- NanNewLocal<v8::Value>(optionsObj->Get(NanSymbol("lte")));
++ NanNew(optionsObj->Get(NanNew<v8::String>("lte")));
+
+ // ignore end if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(lteBuffer) > 0) {
+@@ -373,12 +373,12 @@ NAN_METHOD(Iterator::New) {
+ }
+ }
+
+- if (optionsObj->Has(NanSymbol("gt"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("gt")))
+- || optionsObj->Get(NanSymbol("gt"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("gt"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("gt")))
++ || optionsObj->Get(NanNew<v8::String>("gt"))->IsString())) {
+
+ v8::Local<v8::Value> gtBuffer =
+- NanNewLocal<v8::Value>(optionsObj->Get(NanSymbol("gt")));
++ NanNew(optionsObj->Get(NanNew<v8::String>("gt")));
+
+ // ignore end if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(gtBuffer) > 0) {
+@@ -389,12 +389,12 @@ NAN_METHOD(Iterator::New) {
+ }
+ }
+
+- if (optionsObj->Has(NanSymbol("gte"))
+- && (node::Buffer::HasInstance(optionsObj->Get(NanSymbol("gte")))
+- || optionsObj->Get(NanSymbol("gte"))->IsString())) {
++ if (optionsObj->Has(NanNew<v8::String>("gte"))
++ && (node::Buffer::HasInstance(optionsObj->Get(NanNew<v8::String>("gte")))
++ || optionsObj->Get(NanNew<v8::String>("gte"))->IsString())) {
+
+ v8::Local<v8::Value> gteBuffer =
+- NanNewLocal<v8::Value>(optionsObj->Get(NanSymbol("gte")));
++ NanNew(optionsObj->Get(NanNew<v8::String>("gte")));
+
+ // ignore end if it has size 0 since a Slice can't have length 0
+ if (StringOrBufferLength(gteBuffer) > 0) {
+@@ -407,19 +407,19 @@ NAN_METHOD(Iterator::New) {
+
+ }
+
+- bool keys = NanBooleanOptionValue(optionsObj, NanSymbol("keys"), true);
+- bool values = NanBooleanOptionValue(optionsObj, NanSymbol("values"), true);
++ bool keys = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("keys"), true);
++ bool values = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("values"), true);
+ bool keyAsBuffer = NanBooleanOptionValue(
+ optionsObj
+- , NanSymbol("keyAsBuffer")
++ , NanNew<v8::String>("keyAsBuffer")
+ , true
+ );
+ bool valueAsBuffer = NanBooleanOptionValue(
+ optionsObj
+- , NanSymbol("valueAsBuffer")
++ , NanNew<v8::String>("valueAsBuffer")
+ , true
+ );
+- bool fillCache = NanBooleanOptionValue(optionsObj, NanSymbol("fillCache"));
++ bool fillCache = NanBooleanOptionValue(optionsObj, NanNew<v8::String>("fillCache"));
+
+ Iterator* iterator = new Iterator(
+ database
+--- node-leveldown-0.10.2.orig/src/iterator_async.cc
++++ node-leveldown-0.10.2/src/iterator_async.cc
+@@ -54,7 +54,7 @@ void NextWorker::HandleOKCallback () {
+
+ if (ok) {
+ v8::Local<v8::Value> argv[] = {
+- NanNewLocal<v8::Value>(v8::Null())
++ NanNew(v8::Null())
+ , returnKey
+ , returnValue
+ };
+--- node-leveldown-0.10.2.orig/src/leveldown.cc
++++ node-leveldown-0.10.2/src/leveldown.cc
+@@ -28,7 +28,7 @@ NAN_METHOD(DestroyDB) {
+ return NanThrowError("destroy() requires a callback function argument");
+ }
+
+- char* location = NanFromV8String(args[0].As<v8::Object>(), Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
++ char* location = (char*)NanRawString(args[0], Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
+
+ NanCallback* callback = new NanCallback(
+ v8::Local<v8::Function>::Cast(args[1]));
+@@ -58,7 +58,7 @@ NAN_METHOD(RepairDB) {
+ return NanThrowError("repair() requires a callback function argument");
+ }
+
+- char* location = NanFromV8String(args[0].As<v8::Object>(), Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
++ char* location = (char*) NanRawString(args[0], Nan::UTF8, NULL, NULL, 0, v8::String::NO_OPTIONS);
+
+ NanCallback* callback = new NanCallback(
+ v8::Local<v8::Function>::Cast(args[1]));
+@@ -82,16 +82,16 @@ void Init (v8::Handle<v8::Object> target
+ v8::FunctionTemplate::New(LevelDOWN)->GetFunction();
+
+ leveldown->Set(
+- NanSymbol("destroy")
++ NanNew<v8::String>("destroy")
+ , v8::FunctionTemplate::New(DestroyDB)->GetFunction()
+ );
+
+ leveldown->Set(
+- NanSymbol("repair")
++ NanNew<v8::String>("repair")
+ , v8::FunctionTemplate::New(RepairDB)->GetFunction()
+ );
+
+- target->Set(NanSymbol("leveldown"), leveldown);
++ target->Set(NanNew<v8::String>("leveldown"), leveldown);
+ }
+
+ NODE_MODULE(leveldown, Init)
+--- node-leveldown-0.10.2.orig/src/leveldown.h
++++ node-leveldown-0.10.2/src/leveldown.h
+@@ -23,9 +23,9 @@ static inline void DisposeStringOrBuffer
+ v8::Persistent<v8::Object> &handle
+ , leveldb::Slice slice) {
+
+- if (!node::Buffer::HasInstance(NanPersistentToLocal(handle)->Get(NanSymbol("obj"))))
++ if (!node::Buffer::HasInstance(NanNew(handle)->Get(NanNew<v8::String>("obj"))))
+ delete[] slice.data();
+- NanDispose(handle);
++ NanDisposePersistent(handle);
+ }
+
+ static inline void DisposeStringOrBufferFromSlice(
+@@ -69,7 +69,7 @@ static inline void DisposeStringOrBuffer
+ #define LD_RETURN_CALLBACK_OR_ERROR(callback, msg) \
+ if (!callback.IsEmpty() && callback->IsFunction()) { \
+ v8::Local<v8::Value> argv[] = { \
+- NanNewLocal<v8::Value>(v8::Exception::Error( \
++ NanNew(v8::Exception::Error( \
+ v8::String::New(msg)) \
+ ) \
+ }; \
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/node-leveldown.git
More information about the Pkg-javascript-commits
mailing list