@naanlang/naan 1.0.0 → 1.0.3

package/frameworks/node/filesystem.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2021 by Richard C. Zulch
+ * Copyright (c) 2017-2022 by Richard C. Zulch
  *
  */
 
@@ -273,11 +273,48 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                 callback(false, { md5: md5data })
         })
     }
-    
+       
+    // readlink
+    //
+    // Read the contents of a symbolic link.
+
+    files.readlink = closure readlink(path, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(readlink, path))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.readlink(localpath, function(err, linkString) {
+            if err
+                callback(Error("fs.readlink failed:", localpath, err))
+            else
+                callback(false, linkString)
+        })
+    }
+       
+    // symlink
+    //
+    // Create a symbolic link "path" that points to "target". No options are currently supported.
+
+    files.symlink = closure symlink(target, path, options, callback,
+        local error, localpath) {
+        if !callback
+            return (syncAdapter(symlink, target, path, options))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.symlink(target, localpath, function(err) {
+            if err
+                callback(Error("fs.symlink failed:", target, localpath, err))
+            else
+                callback(false, { ok: true })
+        })
+    }
+
     // delete
     //
     // Delete the file at the specified path, or a directory if the options dictionary includes:
-    //     recursive: true          -- "recursively" delete directory and children
+    //     recursive: true          -- recursively delete directory and children
 
     files.delete = closure delete(path, options, callback, local error, localpath) {
         if !callback
@@ -286,9 +323,9 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         if error
             return (asyncResult(callback, error))
         if options.recursive
-            fs.rmdir(localpath, function(err) {
+            fs.rm(localpath, { recursive: true, force: true }, function(err) {
                 if err
-                    callback(Error("fs.rmdir failed:", localpath, err))
+                    callback(Error("fs.rm failed:", localpath, err))
                 else
                     callback(false, { ok: true })
             })
@@ -303,15 +340,22 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
 
     // info
     //
-    //     Report info on a file or directory.
+    //     Report info on a file or directory. The options are:
+    //  {
+    //      follow:                             <boolean>                   // follow links
+    //  }
 
-    files.info = closure info(path, callback, local error, localpath) {
+    files.info = closure info(path, options, callback, local error, localpath, fsop) {
         if !callback
-            return (syncAdapter(info, path))
+            return (syncAdapter(info, path, options))
         `(error, localpath) = localPath(path)
         if error
             return (asyncResult(callback, error))
-        fs.lstat(localpath, function(err, stat, local data, info, nodetype) {
+        if options.follow
+            fsop = `stat
+        else
+            fsop = `lstat
+        fs[fsop](localpath, function(err, stat, local data, info, nodetype) {
             if err
                 return (callback(Error("fs.stat failed:", localpath, err)))
             info = {
@@ -336,9 +380,102 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         })
     }
 
+    // setInfo
+    //
+    //     Set selected info on a file or directory. The info dictionary has the same layout as that
+    // returned by files.info(), and every applicable key defined in the dictionary is set. To omit
+    // setting some of the information, remove its key from the info dictionary. The applicable keys
+    // are:
+    //  {
+    //      mtimeMs:                            <milliseconds>
+    //      mtime:                              <date>
+    //      nodejs_stat: {
+    //          mode:                           <number>
+    //          uid:                            <uid>
+    //          gid:                            <gid>
+    //          atimeMs:                        <milliseconds>
+    //          atime:                          <date>
+    //          mtimeMs:                        <milliseconds>
+    //          mtime:                          <date>
+    //      }
+    //  }
+    // If more than one timestamp exists of a certain type, the millisecond version is used. Some
+    // values are set together by the OS, like uid & guid, or mtime & atime. Specifying just one of
+    // these will cause setInfo to use the same value for both.
+
+    files.setInfo = closure setInfo(path, info, callback,
+        local error, localpath, mtime, atime, uid, gid) {
+        if !callback
+            return (syncAdapter(setInfo, path, info))
+        if !dictionary(info) && !xobject(info)
+            error = Error("setInfo: invalid argument:", typeof(info))
+        else
+            `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        atime = info.nodejs_stat.atimeMs/1000.0 || info.nodejs_stat.atime
+        mtime = info.mtimeMs/1000.0 || info.mtime
+        if !mtime
+            mtime = info.nodejs_stat.mtimeMs/1000.0 || info.nodejs_stat.mtime
+        if atime || mtime {
+            atime = atime || mtime
+            mtime = mtime || atime
+            `(error) = setTimes(path, atime, mtime)
+        }
+        if !error && info.nodejs_stat.mode
+            `(error) = setMode(path, info.nodejs_stat.mode)
+        uid = info.nodejs_stat.uid
+        gid = info.nodejs_stat.gid
+        if !error && (uid || gid) {
+            uid = uid || gid
+            gid = gid || uid
+            `(error) = setOwnerGroup(path, uid, gid)
+        }
+        if error
+            callback(Error("setInfo failed:", localpath, error))
+        else
+            callback(false, { ok: true})
+    }
+
+    // setOwnerGroup
+    //
+    //     Set owner/group on a file or directory.
+    
+    files.setOwnerGroup = closure setOwnerGroup(path, uid, gid, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(setOwnerGroup, path, uid, gid))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.chown(localpath, uid, gid, function(err, stat) {
+            if err
+                callback(Error("fs.chown failed:", localpath, err))
+            else
+                callback(false, { ok: true})
+        })
+    }
+
+    // setMode
+    //
+    //     Set mode bits on a file or directory.
+    
+    files.setMode = closure setMode(path, mode, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(setMode, path, mode))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.chmod(localpath, mode, function(err, stat) {
+            if err
+                callback(Error("fs.chmod failed:", localpath, err))
+            else
+                callback(false, { ok: true})
+        })
+    }
+
     // setTimes
     //
-    //     Set timestamps on a file or directory.
+    //     Set timestamps on a file or directory. The timestamps can be dates or numeric seconds.
     
     files.setTimes = closure setTimes(path, atime, mtime, callback, local error, localpath) {
         if !callback
@@ -346,9 +483,6 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         `(error, localpath) = localPath(path)
         if error
             return (asyncResult(callback, error))
-        if !numeric(atime, mtime)
-            return (asyncResult(callback, Error("invalid arguments:", atime, mtime)))
-        localpath = JSpath.resolve(rootpath, localpath)
         fs.utimes(localpath, atime, mtime, function(err, stat) {
             if err
                 callback(Error("fs.utimes failed:", localpath, err))
@@ -375,7 +509,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                     if name {                                               // this record is fetchable
                         ++pending.active
                         filepath = JSpath.join(parentpath, name)
-                        files.info(filepath, function(error, info) {
+                        files.info(filepath, false, function(error, info) {
                             if error
                                 input[kdex].error = error                   // this record failed
                             else
@@ -398,7 +532,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
 
     // dirList
     //
-    // Return array of files in a directory if it exists. If options.head is true then this reads 
+    // Return array of files in a directory if it exists. If options.stat is true then this reads 
     // info for each file as well.
 
     files.dirList = closure dirList(path, options, callback, local error, localpath, output, nodelist, file) {
@@ -426,7 +560,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                 output.children.push({
                     name: file
                 })
-            if options.head
+            if options.stat
                 statfetch(output.children, localpath)                       // read all the info records
             callback(false, output)
         })
@@ -638,7 +772,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
             if dest.slice(-1) == JSpath.sep                                 // new location, else entirely new pathname
                 localdest = JSpath.join(localdest, JSpath.basename(srcpath))
         }
-        fs.lstat(localdest, closure(err, stat, local cmd, args) {
+        fs.stat(localdest, closure(err, stat, local cmd, args) {
             if !err && !options.overwrite
                 callback(Error("copy destination already exists",
                     {
@@ -649,6 +783,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                         existing: localdest
                     }))
             else {
+                debuglog("==> Warning: files.copy needs to be rewritten with fs primitives")
                 if options.move {
                     cmd = "mv"
                     args = [localsrc, localdest] }
@@ -717,6 +852,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     files.minimize = closure minimize(input, callback, local child, stdinStream) {
         if !callback
             return (syncAdapter(minimize, input))
+        debuglog("==> Warning: files.minimize is deprecated")
         child = nodecp.execFile("uglifyjs",
             ["--compress", "drop_debugger=false", "--mangle", "eval"],      // ### uglifyjs options should be parameterized
             function(err, stdout, stderr) {
@@ -742,6 +878,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     files.unzip = closure unzip(inpath, outpath, callback) {
         if !callback
             return (syncAdapter(unzip, inpath, outpath))
+        debuglog("==> Warning: files.unzip is deprecated")
         nodecp.execFile("unzip",
             ["-qo", inpath, "-d", outpath],                                 // quiet; no queries
             { },                                                            // execution options
@@ -757,21 +894,27 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     //
     // touch
     //
-    // Execute the touch utility, returning the result as a standard tuple: `(error, result)
+    // Touch the specified file or directory, returning the result as a standard result tuple
+    // `(error, result). When only the path is specified this sets the last-access and last-modified
+    // times to the current Date(). Otherwise the dates are set to the specified value(s). Note that
+    // this sets the times of a symbolic link file itself, not the file the link points to.
     //
-    files.touch = closure touch(outpath, callback) {
+    files.touch = closure touch(path, atime, mtime, callback, local localpath) {
         if !callback
-            return (syncAdapter(touch, outpath))
-        nodecp.execFile("touch",
-            [outpath],
-            { },                                                            // execution options
-            function(err, stdout, stderr) {
-                if err
-                    callback(Error("touch failed", err, stderr))
-                else
-                    callback(false, { ok: true })
-            }
-        )
+            return (syncAdapter(touch, path, atime, mtime))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        if !atime && !mtime
+            atime = mtime = Date()
+        else if atime && !mtime
+            mtime = atime
+        fs.lutimes(localpath, atime, mtime, function(err) {
+            if err
+                callback(Error("touch failed", err))
+            else
+                callback(false, { ok: true })
+        })
     }
 
     //

package/frameworks/node/psm_server.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2019-2021 by Richard C. Zulch
+ * Copyright (c) 2019-2022 by Richard C. Zulch
  *
  */
 
@@ -32,7 +32,12 @@ closure psmsFsView(rootpath, local view, gitter) {
     //  --  view.readLines(path, options, callback)
     //  --  view.readFile(path, options, callback)
     //  --  view.writeFile(path, data, options, callback)
-    //  --  view.info(path, callback)
+    //  --  view.readlink(path, options, callback)
+    //  --  view.symlink(target, path, options, callback)
+    //  --  view.info(path, options, callback)
+    //  --  view.setInfo(path, info, callback)
+    //  --  view.setOwnerGroup(path, uid, gid, callback)
+    //  --  view.setMode(path, mode, callback)
     //  --  view.setTimes(path, atime, mtime, callback)
     //  --  view.dirList(path, options, callback)
     //  --  view.mkdir(path, callback)
@@ -118,7 +123,18 @@ closure psmsFsView(rootpath, local view, gitter) {
                 options.encoding = req.query.encoding
             res.send(new(array, view.writeFile(path, req.body, options)))
         }
- 
+
+        // op: readlink
+        function readlinkApi() {
+            res.send(new(array, view.readlink(path)))
+        }
+
+        // op: symlink
+        function symlinkApi(local options) {
+            options = { }
+            res.send(new(array, view.symlink(req.query.target, path, options)))
+        }
+
         // op: delete
         function deleteApi(local options) {
             options = {  }
@@ -130,8 +146,26 @@ closure psmsFsView(rootpath, local view, gitter) {
         }
 
         // op: info
-        function infoApi() {
-            res.send(new(array, view.info(path)))
+        function infoApi(local options) {
+            options - { }
+            if req.query.follow
+                options.follow = req.query.follow
+            res.send(new(array, view.info(path, options)))
+        }
+
+        // op: setInfo
+        function setInfoApi() {
+            res.send(new(array, view.setInfo(path, req.body)))
+        }
+
+        // op: setOwnerGroup
+        function setOwnerGroupApi() {
+            res.send(new(array, view.setOwnerGroup(path, req.query.uid, req.query.gid)))
+        }
+
+        // op: setMode
+        function setModeApi() {
+            res.send(new(array, view.setMode(path, req.query.mode)))
         }
 
         // op: setTimes
@@ -141,8 +175,8 @@ closure psmsFsView(rootpath, local view, gitter) {
 
         // op: dirList
         function dirListApi(local options) {
-            if req.query.head
-                options = { head: true }
+            if req.query.stat
+                options = { stat: true }
             res.send(new(array, view.dirList(path, options)))
         }
         
@@ -219,8 +253,13 @@ closure psmsFsView(rootpath, local view, gitter) {
             readFile:       readFileApi
             readLines:      readLinesApi
             writeFile:      writeFileApi
+            readlink:       readlinkApi
+            symlink:        symlinkApi
             delete:         deleteApi
             info:           infoApi
+            setInfo:        setInfoApi
+            setOwnerGroup:  setOwnerGroupApi
+            setMode:        setModeApi
             setTimes:       setTimesApi
             dirList:        dirListApi
             mkdir:          mkdirApi
@@ -263,38 +302,38 @@ closure psmsFsConnector(psm, api, local connClassID, connector, watch) {
     connector.vault = psm.vault(connClassID)
     connector.label = "Naan IDE Server"
     watch = psm.watchable(connector)
-    
-    // hashResourceID
-    //
-    // Make a stable hash based on the resource credentials that we can persist or share between
-    // different domains accessing the same resource.
-    connector.hashResourceID = function hashResourceID(resource, local ident) {
-        ident = resource.urlName
-        if resource.label
-            ident = ident.concat(resource.label)
-        HashSHA256(ident)
-    }
-    
+
     // findResource
     //
-    // Find a resource with the specified contents, returning the resID or false. The loose criteria
-    // is: if added, would the specified contents be redundant to an existing resource?
+    // Find a resource with the specified contents, returning the resID or false.
     connector.findResource = function findResource(resource, local resID, creds) {
         for resID in listResources().1 {
             creds = access(resID).1
-            if resource.urlName == creds.urlName
-                && (!resource.label || resource.label == creds.label)
+            if ((!resource.urlName || resource.urlName == creds.urlName)
+                && (!resource.label || resource.label == creds.label))
                 return (resID)
         }
         false
     }
 
-    // addResource
+    // writeResource
     //
-    // Add credentials for a named resource. This is just a stub at the moment
-
-    connector.addResource = function addResource(resource, local creds, errors, error, resID, data) {
+    // Add or update credentials for a named resource. If no resID is specified this adds a new
+    // resource; otherwise it updates an existing one. The resource is a dictionary comprising these
+    // keys:
+    //      label       - [optional] label we use for this resource
+    //      urlName     - URL (e.g. "http://host.com/node/fsapi")
+    //      authSecret  - access-control token for this URL
+    //      hidden      - [optional] don't enumerate to user
+    //      locked      - [optional] don't allow user delete
+    //
+    // The return value is an (error, resID) tuple. Error, if non-false, is a dictionary of field
+    // keys and error diagnostic strings.
+    connector.writeResource = function writeResource(resource, resID,
+        local creds, errors, error, data, change) {
+        // badField - test for a bad string
         function badField(str) { !string(str) || str.trim().length == 0 }
+
         creds = { urlName: resource.urlName }
         errors = { }
         if resource.label
@@ -303,6 +342,8 @@ closure psmsFsConnector(psm, api, local connClassID, connector, watch) {
             creds.label = resource.urlName
         if badField(creds.label)
             errors.label = "invalid label"
+        else if !resID && findResource({ label: creds.label })
+            errors.label = "duplicate name"
         if badField(resource.urlName)
             errors.urlName = "required field"
         if length(errors) > 0
@@ -312,14 +353,36 @@ closure psmsFsConnector(psm, api, local connClassID, connector, watch) {
                 creds.hidden = resource.hidden
             if resource.locked
                 creds.locked = resource.locked
-            resID =  hashResourceID(resource)
-            `(error, data) = connector.vault.addResource(resID, creds)
+            if resID {
+                `(error, data) = connector.vault.updateResource(resID, creds)
+                change = { changed: [resID] }
+            } else {
+                resID = UUID()
+                `(error, data) = connector.vault.addResource(resID, creds)
+                change = { added: [resID] }
+            }
             if data {
-                watch.notify(connClassID, { added: [resID] })
-                data = resID } }
+                watch.notify(connClassID, change)
+                data = resID
+            }
+        }
         list(error, data)
     }
-        
+
+    // addResource
+    //
+    // Add a new resource, returning a standard error tuple per writeResource.
+    connector.addResource = function addResource(resource) {
+        writeResource(resource)
+    }
+
+    // updateResource
+    //
+    // Update an existing resource, returning a standard error tuple per writeResource.
+    connector.updateResource = function updateResource(resID, resource) {
+        writeResource(resource, resID)
+    }
+
     // getResource
     //
     // Get credentials for a named resource, matching the dictionary semantics of addResource. The

package/frameworks/project/build.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2019-2021 by Richard C. Zulch
+ * Copyright (c) 2019-2022 by Richard C. Zulch
  *
  */
 
@@ -267,15 +267,20 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
     //
     // applySubstitutions
     //
-    // Apply substitutions from readSubstitutionFile to string, returning a new string.
+    // Apply substitutions from readSubstitutionFile to string, returning a tuple of the resulting
+    // text and the number of substitution patterns actually used from the supplied dictionary.
     //
-    function applySubstitutions(text, subs) {
-        text.replace(RegExp("[$][-A-Za-z0-9_./()\\\\]+[$]", "g"), function(match) {
-            if subs[match.slice(1,-1)]
-                { }
+    function applySubstitutions(text, subs, local subbed) {
+        subbed = { }
+        list(text.replace(RegExp("[$][-A-Za-z0-9_./()\\\\]+[$]", "g"), function(match, local subst) {
+            subst = subs[match.slice(1,-1)]
+            if subst {
+                subbed[match] = true
+                subst
+            }
             else
                 match
-        })
+        }), length(subbed))
     }
     
     //
@@ -573,7 +578,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
     //
     // Handling the catenates is a bit tricky. One set of buildrules can have multiple catentates,
     // distinguished by having a unique writepath derived from the destfile parameter. All groups
-    // having the same writepath contribute to a single catenate, with the sources ordere first by
+    // having the same writepath contribute to a single catenate, with the sources ordered first by
     // group number (low to high) and then order in the source list, first to last. If any component
     // contributing to a catenate is out-of-date with respect to it then they are all built and
     // combined into the single output file. This computes a set of ordering integers for the parts
@@ -649,13 +654,13 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
                             outfile = JSpath.join(outdirpath, group.destfile)
                         else
                             outfile = JSpath.join(outdirpath, source)
-                        fs.info(infile, function(error, instat, local listing, addgroup, file) {
+                        fs.info(infile, false, function(error, instat, local listing, addgroup, file) {
                             if error
                                 build.errorlist.push(error)
                             else if instat.type != "directory"
                                 addEntry(infile, outfile, instat, sdex)     // add execution entry if needed
                             else {                                          // add a new group for directory source
-                                `(error, listing) = fs.dirList(infile, { head: true })
+                                `(error, listing) = fs.dirList(infile, { stat: true })
                                 if error
                                     build.errorlist.push(error)
                                 else {
@@ -754,19 +759,20 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
                     entry.zip = true
                     if !entry.writepath.toLowerCase().endsWith(".zip")
                         entry.writepath = entry.writepath.concat(".zip")    // always ends with .zip
+                    outfile = entry.writepath
                 }
                 if entry.catenate || entry.zip {
                     entry.catorder = group.groupno * sourcemax + sdex       // order of groups then sources
                     if build.testats[outfile] && instat.mtimeMs < build.testats[outfile].mtimeMs
                         instat = build.testats[outfile]                     // make source at least as recent as template
-                } else
+                } else if !entry.unzip
                     entry.writepath = outfile
                 ++pending.active
                 if destcheck {                                              // destcheck is special target for determining if task needed
                     entry.destcheck = JSpath.join(outdirpath, destcheck.pop())
-                    fs.info(entry.destcheck, addIfOutOfDate)
+                    fs.info(entry.destcheck, false, addIfOutOfDate)
                 } else
-                    fs.info(outfile, addIfOutOfDate)
+                    fs.info(outfile, false, addIfOutOfDate)
                     
                 function addIfOutOfDate(error, outstat, local entryop) {
                     if error || toint(instat.mtimeMs) > toint(outstat.mtimeMs) {
@@ -861,9 +867,8 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
                     if error
                         build.errorlist.push(error)
                     else if content.startsWith("$$")                        // prefix to cause version substitution
-                        build.templates[writepath] = applySubstitutions(content.slice(2), verFileDefs)
-                    else
-                        build.templates[writepath] = content
+                        `(content) = applySubstitutions(content.slice(2), verFileDefs)
+                    build.templates[writepath] = content
                 }
             } ()
         }
@@ -890,13 +895,21 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
                     `(error, result) = fs.unzip(entry.readpath, entry.writepath)   // unzip source into destination
                     if !error && entry.destcheck
                         fs.touch(entry.destcheck)                           // show we completed
-                } else if entry.copy
-                    `(error, result) = fs.copy(entry.readpath, entry.writepath, { overwrite: true })     // copy file from source into destination
+                } else if entry.copy {
+                    `(error, result) = fs.util.deepcopy(entry.readpath, false, fs, dirpath, {
+                        erase: true                                         // not really needed
+                        overwrite: true                                     // overwrite files
+                        force: true                                         // ignore modify date
+                        preserve: true                                      // preserve attributes
+                    })
+                    if error                                                // deepcopy returns a list of errors
+                        error = error.0                                     // but we're only doing one item
+                }
                 else if ((`(error, content) = fs.readFile(entry.readpath)) && !error) {
                     if entry.license
-                        content = applySubstitutions(content, licFileDefs)
+                        `(content) = applySubstitutions(content, licFileDefs)
                     if entry.version
-                        content = applySubstitutions(content, verFileDefs)
+                        `(content) = applySubstitutions(content, verFileDefs)
                     if entry.naanpack
                         `(error, content) = parseAndPack(content, entry.readpath, { naanpack: true })
                     else if entry.jspack
@@ -962,11 +975,15 @@ closure Builder(rules, operation, fs, srcpath, destpath, local build, group, new
                         docat = true
                 }
                 if docat {                                                  // catenate the files
-                    if template
-                        content = applySubstitutions(template, catsub)
+                    if template {
+                        `(content, result) = applySubstitutions(template, catsub)
+                        if length(catsub) != result
+                            build.errorlist.push(Error("Matched ", result, " of ", length(catsub),
+                                "substitutions in template:", build.tepaths[writepath]))
+                    }
                     else
                         content = catenates[writepath].map(function(entry){entry.content}).join("\n")
-                    if zip {
+                    if dozip {
                         zipmap = { }
                         zipmap[JSpath.basename(writepath)] = content
                         `(error, content) = zip(zipmap)                     // compress the catenated file