Use LegacyResourceMapper in allow handler.

Fixes #656.

Author: RubenVerborgh

lib/handlers/allow.js

@@ -2,9 +2,9 @@ module.exports = allow
 
 var ACL = require('../acl-checker')
 var $rdf = require('rdflib')
-var url = require('url')
 var utils = require('../utils')
 var debug = require('../debug.js').ACL
+var LegacyResourceMapper = require('../legacy-resource-mapper')
 
 function allow (mode) {
   return function allowHandler (req, res, next) {
@@ -13,6 +13,14 @@ function allow (mode) {
       return next()
     }
 
+    // Set up URL to filesystem mapping
+    const rootUrl = utils.getBaseUri(req)
+    const mapper = new LegacyResourceMapper({
+      rootUrl,
+      rootPath: ldp.root,
+      includeHost: ldp.multiuser
+    })
+
     // Determine the actual path of the request
     var reqPath = res && res.locals && res.locals.path
       ? res.locals.path
@@ -27,11 +35,10 @@ function allow (mode) {
       }
 
       // Obtain and store the ACL of the requested resource
-      const baseUri = utils.getBaseUri(req)
-      req.acl = new ACL(baseUri + reqPath, {
+      req.acl = new ACL(rootUrl + reqPath, {
         origin: req.get('origin'),
         host: req.protocol + '://' + req.get('host'),
-        fetch: fetchDocument(req.hostname, ldp, baseUri),
+        fetch: fetchFromLdp(mapper, ldp),
         suffix: ldp.suffixAcl,
         strictOrigin: ldp.strictOrigin
       })
@@ -53,40 +60,23 @@ function allow (mode) {
  * The `fetch(uri, callback)` results in the callback, with either:
  *   - `callback(err, graph)` if any error is encountered, or
  *   - `callback(null, graph)` with the parsed RDF graph of the fetched resource
- * @method fetchDocument
- * @param host {string} req.hostname. Used in determining the location of the
- *   document on the file system (the root directory)
- * @param ldp {LDP} LDP instance
- * @param baseUri {string} Base URI of the solid server (including any root
- *   mount), for example `https://example.com/solid`
  * @return {Function} Returns a `fetch(uri, callback)` handler
  */
-function fetchDocument (host, ldp, baseUri) {
-  return function fetch (uri, callback) {
-    readFile(uri, host, ldp, baseUri).then(body => {
+function fetchFromLdp (mapper, ldp) {
+  return function fetch (url, callback) {
+    // Convert the URL into a filename
+    mapper.mapUrlToFile({ url })
+    // Read the file from disk
+    .then(({ path }) => new Promise((resolve, reject) => {
+      ldp.readFile(path, (e, c) => e ? reject(e) : resolve(c))
+    }))
+    // Parse the file as Turtle
+    .then(body => {
       const graph = $rdf.graph()
-      $rdf.parse(body, graph, uri, 'text/turtle')
+      $rdf.parse(body, graph, url, 'text/turtle')
       return graph
     })
+    // Return the ACL 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.multiuser ? 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))
-  })
-}