Implement LDP without async.

Author: RubenVerborgh

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