Add support to keep original file permissions of template/sdk files

languages/c/language.config.json

@@ -10,5 +10,6 @@
         "/include/Common/Module.h",
         "/src/Module_Common.cpp",
         "/src/JsonData_Module.h"
-    ]
-}
+    ],
+    "persistPermission": true
+}

src/macrofier/index.mjs

@@ -18,7 +18,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { emptyDir, readDir, readFiles, readJson, writeFiles, writeText } from '../shared/filesystem.mjs'
+import { emptyDir, readDir, readFiles, readFilesPermissions, readJson,
+         writeFiles, writeFilesPermissions, writeText } from '../shared/filesystem.mjs'
 import { getTemplate, getTemplateForModule } from '../shared/template.mjs'
 import { getModule, hasPublicAPIs } from '../shared/modules.mjs'
 import { logHeader, logSuccess } from '../shared/io.mjs'
@@ -42,6 +43,7 @@ const macrofy = async (
         staticContent,
         templatesPerModule,
         templatesPerSchema,
+        persistPermission,
         createModuleDirectories,
         copySchemasIntoModules,
         aggregateFile,
@@ -87,6 +89,12 @@ const macrofy = async (
         const sharedTemplateList = await readDir(sharedTemplates, { recursive: true })
         const templates = Object.assign(await readFiles(sharedTemplateList, sharedTemplates),
                                         await readFiles(sdkTemplateList, template)) // sdkTemplates are second so they win ties
+        let templatesPermission = {}
+        if (persistPermission) {
+            templatesPermission = Object.assign(await readFilesPermissions(sharedTemplateList, sharedTemplates),
+                                        await readFilesPermissions(sdkTemplateList, template))
+        }
+
         const exampleTemplates = {}
         for (var i=0; i<examples.length; i++) {
             const example = examples[i]
@@ -135,9 +143,14 @@ const macrofy = async (
 
                 const content = engine.insertAggregateMacros(templates[file], aggregateMacros)
                 outputFiles[path.join(output, outputFile)] = content
-
+                if (persistPermission) {
+                    templatesPermission[path.join(output, outputFile)] = templatesPermission[file]
+                }
                 logSuccess(`Generated macros for file ${path.relative(output, path.join(output, outputFile))}`)
             }
+            if (persistPermission) {
+                delete templatesPermission[file]
+            }
         })
 
         let append = false
@@ -262,7 +275,10 @@ const macrofy = async (
             await emptyDir(output)
         }
 
-        await writeFiles(outputFiles)    
+        await writeFiles(outputFiles)
+        if (persistPermission) {
+            await writeFilesPermissions(templatesPermission)
+        }
         logSuccess(`Wrote ${Object.keys(outputFiles).length} files.`)
 
         resolve()

src/sdk/index.mjs

@@ -57,6 +57,7 @@ const run = async ({
     staticContent:      path.join(language, 'src', 'shared'),
     templatesPerModule: config.templatesPerModule,
     templatesPerSchema: config.templatesPerSchema,
+    persistPermission: config.persistPermission,
     operators: config.operators,
     createModuleDirectories: config.createModuleDirectories,
     copySchemasIntoModules: config.copySchemasIntoModules,
@@ -70,4 +71,4 @@ const run = async ({
   })
 }
 
-export default run
+export default run

src/shared/filesystem.mjs

@@ -1,9 +1,11 @@
 import path from 'path'
-import { readFile, writeFile, readdir } from 'fs/promises'
-import { lstatSync } from 'fs'
+import { readFile, writeFile, readdir, stat } from 'fs/promises'
+import { lstatSync, chmodSync } from 'fs'
 import { emptyDir } from 'fs-extra'
 import { mkdirpSync as mkdirSync } from 'fs-extra'
 
+const setPermission = (ref, mode) => chmodSync(ref, mode)
+
 const readText = ref => readFile(ref)
                         .then(resp => resp.toString())
 
@@ -39,6 +41,34 @@ const readDir = async (ref, options) => {
 
     return results.sort()
 }
+const getIndex = (refs, base) => {
+    let index = base ? base.length : 0
+    if (base && !refs[0].startsWith(base)) {
+        refs = refs.map(v => path.relative(base, v))
+        index = 0
+    }
+    else if (index === 0 && refs.length !== 1) {
+        // find the common prefix of all the files
+        while ((new Set(refs.map(r => r[index]))).size === 1) {
+            index++
+        }
+        // back up one dirctory from the common prefix
+        index = path.join(path.join(refs[0].substring(0, index)), '..').length
+    }
+    return index
+}
+
+const readFilesPermissions = (refs, base) => Promise.all(refs.map(ref => stat(ref)))
+                            .then(permissions => {
+                                if (!refs || refs.length === 0) {
+                                    return Promise.resolve({})
+                                }
+                                const results = refs.map(v => [v.substring(getIndex(refs, base)), null])
+                                for (let i=0; i<refs.length; i++) {
+                                    results[i][1] = permissions[i].mode
+                                }
+                                return Promise.resolve(Object.fromEntries(results))
+                            })
 
 const binFormats = [ '.png', '.jpg', '.gif' ]
 
@@ -47,23 +77,7 @@ const readFiles = (refs, base) => Promise.all(refs.map(ref => readFile(ref)))
                                 if (!refs || refs.length === 0) {
                                     return Promise.resolve({})
                                 }
-
-                                let index = base ? base.length : 0
-                                if (base && !refs[0].startsWith(base)) {
-                                    refs = refs.map(v => path.relative(base, v))
-                                    index = 0
-                                }
-                                else if (index === 0 && refs.length !== 1) {
-                                    // find the common prefix of all the files
-                                    while ((new Set(refs.map(r => r[index]))).size === 1) {
-                                        index++
-                                    }
-
-                                    // back up one dirctory from the common prefix
-                                    index = path.join(path.join(refs[0].substring(0, index)), '..').length
-                                }
-
-                                const results = refs.map(v => [v.substring(index), null])
+                                const results = refs.map(v => [v.substring(getIndex(refs, base)), null])
                                 for (let i=0; i<refs.length; i++) {
                                     if (binFormats.find(suffix => refs[i].endsWith(suffix))) {
                                         results[i][1] = contents[i]
@@ -83,6 +97,11 @@ const writeFiles = (files) => {
             .map( ([file, contents]) => writeText(file, contents)))
 }
 
+const writeFilesPermissions = (files) => {
+    return Promise.all(Object.entries(files)
+            .map( ([file, mode]) => setPermission(file, mode)))
+}
+
 export {
     readText,
     writeText,
@@ -91,5 +110,7 @@ export {
     readDir,
     readFiles,
     writeFiles,
-    emptyDir
-}
+    emptyDir,
+    readFilesPermissions,
+    writeFilesPermissions
+}