Remove dependency on async library

lib/handlers/allow.js

@@ -3,7 +3,6 @@ module.exports = allow
 var ACL = require('../acl-checker')
 var $rdf = require('rdflib')
 var url = require('url')
-var async = require('async')
 var utils = require('../utils')
 
 function allow (mode) {
@@ -59,31 +58,30 @@ function allow (mode) {
  */
 function fetchDocument (host, ldp, baseUri) {
   return function fetch (uri, callback) {
-    var graph = $rdf.graph()
-    async.waterfall([
-      function readFile (cb) {
-        // If local request, slice off the initial baseUri
-        // S(uri).chompLeft(baseUri).s
-        var newPath = uri.startsWith(baseUri)
-          ? uri.slice(baseUri.length)
-          : uri
-        // Determine the root file system folder to look in
-        // TODO prettify this
-        var root = !ldp.idp ? ldp.root : ldp.root + host + '/'
-        // Derive the file path for the resource
-        var documentPath = utils.uriToFilename(newPath, root)
-        var documentUri = url.parse(documentPath)
-        documentPath = documentUri.pathname
-        return ldp.readFile(documentPath, cb)
-      },
-      function parseFile (body, cb) {
-        try {
-          $rdf.parse(body, graph, uri, 'text/turtle')
-        } catch (err) {
-          return cb(err, graph)
-        }
-        return cb(null, graph)
-      }
-    ], callback)
+    readFile(uri, host, ldp, baseUri).then(body => {
+      const graph = $rdf.graph()
+      $rdf.parse(body, graph, uri, 'text/turtle')
+      return graph
+    })
+    .then(graph => callback(null, graph), callback)
   }
 }
+
+// Reads the given file, returning its contents
+function readFile (uri, host, ldp, baseUri) {
+  return new Promise((resolve, reject) => {
+    // If local request, slice off the initial baseUri
+    // S(uri).chompLeft(baseUri).s
+    var newPath = uri.startsWith(baseUri)
+      ? uri.slice(baseUri.length)
+      : uri
+    // Determine the root file system folder to look in
+    // TODO prettify this
+    var root = !ldp.idp ? ldp.root : ldp.root + host + '/'
+    // Derive the file path for the resource
+    var documentPath = utils.uriToFilename(newPath, root)
+    var documentUri = url.parse(documentPath)
+    documentPath = documentUri.pathname
+    ldp.readFile(documentPath, (e, c) => e ? reject(e) : resolve(c))
+  })
+}

lib/handlers/get.js

@@ -5,7 +5,6 @@ var glob = require('glob')
 var _path = require('path')
 var $rdf = require('rdflib')
 var S = require('string')
-var async = require('async')
 var Negotiator = require('negotiator')
 const url = require('url')
 const mime = require('mime-types')
@@ -161,35 +160,28 @@ function globHandler (req, res, next) {
     let reqOrigin = utils.getBaseUri(req)
 
     debugGlob('found matches ' + matches)
-    async.each(matches, function (match, done) {
+    Promise.all(matches.map(match => new Promise((resolve, reject) => {
       var baseUri = utils.filenameToBaseUri(match, reqOrigin, root)
       fs.readFile(match, {encoding: 'utf8'}, function (err, fileData) {
         if (err) {
           debugGlob('error ' + err)
-          return done(null)
+          return resolve()
         }
         aclAllow(match, req, res, function (allowed) {
           if (!S(match).endsWith('.ttl') || !allowed) {
-            return done(null)
+            return resolve()
           }
           try {
-            $rdf.parse(
-              fileData,
-              globGraph,
-              baseUri,
-              'text/turtle')
+            $rdf.parse(fileData, globGraph, baseUri, 'text/turtle')
           } catch (parseErr) {
-            debugGlob('error in parsing the files' + parseErr)
+            debugGlob(`error parsing ${match}: ${parseErr}`)
           }
-          return done(null)
+          return resolve()
         })
       })
-    }, function () {
-      var data = $rdf.serialize(
-        undefined,
-        globGraph,
-        requestUri,
-        'text/turtle')
+    })))
+    .then(() => {
+      var data = $rdf.serialize(undefined, globGraph, requestUri, 'text/turtle')
       // TODO this should be added as a middleware in the routes
       res.setHeader('Content-Type', 'text/turtle')
       debugGlob('returning turtle')

lib/ldp.js

@@ -3,7 +3,6 @@ var path = require('path')
 const url = require('url')
 var fs = require('fs')
 var $rdf = require('rdflib')
-var async = require('async')
 // var url = require('url')
 var mkdirp = require('fs-extra').mkdirp
 var uuid = require('uuid')
@@ -13,7 +12,6 @@ var error = require('./http-error')
 var stringToStream = require('./utils').stringToStream
 var serialize = require('./utils').serialize
 var extend = require('extend')
-var doWhilst = require('async').doWhilst
 var rimraf = require('rimraf')
 var ldpContainer = require('./ldp-container')
 var parse = require('./utils').parse
@@ -156,42 +154,40 @@ class LDP {
       return callback(error(500, "Can't parse container"))
     }
 
-    async.waterfall(
-      [
-        // add container stats
-        function (next) {
-          ldpContainer.addContainerStats(ldp, reqUri, filename, resourceGraph, next)
-        },
-        // reading directory
-        function (next) {
-          ldpContainer.readdir(filename, next)
-        },
-        // Iterate through all the files
-        function (files, next) {
-          async.each(
-            files,
-            function (file, cb) {
-              let fileUri = url.resolve(reqUri, encodeURIComponent(file))
-              ldpContainer.addFile(ldp, resourceGraph, reqUri, fileUri, uri,
-                filename, file, cb)
-            },
-            next)
-        }
-      ],
-      function (err, data) {
+    // add container stats
+    new Promise((resolve, reject) =>
+      ldpContainer.addContainerStats(ldp, reqUri, filename, resourceGraph,
+        err => err ? reject(err) : resolve())
+    )
+    // read directory
+    .then(() => new Promise((resolve, reject) =>
+      ldpContainer.readdir(filename,
+        (err, files) => err ? reject(err) : resolve(files))
+    ))
+    // iterate through all the files
+    .then(files => {
+      return Promise.all(files.map(file =>
+        new Promise((resolve, reject) => {
+          const fileUri = url.resolve(reqUri, encodeURIComponent(file))
+          ldpContainer.addFile(ldp, resourceGraph, reqUri, fileUri, uri,
+            filename, file, err => err ? reject(err) : resolve())
+        })
+      ))
+    })
+    .catch(() => { throw error(500, "Can't list container") })
+    .then(() => new Promise((resolve, reject) => {
+      // TODO 'text/turtle' is fixed, should be contentType instead
+      // This forces one more translation turtle -> desired
+      serialize(resourceGraph, reqUri, 'text/turtle', function (err, result) {
         if (err) {
-          return callback(error(500, "Can't list container"))
+          debug.handlers('GET -- Error serializing container: ' + err)
+          reject(error(500, "Can't serialize container"))
+        } else {
+          resolve(result)
         }
-        // TODO 'text/turtle' is fixed, should be contentType instead
-        // This forces one more translation turtle -> desired
-        serialize(resourceGraph, reqUri, 'text/turtle', function (err, result) {
-          if (err) {
-            debug.handlers('GET -- Error serializing container: ' + err)
-            return callback(error(500, "Can't serialize container"))
-          }
-          return callback(null, result)
-        })
       })
+    }))
+    .then(result => callback(null, result), callback)
   }
 
   post (hostname, containerPath, slug, stream, container, callback) {
@@ -351,18 +347,10 @@ class LDP {
     var root = ldp.idp ? ldp.root + host + '/' : ldp.root
     var filename = utils.uriToFilename(reqPath, root)
 
-    async.waterfall([
-      // Read file
-      function (cb) {
-        return ldp.readFile(filename, cb)
-      },
-      // Parse file
-      function (body, cb) {
-        parse(body, baseUri, contentType, function (err, graph) {
-          cb(err, graph)
-        })
-      }
-    ], callback)
+    ldp.readFile(filename, (err, body) => {
+      if (err) return callback(err)
+      parse(body, baseUri, contentType, callback)
+    })
   }
 
   get (options, callback) {
@@ -395,7 +383,7 @@ class LDP {
           if (err) {
             metaFile = ''
           }
-          let absContainerUri = url.resolve(baseUri, reqPath)
+          let absContainerUri = baseUri + reqPath
           ldp.listContainer(filename, absContainerUri, baseUri, metaFile, contentType,
             function (err, data) {
               if (err) {
@@ -498,34 +486,25 @@ class LDP {
 
   getAvailablePath (host, containerURI, slug, callback) {
     var self = this
-    var exists
-
-    if (!slug) {
-      slug = uuid.v1()
-    }
+    slug = slug || uuid.v1()
 
-    var newPath = path.join(containerURI, slug)
-
-    // TODO: maybe a nicer code
-    doWhilst(
-      function (next) {
+    function ensureNotExists (newPath) {
+      return new Promise(resolve => {
         self.exists(host, newPath, function (err) {
-          exists = !err
-
-          if (exists) {
-            var id = uuid.v1().split('-')[ 0 ] + '-'
+          // If an error occurred, the resource does not exist yet
+          if (err) {
+            resolve(newPath)
+          // Otherwise, generate a new path
+          } else {
+            const id = uuid.v1().split('-')[ 0 ] + '-'
             newPath = path.join(containerURI, id + slug)
+            resolve(ensureNotExists(newPath))
           }
-
-          next()
         })
-      },
-      function () {
-        return exists === true
-      },
-      function () {
-        callback(newPath)
       })
+    }
+
+    return ensureNotExists(path.join(containerURI, slug)).then(callback)
   }
 }
 module.exports = LDP

package.json

@@ -30,7 +30,6 @@
   "homepage": "http://github.com/solid/node-solid-server",
   "bugs": "http://github.com/solid/node-solid-server/issues",
   "dependencies": {
-    "async": "^1.3.0",
     "body-parser": "^1.14.2",
     "busboy": "^0.2.12",
     "camelize": "^1.0.0",

test/integration/cors-proxy-test.js

@@ -2,7 +2,6 @@ var assert = require('chai').assert
 var supertest = require('supertest')
 var path = require('path')
 var nock = require('nock')
-var async = require('async')
 
 var ldnode = require('../../index')
 
@@ -108,30 +107,19 @@ describe('CORS Proxy', () => {
       .expect(200, done)
   })
 
-  it('should return the same HTTP status code as the uri', (done) => {
-    async.parallel([
-      // 500
-      (next) => {
-        nock('https://example.org').get('/404').reply(404)
-        server.get('/proxy/?uri=https://example.org/404')
-          .expect(404, next)
-      },
-      (next) => {
-        nock('https://example.org').get('/401').reply(401)
-        server.get('/proxy/?uri=https://example.org/401')
-          .expect(401, next)
-      },
-      (next) => {
-        nock('https://example.org').get('/500').reply(500)
-        server.get('/proxy/?uri=https://example.org/500')
-          .expect(500, next)
-      },
-      (next) => {
-        nock('https://example.org').get('/').reply(200)
-        server.get('/proxy/?uri=https://example.org/')
-          .expect(200, next)
-      }
-    ], done)
+  it('should return the same HTTP status code as the uri', () => {
+    nock('https://example.org')
+      .get('/404').reply(404)
+      .get('/401').reply(401)
+      .get('/500').reply(500)
+      .get('/200').reply(200)
+
+    return Promise.all([
+      server.get('/proxy/?uri=https://example.org/404').expect(404),
+      server.get('/proxy/?uri=https://example.org/401').expect(401),
+      server.get('/proxy/?uri=https://example.org/500').expect(500),
+      server.get('/proxy/?uri=https://example.org/200').expect(200)
+    ])
   })
 
   it('should work with cors', (done) => {