Prettify patch code.

Author: RubenVerborgh

lib/handlers/patch.js

@@ -1,63 +1,69 @@
+// Express handler for LDP PATCH requests
+
 module.exports = handler
 
-var bodyParser = require('body-parser')
-var mime = require('mime-types')
-var fs = require('fs')
-var debug = require('../debug').handlers
-var utils = require('../utils.js')
-var error = require('../http-error')
-var $rdf = require('rdflib')
+const bodyParser = require('body-parser')
+const mime = require('mime-types')
+const fs = require('fs')
+const debug = require('../debug').handlers
+const utils = require('../utils.js')
+const error = require('../http-error')
+const $rdf = require('rdflib')
 
-const DEFAULT_CONTENT_TYPE = 'text/turtle'
+const DEFAULT_TARGET_TYPE = 'text/turtle'
 
+// Patch handlers by request body content type
 const PATCHERS = {
   'application/sparql-update': require('./patch/sparql-update-patcher.js')
 }
 
-const readEntity = bodyParser.text({ type: '*/*' })
-
-function handler (req, res, next) {
-  readEntity(req, res, () => patchHandler(req, res, next))
-}
-
+// Handles a PATCH request
 function patchHandler (req, res, next) {
-  const patchText = req.body ? req.body.toString() : ''
   debug('PATCH -- ' + req.originalUrl)
-  debug('PATCH -- Received patch (%d bytes)', patchText.length)
   res.header('MS-Author-Via', 'SPARQL')
 
-  var ldp = req.app.locals.ldp
-  var root = !ldp.idp ? ldp.root : ldp.root + req.hostname + '/'
-  var targetFile = utils.uriToFilename(req.path, root)
-  var targetContentType = mime.lookup(targetFile) || DEFAULT_CONTENT_TYPE
-  var patchContentType = req.get('content-type')
-    ? req.get('content-type').split(';')[0].trim() // Ignore parameters
-    : ''
-  var targetURI = utils.uriAbs(req) + req.originalUrl
-
-  debug('PATCH -- Content-type ' + patchContentType + ' patching target ' + targetContentType + ' <' + targetURI + '>')
-
-  // Obtain a patcher for the given patch type
-  const patchGraph = PATCHERS[patchContentType]
+  // Obtain details of the patch document
+  const patch = {
+    text: req.body ? req.body.toString() : '',
+    contentType: (req.get('content-type') || '').match(/^[^;\s]*/)[0]
+  }
+  const patchGraph = PATCHERS[patch.contentType]
   if (!patchGraph) {
-    return next(error(415, 'Unknown patch content type: ' + patchContentType))
+    return next(error(415, 'Unknown patch content type: ' + patch.contentType))
+  }
+  debug('PATCH -- Received patch (%d bytes, %s)', patch.text.length, patch.contentType)
+
+  // Obtain details of the target resource
+  const ldp = req.app.locals.ldp
+  const root = !ldp.idp ? ldp.root : ldp.root + req.hostname + '/'
+  const target = {
+    file: utils.uriToFilename(req.path, root),
+    uri: utils.uriAbs(req) + req.originalUrl
   }
+  target.contentType = mime.lookup(target.file) || DEFAULT_TARGET_TYPE
+  debug('PATCH -- Target <%s> (%s)', target.uri, target.contentType)
 
   // Read the RDF graph to be patched from the file
-  readGraph(targetFile, targetURI, targetContentType)
+  readGraph(target)
   // Patch the graph and write it back to the file
-  .then(targetKB => patchGraph(targetKB, targetFile, targetURI, patchText))
-  .then(targetKB => writeGraph(targetKB, targetFile, targetURI, targetContentType))
+  .then(graph => patchGraph(graph, target.uri, patch.text))
+  .then(graph => writeGraph(graph, target))
   // Send the result to the client
   .then(result => { res.send(result) })
   .then(next, next)
 }
 
