Upgrade nan to fix clang linking problem #259

See #189 and jcupitt/libvips@fbe321e

.travis.yml

@@ -2,9 +2,16 @@ language: node_js
 node_js:
   - "0.10"
   - "0.12"
-  - "iojs-v1"
   - "iojs-v2"
+  - "iojs-v3"
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    packages:
+    - g++-4.8
 before_install:
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
   - curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
 after_success:
   - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js

appveyor.yml

@@ -13,6 +13,8 @@ environment:
     nodejs_exec: "node"
   - nodejs_version: "2"
     nodejs_exec: "iojs"
+  - nodejs_version: "3"
+    nodejs_exec: "iojs"
 install:
   - ps: $env:VIPS_VERSION = "$env:VIPS_VERSION_MAJOR_MINOR.$env:VIPS_VERSION_PATCH"
   - ps: Write-Output "Fetching http://www.vips.ecs.soton.ac.uk/supported/$env:VIPS_VERSION_MAJOR_MINOR/win32/vips-dev-$env:VIPS_VERSION.zip"

docs/api.md

@@ -109,7 +109,7 @@ Scale output to `width` x `height`. By default, the resized image is cropped to
 
 Crop the resized image to the exact size specified, the default behaviour.
 
-`gravity`, if present, is an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
+`gravity`, if present, is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
 
 Possible values are `north`, `east`, `south`, `west`, `center` and `centre`. The default gravity is `center`/`centre`.
 

docs/changelog.md

@@ -2,6 +2,14 @@
 
 ### v0.11 - "*knife*"
 
