Add the ability to override generated templates (#500)

in order to support transform scenarios.

Author: Chris McConnell

packages/cli/test/fixtures/lastversioncheck/package.json

@@ -14,5 +14,5 @@
       "init": "../../../src/hooks/init/inithook"
     }
   },
-  "lastversioncheck": "2020-01-27T19:18:56.498Z"
+  "lastversioncheck": "2020-01-28T20:21:57.736Z"
 }

packages/dialog/src/commands/dialog/generate.ts

@@ -24,7 +24,7 @@ export default class GenerateDialog extends Command {
         locale: flags.string({ char: 'l', description: 'Locales to generate. [default: en-us]', multiple: true }),
         output: flags.string({ char: 'o', description: 'Output path for where to put generated .lu, .lg, .qna and .dialog files. [default: .]', default: '.', required: false }),
         schema: flags.string({ char: 's', description: 'Path to your app.schema file.', required: false }),
-        templates: flags.string({ char: 't', description: 'Directory with templates to use for generating assets.', multiple: true }),
+        templates: flags.string({ char: 't', description: 'Directory with templates to use for generating assets.  With multiple directories, the first definition found wins.  To include the standard templates, just use "standard" as a template directory name.', multiple: true }),
         verbose: flags.boolean({ description: 'Output verbose logging of files as they are processed', default: false }),
     }
 

packages/dialog/src/commands/dialog/readme.md

@@ -30,7 +30,7 @@ The generate command generates .lu, .lg, .qna and .dialog assets from a schema d
 - **--locale, -l** Locales to generate. By default en-us.
 - **--output, -o** Output directory.
 - **--schema, -s** Path to your app.schema file. By default is the standard SDK app.schema.
-- **--templates, -t** Directories with templates to use for generating assets.
+- **--templates, -t** Directories with templates to use for generating assets.  First definition wins.  A directory of "standard" includes the standard templates included with the tool.
 - **--verbose, -v** Verbose logging of generated files.
 
 ### Schema

packages/dialog/src/library/dialogGenerator.ts

@@ -124,6 +124,8 @@ async function processLibraryTemplates(template: string, outPath: string, templa
     }
 }
 
+// Add entry to the .lg generation context and return it.  
+// This also ensures the file does not exist already.
 type FileRef = { name: string, fallbackName: string, fullName: string, relative: string }
 function addEntry(fullPath: string, outDir: string, tracker: any): FileRef | undefined {
     let ref: FileRef | undefined
@@ -181,6 +183,13 @@ async function processTemplate(
                                     filename = template.evaluateTemplate('filename', scope)
                                 }
                             }
+
+                            // See if generated file has been overridden in templates
+                            let existing = await findTemplate(filename, templateDirs, scope.locale)
+                            if (existing) {
+                                result = existing
+                            }
+
                             result = await processLibraryTemplates(result as string, outPath, templateDirs, outDir, scope, force, feedback)
                             let dir = ppath.dirname(outPath)
                             await fs.ensureDir(dir)
