Merge branch 'master' into emilio/luis

Author: munozemilio

package.json

@@ -1,5 +1,6 @@
 {
   "name": "root",
+  "version": "1.0.0",
   "scripts": {
     "build": "lerna run build && lerna bootstrap",
     "test": "lerna run test",

packages/luis/README.md

@@ -11,6 +11,8 @@
 # Commands
 <!-- commands -->
 * [`bf luis:convert`](#bf-luisconvert)
+* [`bf luis:generate:cs`](#bf-luisgeneratecs)
+* [`bf luis:generate:ts`](#bf-luisgeneratets)
 * [`bf luis:translate`](#bf-luistranslate)
 * [`bf qnamaker:convert`](#bf-qnamakerconvert)
 * [`bf qnamaker:translate`](#bf-qnamakertranslate)
@@ -38,6 +40,38 @@ OPTIONS
 
 _See code: [src/commands/luis/convert.ts](https://github.com/microsoft/botframework-cli/blob/v1.0.0/src/commands/luis/convert.ts)_
 
+## `bf luis:generate:cs`
+
+Generate:cs generates a strongly typed C# source code from an exported (json) LUIS model.
+
+```
+USAGE
+  $ bf luis:generate:cs
+
+OPTIONS
+  --className=className  Name of the class
+  --in=in                Source .lu file(s) or LUIS application JSON model
+  --out=out              Output file or folder name. If not specified stdout will be used as output
+```
+
+_See code: [src/commands/luis/generate/cs.ts](https://github.com/microsoft/botframework-cli/blob/v1.0.0/src/commands/luis/generate/cs.ts)_
+
+## `bf luis:generate:ts`
+
+Generate:ts generates a strongly typed typescript source code from an exported (json) LUIS model.
+
+```
+USAGE
+  $ bf luis:generate:ts
+
+OPTIONS
+  --className=className  Name of the class
+  --in=in                Source .lu file(s) or LUIS application JSON model
+  --out=out              Output file or folder name. If not specified stdout will be used as output
+```
+
+_See code: [src/commands/luis/generate/ts.ts](https://github.com/microsoft/botframework-cli/blob/v1.0.0/src/commands/luis/generate/ts.ts)_
+
 ## `bf luis:translate`
 
 Translate given LUIS application JSON model or lu file(s)

packages/luis/package.json

@@ -7,15 +7,17 @@
   "dependencies": {
     "@microsoft/bf-cli-command": "1.0.0",
     "@oclif/config": "~1.13.3",
+    "antlr4": "^4.7.2",
     "chalk": "2.4.1",
+    "console-stream": "^0.1.1",
     "deep-equal": "^1.0.1",
     "fs-extra": "^8.1.0",
     "get-stdin": "^6.0.0",
     "intercept-stdout": "^0.1.2",
+    "lodash": "^4.17.15",
     "node-fetch": "^2.1.2",
     "semver": "^5.5.1",
-    "tslib": "^1.10.0",
-    "antlr4": "^4.7.2"
+    "tslib": "^1.10.0"
   },
   "devDependencies": {
     "@oclif/dev-cli": "^1.22.2",

packages/luis/src/commands/luis/generate/cs.ts

@@ -0,0 +1,57 @@
+import {Command, flags} from '@microsoft/bf-cli-command'
+import {camelCase, upperFirst} from 'lodash'
+import * as path from 'path'
+
+import {LuisToCsConverter} from '../../../parser/converters/luis-to-cs-converter'
+import {Utils} from '../../../utils'
+
+const fs = require('fs-extra')
+
+export default class LuisGenerateCs extends Command {
+  static description = 'Generate:cs generates a strongly typed C# source code from an exported (json) LUIS model.'
+
+  static flags: flags.Input<any> = {
+    in: flags.string({description: 'Source .lu file(s) or LUIS application JSON model'}),
+    out: flags.string({description: 'Output file or folder name. If not specified stdout will be used as output', default: ''}),
+    className: flags.string({description: 'Name of the class'}),
+  }
+
+  reorderEntities(app: any, name: string): void {
+    if (app[name] !== null && app[name] !== undefined) {
+      app[name].sort((a: any, b: any) => (a.name > b.name ? 1 : -1))
+    }
+  }
+
+  async run() {
+    const {flags} = this.parse(LuisGenerateCs)
+    let space = 'Luis'
+    let stdInput = await this.readStdin()
+
+    const pathPrefix = path.isAbsolute(flags.in) ? '' : process.cwd()
+    const app = stdInput ? JSON.parse(stdInput as string) : await fs.readJSON(path.join(pathPrefix, flags.in))
+
+    flags.className = flags.className || app.name
+    flags.className = upperFirst(camelCase(flags.className))
+
+    const dot_index = flags.className ? flags.className.indexOf('.') : -1
+    if (dot_index !== -1) {
+      space = flags.className.substr(dot_index + 1)
+      flags.className = flags.className.substr(0, dot_index)
+    }
+
+    this.reorderEntities(app, 'entities')
+    this.reorderEntities(app, 'prebuiltEntities')
+    this.reorderEntities(app, 'closedLists')
+    this.reorderEntities(app, 'regex_entities')
+    this.reorderEntities(app, 'patternAnyEntities')
+    this.reorderEntities(app, 'composites')
+
+    const outputPath = Utils.validatePath(flags.out, process.cwd(), flags.className + '.cs')
+
+    this.log(
+      `Generating file at ${outputPath || ''} that contains class ${space}.${flags.className}.`
+    )
+
+    await LuisToCsConverter.writeFromLuisJson(app, flags.className, space, outputPath)
+  }
+}

packages/luis/src/commands/luis/generate/ts.ts

@@ -0,0 +1,50 @@
+import {Command, flags} from '@microsoft/bf-cli-command'
+import {camelCase, kebabCase, upperFirst} from 'lodash'
+import * as path from 'path'
+
+import {LuisToTsConverter} from '../../../parser/converters/luis-to-ts-converter'
+import {Utils} from '../../../utils'
+
+const fs = require('fs-extra')
+
+export default class LuisGenerateTs extends Command {
+  static description = 'Generate:ts generates a strongly typed typescript source code from an exported (json) LUIS model.'
+
+  static flags: flags.Input<any> = {
+    in: flags.string({description: 'Source .lu file(s) or LUIS application JSON model'}),
+    out: flags.string({description: 'Output file or folder name. If not specified stdout will be used as output', default: ''}),
+    className: flags.string({description: 'Name of the class'}),
+  }
+
+  reorderEntities(app: any, name: string): void {
+    if (app[name] !== null && app[name] !== undefined) {
+      app[name].sort((a: any, b: any) => (a.name > b.name ? 1 : -1))
+    }
+  }
+
+  async run() {
+    const {flags} = this.parse(LuisGenerateTs)
+    let stdInput = await this.readStdin()
+
+    const pathPrefix = path.isAbsolute(flags.in) ? '' : process.cwd()
+    const app = stdInput ? JSON.parse(stdInput as string) : await fs.readJSON(path.join(pathPrefix, flags.in))
+
+    flags.className = flags.className || app.name
+    flags.className = upperFirst(camelCase(flags.className))
+
+    this.reorderEntities(app, 'entities')
+    this.reorderEntities(app, 'prebuiltEntities')
+    this.reorderEntities(app, 'closedLists')
+    this.reorderEntities(app, 'regex_entities')
+    this.reorderEntities(app, 'patternAnyEntities')
+    this.reorderEntities(app, 'composites')
+
+    const outputPath = Utils.validatePath(flags.out, process.cwd(), kebabCase(flags.className) + '.ts')
+
+    this.log(
+      `Generating file at ${outputPath || ''} that contains class ${flags.className}.`
+    )
+
+    await LuisToTsConverter.writeFromLuisJson(app, flags.className, outputPath)
+  }
+}

packages/luis/src/parser/converters/helpers/writer.ts

@@ -0,0 +1,104 @@
+import {createWriteStream, WriteStream} from 'fs'
+import {Writable} from 'stream'
+
+export class Writer {
+  public indentSize = 4
+  public indentLevel = 0
+  private outputStream?: Writable = undefined
+
+  public async setOutputStream(outputPath: string): Promise<void> {
+    const ConsoleStream = require('console-stream')
+    const stream: Writable = outputPath ? createWriteStream(outputPath) : ConsoleStream()
+    const streamPromise = new Promise((resolve: any) => {
+      if (stream instanceof WriteStream) {
+        stream.once('ready', (_fd: number) => {
+          this.outputStream = stream
+          resolve()
+        })
+      } else {
+        this.outputStream = stream
+        resolve()
+      }
+    })
+
+    const timeoutPromise = new Promise((resolve: (...args: any) => void) => {
+      setTimeout(resolve, 2000)
+      this.outputStream = stream
+    })
+
+    return Promise.race([streamPromise, timeoutPromise]).then(() => {
+    })
+  }
+
+  public increaseIndentation(): void {
+    this.indentLevel += this.indentSize
+  }
+
+  public decreaseIndentation(): void {
+    this.indentLevel -= this.indentSize
+  }
+
+  public write(str: string): void {
+    this.outputStream!.write(str)
+  }
+
+  public writeLine(str: string | string[] = ''): void {
+    if (typeof str === 'string') {
+      this.write(str + '\n')
+    } else {
+      str.forEach(line => {
+        this.write(line + '\n')
+      })
+    }
+  }
+
+  public writeIndented(str: string | string[]): void {
+    let writeFunction = (text: string) => {
+      for (let index = 0; index < this.indentLevel; index++) {
+        this.write(' ')
+      }
+      this.write(text)
+    }
+
+    writeFunction.bind(this)
+
+    if (typeof str === 'string') {
+      writeFunction(str)
+    } else {
+      str.forEach(line => {
+        writeFunction(line)
+      })
+    }
+  }
+
+  public writeLineIndented(lines: string | string[]): void {
+    if (typeof lines === 'string') {
+      this.writeIndented(lines + '\n')
+    } else {
+      lines.forEach(line => {
+        this.writeIndented(line + '\n')
+      })
+    }
+  }
+
+  public async closeOutputStream(): Promise<void> {
+    this.outputStream!.end()
+    const streamPromise = new Promise((resolve: any) => {
+      if (this.outputStream instanceof WriteStream) {
+        this.outputStream!.on('finish', (_fd: number) => {
+          resolve()
+        })
+      } else {
+        resolve()
+      }
+    })
+
+    const timeoutPromise = new Promise((resolve: (...args: any) => void) => {
+      setTimeout(resolve, 1000)
+    })
+
+    return Promise.race([streamPromise, timeoutPromise]).then(() => {
+      this.outputStream = undefined
+    })
+  }
+}