-// Reads the RDF graph in the given file with the corresponding URI
-function readGraph (resourceFile, resourceURI, contentType) {
-  // Read the file
+// Reads the request body and calls the actual patch handler
+function handler (req, res, next) {
+  readEntity(req, res, () => patchHandler(req, res, next))
+}
+const readEntity = bodyParser.text({ type: () => true })
+
+// Reads the RDF graph in the given resource
+function readGraph (resource) {
+  // Read the resource's file
   return new Promise((resolve, reject) =>
-    fs.readFile(resourceFile, {encoding: 'utf8'}, function (err, fileContents) {
+    fs.readFile(resource.file, {encoding: 'utf8'}, function (err, fileContents) {
       if (err) {
         // If the file does not exist, assume empty contents
         // (it will be created after a successful patch)
@@ -72,27 +78,27 @@ function readGraph (resourceFile, resourceURI, contentType) {
       resolve(fileContents)
     })
   )
-  // Parse the file
+  // Parse the resource's file contents
   .then((fileContents) => {
     const graph = $rdf.graph()
-    debug('PATCH -- Reading %s with content type %s', resourceURI, contentType)
+    debug('PATCH -- Reading %s with content type %s', resource.uri, resource.contentType)
     try {
-      $rdf.parse(fileContents, graph, resourceURI, contentType)
+      $rdf.parse(fileContents, graph, resource.uri, resource.contentType)
     } catch (err) {
-      throw error(500, 'Patch: Target ' + contentType + ' file syntax error:' + err)
+      throw error(500, 'Patch: Target ' + resource.contentType + ' file syntax error:' + err)
     }
     debug('PATCH -- Parsed target file')
     return graph
   })
 }
 
-// Writes the RDF graph to the given file
-function writeGraph (graph, resourceFile, resourceURI, contentType) {
+// Writes the RDF graph to the given resource
+function writeGraph (graph, resource) {
   return new Promise((resolve, reject) => {
-    const resource = graph.sym(resourceURI)
-    const serialized = $rdf.serialize(resource, graph, resourceURI, contentType)
+    const resourceSym = graph.sym(resource.uri)
+    const serialized = $rdf.serialize(resourceSym, graph, resource.uri, resource.contentType)
 
-    fs.writeFile(resourceFile, serialized, {encoding: 'utf8'}, function (err) {
+    fs.writeFile(resource.file, serialized, {encoding: 'utf8'}, function (err) {
       if (err) {
         return reject(error(500, 'Failed to write file back after patch: ' + err))
       }

lib/handlers/patch/sparql-update-patcher.js

@@ -1,24 +1,28 @@
+// Performs an application/sparql-update patch on a graph
+
 module.exports = patch
 
-var $rdf = require('rdflib')
-var debug = require('../../debug').handlers
-var error = require('../../http-error')
+const $rdf = require('rdflib')
+const debug = require('../../debug').handlers
+const error = require('../../http-error')
 
-function patch (targetKB, filename, targetURI, text) {
+// Patches the given graph
+function patch (targetKB, targetURI, patchText) {
   return new Promise((resolve, reject) => {
-    var patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
-    var patchKB = $rdf.graph()
-
-    debug('PATCH -- parsing patch ...')
+    // Parse the patch document
+    debug('PATCH -- Parsing patch...')
+    const patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
+    const patchKB = $rdf.graph()
     var patchObject
     try {
       // Must parse relative to document's base address but patch doc should get diff URI
-      patchObject = $rdf.sparqlUpdateParser(text, patchKB, patchURI)
+      patchObject = $rdf.sparqlUpdateParser(patchText, patchKB, patchURI)
     } catch (e) {
       return reject(error(400, 'Patch format syntax error:\n' + e + '\n'))
     }
     debug('PATCH -- reading target file ...')
 
+    // Apply the patch to the target graph
     var target = patchKB.sym(targetURI)
     targetKB.applyPatch(patchObject, target, function (err) {
       if (err) {