@@ -271,7 +280,7 @@ function expandSchema(schema: any, scope: any, path: string, inProperties: boole
             if (inProperties) {
                 newPath += newPath === '' ? key : '.' + key;
             }
-            let newVal = expandSchema(val, { ...scope, property: newPath}, newPath, key === 'properties', missingIsError, feedback)
+            let newVal = expandSchema(val, { ...scope, property: newPath }, newPath, key === 'properties', missingIsError, feedback)
             newSchema[key] = newVal
         }
     } else if (typeof schema === 'string' && schema.startsWith('@{')) {
@@ -294,9 +303,21 @@ function expandSchema(schema: any, scope: any, path: string, inProperties: boole
     return newSchema
 }
 
+function expandStandard(dirs: string[]): string[] {
+    let expanded: string[] = []
+    for (let dir of dirs) {
+        if (dir === 'standard') {
+            dir = ppath.join(__dirname, '../../templates')
+        }
+        expanded.push(dir)
+    }
+    return expanded;
+}
+
 /**
  * Iterate through the locale templates and generate per property/locale files.
  * Each template file will map to <filename>_<property>.<ext>.
+ * @param schemaPath Path to JSON Schema to use for generation.
  * @param outDir Where to put generated files.
  * @param metaSchema Schema to use when generating .dialog files
  * @param allLocales Locales to generate.
@@ -330,7 +351,7 @@ export async function generate(
     }
 
     if (!templateDirs) {
-        templateDirs = [ppath.join(__dirname, '../../templates')]
+        templateDirs = ['standard']
     }
 
     let op = 'Regenerating'
@@ -343,6 +364,7 @@ export async function generate(
     feedback(FeedbackType.message, `Templates: ${JSON.stringify(templateDirs)} `)
     feedback(FeedbackType.message, `App.schema: ${metaSchema} `)
     try {
+        templateDirs = expandStandard(templateDirs)
         await fs.ensureDir(outDir)
         let schema = await processSchemas(schemaPath, templateDirs, feedback)
         schema.schema = expandSchema(schema.schema, {}, '', false, false, feedback)

packages/dialog/src/library/processSchemas.ts

@@ -21,6 +21,7 @@ async function templateSchemas(templateDirs: string[], feedback: fg.Feedback): P
             let schema = await getSchema(file, feedback)
             let id: string = schema.$id || ppath.basename(file)
             if (!map[id]) {
+                // First definition found wins
                 map[id] = schema
             }
         }

packages/dialog/test/commands/dialog/generator.test.ts

@@ -12,31 +12,48 @@ import * as os from 'os'
 import * as ppath from 'path'
 import * as ft from '../../../src/library/schema'
 import * as gen from '../../../src/library/dialogGenerator'
-import { fail } from 'assert';
+import * as assert from 'assert';
 
 describe('dialog:generate', async () => {
     let output = ppath.join(os.tmpdir(), 'sandwich.out')
     let schemaPath = 'test/commands/dialog/forms/sandwich.schema'
     let badSchema = 'test/commands/dialog/forms/bad-schema.schema'
     let notObject = 'test/commands/dialog/forms/not-object.schema'
+    let override = 'test/commands/dialog/templates/override'
+
     beforeEach(async () => {
         await fs.remove(output)
     })
 
+    it('Generation with override', async () => {
+        try {
+            await gen.generate(schemaPath, output, undefined, ['en-us'], [override, 'standard'], false, (type, msg) => {
+                console.log(`${type}: ${msg}`)
+            })
+            let lg = await fs.readFile(ppath.join(output, 'en-us', 'sandwich-Bread.en-us.lg'))
+            assert.ok(lg.toString().includes('What kind of bread?'), 'Did not override locale generated file')
+            let dialog = await fs.readFile(ppath.join(output, 'sandwich-BreadAsk.dialog'))
+            assert.ok(!dialog.toString().includes('priority'), 'Did not override top-level file')
+        } catch (e) {
+            assert.fail(e.message)
+        }
+    })
+
     it('Generation', async () => {
         try {
             await gen.generate(schemaPath, output, undefined, ['en-us'], undefined, false, (type, msg) => {
                 console.log(`${type}: ${msg}`)
             })
         } catch (e) {
-            fail(e.message)
+            assert.fail(e.message)
         }
     })
 
+
     it('Not object type', async () => {
         try {
             await ft.Schema.readSchema(notObject)
-            fail('Did not detect bad schema');
+            assert.fail('Did not detect bad schema');
         } catch (e) {
             expect(e.message).to.contain('must be of type object')
         }
@@ -45,7 +62,7 @@ describe('dialog:generate', async () => {
     it('Illegal schema', async () => {
         try {
             await ft.Schema.readSchema(badSchema)
-            fail('Did not detect bad schema');
+            assert.fail('Did not detect bad schema');
         } catch (e) {
             expect(e.message).to.contain('is not a valid JSON Schema')
         }

packages/dialog/test/commands/dialog/templates/override/en-us/sandwich-Bread.en-us.lg

@@ -0,0 +1,12 @@
+# AskBread
+- What kind of bread?
+
+# BreadName
+- bread
+
+# Bread(val)
+- @{BreadEntity(val)}
+
+[sandwich-BreadEntity.lg](sandwich-BreadEntity.lg)
+
+[sandwich-common.lg](sandwich-common.lg)

packages/dialog/test/commands/dialog/templates/override/sandwich-BreadAsk.dialog

@@ -0,0 +1,15 @@
+
+{
+    "$schema": "https://raw.githubusercontent.com/microsoft/botbuilder-dotnet/master/schemas/sdk.schema",
+    "$kind": "Microsoft.OnEndOfActions",
+    "condition":"!$Bread",
+    "actions": [       
+        {
+            "$kind": "Microsoft.Ask",
+            "activity": "@{AskBread()}",
+            "expectedProperties": [
+                "Bread"
+            ]
+        }
+    ]
+}