+#### v0.11.2 - 28<sup>th</sup> August 2015
+
+* Allow crop gravity to be provided as a String.
+  [#255](https://github.com/lovell/sharp/pull/255)
+  [@papandreou](https://github.com/papandreou)
+* Add support for io.js v3 and Node v4.
+  [#246](https://github.com/lovell/sharp/issues/246)
+
 #### v0.11.1 - 12<sup>th</sup> August 2015
 
 * Silence MSVC warning: "C4530: C++ exception handler used, but unwind semantics are not enabled".

docs/install.md

@@ -8,7 +8,7 @@ npm install sharp
 
 * Node.js v0.10+ or io.js
 * [libvips](https://github.com/jcupitt/libvips) v7.40.0+ (7.42.0+ recommended)
-* C++11 compatible compiler such as gcc 4.6+, clang 3.0+ or MSVC 2013
+* C++11 compatible compiler such as gcc 4.6+, clang 3.0+ or MSVC 2013 (io.js v3+ requires gcc 4.8+)
 
 ### Linux
 

index.js

@@ -143,6 +143,8 @@ Sharp.prototype.crop = function(gravity) {
   this.options.canvas = 'crop';
   if (typeof gravity === 'number' && !Number.isNaN(gravity) && gravity >= 0 && gravity <= 4) {
     this.options.gravity = gravity;
+  } else if (typeof gravity === 'string' && typeof module.exports.gravity[gravity] === 'number') {
+    this.options.gravity = module.exports.gravity[gravity];
   } else {
     throw new Error('Unsupported crop gravity ' + gravity);
   }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharp",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
@@ -23,7 +23,7 @@
     "clean": "rm -rf test/fixtures/output.*",
     "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=20000 ./test/unit/*.js",
     "test-clean": "npm run clean && npm install && npm test",
-    "test-leak": "cd test/leak; ./leak.sh; cd - > /dev/null",
+    "test-leak": "./test/leak/leak.sh",
     "test-win32-node": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js",
     "test-win32-iojs": "iojs ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js"
   },
@@ -45,21 +45,22 @@
     "vips"
   ],
   "dependencies": {
-    "bluebird": "^2.9.33",
+    "bluebird": "^2.9.34",
     "color": "^0.10.1",
-    "nan": "^1.8.4",
+    "nan": "^2.0.8",
     "semver": "^5.0.1"
   },
   "devDependencies": {
     "async": "^1.4.2",
-    "coveralls": "^2.11.2",
+    "coveralls": "^2.11.4",
     "exif-reader": "1.0.0",
     "icc": "^0.0.2",
-    "istanbul": "^0.3.17",
+    "istanbul": "^0.3.18",
     "mocha": "^2.2.5",
     "mocha-jshint": "^2.2.3",
     "node-cpplint": "^0.4.0",
-    "rimraf": "^2.4.1"
+    "rimraf": "^2.4.2",
+    "bufferutil": "^1.2.1"
   },
   "license": "Apache-2.0",
   "engines": {

src/common.cc

@@ -164,7 +164,7 @@ namespace sharp {
     Remove EXIF Orientation from image.
   */
   void RemoveExifOrientation(VipsImage *image) {
-    vips_image_remove(image, EXIF_IFD0_ORIENTATION);
+    SetExifOrientation(image, 0);
   }
 
   /*

src/metadata.cc

@@ -16,6 +16,19 @@ using v8::Boolean;
 using v8::Function;
 using v8::Exception;
 
+using Nan::AsyncQueueWorker;
+using Nan::AsyncWorker;
+using Nan::Callback;
+using Nan::HandleScope;
+using Nan::Utf8String;
+using Nan::Has;
+using Nan::Get;
+using Nan::Set;
+using Nan::New;
+using Nan::NewBuffer;
+using Nan::Null;
+using Nan::Error;
+
 using sharp::ImageType;
 using sharp::DetermineImageType;
 using sharp::InitImage;
@@ -61,10 +74,10 @@ static void DeleteBuffer(VipsObject *object, char *buffer) {
   }
 }
 
-class MetadataWorker : public NanAsyncWorker {
+class MetadataWorker : public AsyncWorker {
 
  public:
-  MetadataWorker(NanCallback *callback, MetadataBaton *baton) : NanAsyncWorker(callback), baton(baton) {}
+  MetadataWorker(Callback *callback, MetadataBaton *baton) : AsyncWorker(callback), baton(baton) {}
   ~MetadataWorker() {}
 
   void Execute() {
@@ -129,7 +142,7 @@ class MetadataWorker : public NanAsyncWorker {
         size_t exifLength;
         if (!vips_image_get_blob(image, VIPS_META_EXIF_NAME, &exif, &exifLength)) {
           baton->exifLength = exifLength;
-          baton->exif = new char[exifLength];
+          baton->exif = static_cast<char*>(malloc(exifLength));
           memcpy(baton->exif, exif, exifLength);
         }
       }
@@ -139,7 +152,7 @@ class MetadataWorker : public NanAsyncWorker {
         size_t iccLength;
         if (!vips_image_get_blob(image, VIPS_META_ICC_NAME, &icc, &iccLength)) {
           baton->iccLength = iccLength;
-          baton->icc = new char[iccLength];
+          baton->icc = static_cast<char*>(malloc(iccLength));
           memcpy(baton->icc, icc, iccLength);
         }
       }
@@ -152,30 +165,30 @@ class MetadataWorker : public NanAsyncWorker {
   }
 
   void HandleOKCallback () {
-    NanScope();
+    HandleScope();
 
-    Handle<Value> argv[2] = { NanNull(), NanNull() };
+    Local<Value> argv[2] = { Null(), Null() };
     if (!baton->err.empty()) {
       // Error
-      argv[0] = Exception::Error(NanNew<String>(baton->err.data(), baton->err.size()));
+      argv[0] = Error(baton->err.c_str());
     } else {
       // Metadata Object
-      Local<Object> info = NanNew<Object>();
-      info->Set(NanNew<String>("format"), NanNew<String>(baton->format));
-      info->Set(NanNew<String>("width"), NanNew<Number>(baton->width));
-      info->Set(NanNew<String>("height"), NanNew<Number>(baton->height));
-      info->Set(NanNew<String>("space"), NanNew<String>(baton->space));
-      info->Set(NanNew<String>("channels"), NanNew<Number>(baton->channels));
-      info->Set(NanNew<String>("hasProfile"), NanNew<Boolean>(baton->hasProfile));
-      info->Set(NanNew<String>("hasAlpha"), NanNew<Boolean>(baton->hasAlpha));
+      Local<Object> info = New<Object>();
+      Set(info, New("format").ToLocalChecked(), New<String>(baton->format).ToLocalChecked());
+      Set(info, New("width").ToLocalChecked(), New<Number>(baton->width));
+      Set(info, New("height").ToLocalChecked(), New<Number>(baton->height));
+      Set(info, New("space").ToLocalChecked(), New<String>(baton->space).ToLocalChecked());
+      Set(info, New("channels").ToLocalChecked(), New<Number>(baton->channels));
+      Set(info, New("hasProfile").ToLocalChecked(), New<Boolean>(baton->hasProfile));
+      Set(info, New("hasAlpha").ToLocalChecked(), New<Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {
-        info->Set(NanNew<String>("orientation"), NanNew<Number>(baton->orientation));
+        Set(info, New("orientation").ToLocalChecked(), New<Number>(baton->orientation));
       }
       if (baton->exifLength > 0) {
-        info->Set(NanNew<String>("exif"), NanBufferUse(baton->exif, baton->exifLength));
+        Set(info, New("exif").ToLocalChecked(), NewBuffer(baton->exif, baton->exifLength).ToLocalChecked());
       }
       if (baton->iccLength > 0) {
-        info->Set(NanNew<String>("icc"), NanBufferUse(baton->icc, baton->iccLength));
+        Set(info, New("icc").ToLocalChecked(), NewBuffer(baton->icc, baton->iccLength).ToLocalChecked());
       }
       argv[1] = info;
     }
@@ -193,17 +206,17 @@ class MetadataWorker : public NanAsyncWorker {
   metadata(options, callback)
 */
 NAN_METHOD(metadata) {
-  NanScope();
+  HandleScope();
 
   // V8 objects are converted to non-V8 types held in the baton struct
   MetadataBaton *baton = new MetadataBaton;
-  Local<Object> options = args[0]->ToObject();
+  Local<Object> options = info[0].As<Object>();
 
   // Input filename
-  baton->fileIn = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
+  baton->fileIn = *Utf8String(Get(options, New("fileIn").ToLocalChecked()).ToLocalChecked());
   // Input Buffer object
-  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
-    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
+  if (node::Buffer::HasInstance(Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked())) {
+    Local<Object> buffer = Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked().As<Object>();
     // Take a copy of the input Buffer to avoid problems with V8 heap compaction
     baton->bufferInLength = node::Buffer::Length(buffer);
     baton->bufferIn = new char[baton->bufferInLength];
@@ -211,11 +224,9 @@ NAN_METHOD(metadata) {
   }
 
   // Join queue for worker thread
-  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
-  NanAsyncQueueWorker(new MetadataWorker(callback, baton));
+  Callback *callback = new Callback(info[1].As<Function>());
+  AsyncQueueWorker(new MetadataWorker(callback, baton));
 
   // Increment queued task counter
   g_atomic_int_inc(&counterQueue);
-
-  NanReturnUndefined();
 }

src/pipeline.cc

@@ -22,6 +22,20 @@ using v8::Array;
 using v8::Function;
 using v8::Exception;
 
+using Nan::AsyncQueueWorker;
+using Nan::AsyncWorker;
+using Nan::Callback;
+using Nan::HandleScope;
+using Nan::Utf8String;
+using Nan::Has;
+using Nan::Get;
+using Nan::Set;
+using Nan::To;
+using Nan::New;
+using Nan::CopyBuffer;
+using Nan::Null;
+using Nan::Equals;
+
 using sharp::Composite;
 using sharp::Premultiply;
 using sharp::Unpremultiply;
@@ -165,11 +179,11 @@ static void DeleteBuffer(VipsObject *object, char *buffer) {
   }
 }
 
-class PipelineWorker : public NanAsyncWorker {
+class PipelineWorker : public AsyncWorker {
 
  public:
-  PipelineWorker(NanCallback *callback, PipelineBaton *baton, NanCallback *queueListener) :
-    NanAsyncWorker(callback), baton(baton), queueListener(queueListener) {}
+  PipelineWorker(Callback *callback, PipelineBaton *baton, Callback *queueListener) :
+    AsyncWorker(callback), baton(baton), queueListener(queueListener) {}
   ~PipelineWorker() {}
 
   /*
@@ -963,12 +977,12 @@ class PipelineWorker : public NanAsyncWorker {
   }
 
   void HandleOKCallback () {
-    NanScope();
+    HandleScope();
 
-    Handle<Value> argv[3] = { NanNull(), NanNull(),  NanNull() };
+    Local<Value> argv[3] = { Null(), Null(),  Null() };
     if (!baton->err.empty()) {
       // Error
-      argv[0] = Exception::Error(NanNew<String>(baton->err.data(), baton->err.size()));
+      argv[0] = Nan::Error(baton->err.c_str());
     } else {
       int width = baton->width;
       int height = baton->height;
@@ -981,32 +995,33 @@ class PipelineWorker : public NanAsyncWorker {
         height = baton->heightPost;
       }
       // Info Object
-      Local<Object> info = NanNew<Object>();
-      info->Set(NanNew<String>("format"), NanNew<String>(baton->outputFormat));
-      info->Set(NanNew<String>("width"), NanNew<Uint32>(static_cast<uint32_t>(width)));
-      info->Set(NanNew<String>("height"), NanNew<Uint32>(static_cast<uint32_t>(height)));
+      Local<Object> info = New<Object>();
+      Set(info, New("format").ToLocalChecked(), New<String>(baton->outputFormat).ToLocalChecked());
+      Set(info, New("width").ToLocalChecked(), New<Uint32>(static_cast<uint32_t>(width)));
+      Set(info, New("height").ToLocalChecked(), New<Uint32>(static_cast<uint32_t>(height)));
 
       if (baton->bufferOutLength > 0) {
         // Copy data to new Buffer
-        argv[1] = NanNewBufferHandle(static_cast<char*>(baton->bufferOut), baton->bufferOutLength);
+        argv[1] = CopyBuffer(static_cast<char*>(baton->bufferOut), baton->bufferOutLength).ToLocalChecked();
         // bufferOut was allocated via g_malloc
         g_free(baton->bufferOut);
         // Add buffer size to info
-        info->Set(NanNew<String>("size"), NanNew<Uint32>(static_cast<uint32_t>(baton->bufferOutLength)));
+        Set(info, New("size").ToLocalChecked(), New<Uint32>(static_cast<uint32_t>(baton->bufferOutLength)));
         argv[2] = info;
       } else {
         // Add file size to info
         GStatBuf st;
         g_stat(baton->output.c_str(), &st);
-        info->Set(NanNew<String>("size"), NanNew<Uint32>(static_cast<uint32_t>(st.st_size)));
+        Set(info, New("size").ToLocalChecked(), New<Uint32>(static_cast<uint32_t>(st.st_size)));
         argv[1] = info;
       }
     }
     delete baton;
+    // to here
 
     // Decrement processing task counter
     g_atomic_int_dec_and_test(&counterProcess);
-    Handle<Value> queueLength[1] = { NanNew<Uint32>(counterQueue) };
+    Local<Value> queueLength[1] = { New<Uint32>(counterQueue) };
     queueListener->Call(1, queueLength);
     delete queueListener;
 
@@ -1016,7 +1031,7 @@ class PipelineWorker : public NanAsyncWorker {
 
  private:
   PipelineBaton *baton;
-  NanCallback *queueListener;
+  Callback *queueListener;
   VipsObject *hook;
 
   /*
@@ -1126,102 +1141,102 @@ class PipelineWorker : public NanAsyncWorker {
   pipeline(options, output, callback)
 */
 NAN_METHOD(pipeline) {
-  NanScope();
+  HandleScope();
 
   // V8 objects are converted to non-V8 types held in the baton struct
   PipelineBaton *baton = new PipelineBaton;
-  Local<Object> options = args[0]->ToObject();
+  Local<Object> options = info[0].As<Object>();
 
   // Input filename
-  baton->fileIn = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
-  baton->accessMethod = options->Get(NanNew<String>("sequentialRead"))->BooleanValue() ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+  baton->fileIn = *Utf8String(Get(options, New("fileIn").ToLocalChecked()).ToLocalChecked());
+  baton->accessMethod =
+    To<bool>(Get(options, New("sequentialRead").ToLocalChecked()).ToLocalChecked()).FromJust() ?
+    VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
   // Input Buffer object
-  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
-    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
+  if (node::Buffer::HasInstance(Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked())) {
+    Local<Object> buffer = Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked().As<Object>();
     // Take a copy of the input Buffer to avoid problems with V8 heap compaction
     baton->bufferInLength = node::Buffer::Length(buffer);
     baton->bufferIn = new char[baton->bufferInLength];
     memcpy(baton->bufferIn, node::Buffer::Data(buffer), baton->bufferInLength);
   }
   // ICC profile to use when input CMYK image has no embedded profile
-  baton->iccProfilePath = *String::Utf8Value(options->Get(NanNew<String>("iccProfilePath"))->ToString());
+  baton->iccProfilePath = *Utf8String(Get(options, New("iccProfilePath").ToLocalChecked()).ToLocalChecked());
   // Limit input images to a given number of pixels, where pixels = width * height
-  baton->limitInputPixels = options->Get(NanNew<String>("limitInputPixels"))->Int32Value();
+  baton->limitInputPixels = To<int32_t>(Get(options, New("limitInputPixels").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Extract image options
-  baton->topOffsetPre = options->Get(NanNew<String>("topOffsetPre"))->Int32Value();
-  baton->leftOffsetPre = options->Get(NanNew<String>("leftOffsetPre"))->Int32Value();
-  baton->widthPre = options->Get(NanNew<String>("widthPre"))->Int32Value();
-  baton->heightPre = options->Get(NanNew<String>("heightPre"))->Int32Value();
-  baton->topOffsetPost = options->Get(NanNew<String>("topOffsetPost"))->Int32Value();
-  baton->leftOffsetPost = options->Get(NanNew<String>("leftOffsetPost"))->Int32Value();
-  baton->widthPost = options->Get(NanNew<String>("widthPost"))->Int32Value();
-  baton->heightPost = options->Get(NanNew<String>("heightPost"))->Int32Value();
+  baton->topOffsetPre = To<int32_t>(Get(options, New("topOffsetPre").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->leftOffsetPre = To<int32_t>(Get(options, New("leftOffsetPre").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->widthPre = To<int32_t>(Get(options, New("widthPre").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->heightPre = To<int32_t>(Get(options, New("heightPre").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->topOffsetPost = To<int32_t>(Get(options, New("topOffsetPost").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->leftOffsetPost = To<int32_t>(Get(options, New("leftOffsetPost").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->widthPost = To<int32_t>(Get(options, New("widthPost").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->heightPost = To<int32_t>(Get(options, New("heightPost").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Output image dimensions
-  baton->width = options->Get(NanNew<String>("width"))->Int32Value();
-  baton->height = options->Get(NanNew<String>("height"))->Int32Value();
+  baton->width = To<int32_t>(Get(options, New("width").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->height = To<int32_t>(Get(options, New("height").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Canvas option
-  Local<String> canvas = options->Get(NanNew<String>("canvas"))->ToString();
-  if (canvas->Equals(NanNew<String>("crop"))) {
+  Local<String> canvas = To<String>(Get(options, New("canvas").ToLocalChecked()).ToLocalChecked()).ToLocalChecked();
+  if (Equals(canvas, New("crop").ToLocalChecked()).FromJust()) {
     baton->canvas = Canvas::CROP;
-  } else if (canvas->Equals(NanNew<String>("embed"))) {
+  } else if (Equals(canvas, New("embed").ToLocalChecked()).FromJust()) {
     baton->canvas = Canvas::EMBED;
-  } else if (canvas->Equals(NanNew<String>("max"))) {
+  } else if (Equals(canvas, New("max").ToLocalChecked()).FromJust()) {
     baton->canvas = Canvas::MAX;
-  } else if (canvas->Equals(NanNew<String>("min"))) {
+  } else if (Equals(canvas, New("min").ToLocalChecked()).FromJust()) {
     baton->canvas = Canvas::MIN;
-  } else if (canvas->Equals(NanNew<String>("ignore_aspect"))) {
+  } else if (Equals(canvas, New("ignore_aspect").ToLocalChecked()).FromJust()) {
     baton->canvas = Canvas::IGNORE_ASPECT;
   }
   // Background colour
-  Local<Array> background = Local<Array>::Cast(options->Get(NanNew<String>("background")));
+  Local<Object> background = Get(options, New("background").ToLocalChecked()).ToLocalChecked().As<Object>();
   for (int i = 0; i < 4; i++) {
-    baton->background[i] = background->Get(i)->NumberValue();
+    baton->background[i] = To<int32_t>(Get(background, i).ToLocalChecked()).FromJust();
   }
   // Overlay options
-  baton->overlayPath = *String::Utf8Value(options->Get(NanNew<String>("overlayPath"))->ToString());
+  baton->overlayPath = *Utf8String(Get(options, New("overlayPath").ToLocalChecked()).ToLocalChecked());
   // Resize options
-  baton->withoutEnlargement = options->Get(NanNew<String>("withoutEnlargement"))->BooleanValue();
-  baton->gravity = options->Get(NanNew<String>("gravity"))->Int32Value();
-  baton->interpolator = *String::Utf8Value(options->Get(NanNew<String>("interpolator"))->ToString());
+  baton->withoutEnlargement = To<bool>(Get(options, New("withoutEnlargement").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->gravity = To<int32_t>(Get(options, New("gravity").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->interpolator = *Utf8String(Get(options, New("interpolator").ToLocalChecked()).ToLocalChecked());
   // Operators
-  baton->flatten = options->Get(NanNew<String>("flatten"))->BooleanValue();
-  baton->blurSigma = options->Get(NanNew<String>("blurSigma"))->NumberValue();
-  baton->sharpenRadius = options->Get(NanNew<String>("sharpenRadius"))->Int32Value();
-  baton->sharpenFlat = options->Get(NanNew<String>("sharpenFlat"))->NumberValue();
-  baton->sharpenJagged = options->Get(NanNew<String>("sharpenJagged"))->NumberValue();
-  baton->gamma = options->Get(NanNew<String>("gamma"))->NumberValue();
-  baton->greyscale = options->Get(NanNew<String>("greyscale"))->BooleanValue();
-  baton->normalize = options->Get(NanNew<String>("normalize"))->BooleanValue();
-  baton->angle = options->Get(NanNew<String>("angle"))->Int32Value();
-  baton->rotateBeforePreExtract = options->Get(NanNew<String>("rotateBeforePreExtract"))->BooleanValue();
-  baton->flip = options->Get(NanNew<String>("flip"))->BooleanValue();
-  baton->flop = options->Get(NanNew<String>("flop"))->BooleanValue();
+  baton->flatten = To<bool>(Get(options, New("flatten").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->blurSigma = To<int32_t>(Get(options, New("blurSigma").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->sharpenRadius = To<int32_t>(Get(options, New("sharpenRadius").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->sharpenFlat = To<int32_t>(Get(options, New("sharpenFlat").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->sharpenJagged = To<int32_t>(Get(options, New("sharpenJagged").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->gamma = To<int32_t>(Get(options, New("gamma").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->greyscale = To<bool>(Get(options, New("greyscale").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->normalize = To<bool>(Get(options, New("normalize").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->angle = To<int32_t>(Get(options, New("angle").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->rotateBeforePreExtract = To<bool>(Get(options, New("rotateBeforePreExtract").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->flip = To<bool>(Get(options, New("flip").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->flop = To<bool>(Get(options, New("flop").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Output options
-  baton->progressive = options->Get(NanNew<String>("progressive"))->BooleanValue();
-  baton->quality = options->Get(NanNew<String>("quality"))->Int32Value();
-  baton->compressionLevel = options->Get(NanNew<String>("compressionLevel"))->Int32Value();
-  baton->withoutAdaptiveFiltering = options->Get(NanNew<String>("withoutAdaptiveFiltering"))->BooleanValue();
-  baton->withoutChromaSubsampling = options->Get(NanNew<String>("withoutChromaSubsampling"))->BooleanValue();
-  baton->trellisQuantisation = options->Get(NanNew<String>("trellisQuantisation"))->BooleanValue();
-  baton->overshootDeringing = options->Get(NanNew<String>("overshootDeringing"))->BooleanValue();
-  baton->optimiseScans = options->Get(NanNew<String>("optimiseScans"))->BooleanValue();
-  baton->withMetadata = options->Get(NanNew<String>("withMetadata"))->BooleanValue();
-  baton->withMetadataOrientation = options->Get(NanNew<String>("withMetadataOrientation"))->Int32Value();
+  baton->progressive = To<bool>(Get(options, New("progressive").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->quality = To<int32_t>(Get(options, New("quality").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->compressionLevel = To<int32_t>(Get(options, New("compressionLevel").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->withoutAdaptiveFiltering = To<bool>(Get(options, New("withoutAdaptiveFiltering").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->withoutChromaSubsampling = To<bool>(Get(options, New("withoutChromaSubsampling").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->trellisQuantisation = To<bool>(Get(options, New("trellisQuantisation").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->overshootDeringing = To<bool>(Get(options, New("overshootDeringing").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->optimiseScans = To<bool>(Get(options, New("optimiseScans").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->withMetadata = To<bool>(Get(options, New("withMetadata").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->withMetadataOrientation = To<int32_t>(Get(options, New("withMetadataOrientation").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Output filename or __format for Buffer
-  baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());
-  baton->tileSize = options->Get(NanNew<String>("tileSize"))->Int32Value();
-  baton->tileOverlap = options->Get(NanNew<String>("tileOverlap"))->Int32Value();
+  baton->output = *Utf8String(Get(options, New("output").ToLocalChecked()).ToLocalChecked());
+  baton->tileSize = To<int32_t>(Get(options, New("tileSize").ToLocalChecked()).ToLocalChecked()).FromJust();
+  baton->tileOverlap = To<int32_t>(Get(options, New("tileOverlap").ToLocalChecked()).ToLocalChecked()).FromJust();
   // Function to notify of queue length changes
-  NanCallback *queueListener = new NanCallback(Handle<Function>::Cast(options->Get(NanNew<String>("queueListener"))));
+  Callback *queueListener = new Callback(Get(options, New("queueListener").ToLocalChecked()).ToLocalChecked().As<Function>());
 
   // Join queue for worker thread
-  NanCallback *callback = new NanCallback(args[1].As<Function>());
-  NanAsyncQueueWorker(new PipelineWorker(callback, baton, queueListener));
+  Callback *callback = new Callback(info[1].As<Function>());
+  AsyncQueueWorker(new PipelineWorker(callback, baton, queueListener));
 
   // Increment queued task counter
   g_atomic_int_inc(&counterQueue);
-  Handle<Value> queueLength[1] = { NanNew<Uint32>(counterQueue) };
+  Local<Value> queueLength[1] = { New<Uint32>(counterQueue) };
   queueListener->Call(1, queueLength);
-
-  NanReturnUndefined();
 }

src/sharp.cc

@@ -8,8 +8,7 @@
 #include "pipeline.h"
 #include "utilities.h"
 
-extern "C" void init(v8::Handle<v8::Object> target) {
-  NanScope();
+NAN_MODULE_INIT(init) {
   vips_init("sharp");
 
   // Set libvips operation cache limits
@@ -17,14 +16,22 @@ extern "C" void init(v8::Handle<v8::Object> target) {
   vips_cache_set_max(500); // 500 operations
 
   // Methods available to JavaScript
-  NODE_SET_METHOD(target, "metadata", metadata);
-  NODE_SET_METHOD(target, "pipeline", pipeline);
-  NODE_SET_METHOD(target, "cache", cache);
-  NODE_SET_METHOD(target, "concurrency", concurrency);
-  NODE_SET_METHOD(target, "counters", counters);
-  NODE_SET_METHOD(target, "libvipsVersion", libvipsVersion);
-  NODE_SET_METHOD(target, "format", format);
-  NODE_SET_METHOD(target, "_maxColourDistance", _maxColourDistance);
+  Nan::Set(target, Nan::New("metadata").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(metadata)).ToLocalChecked());
+  Nan::Set(target, Nan::New("pipeline").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(pipeline)).ToLocalChecked());
+  Nan::Set(target, Nan::New("cache").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(cache)).ToLocalChecked());
+  Nan::Set(target, Nan::New("concurrency").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(concurrency)).ToLocalChecked());
+  Nan::Set(target, Nan::New("counters").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(counters)).ToLocalChecked());
+  Nan::Set(target, Nan::New("libvipsVersion").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(libvipsVersion)).ToLocalChecked());
+  Nan::Set(target, Nan::New("format").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(format)).ToLocalChecked());
+  Nan::Set(target, Nan::New("_maxColourDistance").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(_maxColourDistance)).ToLocalChecked());
 }
 
 NODE_MODULE(sharp, init)

src/utilities.cc

@@ -13,48 +13,50 @@ using v8::Number;
 using v8::String;
 using v8::Boolean;
 
+using Nan::HandleScope;
+using Nan::New;
+using Nan::Set;
+using Nan::ThrowError;
+using Nan::To;
+using Nan::Utf8String;
+
 /*
   Get and set cache memory and item limits
 */
 NAN_METHOD(cache) {
-  NanScope();
+  HandleScope();
 
   // Set cache memory limit
-  if (args[0]->IsInt32()) {
-    int newMax = args[0]->Int32Value() * 1048576;
-    int oldMax = vips_cache_get_max_mem();
-    vips_cache_set_max_mem(newMax);
-
-    // Notify the V8 garbage collector of delta in max cache size
-    NanAdjustExternalMemory(newMax - oldMax);
+  if (info[0]->IsInt32()) {
+    vips_cache_set_max_mem(To<int32_t>(info[0]).FromJust() * 1048576);
   }
 
   // Set cache items limit
-  if (args[1]->IsInt32()) {
-    vips_cache_set_max(args[1]->Int32Value());
+  if (info[1]->IsInt32()) {
+    vips_cache_set_max(To<int32_t>(info[1]).FromJust());
   }
 
   // Get cache statistics
-  Local<Object> cache = NanNew<Object>();
-  cache->Set(NanNew<String>("current"), NanNew<Number>(vips_tracked_get_mem() / 1048576));
-  cache->Set(NanNew<String>("high"), NanNew<Number>(vips_tracked_get_mem_highwater() / 1048576));
-  cache->Set(NanNew<String>("memory"), NanNew<Number>(vips_cache_get_max_mem() / 1048576));
-  cache->Set(NanNew<String>("items"), NanNew<Number>(vips_cache_get_max()));
-  NanReturnValue(cache);
+  Local<Object> cache = New<Object>();
+  Set(cache, New("current").ToLocalChecked(), New<Number>(vips_tracked_get_mem() / 1048576));
+  Set(cache, New("high").ToLocalChecked(), New<Number>(vips_tracked_get_mem_highwater() / 1048576));
+  Set(cache, New("memory").ToLocalChecked(), New<Number>(vips_cache_get_max_mem() / 1048576));
+  Set(cache, New("items").ToLocalChecked(), New<Number>(vips_cache_get_max()));
+  info.GetReturnValue().Set(cache);
 }
 
 /*
   Get and set size of thread pool
 */
 NAN_METHOD(concurrency) {
-  NanScope();
+  HandleScope();
 
   // Set concurrency
-  if (args[0]->IsInt32()) {
-    vips_concurrency_set(args[0]->Int32Value());
+  if (info[0]->IsInt32()) {
+    vips_concurrency_set(To<int32_t>(info[0]).FromJust());
   }
   // Get concurrency
-  NanReturnValue(NanNew<Number>(vips_concurrency_get()));
+  info.GetReturnValue().Set(New<Number>(vips_concurrency_get()));
 }
 
 /*
@@ -64,84 +66,89 @@ NAN_METHOD(counters) {
   using sharp::counterProcess;
   using sharp::counterQueue;
 
-  NanScope();
-  Local<Object> counters = NanNew<Object>();
-  counters->Set(NanNew<String>("queue"), NanNew<Number>(counterQueue));
-  counters->Set(NanNew<String>("process"), NanNew<Number>(counterProcess));
-  NanReturnValue(counters);
+  HandleScope();
+  Local<Object> counters = New<Object>();
+  Set(counters, New("queue").ToLocalChecked(), New<Number>(counterQueue));
+  Set(counters, New("process").ToLocalChecked(), New<Number>(counterProcess));
+  info.GetReturnValue().Set(counters);
 }
 
 /*
   Get libvips version
 */
 NAN_METHOD(libvipsVersion) {
-  NanScope();
+  HandleScope();
   char version[9];
   g_snprintf(version, sizeof(version), "%d.%d.%d", vips_version(0), vips_version(1), vips_version(2));
-  NanReturnValue(NanNew<String>(version));
+  info.GetReturnValue().Set(New(version).ToLocalChecked());
 }
 
 /*
   Get available input/output file/buffer/stream formats
 */
 NAN_METHOD(format) {
-  NanScope();
+  HandleScope();
 
   // Attribute names
-  Local<String> attrId =  NanNew<String>("id");
-  Local<String> attrInput =  NanNew<String>("input");
-  Local<String> attrOutput =  NanNew<String>("output");
-  Local<String> attrFile =  NanNew<String>("file");
-  Local<String> attrBuffer =  NanNew<String>("buffer");
-  Local<String> attrStream =  NanNew<String>("stream");
+  Local<String> attrId = New("id").ToLocalChecked();
+  Local<String> attrInput = New("input").ToLocalChecked();
+  Local<String> attrOutput = New("output").ToLocalChecked();
+  Local<String> attrFile = New("file").ToLocalChecked();
+  Local<String> attrBuffer = New("buffer").ToLocalChecked();
+  Local<String> attrStream = New("stream").ToLocalChecked();
 
   // Which load/save operations are available for each compressed format?
-  Local<Object> format = NanNew<Object>();
+  Local<Object> format = New<Object>();
   for (std::string f : {"jpeg", "png", "webp", "tiff", "magick", "openslide", "dz"}) {
     // Input
-    Local<Object> input = NanNew<Object>();
-    input->Set(attrFile, NanNew<Boolean>(
-      vips_type_find("VipsOperation", (f + "load").c_str())));
-    input->Set(attrBuffer, NanNew<Boolean>(
-      vips_type_find("VipsOperation", (f + "load_buffer").c_str())));
-    input->Set(attrStream, input->Get(attrBuffer));
+    Local<Boolean> hasInputFile =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "load").c_str()));
+    Local<Boolean> hasInputBuffer =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "load_buffer").c_str()));
+    Local<Object> input = New<Object>();
+    Set(input, attrFile, hasInputFile);
+    Set(input, attrBuffer, hasInputBuffer);
+    Set(input, attrStream, hasInputBuffer);
     // Output
-    Local<Object> output = NanNew<Object>();
-    output->Set(attrFile, NanNew<Boolean>(
-      vips_type_find("VipsOperation", (f + "save").c_str())));
-    output->Set(attrBuffer, NanNew<Boolean>(
-      vips_type_find("VipsOperation", (f + "save_buffer").c_str())));
-    output->Set(attrStream, output->Get(attrBuffer));
+    Local<Boolean> hasOutputFile =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "save").c_str()));
+    Local<Boolean> hasOutputBuffer =
+      New<Boolean>(vips_type_find("VipsOperation", (f + "save_buffer").c_str()));
+    Local<Object> output = New<Object>();
+    Set(output, attrFile, hasOutputFile);
+    Set(output, attrBuffer, hasOutputBuffer);
+    Set(output, attrStream, hasOutputBuffer);
     // Other attributes
-    Local<Object> container = NanNew<Object>();
-    Local<String> formatId = NanNew<String>(f);
-    container->Set(attrId, formatId);
-    container->Set(attrInput, input);
-    container->Set(attrOutput, output);
+    Local<Object> container = New<Object>();
+    Local<String> formatId = New(f).ToLocalChecked();
+    Set(container, attrId, formatId);
+    Set(container, attrInput, input);
+    Set(container, attrOutput, output);
     // Add to set of formats
-    format->Set(formatId, container);
+    Set(format, formatId, container);
   }
 
   // Raw, uncompressed data
-  Local<Object> raw = NanNew<Object>();
-  raw->Set(attrId, NanNew<String>("raw"));
-  format->Set(NanNew<String>("raw"), raw);
+  Local<Object> raw = New<Object>();
+  Local<String> rawId = New("raw").ToLocalChecked();
+  Set(raw, attrId, rawId);
+  Set(format, rawId, raw);
   // No support for raw input yet, so always false
-  Local<Boolean> unsupported = NanNew<Boolean>(false);
-  Local<Object> rawInput = NanNew<Object>();
-  rawInput->Set(attrFile, unsupported);
-  rawInput->Set(attrBuffer, unsupported);
-  rawInput->Set(attrStream, unsupported);
-  raw->Set(attrInput, rawInput);
+  Local<Boolean> unsupported = New<Boolean>(false);
+  Local<Object> rawInput = New<Object>();
+  Set(rawInput, attrFile, unsupported);
+  Set(rawInput, attrBuffer, unsupported);
+  Set(rawInput, attrStream, unsupported);
+  Set(raw, attrInput, rawInput);
   // Raw output via Buffer/Stream is available in libvips >= 7.42.0
-  Local<Boolean> supportsRawOutput = NanNew<Boolean>(vips_version(0) >= 8 || (vips_version(0) == 7 && vips_version(1) >= 42));
-  Local<Object> rawOutput = NanNew<Object>();
-  rawOutput->Set(attrFile, unsupported);
-  rawOutput->Set(attrBuffer, supportsRawOutput);
-  rawOutput->Set(attrStream, supportsRawOutput);
-  raw->Set(attrOutput, rawOutput);
+  Local<Boolean> hasOutputBufferRaw = New<Boolean>(vips_version(0) >= 8 || (vips_version(0) == 7 && vips_version(1) >= 42));
+  Local<Object> rawOutput = New<Object>();
+  Set(rawOutput, attrFile, unsupported);
+  Set(rawOutput, attrBuffer, hasOutputBufferRaw);
+  Set(rawOutput, attrStream, hasOutputBufferRaw);
+  Set(raw, attrOutput, rawOutput);
 
-  NanReturnValue(format);
+  info.GetReturnValue().Set(format);
 }
 
 /*
@@ -156,50 +163,50 @@ NAN_METHOD(_maxColourDistance) {
   using sharp::InitImage;
   using sharp::HasAlpha;
 
-  NanScope();
+  HandleScope();
 
   // Create "hook" VipsObject to hang image references from
   VipsObject *hook = reinterpret_cast<VipsObject*>(vips_image_new());
 
   // Open input files
   VipsImage *image1 = NULL;
-  ImageType imageType1 = DetermineImageType(*String::Utf8Value(args[0]));
+  ImageType imageType1 = DetermineImageType(*Utf8String(info[0]));
   if (imageType1 != ImageType::UNKNOWN) {
-    image1 = InitImage(*String::Utf8Value(args[0]), VIPS_ACCESS_SEQUENTIAL);
+    image1 = InitImage(*Utf8String(info[0]), VIPS_ACCESS_SEQUENTIAL);
     if (image1 == NULL) {
       g_object_unref(hook);
-      return NanThrowError("Input file 1 has corrupt header");
+      return ThrowError("Input file 1 has corrupt header");
     } else {
       vips_object_local(hook, image1);
     }
   } else {
     g_object_unref(hook);
-    return NanThrowError("Input file 1 is of an unsupported image format");
+    return ThrowError("Input file 1 is of an unsupported image format");
   }
   VipsImage *image2 = NULL;
-  ImageType imageType2 = DetermineImageType(*String::Utf8Value(args[1]));
+  ImageType imageType2 = DetermineImageType(*Utf8String(info[1]));
   if (imageType2 != ImageType::UNKNOWN) {
-    image2 = InitImage(*String::Utf8Value(args[1]), VIPS_ACCESS_SEQUENTIAL);
+    image2 = InitImage(*Utf8String(info[1]), VIPS_ACCESS_SEQUENTIAL);
     if (image2 == NULL) {
       g_object_unref(hook);
-      return NanThrowError("Input file 2 has corrupt header");
+      return ThrowError("Input file 2 has corrupt header");
     } else {
       vips_object_local(hook, image2);
     }
   } else {
     g_object_unref(hook);
-    return NanThrowError("Input file 2 is of an unsupported image format");
+    return ThrowError("Input file 2 is of an unsupported image format");
   }
 
   // Ensure same number of channels
   if (image1->Bands != image2->Bands) {
     g_object_unref(hook);
-    return NanThrowError("mismatchedBands");
+    return ThrowError("mismatchedBands");
   }
   // Ensure same dimensions
   if (image1->Xsize != image2->Xsize || image1->Ysize != image2->Ysize) {
     g_object_unref(hook);
-    return NanThrowError("mismatchedDimensions");
+    return ThrowError("mismatchedDimensions");
   }
 
   // Premultiply and remove alpha
@@ -207,13 +214,13 @@ NAN_METHOD(_maxColourDistance) {
     VipsImage *imagePremultiplied1;
     if (Premultiply(hook, image1, &imagePremultiplied1)) {
       g_object_unref(hook);
-      return NanThrowError(vips_error_buffer());
+      return ThrowError(vips_error_buffer());
     }
     vips_object_local(hook, imagePremultiplied1);
     VipsImage *imagePremultipliedNoAlpha1;
     if (vips_extract_band(image1, &imagePremultipliedNoAlpha1, 1, "n", image1->Bands - 1, NULL)) {
       g_object_unref(hook);
-      return NanThrowError(vips_error_buffer());
+      return ThrowError(vips_error_buffer());
     }
     vips_object_local(hook, imagePremultipliedNoAlpha1);
     image1 = imagePremultipliedNoAlpha1;
@@ -222,13 +229,13 @@ NAN_METHOD(_maxColourDistance) {
     VipsImage *imagePremultiplied2;
     if (Premultiply(hook, image2, &imagePremultiplied2)) {
       g_object_unref(hook);
-      return NanThrowError(vips_error_buffer());
+      return ThrowError(vips_error_buffer());
     }
     vips_object_local(hook, imagePremultiplied2);
     VipsImage *imagePremultipliedNoAlpha2;
     if (vips_extract_band(image2, &imagePremultipliedNoAlpha2, 1, "n", image2->Bands - 1, NULL)) {
       g_object_unref(hook);
-      return NanThrowError(vips_error_buffer());
+      return ThrowError(vips_error_buffer());
     }
     vips_object_local(hook, imagePremultipliedNoAlpha2);
     image2 = imagePremultipliedNoAlpha2;
@@ -237,15 +244,15 @@ NAN_METHOD(_maxColourDistance) {
   VipsImage *difference;
   if (vips_dE00(image1, image2, &difference, NULL)) {
     g_object_unref(hook);
-    return NanThrowError(vips_error_buffer());
+    return ThrowError(vips_error_buffer());
   }
   vips_object_local(hook, difference);
   // Extract maximum distance
   double maxColourDistance;
   if (vips_max(difference, &maxColourDistance, NULL)) {
     g_object_unref(hook);
-    return NanThrowError(vips_error_buffer());
+    return ThrowError(vips_error_buffer());
   }
   g_object_unref(hook);
-  NanReturnValue(maxColourDistance);
+  info.GetReturnValue().Set(New<Number>(maxColourDistance));
 }

test/bench/perf.js

@@ -7,11 +7,22 @@ var assert = require('assert');
 var Benchmark = require('benchmark');
 var semver = require('semver');
 
-var imagemagick = require('imagemagick');
-var imagemagickNative = require('imagemagick-native');
+// Contenders
 var gm = require('gm');
-var lwip = require('lwip');
+var imagemagick = require('imagemagick');
 var sharp = require('../../index');
+var imagemagickNative;
+try {
+  imagemagickNative = require('imagemagick-native');
+} catch (err) {
+  console.log('Excluding imagemagick-native');
+}
+var lwip;
+try {
+  lwip = require('lwip');
+} catch (err) {
+  console.log('Excluding lwip');
+}
 
 var fixtures = require('../fixtures');
 
@@ -27,48 +38,54 @@ sharp.cache(0);
 async.series({
   jpeg: function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    (new Benchmark.Suite('jpeg')).add('lwip-file-file', {
-      defer: true,
-      fn: function(deferred) {
-        lwip.open(fixtures.inputJpg, function (err, image) {
-          if (err) {
-            throw err;
-          }
-          image.resize(width, height, 'linear', function (err, image) {
+    var jpegSuite = new Benchmark.Suite('jpeg');
+    // lwip
+    if (typeof lwip !== 'undefined') {
+      jpegSuite.add('lwip-file-file', {
+        defer: true,
+        fn: function(deferred) {
+          lwip.open(fixtures.inputJpg, function (err, image) {
             if (err) {
               throw err;
             }
-            image.writeFile(fixtures.outputJpg, {quality: 80}, function (err) {
+            image.resize(width, height, 'linear', function (err, image) {
               if (err) {
                 throw err;
               }
-              deferred.resolve();
+              image.writeFile(fixtures.outputJpg, {quality: 80}, function (err) {
+                if (err) {
+                  throw err;
+                }
+                deferred.resolve();
+              });
             });
           });
-        });
-      }
-    }).add('lwip-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        lwip.open(inputJpgBuffer, 'jpg', function (err, image) {
-          if (err) {
-            throw err;
-          }
-          image.resize(width, height, 'linear', function (err, image) {
+        }
+      }).add('lwip-buffer-buffer', {
+        defer: true,
+        fn: function(deferred) {
+          lwip.open(inputJpgBuffer, 'jpg', function (err, image) {
             if (err) {
               throw err;
             }
-            image.toBuffer('jpg', {quality: 80}, function (err, buffer) {
+            image.resize(width, height, 'linear', function (err, image) {
               if (err) {
                 throw err;
               }
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
+              image.toBuffer('jpg', {quality: 80}, function (err, buffer) {
+                if (err) {
+                  throw err;
+                }
+                assert.notStrictEqual(null, buffer);
+                deferred.resolve();
+              });
             });
           });
-        });
-      }
-    }).add('imagemagick-file-file', {
+        }
+      });
+    }
+    // imagemagick
+    jpegSuite.add('imagemagick-file-file', {
       defer: true,
       fn: function(deferred) {
         imagemagick.resize({
@@ -87,26 +104,32 @@ async.series({
           }
         });
       }
-    }).add('imagemagick-native-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        imagemagickNative.convert({
-          srcData: inputJpgBuffer,
-          quality: 80,
-          width: width,
-          height: height,
-          format: 'JPEG',
-          filter: magickFilter
-        }, function (err, buffer) {
-          if (err) {
-            throw err;
-          } else {
-            assert.notStrictEqual(null, buffer);
-            deferred.resolve();
-          }
-        });
-      }
-    }).add('gm-buffer-file', {
+    });
+    // imagemagick-native
+    if (typeof imagemagickNative !== 'undefined') {
+      jpegSuite.add('imagemagick-native-buffer-buffer', {
+        defer: true,
+        fn: function(deferred) {
+          imagemagickNative.convert({
+            srcData: inputJpgBuffer,
+            quality: 80,
+            width: width,
+            height: height,
+            format: 'JPEG',
+            filter: magickFilter
+          }, function (err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+        }
+      });
+    }
+    // gm
+    jpegSuite.add('gm-buffer-file', {
       defer: true,
       fn: function(deferred) {
         gm(inputJpgBuffer)
@@ -168,7 +191,9 @@ async.series({
             }
           });
       }
-    }).add('sharp-buffer-file', {
+    });
+    // sharp
+    jpegSuite.add('sharp-buffer-file', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer).resize(width, height).toFile(fixtures.outputJpg, function(err) {
@@ -446,28 +471,33 @@ async.series({
   png: function(callback) {
     var inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     var pngSuite = new Benchmark.Suite('png');
-    pngSuite.add('lwip-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        lwip.open(inputPngBuffer, 'png', function (err, image) {
-          if (err) {
-            throw err;
-          }
-          image.resize(width, height, 'linear', function (err, image) {
+    // lwip
+    if (typeof lwip !== 'undefined') {
+      pngSuite.add('lwip-buffer-buffer', {
+        defer: true,
+        fn: function(deferred) {
+          lwip.open(inputPngBuffer, 'png', function (err, image) {
             if (err) {
               throw err;
             }
-            image.toBuffer('png', function (err, buffer) {
+            image.resize(width, height, 'linear', function (err, image) {
               if (err) {
                 throw err;
               }
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
+              image.toBuffer('png', function (err, buffer) {
+                if (err) {
+                  throw err;
+                }
+                assert.notStrictEqual(null, buffer);
+                deferred.resolve();
+              });
             });
           });
-        });
-      }
-    }).add('imagemagick-file-file', {
+        }
+      });
+    }
+    // imagemagick
+    pngSuite.add('imagemagick-file-file', {
       defer: true,
       fn: function(deferred) {
         imagemagick.resize({
@@ -484,19 +514,25 @@ async.series({
           }
         });
       }
-    }).add('imagemagick-native-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        imagemagickNative.convert({
-          srcData: inputPngBuffer,
-          width: width,
-          height: height,
-          format: 'PNG',
-          filter: magickFilter
-        });
-        deferred.resolve();
-      }
-    }).add('gm-file-file', {
+    });
+    // imagemagick-native
+    if (typeof imagemagickNative !== 'undefined') {
+      pngSuite.add('imagemagick-native-buffer-buffer', {
+        defer: true,
+        fn: function(deferred) {
+          imagemagickNative.convert({
+            srcData: inputPngBuffer,
+            width: width,
+            height: height,
+            format: 'PNG',
+            filter: magickFilter
+          });
+          deferred.resolve();
+        }
+      });
+    }
+    // gm
+    pngSuite.add('gm-file-file', {
       defer: true,
       fn: function(deferred) {
         gm(fixtures.inputPng)
@@ -525,7 +561,9 @@ async.series({
             }
           });
       }
-    }).add('sharp-buffer-file', {
+    });
+    // sharp
+    pngSuite.add('sharp-buffer-file', {
       defer: true,
       fn: function(deferred) {
         sharp(inputPngBuffer).resize(width, height).toFile(fixtures.outputPng, function(err) {

test/leak/leak.sh

@@ -1,8 +1,18 @@
+#!/bin/sh
+
 if ! type valgrind >/dev/null; then
   echo "Please install valgrind before running memory leak tests"
   exit 1
 fi
 
-curl -O https://raw.githubusercontent.com/jcupitt/libvips/master/libvips.supp
-cd ../../
-G_SLICE=always-malloc G_DEBUG=gc-friendly valgrind --suppressions=test/leak/libvips.supp --suppressions=test/leak/sharp.supp --leak-check=full --show-leak-kinds=definite,indirect,possible --num-callers=20 --trace-children=yes npm test
+curl -o ./test/leak/libvips.supp https://raw.githubusercontent.com/jcupitt/libvips/master/libvips.supp
+
+G_SLICE=always-malloc G_DEBUG=gc-friendly valgrind \
+  --suppressions=test/leak/libvips.supp \
+  --suppressions=test/leak/sharp.supp \
+  --gen-suppressions=yes \
+  --leak-check=full \
+  --show-leak-kinds=definite,indirect,possible \
+  --num-callers=20 \
+  --trace-children=yes \
+  npm test

test/leak/sharp.supp

@@ -30,7 +30,61 @@
   fun:jpeg_finish_compress
 }
 
-# libvips interpolator warnings
+# libpng
+{
+  cond_libpng_png_read_row
+  Memcheck:Cond
+  ...
+  fun:png_read_row
+}
+{
+  value_libpng_png_read_row
+  Memcheck:Value8
+  ...
+  fun:png_read_row
+}
+{
+  cond_libpng_png_write_rows
+  Memcheck:Cond
+  ...
+  fun:png_write_row
+  fun:png_write_rows
+}
+{
+  value_libpng_png_write_rows
+  Memcheck:Value8
+  ...
+  fun:png_write_row
+  fun:png_write_rows
+}
+
+# libwebp
+{
+  cond_libwebp_WebPEncodeRGBA
+  Memcheck:Cond
+  ...
+  fun:WebPEncodeRGBA
+}
+{
+  value_libwebp_WebPEncodeRGBA
+  Memcheck:Value8
+  ...
+  fun:WebPEncodeRGBA
+}
+{
+  cond_libwebp_WebPEncodeRGB
+  Memcheck:Cond
+  ...
+  fun:WebPEncodeRGB
+}
+{
+  value_libwebp_WebPEncodeRGB
+  Memcheck:Value8
+  ...
+  fun:WebPEncodeRGB
+}
+
+# libvips
 {
   cond_libvips_interpolate_lbb
   Memcheck:Cond
@@ -38,6 +92,18 @@
   fun:_ZL32vips_interpolate_lbb_interpolateP16_VipsInterpolatePvP11_VipsRegiondd
   fun:vips_affine_gen
 }
+{
+  cond_libvips_conv_gen
+  Memcheck:Cond
+  fun:conv_gen
+  fun:vips_region_generate
+}
+{
+  cond_libvips_col_sRGB2scRGB_8
+  Memcheck:Value8
+  fun:vips_col_sRGB2scRGB_8
+  fun:vips_sRGB2scRGB_gen
+}
 
 # libuv warnings
 {
@@ -46,6 +112,19 @@
   ...
   fun:uv__work_done
 }
+{
+  param_libuv_fs_work
+  Memcheck:Param
+  write(buf)
+  ...
+  fun:uv__fs_work
+}
+{
+  cond_libuv_work_done
+  Memcheck:Cond
+  ...
+  fun:uv__work_done
+}
 
 # nodejs warnings
 {
@@ -55,6 +134,13 @@
   ...
   obj:/usr/bin/nodejs
 }
+{
+  param_iojs_write_buffer
+  Memcheck:Param
+  write(buf)
+  ...
+  obj:/usr/bin/iojs
+}
 {
   leak_nodejs_ImmutableAsciiSource_CreateFromLiteral
   Memcheck:Leak
@@ -99,6 +185,69 @@
   ...
   fun:ares_init_options
 }
+{
+  leak_nodejs_CreateEnvironment_Handle
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node17CreateEnvironmentEPN2v87IsolateEP9uv_loop_sNS0_6HandleINS0_7ContextEEEiPKPKciSB_
+}
+{
+  leak_nodejs_CreateEnvironment_Local
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node17CreateEnvironmentEPN2v87IsolateEP9uv_loop_sNS0_5LocalINS0_7ContextEEEiPKPKciSB_
+}
+{
+  leak_nan_FunctionCallbackInfo
+  Memcheck:Leak
+  match-leak-kinds: definite
+  ...
+  fun:_ZN3Nan3impL23FunctionCallbackWrapperERKN2v820FunctionCallbackInfoINS1_5ValueEEE
+}
+{
+  leak_v8_FunctionCallbackInfo
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal25FunctionCallbackArguments4CallEPFvRKNS_20FunctionCallbackInfoINS_5ValueEEEE
+}
+{
+  leak_v8_CallInterfaceDescriptorData
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal27CallInterfaceDescriptorData10InitializeEiPNS0_8RegisterEPNS0_14RepresentationEPNS0_27PlatformInterfaceDescriptorE
+}
+{
+  leak_v8_Isolate_Init
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal7Isolate4InitEPNS0_12DeserializerE
+}
+{
+  leak_v8_StoreDescriptor_Initialize
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal15StoreDescriptor10InitializeEPNS0_27CallInterfaceDescriptorDataE
+}
+{
+  leak_v8_CodeStub_GetCode
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal8CodeStub7GetCodeEv
+}
+{
+  leak_v8_CreateICUCollator
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN2v88internal12_GLOBAL__N_117CreateICUCollatorEPNS0_7IsolateERKN6icu_556LocaleENS0_6HandleINS0_8JSObjectEEE
+}
 
 # vips__init warnings
 {

test/unit/crop.js

@@ -81,10 +81,27 @@ describe('Crop gravities', function() {
       });
   });
 
-  it('Invalid', function() {
+  it('allows specifying the gravity as a string', function(done) {
+    sharp(fixtures.inputJpg)
+      .resize(80, 320)
+      .crop('east')
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(80, info.width);
+        assert.strictEqual(320, info.height);
+        fixtures.assertSimilar(fixtures.expected('gravity-east.jpg'), data, done);
+      });
+  });
+
+  it('Invalid number', function() {
     assert.throws(function() {
       sharp(fixtures.inputJpg).crop(5);
     });
   });
 
+  it('Invalid string', function() {
+    assert.throws(function() {
+      sharp(fixtures.inputJpg).crop('yadda');
+    });
+  });
 });

test/unit/gamma.js

@@ -16,7 +16,7 @@ describe('Gamma correction', function() {
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(129, info.width);
         assert.strictEqual(111, info.height);
-        fixtures.assertSimilar(fixtures.expected('gamma-0.0.jpg'), data, done);
+        fixtures.assertSimilar(fixtures.expected('gamma-0.0.jpg'), data, {threshold: 12}, done);
       });
   });
 

test/unit/require.js

@@ -0,0 +1,15 @@
+'use strict';
+
+describe('Require-time checks', function() {
+
+  /*
+    Including sharp alongside another C++ module that does not require
+    -stdlib=libc++ (for its C++11 features) has caused clang/llvm to
+    segfault due to the use of static function variables.
+  */
+  it('Require alongside C++ module that does not use libc++', function() {
+    var bufferutil = require('bufferutil');
+    var sharp = require('../../index');
+  });
+
+});