From b0ae0f9920ca01c89782a440ad65e3c99d378d98 Mon Sep 17 00:00:00 2001
From: Dan Fabulich <dan.fabulich@redfin.com>
Date: Wed, 9 Dec 2015 13:50:34 -0800
Subject: [PATCH] fs: add accessibleSync() which returns a boolean

As opposed to accessSync() which does nothing or throws
---
 doc/api/fs.md                   |  6 ++++++
 lib/fs.js                       | 11 +++++++++++
 src/node_file.cc                | 26 ++++++++++++++++++++++++++
 test/parallel/test-fs-access.js |  5 +++++
 4 files changed, 48 insertions(+)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 022fa0d2cf2732..4a2e93ed4bef8a 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -345,6 +345,12 @@ added: v0.11.15
 Synchronous version of [`fs.access()`][]. This throws if any accessibility
 checks fail, and does nothing otherwise.
 
+## fs.accessibleSync(path[, mode])
+
+Returns false if any accessibility checks fail, and returns true otherwise.
+This version is faster and more convenient to use than [`fs.accessSync()`][]
+if you don't need to know why the file is not accessible.
+
 ## fs.appendFile(file, data[, options], callback)
 <!-- YAML
 added: v0.6.7
diff --git a/lib/fs.js b/lib/fs.js
index 39bb3777bf9035..24e85425be1170 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -248,6 +248,17 @@ fs.accessSync = function(path, mode) {
   binding.access(pathModule._makeLong(path), mode);
 };
 
+fs.accessibleSync = function(path, mode) {
+  nullCheck(path);
+
+  if (mode === undefined)
+    mode = fs.F_OK;
+  else
+    mode = mode | 0;
+
+  return binding.accessibleSync(pathModule._makeLong(path), mode);
+};
+
 fs.exists = function(path, callback) {
   if (!nullCheck(path, cb)) return;
   var req = new FSReqWrap();
diff --git a/src/node_file.cc b/src/node_file.cc
index c1dd59b9b710f5..5c94d9599a53c5 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -27,6 +27,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Boolean;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Function;
@@ -397,6 +398,30 @@ static void Access(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+static void AccessibleSync(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope scope(env->isolate());
+
+  if (args.Length() < 2)
+    return TYPE_ERROR("path and mode are required");
+  if (!args[1]->IsInt32())
+    return TYPE_ERROR("mode must be an integer");
+
+  BufferValue path(env->isolate(), args[0]);
+  ASSERT_PATH(path)
+
+  int mode = static_cast<int>(args[1]->Int32Value());
+
+  fs_req_wrap req_wrap;
+  env->PrintSyncTrace();
+  int err = uv_fs_access(
+    env->event_loop(), &req_wrap.req, *path, mode, nullptr);
+
+  bool failed = err < 0;
+
+  args.GetReturnValue().Set(Boolean::New(env->isolate(), !failed));
+}
+
 
 static void Close(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1461,6 +1486,7 @@ void InitFs(Local<Object> target,
               env->NewFunctionTemplate(FSInitialize)->GetFunction());
 
   env->SetMethod(target, "access", Access);
+  env->SetMethod(target, "accessibleSync", AccessibleSync);
   env->SetMethod(target, "close", Close);
   env->SetMethod(target, "open", Open);
   env->SetMethod(target, "read", Read);
diff --git a/test/parallel/test-fs-access.js b/test/parallel/test-fs-access.js
index 6b82b4bbf312c3..d2750ce50607a5 100644
--- a/test/parallel/test-fs-access.js
+++ b/test/parallel/test-fs-access.js
@@ -106,6 +106,8 @@ assert.doesNotThrow(function() {
   fs.accessSync(__filename);
 });
 
+assert.equal(fs.accessibleSync(__filename), true, 'file should be accessible');
+
 assert.doesNotThrow(function() {
   var mode = fs.F_OK | fs.R_OK | fs.W_OK;
 
@@ -118,6 +120,9 @@ assert.throws(function() {
   return err.code === 'ENOENT' && err.path === doesNotExist;
 });
 
+assert.equal(fs.accessibleSync(doesNotExist), false,
+  'file should not be accessible');
+
 process.on('exit', function() {
   removeFile(readOnlyFile);
   removeFile(readWriteFile);