From 5701081b9210451efb1a99f2f8d327a2a1480951 Mon Sep 17 00:00:00 2001 From: t-hahan Date: Tue, 13 Aug 2019 17:01:28 +0800 Subject: [PATCH 01/11] LGgen basic structure + LG interface --- packages/LGgen/LGgen.sln | 25 +++++++++++ packages/LGgen/LGgen/LGgen.csproj | 12 +++++ packages/LGgen/LGgen/Program.cs | 75 +++++++++++++++++++++++++++++++ packages/LGgen/LGgen/csharp.cs | 18 ++++++++ 4 files changed, 130 insertions(+) create mode 100644 packages/LGgen/LGgen.sln create mode 100644 packages/LGgen/LGgen/LGgen.csproj create mode 100644 packages/LGgen/LGgen/Program.cs create mode 100644 packages/LGgen/LGgen/csharp.cs diff --git a/packages/LGgen/LGgen.sln b/packages/LGgen/LGgen.sln new file mode 100644 index 000000000..ca6d4d497 --- /dev/null +++ b/packages/LGgen/LGgen.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29201.188 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen", "LGgen\LGgen.csproj", "{78727352-DA0F-4E1C-A57B-F1D11A2B2138}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Debug|Any CPU.Build.0 = Debug|Any CPU + {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Release|Any CPU.ActiveCfg = Release|Any CPU + {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {BD0D2E7C-4996-4B68-9932-40ECB6B0CE64} + EndGlobalSection +EndGlobal diff --git a/packages/LGgen/LGgen/LGgen.csproj b/packages/LGgen/LGgen/LGgen.csproj new file mode 100644 index 000000000..c9d173967 --- /dev/null +++ b/packages/LGgen/LGgen/LGgen.csproj @@ -0,0 +1,12 @@ + + + + Exe + netcoreapp2.1 + + + + + + + diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs new file mode 100644 index 000000000..ca1cd4173 --- /dev/null +++ b/packages/LGgen/LGgen/Program.cs @@ -0,0 +1,75 @@ +using System; +using System.Reflection; +using System.Resources; +using System.Runtime; +using System.Runtime.Serialization.Formatters; + +namespace LGgen +{ + class Program + { + static void Usage() + { + Console.Error.WriteLine("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH]"); + Console.Error.WriteLine("Generate a strongly typed class from a LG file"); + Console.Error.WriteLine("-l cs/ts : select C# or Typescript."); + Console.Error.WriteLine("-i : LG file path"); + Console.Error.WriteLine("-o : output path, defaults to directory where LG file is and the same name with LG file"); + System.Environment.Exit(-1); + } + + static void Main(string[] args) + { + string lang = null; + string input = null; + string output = null; + //Usage(); + + if (args == null) Usage(); + + + for (var i = 0; i < args.Length; ++i) + { + var arg = args[i]; + switch(arg) + { + case "-l" : + lang = args[++i]; + break; + + case "-i" : + input = args[++i]; + break; + + case "-o" : + if (args.Length == i + 1) + { + output = input.Substring(0, input.IndexOf('.')); + switch(lang) + { + case "cs": + output += ".cs"; + break; + case "ts": + output += ".ts"; + break; + } + } + else + { + output = args[++i]; + } + break; + default: + Usage(); + break; + } + }; + + CSharp.test(); + + + + } + } +} diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs new file mode 100644 index 000000000..d6e055a28 --- /dev/null +++ b/packages/LGgen/LGgen/csharp.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Microsoft.Bot.Builder.LanguageGeneration; + +namespace LGgen +{ + class CSharp + { + public static void test() + { + TemplateEngine lgEngine = new TemplateEngine(); + lgEngine.AddFile("C:/Users/t-hahan/Desktop/New folder/mytest.lg"); + lgEngine.Templates.ForEach(num => Console.WriteLine(num.Name)); + + } + } +} From 01ea5f3f71cd239f6fba935bc1cbf2f1997d1c4f Mon Sep 17 00:00:00 2001 From: t-hahan Date: Wed, 14 Aug 2019 17:39:34 +0800 Subject: [PATCH 02/11] user interface change & generate class file --- packages/LGgen/LGgen/LGgenTest.cs | 1 + packages/LGgen/LGgen/Program.cs | 81 +++++++++++++++++++++--------- packages/LGgen/LGgen/Writer.cs | 70 ++++++++++++++++++++++++++ packages/LGgen/LGgen/csharp.cs | 25 +++++++-- packages/LGgen/LGgen/lgtemplate.cs | 9 ++++ packages/LGgen/LGgen/lgtemplate.lg | 10 ++++ 6 files changed, 168 insertions(+), 28 deletions(-) create mode 100644 packages/LGgen/LGgen/LGgenTest.cs create mode 100644 packages/LGgen/LGgen/Writer.cs create mode 100644 packages/LGgen/LGgen/lgtemplate.cs create mode 100644 packages/LGgen/LGgen/lgtemplate.lg diff --git a/packages/LGgen/LGgen/LGgenTest.cs b/packages/LGgen/LGgen/LGgenTest.cs new file mode 100644 index 000000000..5f282702b --- /dev/null +++ b/packages/LGgen/LGgen/LGgenTest.cs @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index ca1cd4173..7f4100168 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -3,6 +3,9 @@ using System.Resources; using System.Runtime; using System.Runtime.Serialization.Formatters; +using Microsoft.Bot.Builder.LanguageGeneration; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; namespace LGgen { @@ -10,11 +13,12 @@ class Program { static void Usage() { - Console.Error.WriteLine("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH]"); + Console.Error.WriteLine("LGgen [-l cs/ts] [-n CLASS_NAME] [-i LG_FILE_PATH] [-o OUTPUT_PATH]"); Console.Error.WriteLine("Generate a strongly typed class from a LG file"); Console.Error.WriteLine("-l cs/ts : select C# or Typescript."); Console.Error.WriteLine("-i : LG file path"); Console.Error.WriteLine("-o : output path, defaults to directory where LG file is and the same name with LG file"); + Console.Error.WriteLine("-n : designate class name, defaults to the same name of LG file"); System.Environment.Exit(-1); } @@ -23,6 +27,7 @@ static void Main(string[] args) string lang = null; string input = null; string output = null; + string classname = null; //Usage(); if (args == null) Usage(); @@ -31,45 +36,75 @@ static void Main(string[] args) for (var i = 0; i < args.Length; ++i) { var arg = args[i]; - switch(arg) + switch (arg) { - case "-l" : + case "-l": lang = args[++i]; break; - case "-i" : + case "-i": input = args[++i]; break; - case "-o" : - if (args.Length == i + 1) - { - output = input.Substring(0, input.IndexOf('.')); - switch(lang) - { - case "cs": - output += ".cs"; - break; - case "ts": - output += ".ts"; - break; - } - } - else - { - output = args[++i]; - } + case "-n": + classname = args[++i]; break; + + case "-o": + output = args[++i]; + break; + default: Usage(); break; } + }; - CSharp.test(); + if(output == null) + { + output = input.Substring(0, input.IndexOf('.')); + switch (lang) + { + case "cs": + output += ".cs"; + break; + case "ts": + output += ".ts"; + break; + } + } + if(classname == null) + { + classname = FindClassName(input); + } + + + TemplateEngine lgEngine = new TemplateEngine(); + lgEngine.AddFile(input); + List lgtemplatename = new List(); + lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); + Console.WriteLine($"generating class file {output}"); + + if(lang == "cs") + { + CSharp.generate(output, classname, lgtemplatename); + } + } + static string FindClassName(string input) + { + if(input.IndexOf('\\') == -1 && input.IndexOf('/') == -1) + { + return input.Substring(0, input.IndexOf('.')); + } + else + { + var index = Math.Max(input.LastIndexOf('\\'), input.LastIndexOf('/')); + return input.Substring(index+1, input.LastIndexOf('.')-index-1); + } } } } diff --git a/packages/LGgen/LGgen/Writer.cs b/packages/LGgen/LGgen/Writer.cs new file mode 100644 index 000000000..5320f7114 --- /dev/null +++ b/packages/LGgen/LGgen/Writer.cs @@ -0,0 +1,70 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace LGgen +{ + public class Writer + { + public int IndentSize = 4; + public int IndentLevel = 0; + private StreamWriter _output; + + public void Indent() + { + IndentLevel += IndentSize; + } + + public void Outdent() + { + IndentLevel -= IndentSize; + } + + public Writer(string outputPath) + { + _output = new StreamWriter(outputPath); + } + + public void Write(string str) + { + _output.Write(str); + } + + public void WriteLine(string str) + { + _output.WriteLine(str); + } + + public void WriteLine() + { + _output.WriteLine(); + } + + public void Indent(string str) + { + for (var i = 0; i < IndentLevel; ++i) + { + _output.Write(' '); + } + _output.Write(str); + } + + public void IndentLine(string str) + { + Indent(str + _output.NewLine); + } + + public void Close() + { + _output.Close(); + } + + public void Flush() + { + _output.Flush(); + } + } +} diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs index d6e055a28..7068cbf30 100644 --- a/packages/LGgen/LGgen/csharp.cs +++ b/packages/LGgen/LGgen/csharp.cs @@ -1,17 +1,32 @@ using System; using System.Collections.Generic; +using System.Globalization; using System.IO; -using Microsoft.Bot.Builder.LanguageGeneration; namespace LGgen { class CSharp { - public static void test() + + public static void generate(string outclass, string classname, List lgtemplatename) { - TemplateEngine lgEngine = new TemplateEngine(); - lgEngine.AddFile("C:/Users/t-hahan/Desktop/New folder/mytest.lg"); - lgEngine.Templates.ForEach(num => Console.WriteLine(num.Name)); + var w = new Writer(outclass); + w.WriteLine("namespace LGgen"); + w.WriteLine("{"); + w.Indent(); + w.IndentLine($"public class {classname}"); + w.IndentLine("{"); + w.Indent(); + + foreach (var name in lgtemplatename) + w.IndentLine($"public const string {name} = \"{name}\";"); + w.Outdent(); + w.IndentLine("}"); + w.Outdent(); + w.IndentLine("}"); + + w.Flush(); + w.Close(); } } diff --git a/packages/LGgen/LGgen/lgtemplate.cs b/packages/LGgen/LGgen/lgtemplate.cs new file mode 100644 index 000000000..c784bb406 --- /dev/null +++ b/packages/LGgen/LGgen/lgtemplate.cs @@ -0,0 +1,9 @@ +namespace LGgen +{ + public class lgtemplate + { + public const string test = "test"; + public const string hoho = "hoho"; + public const string ququ = "ququ"; + } +} diff --git a/packages/LGgen/LGgen/lgtemplate.lg b/packages/LGgen/LGgen/lgtemplate.lg new file mode 100644 index 000000000..a60ebda25 --- /dev/null +++ b/packages/LGgen/LGgen/lgtemplate.lg @@ -0,0 +1,10 @@ +# test +- hahaha + +# hoho +- xixi + +# ququ +- huhu +- xixi + From d301b122ed1f50a53a15ec78bf1f9047b812e22a Mon Sep 17 00:00:00 2001 From: t-hahan Date: Fri, 16 Aug 2019 11:02:00 +0800 Subject: [PATCH 03/11] add TS support and README file --- packages/LGgen/LGgen/.vscode/launch.json | 27 +++++++++++++++ packages/LGgen/LGgen/.vscode/tasks.json | 42 ++++++++++++++++++++++++ packages/LGgen/LGgen/LGgenTest.cs | 8 ++++- packages/LGgen/LGgen/LGgenTest.ts | 3 ++ packages/LGgen/LGgen/Program.cs | 6 +++- packages/LGgen/LGgen/README.md | 17 ++++++++++ packages/LGgen/LGgen/lgtemplate.ts | 6 ++++ packages/LGgen/LGgen/typescript.cs | 23 +++++++++++++ 8 files changed, 130 insertions(+), 2 deletions(-) create mode 100644 packages/LGgen/LGgen/.vscode/launch.json create mode 100644 packages/LGgen/LGgen/.vscode/tasks.json create mode 100644 packages/LGgen/LGgen/LGgenTest.ts create mode 100644 packages/LGgen/LGgen/README.md create mode 100644 packages/LGgen/LGgen/lgtemplate.ts create mode 100644 packages/LGgen/LGgen/typescript.cs diff --git a/packages/LGgen/LGgen/.vscode/launch.json b/packages/LGgen/LGgen/.vscode/launch.json new file mode 100644 index 000000000..d4119fc48 --- /dev/null +++ b/packages/LGgen/LGgen/.vscode/launch.json @@ -0,0 +1,27 @@ +{ + // Use IntelliSense to find out which attributes exist for C# debugging + // Use hover for the description of the existing attributes + // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md + "version": "0.2.0", + "configurations": [ + { + "name": ".NET Core Launch (console)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + // If you have changed target frameworks, make sure to update the program path. + "program": "${workspaceFolder}/bin/Debug/netcoreapp2.1/LGgen.dll", + "args": [], + "cwd": "${workspaceFolder}", + // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": ".NET Core Attach", + "type": "coreclr", + "request": "attach", + "processId": "${command:pickProcess}" + } + ] +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/.vscode/tasks.json b/packages/LGgen/LGgen/.vscode/tasks.json new file mode 100644 index 000000000..731f62b48 --- /dev/null +++ b/packages/LGgen/LGgen/.vscode/tasks.json @@ -0,0 +1,42 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/LGgen.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "publish", + "command": "dotnet", + "type": "process", + "args": [ + "publish", + "${workspaceFolder}/LGgen.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "watch", + "command": "dotnet", + "type": "process", + "args": [ + "watch", + "run", + "${workspaceFolder}/LGgen.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + } + ] +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/LGgenTest.cs b/packages/LGgen/LGgen/LGgenTest.cs index 5f282702b..8015c821a 100644 --- a/packages/LGgen/LGgen/LGgenTest.cs +++ b/packages/LGgen/LGgen/LGgenTest.cs @@ -1 +1,7 @@ - \ No newline at end of file +namespace LGgen +{ + public static class test + { + public const string a = lgtemplate.hoho; + } +} diff --git a/packages/LGgen/LGgen/LGgenTest.ts b/packages/LGgen/LGgen/LGgenTest.ts new file mode 100644 index 000000000..397b21c1f --- /dev/null +++ b/packages/LGgen/LGgen/LGgenTest.ts @@ -0,0 +1,3 @@ +import LGgen from './lgtemplate' + +var hi: string = LGgen.hoho diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index 7f4100168..cd186c4dc 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -91,6 +91,10 @@ static void Main(string[] args) { CSharp.generate(output, classname, lgtemplatename); } + else if(lang == "ts") + { + Typescript.generate(output, classname, lgtemplatename); + } } @@ -103,7 +107,7 @@ static string FindClassName(string input) else { var index = Math.Max(input.LastIndexOf('\\'), input.LastIndexOf('/')); - return input.Substring(index+1, input.LastIndexOf('.')-index-1); + return input.Substring(index + 1, input.LastIndexOf('.') - index - 1); } } } diff --git a/packages/LGgen/LGgen/README.md b/packages/LGgen/LGgen/README.md new file mode 100644 index 000000000..2a7b6fc6e --- /dev/null +++ b/packages/LGgen/LGgen/README.md @@ -0,0 +1,17 @@ +# README + +LGgen is a tool for generating strongly typed C# and typescript class file from a LG file. + +## Usage + +1. build the project. +2. navigate to 'bin/Debug/netcoreapp2.1'. +3. run the command "dotnet LGgen.dll [-l cs/ts] [-n CLASS_NAME] [-i LG_FILE_PATH] [-o OUTPUT_PATH]". +-l cs/ts : select C# or Typescript. +-i : LG file path +-o : output path, defaults to directory where LG file is and the same name with LG file +-n : designate class name, defaults to the same name of LG file +4. The tool will generate a class file. Add this file into your project. +5. For C# file, use the same namespace with the LGfile. +For Typescript file, use "import CLASS_NAME from './FILENAME'. +6. Then you can reference your LG template name by typing CLASSNAME.TEMPLATENAME and enjoy the auto-completing. \ No newline at end of file diff --git a/packages/LGgen/LGgen/lgtemplate.ts b/packages/LGgen/LGgen/lgtemplate.ts new file mode 100644 index 000000000..e7c207613 --- /dev/null +++ b/packages/LGgen/LGgen/lgtemplate.ts @@ -0,0 +1,6 @@ +export default class LGgen +{ + static test:string = "test"; + static hoho:string = "hoho"; + static ququ:string = "ququ"; +} diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs new file mode 100644 index 000000000..5e2f7ab3d --- /dev/null +++ b/packages/LGgen/LGgen/typescript.cs @@ -0,0 +1,23 @@ +using System.Collections.Generic; + +namespace LGgen +{ + class Typescript + { + public static void generate(string outclass, string classname, List lgtemplatename) + { + var w = new Writer(outclass); + w.WriteLine("export default class LGgen"); + w.WriteLine("{"); + w.Indent(); + + foreach (var name in lgtemplatename) + w.IndentLine($"static {name}:string = \"{name}\";"); + w.Outdent(); + w.IndentLine("}"); + + w.Flush(); + w.Close(); + } + } +} From 11e2bab518e4f10c504b19652759256c01cd59fa Mon Sep 17 00:00:00 2001 From: t-hahan Date: Fri, 16 Aug 2019 18:05:43 +0800 Subject: [PATCH 04/11] add grammar check function --- packages/LGgen/LGgen/Program.cs | 47 ++++++++++++++++++++++++++---- packages/LGgen/LGgen/lgtemplate.lg | 14 ++++----- 2 files changed, 48 insertions(+), 13 deletions(-) diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index cd186c4dc..6a38ee1d4 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -6,6 +6,8 @@ using Microsoft.Bot.Builder.LanguageGeneration; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; +using System.ComponentModel.Design; +using System.Linq; namespace LGgen { @@ -19,6 +21,8 @@ static void Usage() Console.Error.WriteLine("-i : LG file path"); Console.Error.WriteLine("-o : output path, defaults to directory where LG file is and the same name with LG file"); Console.Error.WriteLine("-n : designate class name, defaults to the same name of LG file"); + Console.Error.WriteLine("-v : show the version"); + Console.Error.WriteLine("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); System.Environment.Exit(-1); } @@ -28,10 +32,15 @@ static void Main(string[] args) string input = null; string output = null; string classname = null; - //Usage(); + bool grammarcheck = false; if (args == null) Usage(); + if (args.Length == 1 && args[0] == "-v") + { + Console.WriteLine("LGgen version 1.0.0"); + return; + } for (var i = 0; i < args.Length; ++i) { @@ -42,6 +51,10 @@ static void Main(string[] args) lang = args[++i]; break; + case "-c": + grammarcheck = true; + break; + case "-i": input = args[++i]; break; @@ -61,7 +74,7 @@ static void Main(string[] args) }; - if(output == null) + if(output == null && grammarcheck == false) { output = input.Substring(0, input.IndexOf('.')); switch (lang) @@ -75,14 +88,23 @@ static void Main(string[] args) } } - if(classname == null) + if(classname == null && grammarcheck == false) { classname = FindClassName(input); } - + TemplateEngine lgEngine = new TemplateEngine(); - lgEngine.AddFile(input); + + if (grammarcheck == true) + { + Check(lgEngine, input); + return; + } + else + { + lgEngine.AddFile(input); + } List lgtemplatename = new List(); lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); Console.WriteLine($"generating class file {output}"); @@ -110,5 +132,20 @@ static string FindClassName(string input) return input.Substring(index + 1, input.LastIndexOf('.') - index - 1); } } + + static void Check(TemplateEngine lgEngine, string input) + { + try + { + lgEngine.AddFile(input); + Console.WriteLine("Congratulations! No error in this LG file! "); + } + catch(Exception e) + { + List errors = e.Message.Split('\n').ToList(); + Console.WriteLine($"This LG file has {errors.Count} errors: "); + errors.ForEach(i => Console.WriteLine(i)); + } + } } } diff --git a/packages/LGgen/LGgen/lgtemplate.lg b/packages/LGgen/LGgen/lgtemplate.lg index a60ebda25..ec26ce687 100644 --- a/packages/LGgen/LGgen/lgtemplate.lg +++ b/packages/LGgen/LGgen/lgtemplate.lg @@ -1,10 +1,8 @@ -# test -- hahaha +# 123 +- 123 -# hoho -- xixi - -# ququ -- huhu -- xixi +# 1233 +- 123 +# 133 +- IF : From d7724f2401666cd6538bdbe6f8bffd967a7f398a Mon Sep 17 00:00:00 2001 From: t-hahan Date: Wed, 21 Aug 2019 16:59:29 +0800 Subject: [PATCH 05/11] refactoring --- packages/LGgen/LGgen.sln | 20 +- packages/LGgen/LGgen/.vscode/launch.json | 27 --- packages/LGgen/LGgen/.vscode/tasks.json | 42 ---- packages/LGgen/LGgen/LGgen.csproj | 2 +- packages/LGgen/LGgen/LGgenTest.cs | 7 - packages/LGgen/LGgen/LGgenTest.ts | 3 - packages/LGgen/LGgen/Program.cs | 222 ++++++++++---------- packages/LGgen/LGgen/README.md | 24 ++- packages/LGgen/LGgen/Util.cs | 46 ++++ packages/LGgen/LGgen/csharp.cs | 5 +- packages/LGgen/LGgen/factory.cs | 45 ++++ packages/LGgen/LGgen/lgtemplate.cs | 9 - packages/LGgen/LGgen/lgtemplate.lg | 8 - packages/LGgen/LGgen/lgtemplate.ts | 6 - packages/LGgen/LGgen/typescript.cs | 4 +- packages/LGgen/LGgen_Test/LGgen_Test.csproj | 19 ++ packages/LGgen/LGgen_Test/UnitTest1.cs | 14 ++ 17 files changed, 271 insertions(+), 232 deletions(-) delete mode 100644 packages/LGgen/LGgen/.vscode/launch.json delete mode 100644 packages/LGgen/LGgen/.vscode/tasks.json delete mode 100644 packages/LGgen/LGgen/LGgenTest.cs delete mode 100644 packages/LGgen/LGgen/LGgenTest.ts create mode 100644 packages/LGgen/LGgen/Util.cs create mode 100644 packages/LGgen/LGgen/factory.cs delete mode 100644 packages/LGgen/LGgen/lgtemplate.cs delete mode 100644 packages/LGgen/LGgen/lgtemplate.lg delete mode 100644 packages/LGgen/LGgen/lgtemplate.ts create mode 100644 packages/LGgen/LGgen_Test/LGgen_Test.csproj create mode 100644 packages/LGgen/LGgen_Test/UnitTest1.cs diff --git a/packages/LGgen/LGgen.sln b/packages/LGgen/LGgen.sln index ca6d4d497..f1f7b6646 100644 --- a/packages/LGgen/LGgen.sln +++ b/packages/LGgen/LGgen.sln @@ -1,9 +1,11 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 -VisualStudioVersion = 16.0.29201.188 +VisualStudioVersion = 16.0.29215.179 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen", "LGgen\LGgen.csproj", "{78727352-DA0F-4E1C-A57B-F1D11A2B2138}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen", "LGgen\LGgen.csproj", "{E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen_Test", "LGgen_Test\LGgen_Test.csproj", "{2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -11,15 +13,19 @@ Global Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Debug|Any CPU.Build.0 = Debug|Any CPU - {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Release|Any CPU.ActiveCfg = Release|Any CPU - {78727352-DA0F-4E1C-A57B-F1D11A2B2138}.Release|Any CPU.Build.0 = Release|Any CPU + {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Release|Any CPU.Build.0 = Release|Any CPU + {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {BD0D2E7C-4996-4B68-9932-40ECB6B0CE64} + SolutionGuid = {F38B6EE2-4DA8-4C32-9405-6CEE2DAA0675} EndGlobalSection EndGlobal diff --git a/packages/LGgen/LGgen/.vscode/launch.json b/packages/LGgen/LGgen/.vscode/launch.json deleted file mode 100644 index d4119fc48..000000000 --- a/packages/LGgen/LGgen/.vscode/launch.json +++ /dev/null @@ -1,27 +0,0 @@ -{ - // Use IntelliSense to find out which attributes exist for C# debugging - // Use hover for the description of the existing attributes - // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md - "version": "0.2.0", - "configurations": [ - { - "name": ".NET Core Launch (console)", - "type": "coreclr", - "request": "launch", - "preLaunchTask": "build", - // If you have changed target frameworks, make sure to update the program path. - "program": "${workspaceFolder}/bin/Debug/netcoreapp2.1/LGgen.dll", - "args": [], - "cwd": "${workspaceFolder}", - // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console - "console": "internalConsole", - "stopAtEntry": false - }, - { - "name": ".NET Core Attach", - "type": "coreclr", - "request": "attach", - "processId": "${command:pickProcess}" - } - ] -} \ No newline at end of file diff --git a/packages/LGgen/LGgen/.vscode/tasks.json b/packages/LGgen/LGgen/.vscode/tasks.json deleted file mode 100644 index 731f62b48..000000000 --- a/packages/LGgen/LGgen/.vscode/tasks.json +++ /dev/null @@ -1,42 +0,0 @@ -{ - "version": "2.0.0", - "tasks": [ - { - "label": "build", - "command": "dotnet", - "type": "process", - "args": [ - "build", - "${workspaceFolder}/LGgen.csproj", - "/property:GenerateFullPaths=true", - "/consoleloggerparameters:NoSummary" - ], - "problemMatcher": "$msCompile" - }, - { - "label": "publish", - "command": "dotnet", - "type": "process", - "args": [ - "publish", - "${workspaceFolder}/LGgen.csproj", - "/property:GenerateFullPaths=true", - "/consoleloggerparameters:NoSummary" - ], - "problemMatcher": "$msCompile" - }, - { - "label": "watch", - "command": "dotnet", - "type": "process", - "args": [ - "watch", - "run", - "${workspaceFolder}/LGgen.csproj", - "/property:GenerateFullPaths=true", - "/consoleloggerparameters:NoSummary" - ], - "problemMatcher": "$msCompile" - } - ] -} \ No newline at end of file diff --git a/packages/LGgen/LGgen/LGgen.csproj b/packages/LGgen/LGgen/LGgen.csproj index c9d173967..0fe9fa076 100644 --- a/packages/LGgen/LGgen/LGgen.csproj +++ b/packages/LGgen/LGgen/LGgen.csproj @@ -6,7 +6,7 @@ - + diff --git a/packages/LGgen/LGgen/LGgenTest.cs b/packages/LGgen/LGgen/LGgenTest.cs deleted file mode 100644 index 8015c821a..000000000 --- a/packages/LGgen/LGgen/LGgenTest.cs +++ /dev/null @@ -1,7 +0,0 @@ -namespace LGgen -{ - public static class test - { - public const string a = lgtemplate.hoho; - } -} diff --git a/packages/LGgen/LGgen/LGgenTest.ts b/packages/LGgen/LGgen/LGgenTest.ts deleted file mode 100644 index 397b21c1f..000000000 --- a/packages/LGgen/LGgen/LGgenTest.ts +++ /dev/null @@ -1,3 +0,0 @@ -import LGgen from './lgtemplate' - -var hi: string = LGgen.hoho diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index 6a38ee1d4..262207caf 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -1,151 +1,151 @@ -using System; -using System.Reflection; -using System.Resources; -using System.Runtime; -using System.Runtime.Serialization.Formatters; -using Microsoft.Bot.Builder.LanguageGeneration; +using System; using System.Collections.Generic; -using System.ComponentModel.DataAnnotations; -using System.ComponentModel.Design; +using System.IO; using System.Linq; +using System.Net; +using System.Reflection.Metadata; +using Microsoft.Bot.Builder.LanguageGeneration; namespace LGgen { - class Program + public class Program { - static void Usage() + public static void Main(string[] args) { - Console.Error.WriteLine("LGgen [-l cs/ts] [-n CLASS_NAME] [-i LG_FILE_PATH] [-o OUTPUT_PATH]"); - Console.Error.WriteLine("Generate a strongly typed class from a LG file"); - Console.Error.WriteLine("-l cs/ts : select C# or Typescript."); - Console.Error.WriteLine("-i : LG file path"); - Console.Error.WriteLine("-o : output path, defaults to directory where LG file is and the same name with LG file"); - Console.Error.WriteLine("-n : designate class name, defaults to the same name of LG file"); - Console.Error.WriteLine("-v : show the version"); - Console.Error.WriteLine("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); - System.Environment.Exit(-1); + Handler.Import(args.ToList()); + Handler.UseDashLHandler(); + Handler.UseDashIHandler(); + Handler.UseDashCHandler(); + Handler.UseDashOHandler(); + Handler.UseDashNHandler(); + Handler.Generate(); } - static void Main(string[] args) - { - string lang = null; - string input = null; - string output = null; - string classname = null; - bool grammarcheck = false; - - if (args == null) Usage(); + } - if (args.Length == 1 && args[0] == "-v") - { - Console.WriteLine("LGgen version 1.0.0"); - return; - } + public static class Handler + { + static string InputPath = null; + static List LGFiles = new List(); + static string lang = null; + static string OutputPath = null; + static string ClassName = null; + static List Args = new List(); + static string[] Usage = null; + static bool Dire = false; + + public static void Import(List args) + { + Args = args; + } - for (var i = 0; i < args.Length; ++i) + public static void UseDashLHandler() + { + + if (Args.Contains("-l")) { - var arg = args[i]; - switch (arg) - { - case "-l": - lang = args[++i]; - break; - - case "-c": - grammarcheck = true; - break; - - case "-i": - input = args[++i]; - break; + lang = Args[Args.IndexOf("-l") + 1]; + } - case "-n": - classname = args[++i]; - break; + } - case "-o": - output = args[++i]; - break; + public static void UseDashIHandler() + { + + if (Args.Contains("-i")) + { + InputPath = Args[Args.IndexOf("-i") + 1]; - default: - Usage(); - break; + if (Directory.Exists(InputPath)) + { + Dire = true; + Utils.GetAllFiles(InputPath, LGFiles); } - - }; - - if(output == null && grammarcheck == false) - { - output = input.Substring(0, input.IndexOf('.')); - switch (lang) + else if (File.Exists(InputPath) && InputPath.EndsWith(".lg")) { - case "cs": - output += ".cs"; - break; - case "ts": - output += ".ts"; - break; + LGFiles.Add(InputPath); } + else + { + Console.WriteLine("Can't read your input"); + } } - if(classname == null && grammarcheck == false) - { - classname = FindClassName(input); - } - - - TemplateEngine lgEngine = new TemplateEngine(); + } - if (grammarcheck == true) + public static void UseDashOHandler() + { + if (Args.Contains("-o")) { - Check(lgEngine, input); - return; + OutputPath = Args[Args.IndexOf("-o") + 1]; } else { - lgEngine.AddFile(input); - } - List lgtemplatename = new List(); - lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); - Console.WriteLine($"generating class file {output}"); - - if(lang == "cs") - { - CSharp.generate(output, classname, lgtemplatename); - } - else if(lang == "ts") - { - Typescript.generate(output, classname, lgtemplatename); + if(Dire) + { + OutputPath = InputPath + "/common" + Factory.getSuffix(lang); + } + else + { + OutputPath = InputPath.Substring(0, InputPath.LastIndexOf('.')) + Factory.getSuffix(lang); + } } - } - static string FindClassName(string input) + public static void UseDashNHandler() { - if(input.IndexOf('\\') == -1 && input.IndexOf('/') == -1) + if(Args.Contains("-n")) { - return input.Substring(0, input.IndexOf('.')); + + ClassName = Args[Args.IndexOf("-n") + 1]; } - else + else if(Dire) + { + ClassName = "common"; + } + else { - var index = Math.Max(input.LastIndexOf('\\'), input.LastIndexOf('/')); - return input.Substring(index + 1, input.LastIndexOf('.') - index - 1); + ClassName = Utils.FindClassName(InputPath); } } - static void Check(TemplateEngine lgEngine, string input) + public static void UseDashCHandler() { - try + if (Args.Contains("-c")) { - lgEngine.AddFile(input); - Console.WriteLine("Congratulations! No error in this LG file! "); - } - catch(Exception e) - { - List errors = e.Message.Split('\n').ToList(); - Console.WriteLine($"This LG file has {errors.Count} errors: "); - errors.ForEach(i => Console.WriteLine(i)); + TemplateEngine lgEngine = new TemplateEngine(); + try + { + lgEngine.AddFiles(LGFiles); + Console.WriteLine("Congratulations! No error in this LG file! "); + } + catch (Exception e) + { + List errors = e.Message.Split('\n').ToList(); + Console.WriteLine($"This LG file has {errors.Count} errors: "); + errors.ForEach(i => Console.WriteLine(i)); + } + finally + { + Environment.Exit(0); + } } + } + + public static void Generate() + { + TemplateEngine lgEngine = new TemplateEngine(); + lgEngine.AddFiles(LGFiles); + + List lgtemplatename = new List(); + lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); + Console.WriteLine($"generating class file {OutputPath}"); + + LanguageBase languagebase = Factory.getInstance(lang); + languagebase.generate(OutputPath, ClassName, lgtemplatename); + } + } -} + +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/README.md b/packages/LGgen/LGgen/README.md index 2a7b6fc6e..c03169cd4 100644 --- a/packages/LGgen/LGgen/README.md +++ b/packages/LGgen/LGgen/README.md @@ -6,12 +6,24 @@ LGgen is a tool for generating strongly typed C# and typescript class file from 1. build the project. 2. navigate to 'bin/Debug/netcoreapp2.1'. -3. run the command "dotnet LGgen.dll [-l cs/ts] [-n CLASS_NAME] [-i LG_FILE_PATH] [-o OUTPUT_PATH]". --l cs/ts : select C# or Typescript. --i : LG file path --o : output path, defaults to directory where LG file is and the same name with LG file --n : designate class name, defaults to the same name of LG file +3. run the command +`dotnet LGgen.dll [-l cs/ts] [-n CLASS_NAME] [-c] [-i LG_FILE_PATH] [-o OUTPUT_PATH]` + * `-l cs/ts` : Select C# or Typescript. + * `-i` : LG file path or folder. + * `-o` : Output path, defaults to directory where LG file is and the same name with LG file + * `-n` : Designate class name, defaults to the same name of LG file + * `-c` : Grammar check mode. You only need to input `[-c] [-i LG_FILE_PATH]` to run the grammar check. 4. The tool will generate a class file. Add this file into your project. 5. For C# file, use the same namespace with the LGfile. For Typescript file, use "import CLASS_NAME from './FILENAME'. -6. Then you can reference your LG template name by typing CLASSNAME.TEMPLATENAME and enjoy the auto-completing. \ No newline at end of file +6. Then you can reference your LG template name by typing CLASSNAME.TEMPLATENAME and enjoy the auto-completing. + +## EXTEND + +### Add command line arguments + +Implement the method in the "Handler" class and add to Main function. + +### Add language support + +Build a class base on interface "LanguageBase" and update the "Factory" class. \ No newline at end of file diff --git a/packages/LGgen/LGgen/Util.cs b/packages/LGgen/LGgen/Util.cs new file mode 100644 index 000000000..0813e10fd --- /dev/null +++ b/packages/LGgen/LGgen/Util.cs @@ -0,0 +1,46 @@ +using AdaptiveCards.Rendering; +using System; +using Microsoft.Bot.Builder.LanguageGeneration; +using System.Collections.Generic; +using System.Linq; +using System.IO; + +namespace LGgen +{ + class Utils + { + public static string FindClassName(string input) + { + + if (input.IndexOf('\\') == -1 && input.IndexOf('/') == -1) + { + return input.Substring(0, input.IndexOf('.')); + } + else + { + var index = Math.Max(input.LastIndexOf('\\'), input.LastIndexOf('/')); + return input.Substring(index + 1, input.LastIndexOf('.') - index - 1); + } + } + + public static void GetAllFiles(string dir, List LGfiles) + { + DirectoryInfo d = new DirectoryInfo(dir); + FileSystemInfo[] fsinfos = d.GetFileSystemInfos(); + foreach (var fsinfo in fsinfos) + { + if(fsinfo is DirectoryInfo) + { + GetAllFiles(fsinfo.FullName, LGfiles); + } + else + { + if(fsinfo.FullName.EndsWith(".lg")) + { + LGfiles.Add(fsinfo.FullName); + } + } + } + } + } +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs index 7068cbf30..3c2d326b2 100644 --- a/packages/LGgen/LGgen/csharp.cs +++ b/packages/LGgen/LGgen/csharp.cs @@ -5,10 +5,10 @@ namespace LGgen { - class CSharp + class CSharp:LanguageBase { - public static void generate(string outclass, string classname, List lgtemplatename) + public void generate(string outclass, string classname, List lgtemplatename) { var w = new Writer(outclass); w.WriteLine("namespace LGgen"); @@ -27,7 +27,6 @@ public static void generate(string outclass, string classname, List lgte w.Flush(); w.Close(); - } } } diff --git a/packages/LGgen/LGgen/factory.cs b/packages/LGgen/LGgen/factory.cs new file mode 100644 index 000000000..ed39318c9 --- /dev/null +++ b/packages/LGgen/LGgen/factory.cs @@ -0,0 +1,45 @@ +using System.Collections.Generic; + +namespace LGgen +{ + public interface LanguageBase + { + void generate(string outclass, string classname, List lgtemplatename); + } + + public class Factory + { + public static string[] LanguageList = { "cs", "ts" }; + public static LanguageBase getInstance(string name) + { + if (name.Equals("cs")) + { + return new CSharp(); + } + else if(name.Equals("ts")) + { + return new Typescript(); + } + else + { + return null; + } + } + + public static string getSuffix(string name) + { + if (name.Equals("cs")) + { + return ".cs"; + } + else if (name.Equals("ts")) + { + return ".ts"; + } + else + { + return null; + } + } + } +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/lgtemplate.cs b/packages/LGgen/LGgen/lgtemplate.cs deleted file mode 100644 index c784bb406..000000000 --- a/packages/LGgen/LGgen/lgtemplate.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace LGgen -{ - public class lgtemplate - { - public const string test = "test"; - public const string hoho = "hoho"; - public const string ququ = "ququ"; - } -} diff --git a/packages/LGgen/LGgen/lgtemplate.lg b/packages/LGgen/LGgen/lgtemplate.lg deleted file mode 100644 index ec26ce687..000000000 --- a/packages/LGgen/LGgen/lgtemplate.lg +++ /dev/null @@ -1,8 +0,0 @@ -# 123 -- 123 - -# 1233 -- 123 - -# 133 -- IF : diff --git a/packages/LGgen/LGgen/lgtemplate.ts b/packages/LGgen/LGgen/lgtemplate.ts deleted file mode 100644 index e7c207613..000000000 --- a/packages/LGgen/LGgen/lgtemplate.ts +++ /dev/null @@ -1,6 +0,0 @@ -export default class LGgen -{ - static test:string = "test"; - static hoho:string = "hoho"; - static ququ:string = "ququ"; -} diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs index 5e2f7ab3d..71fa1d42a 100644 --- a/packages/LGgen/LGgen/typescript.cs +++ b/packages/LGgen/LGgen/typescript.cs @@ -2,9 +2,9 @@ namespace LGgen { - class Typescript + class Typescript:LanguageBase { - public static void generate(string outclass, string classname, List lgtemplatename) + public void generate(string outclass, string classname, List lgtemplatename) { var w = new Writer(outclass); w.WriteLine("export default class LGgen"); diff --git a/packages/LGgen/LGgen_Test/LGgen_Test.csproj b/packages/LGgen/LGgen_Test/LGgen_Test.csproj new file mode 100644 index 000000000..4838eef10 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGgen_Test.csproj @@ -0,0 +1,19 @@ + + + + netcoreapp2.1 + + false + + + + + + + + + + + + + diff --git a/packages/LGgen/LGgen_Test/UnitTest1.cs b/packages/LGgen/LGgen_Test/UnitTest1.cs new file mode 100644 index 000000000..235c1bf7a --- /dev/null +++ b/packages/LGgen/LGgen_Test/UnitTest1.cs @@ -0,0 +1,14 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace LGgen_Test +{ + [TestClass] + public class UnitTest1 + { + [TestMethod] + public void TestMethod1() + { + LGgen.Program.Main(new string[] { "-i", "C:/Users/t-hahan/Desktop/Newfolder/mytest1.lg", "-l", "-cs" }); + } + } +} From dd4f947f61d121fe05d45d8cc820caa371bdd38a Mon Sep 17 00:00:00 2001 From: t-hahan Date: Wed, 21 Aug 2019 19:11:28 +0800 Subject: [PATCH 06/11] Add usage --- packages/LGgen/LGgen/Program.cs | 130 +++++++++++++++++++---------- packages/LGgen/LGgen/Util.cs | 4 +- packages/LGgen/LGgen/csharp.cs | 8 +- packages/LGgen/LGgen/factory.cs | 13 +-- packages/LGgen/LGgen/typescript.cs | 8 +- 5 files changed, 102 insertions(+), 61 deletions(-) diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index 262207caf..2ba180f07 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.IO; using System.Linq; @@ -13,11 +13,11 @@ public class Program public static void Main(string[] args) { Handler.Import(args.ToList()); - Handler.UseDashLHandler(); - Handler.UseDashIHandler(); - Handler.UseDashCHandler(); - Handler.UseDashOHandler(); - Handler.UseDashNHandler(); + Handler.UseInputHandler(); + Handler.UseCheckHandler(); + Handler.UseLangHandler(); + Handler.UseOutputHandler(); + Handler.UseNameHandler(); Handler.Generate(); } @@ -25,94 +25,132 @@ public static void Main(string[] args) public static class Handler { - static string InputPath = null; + static string inputPath = null; static List LGFiles = new List(); static string lang = null; - static string OutputPath = null; - static string ClassName = null; + static string outputPath = null; + static string className = null; static List Args = new List(); - static string[] Usage = null; + static List Usage = new List(); static bool Dire = false; public static void Import(List args) { - Args = args; + Args = args; + Usage.Add("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH] [-n CLASS_NAME]"); + Usage.Add("Generate a strongly typed class from a LG file"); + Usage.Add("Options: "); } - public static void UseDashLHandler() + public static void Error_Usage() { - + Console.WriteLine("Error! Please Read the Usage. "); + Usage.ForEach(num => Console.Error.WriteLine(num)); + Environment.Exit(-1); + } + + public static string InputCheck(string arg) + { + if (Args.Count == Args.IndexOf(arg) + 1) + { + Error_Usage(); + return null; + } + else + { + var temp = Args[Args.IndexOf(arg) + 1]; + if (!temp.StartsWith('-')) + return temp; + else + { + Error_Usage(); + return null; + } + } + } + + public static void UseLangHandler() + { + Usage.Add("-l cs/ts : select C# or Typescript."); + if (Args.Contains("-l")) { - lang = Args[Args.IndexOf("-l") + 1]; + lang = InputCheck("-l"); + if (!Factory.languageList.Contains(Args[Args.IndexOf("-l") + 1])) Error_Usage(); + } + else + { + Error_Usage(); } } - public static void UseDashIHandler() + public static void UseInputHandler() { - + Usage.Add("-i : LG file path or file folder. "); if (Args.Contains("-i")) { - InputPath = Args[Args.IndexOf("-i") + 1]; + inputPath = InputCheck("-i"); - if (Directory.Exists(InputPath)) + if (Directory.Exists(inputPath)) { Dire = true; - Utils.GetAllFiles(InputPath, LGFiles); + Utils.GetAllFiles(inputPath, LGFiles); } - else if (File.Exists(InputPath) && InputPath.EndsWith(".lg")) + else if (File.Exists(inputPath) && inputPath.EndsWith(".lg")) { - LGFiles.Add(InputPath); + LGFiles.Add(inputPath); } else { Console.WriteLine("Can't read your input"); + Error_Usage(); } } + else + { + Error_Usage(); + } } - public static void UseDashOHandler() + public static void UseOutputHandler() { + Usage.Add("-o : output path, defaults to directory where LG file is and the same name with LG file"); + + if (Args.Contains("-o")) { - OutputPath = Args[Args.IndexOf("-o") + 1]; + outputPath = InputCheck("-o"); } else { - if(Dire) - { - OutputPath = InputPath + "/common" + Factory.getSuffix(lang); - } - else - { - OutputPath = InputPath.Substring(0, InputPath.LastIndexOf('.')) + Factory.getSuffix(lang); - } + outputPath = Dire ? inputPath + "/common" + Factory.GetSuffix(lang) : inputPath.Substring(0, inputPath.LastIndexOf('.')) + Factory.GetSuffix(lang); } } - public static void UseDashNHandler() + public static void UseNameHandler() { - if(Args.Contains("-n")) - { + Usage.Add("-n : designate class name, defaults to the same name of LG file"); - ClassName = Args[Args.IndexOf("-n") + 1]; - } - else if(Dire) + if (Args.Contains("-n")) { - ClassName = "common"; + className = InputCheck("-n"); } - else + else { - ClassName = Utils.FindClassName(InputPath); + className = Dire ? "common": Utils.FindClassName(inputPath); } } - public static void UseDashCHandler() + public static void UseCheckHandler() { + Usage.Add("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); + if (Args.Contains("-c")) { + if (LGFiles == null) Error_Usage(); + TemplateEngine lgEngine = new TemplateEngine(); try { @@ -135,17 +173,19 @@ public static void UseDashCHandler() public static void Generate() { + if (LGFiles == null) Error_Usage(); + TemplateEngine lgEngine = new TemplateEngine(); lgEngine.AddFiles(LGFiles); List lgtemplatename = new List(); lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); - Console.WriteLine($"generating class file {OutputPath}"); + Console.WriteLine($"generating class file {outputPath}"); - LanguageBase languagebase = Factory.getInstance(lang); - languagebase.generate(OutputPath, ClassName, lgtemplatename); + LanguageBase languagebase = Factory.GetInstance(lang); + languagebase.Generate(outputPath, className, lgtemplatename); } } -} \ No newline at end of file +} diff --git a/packages/LGgen/LGgen/Util.cs b/packages/LGgen/LGgen/Util.cs index 0813e10fd..0929d0604 100644 --- a/packages/LGgen/LGgen/Util.cs +++ b/packages/LGgen/LGgen/Util.cs @@ -1,4 +1,4 @@ -using AdaptiveCards.Rendering; +using AdaptiveCards.Rendering; using System; using Microsoft.Bot.Builder.LanguageGeneration; using System.Collections.Generic; @@ -43,4 +43,4 @@ public static void GetAllFiles(string dir, List LGfiles) } } } -} \ No newline at end of file +} diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs index 3c2d326b2..e62c22acb 100644 --- a/packages/LGgen/LGgen/csharp.cs +++ b/packages/LGgen/LGgen/csharp.cs @@ -8,17 +8,17 @@ namespace LGgen class CSharp:LanguageBase { - public void generate(string outclass, string classname, List lgtemplatename) + public void Generate(string outClass, string className, List lgTemplateName) { - var w = new Writer(outclass); + var w = new Writer(outClass); w.WriteLine("namespace LGgen"); w.WriteLine("{"); w.Indent(); - w.IndentLine($"public class {classname}"); + w.IndentLine($"public class {className}"); w.IndentLine("{"); w.Indent(); - foreach (var name in lgtemplatename) + foreach (var name in lgTemplateName) w.IndentLine($"public const string {name} = \"{name}\";"); w.Outdent(); w.IndentLine("}"); diff --git a/packages/LGgen/LGgen/factory.cs b/packages/LGgen/LGgen/factory.cs index ed39318c9..1c9d242f9 100644 --- a/packages/LGgen/LGgen/factory.cs +++ b/packages/LGgen/LGgen/factory.cs @@ -1,16 +1,17 @@ -using System.Collections.Generic; +using System.Collections.Generic; namespace LGgen { public interface LanguageBase { - void generate(string outclass, string classname, List lgtemplatename); + void Generate(string outClass, string className, List lgTemplateName); } public class Factory { - public static string[] LanguageList = { "cs", "ts" }; - public static LanguageBase getInstance(string name) + public static string[] languageList = { "cs", "ts" }; + + public static LanguageBase GetInstance(string name) { if (name.Equals("cs")) { @@ -26,7 +27,7 @@ public static LanguageBase getInstance(string name) } } - public static string getSuffix(string name) + public static string GetSuffix(string name) { if (name.Equals("cs")) { @@ -42,4 +43,4 @@ public static string getSuffix(string name) } } } -} \ No newline at end of file +} diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs index 71fa1d42a..b6e1c4a57 100644 --- a/packages/LGgen/LGgen/typescript.cs +++ b/packages/LGgen/LGgen/typescript.cs @@ -4,14 +4,14 @@ namespace LGgen { class Typescript:LanguageBase { - public void generate(string outclass, string classname, List lgtemplatename) + public void Generate(string outClass, string className, List lgTemplateName) { - var w = new Writer(outclass); - w.WriteLine("export default class LGgen"); + var w = new Writer(outClass); + w.WriteLine($"export default class {className}"); w.WriteLine("{"); w.Indent(); - foreach (var name in lgtemplatename) + foreach (var name in lgTemplateName) w.IndentLine($"static {name}:string = \"{name}\";"); w.Outdent(); w.IndentLine("}"); From badd4c16118cdb44787516dd53fac9039abf7517 Mon Sep 17 00:00:00 2001 From: t-hahan Date: Tue, 27 Aug 2019 11:17:21 +0800 Subject: [PATCH 07/11] refactoring --- packages/LGgen/LGgen.sln | 4 +- packages/LGgen/LGgen/CommandHandler.cs | 152 +++++++++++++++++ packages/LGgen/LGgen/CommandHandlerBase.cs | 49 ++++++ packages/LGgen/LGgen/ILanguage.cs | 9 + packages/LGgen/LGgen/LanguageRegister.cs | 41 +++++ packages/LGgen/LGgen/LgTemplate.cs | 10 ++ packages/LGgen/LGgen/Program.cs | 187 ++------------------- packages/LGgen/LGgen/README.md | 4 +- packages/LGgen/LGgen/Util.cs | 29 ++-- packages/LGgen/LGgen/csharp.cs | 10 +- packages/LGgen/LGgen/factory.cs | 46 ----- packages/LGgen/LGgen/typescript.cs | 10 +- packages/LGgen/LGgen_Test/UnitTest1.cs | 8 +- 13 files changed, 308 insertions(+), 251 deletions(-) create mode 100644 packages/LGgen/LGgen/CommandHandler.cs create mode 100644 packages/LGgen/LGgen/CommandHandlerBase.cs create mode 100644 packages/LGgen/LGgen/ILanguage.cs create mode 100644 packages/LGgen/LGgen/LanguageRegister.cs create mode 100644 packages/LGgen/LGgen/LgTemplate.cs delete mode 100644 packages/LGgen/LGgen/factory.cs diff --git a/packages/LGgen/LGgen.sln b/packages/LGgen/LGgen.sln index f1f7b6646..0d1b4e521 100644 --- a/packages/LGgen/LGgen.sln +++ b/packages/LGgen/LGgen.sln @@ -3,9 +3,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.29215.179 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen", "LGgen\LGgen.csproj", "{E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LGgen", "LGgen\LGgen.csproj", "{E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen_Test", "LGgen_Test\LGgen_Test.csproj", "{2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LGgen_Test", "LGgen_Test\LGgen_Test.csproj", "{2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/packages/LGgen/LGgen/CommandHandler.cs b/packages/LGgen/LGgen/CommandHandler.cs new file mode 100644 index 000000000..deff4ee78 --- /dev/null +++ b/packages/LGgen/LGgen/CommandHandler.cs @@ -0,0 +1,152 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Net.Http; +using Microsoft.Bot.Builder.LanguageGeneration; + +namespace LGgen +{ + public class CommandHandler : CommandHandlerBase + { + private string inputPath = null; + private string lang = null; + private string outputPath = null; + private new List args = new List(); + private List LGFiles = new List(); + private bool Dire = false; + private bool GrammarCheckMode = false; + LgTemplate template = new LgTemplate(); + public static List Message = new List(); + + public CommandHandler(List args) : base(args) + { + this.args = args; + } + + public CommandHandler UseLangHandler() + { + if (GrammarCheckMode) return this; + + if (args.Contains("-l")) + { + lang = CommandGrammarCheck("-l"); + if (!LanguageRegister.IsLanguage(lang)) throw new Exception("Not Support this Language. " + Utils.SupportLanguage()); + } + else + { + throw new Exception("-l Command is Complosory. "); + } + return this; + } + + public CommandHandler UseInputHandler() + { + if (args.Contains("-i")) + { + inputPath = CommandGrammarCheck("-i"); + + if (Directory.Exists(inputPath)) + { + Dire = true; + Utils.GetAllFiles(inputPath, LGFiles); + } + else if (File.Exists(inputPath) && Path.GetExtension(inputPath) == ".lg") + { + LGFiles.Add(inputPath); + } + else + { + throw new Exception("Can't Read your Input. "); + } + } + else + { + throw new Exception("-i Command is Complosory. "); + } + + return this; + + } + public CommandHandler UseOutputHandler() + { + if (GrammarCheckMode) return this; + + if (args.Contains("-o")) + { + outputPath = CommandGrammarCheck("-o"); + } + else + { + outputPath = Dire ? Path.Join(inputPath, "common" + LanguageRegister.GetSuffix(lang)) : Path.ChangeExtension(inputPath, LanguageRegister.GetSuffix(lang)); + } + + return this; + } + + public CommandHandler UseNameHandler() + { + if (GrammarCheckMode) return this; + + if (args.Contains("-n")) + { + template.className = CommandGrammarCheck("-n"); + } + else + { + template.className = Dire ? "common" : Path.GetFileNameWithoutExtension(inputPath); + } + + return this; + } + + public CommandHandler UseCheckHandler() + { + if (args.Contains("-c")) + { + if (LGFiles == null) throw new Exception("Fail to Read any LG File. "); + + TemplateEngine lgEngine = new TemplateEngine(); + try + { + lgEngine.AddFiles(LGFiles); + Message.Add("Congratulations! No error in this LG file! "); + } + catch (Exception e) + { + List errors = e.Message.Split('\n').ToList(); + Message.Add($"This LG file has {errors.Count} errors: "); + errors.ForEach(i => Message.Add(i)); + } + + GrammarCheckMode = true; + } + + return this; + + } + + public CommandHandler Generate() + { + if (GrammarCheckMode) return this; + + if (LGFiles == null) throw new Exception("Fail to Read any LG File. "); + + TemplateEngine lgEngine = new TemplateEngine(); + lgEngine.AddFiles(LGFiles); + + lgEngine.Templates.ForEach(num => template.lgTemplateName.Add(num.Name)); + Message.Add($"generating class file {outputPath}"); + + ILanguage languagebase = LanguageRegister.GetGenerate(lang); + languagebase.Generate(outputPath, template); + + return this; + } + + } + + +} + diff --git a/packages/LGgen/LGgen/CommandHandlerBase.cs b/packages/LGgen/LGgen/CommandHandlerBase.cs new file mode 100644 index 000000000..8eb34a44f --- /dev/null +++ b/packages/LGgen/LGgen/CommandHandlerBase.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; + +namespace LGgen +{ + public class CommandHandlerBase + { + protected List args = new List(); + public static List Usage = new List(); + + public CommandHandlerBase(List args) + { + this.args = args; + LanguageRegister.RegisterAllLanguages(); + Usage_Init(); + } + + protected void Usage_Init() + { + Usage.Add("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH] [-n CLASS_NAME]"); + Usage.Add("Generate a strongly typed class from a LG file"); + Usage.Add("Options: "); + Usage.Add("-l : choose language. " + Utils.SupportLanguage()); + Usage.Add("-i : LG file path or file folder. "); + Usage.Add("-o : output path, defaults to directory where LG file is and the same name with LG file"); + Usage.Add("-n : designate class name, defaults to the same name of LG file"); + Usage.Add("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); + + } + + protected string CommandGrammarCheck(string arg) + { + if (args.Count == args.IndexOf(arg) + 1) + { + throw new Exception("End with a Command without Value. "); + } + else + { + var temp = args[args.IndexOf(arg) + 1]; + if (!temp.StartsWith('-')) + return temp; + else + { + throw new Exception("No Corresponding Value with the Command. "); + } + } + } + } +} diff --git a/packages/LGgen/LGgen/ILanguage.cs b/packages/LGgen/LGgen/ILanguage.cs new file mode 100644 index 000000000..fb31e9838 --- /dev/null +++ b/packages/LGgen/LGgen/ILanguage.cs @@ -0,0 +1,9 @@ +using System.Collections.Generic; + +namespace LGgen +{ + public interface ILanguage + { + void Generate(string outPath, LgTemplate temp); + } +} diff --git a/packages/LGgen/LGgen/LanguageRegister.cs b/packages/LGgen/LGgen/LanguageRegister.cs new file mode 100644 index 000000000..446ecb64b --- /dev/null +++ b/packages/LGgen/LGgen/LanguageRegister.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; + +namespace LGgen +{ + public static class LanguageRegister + { + private static Dictionary generateDict = new Dictionary(); + private static Dictionary suffixDict = new Dictionary(); + public static List languageList = new List(); + private static void Register(string name, string suffix, ILanguage Language) + { + generateDict.Add(name, Language); + suffixDict.Add(name, suffix); + languageList.Add(name); + } + + public static bool IsLanguage(string name) + { + return languageList.Contains(name); + } + + public static ILanguage GetGenerate(string name) + { + return generateDict[name]; + } + + public static string GetSuffix(string name) + { + return suffixDict[name]; + } + + public static void RegisterAllLanguages() + { + Register("cs", ".cs", new CSharp()); + Register("ts", ".ts", new Typescript()); + } + + } +} diff --git a/packages/LGgen/LGgen/LgTemplate.cs b/packages/LGgen/LGgen/LgTemplate.cs new file mode 100644 index 000000000..8005cd9af --- /dev/null +++ b/packages/LGgen/LGgen/LgTemplate.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; + +namespace LGgen +{ + public class LgTemplate + { + public string className; + public List lgTemplateName = new List(); + } +} diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index 2ba180f07..d3f424307 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -1,191 +1,36 @@ using System; -using System.Collections.Generic; using System.IO; +using System.Collections.Generic; using System.Linq; -using System.Net; -using System.Reflection.Metadata; -using Microsoft.Bot.Builder.LanguageGeneration; + namespace LGgen { - public class Program + public class LGgenTool { public static void Main(string[] args) { - Handler.Import(args.ToList()); - Handler.UseInputHandler(); - Handler.UseCheckHandler(); - Handler.UseLangHandler(); - Handler.UseOutputHandler(); - Handler.UseNameHandler(); - Handler.Generate(); - } - - } - - public static class Handler - { - static string inputPath = null; - static List LGFiles = new List(); - static string lang = null; - static string outputPath = null; - static string className = null; - static List Args = new List(); - static List Usage = new List(); - static bool Dire = false; - - public static void Import(List args) - { - Args = args; - Usage.Add("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH] [-n CLASS_NAME]"); - Usage.Add("Generate a strongly typed class from a LG file"); - Usage.Add("Options: "); - } - - public static void Error_Usage() - { - Console.WriteLine("Error! Please Read the Usage. "); - Usage.ForEach(num => Console.Error.WriteLine(num)); - Environment.Exit(-1); - } - - public static string InputCheck(string arg) - { - if (Args.Count == Args.IndexOf(arg) + 1) + try { - Error_Usage(); - return null; - } - else - { - var temp = Args[Args.IndexOf(arg) + 1]; - if (!temp.StartsWith('-')) - return temp; - else - { - Error_Usage(); - return null; - } - } - } + _ = new CommandHandler(args.ToList()) + .UseInputHandler() + .UseCheckHandler() + .UseLangHandler() + .UseOutputHandler() + .UseNameHandler() + .Generate(); - public static void UseLangHandler() - { - Usage.Add("-l cs/ts : select C# or Typescript."); - - if (Args.Contains("-l")) - { - lang = InputCheck("-l"); - if (!Factory.languageList.Contains(Args[Args.IndexOf("-l") + 1])) Error_Usage(); + CommandHandler.Message.ForEach(num => Console.WriteLine(num)); } - else + catch(Exception e) { - Error_Usage(); + Console.WriteLine(e.Message); + CommandHandlerBase.Usage.ForEach(num => Console.Error.WriteLine(num)); + Environment.Exit(-1); } } - public static void UseInputHandler() - { - Usage.Add("-i : LG file path or file folder. "); - if (Args.Contains("-i")) - { - inputPath = InputCheck("-i"); - - if (Directory.Exists(inputPath)) - { - Dire = true; - Utils.GetAllFiles(inputPath, LGFiles); - } - else if (File.Exists(inputPath) && inputPath.EndsWith(".lg")) - { - LGFiles.Add(inputPath); - } - else - { - Console.WriteLine("Can't read your input"); - Error_Usage(); - } - } - else - { - Error_Usage(); - } - - } - - public static void UseOutputHandler() - { - Usage.Add("-o : output path, defaults to directory where LG file is and the same name with LG file"); - - - if (Args.Contains("-o")) - { - outputPath = InputCheck("-o"); - } - else - { - outputPath = Dire ? inputPath + "/common" + Factory.GetSuffix(lang) : inputPath.Substring(0, inputPath.LastIndexOf('.')) + Factory.GetSuffix(lang); - } - } - - public static void UseNameHandler() - { - Usage.Add("-n : designate class name, defaults to the same name of LG file"); - - if (Args.Contains("-n")) - { - className = InputCheck("-n"); - } - else - { - className = Dire ? "common": Utils.FindClassName(inputPath); - } - } - - public static void UseCheckHandler() - { - Usage.Add("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); - - if (Args.Contains("-c")) - { - if (LGFiles == null) Error_Usage(); - - TemplateEngine lgEngine = new TemplateEngine(); - try - { - lgEngine.AddFiles(LGFiles); - Console.WriteLine("Congratulations! No error in this LG file! "); - } - catch (Exception e) - { - List errors = e.Message.Split('\n').ToList(); - Console.WriteLine($"This LG file has {errors.Count} errors: "); - errors.ForEach(i => Console.WriteLine(i)); - } - finally - { - Environment.Exit(0); - } - } - - } - - public static void Generate() - { - if (LGFiles == null) Error_Usage(); - - TemplateEngine lgEngine = new TemplateEngine(); - lgEngine.AddFiles(LGFiles); - - List lgtemplatename = new List(); - lgEngine.Templates.ForEach(num => lgtemplatename.Add(num.Name)); - Console.WriteLine($"generating class file {outputPath}"); - - LanguageBase languagebase = Factory.GetInstance(lang); - languagebase.Generate(outputPath, className, lgtemplatename); - } - } } diff --git a/packages/LGgen/LGgen/README.md b/packages/LGgen/LGgen/README.md index c03169cd4..f9bc0e612 100644 --- a/packages/LGgen/LGgen/README.md +++ b/packages/LGgen/LGgen/README.md @@ -22,8 +22,8 @@ For Typescript file, use "import CLASS_NAME from './FILENAME'. ### Add command line arguments -Implement the method in the "Handler" class and add to Main function. +Implement the method in the "CommandHandler" class and add to Main function. ### Add language support -Build a class base on interface "LanguageBase" and update the "Factory" class. \ No newline at end of file +Build a class base on interface "ILanguage" and update the "RegisterAllLanguage" method in "LanguageRegister" class. diff --git a/packages/LGgen/LGgen/Util.cs b/packages/LGgen/LGgen/Util.cs index 0929d0604..a09811d73 100644 --- a/packages/LGgen/LGgen/Util.cs +++ b/packages/LGgen/LGgen/Util.cs @@ -9,20 +9,6 @@ namespace LGgen { class Utils { - public static string FindClassName(string input) - { - - if (input.IndexOf('\\') == -1 && input.IndexOf('/') == -1) - { - return input.Substring(0, input.IndexOf('.')); - } - else - { - var index = Math.Max(input.LastIndexOf('\\'), input.LastIndexOf('/')); - return input.Substring(index + 1, input.LastIndexOf('.') - index - 1); - } - } - public static void GetAllFiles(string dir, List LGfiles) { DirectoryInfo d = new DirectoryInfo(dir); @@ -35,12 +21,25 @@ public static void GetAllFiles(string dir, List LGfiles) } else { - if(fsinfo.FullName.EndsWith(".lg")) + if(Path.GetExtension(fsinfo.FullName) == ".lg") { LGfiles.Add(fsinfo.FullName); } } } } + + public static string SupportLanguage() + { + string s = "Support Language: "; + foreach (var temp in LanguageRegister.languageList) + { + s += temp; + s += " "; + } + s += ". "; + + return s; + } } } diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs index e62c22acb..8118ff7a9 100644 --- a/packages/LGgen/LGgen/csharp.cs +++ b/packages/LGgen/LGgen/csharp.cs @@ -5,20 +5,20 @@ namespace LGgen { - class CSharp:LanguageBase + class CSharp:ILanguage { - public void Generate(string outClass, string className, List lgTemplateName) + public void Generate(string outPath, LgTemplate temp) { - var w = new Writer(outClass); + var w = new Writer(outPath); w.WriteLine("namespace LGgen"); w.WriteLine("{"); w.Indent(); - w.IndentLine($"public class {className}"); + w.IndentLine($"public class {temp.className}"); w.IndentLine("{"); w.Indent(); - foreach (var name in lgTemplateName) + foreach (var name in temp.lgTemplateName) w.IndentLine($"public const string {name} = \"{name}\";"); w.Outdent(); w.IndentLine("}"); diff --git a/packages/LGgen/LGgen/factory.cs b/packages/LGgen/LGgen/factory.cs deleted file mode 100644 index 1c9d242f9..000000000 --- a/packages/LGgen/LGgen/factory.cs +++ /dev/null @@ -1,46 +0,0 @@ -using System.Collections.Generic; - -namespace LGgen -{ - public interface LanguageBase - { - void Generate(string outClass, string className, List lgTemplateName); - } - - public class Factory - { - public static string[] languageList = { "cs", "ts" }; - - public static LanguageBase GetInstance(string name) - { - if (name.Equals("cs")) - { - return new CSharp(); - } - else if(name.Equals("ts")) - { - return new Typescript(); - } - else - { - return null; - } - } - - public static string GetSuffix(string name) - { - if (name.Equals("cs")) - { - return ".cs"; - } - else if (name.Equals("ts")) - { - return ".ts"; - } - else - { - return null; - } - } - } -} diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs index b6e1c4a57..1b7ba1b68 100644 --- a/packages/LGgen/LGgen/typescript.cs +++ b/packages/LGgen/LGgen/typescript.cs @@ -2,16 +2,16 @@ namespace LGgen { - class Typescript:LanguageBase + class Typescript:ILanguage { - public void Generate(string outClass, string className, List lgTemplateName) + public void Generate(string outPath, LgTemplate temp) { - var w = new Writer(outClass); - w.WriteLine($"export default class {className}"); + var w = new Writer(outPath); + w.WriteLine($"export default class {temp.className}"); w.WriteLine("{"); w.Indent(); - foreach (var name in lgTemplateName) + foreach (var name in temp.lgTemplateName) w.IndentLine($"static {name}:string = \"{name}\";"); w.Outdent(); w.IndentLine("}"); diff --git a/packages/LGgen/LGgen_Test/UnitTest1.cs b/packages/LGgen/LGgen_Test/UnitTest1.cs index 235c1bf7a..70640bac9 100644 --- a/packages/LGgen/LGgen_Test/UnitTest1.cs +++ b/packages/LGgen/LGgen_Test/UnitTest1.cs @@ -1,14 +1,12 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; -namespace LGgen_Test +namespace LGgen { - [TestClass] public class UnitTest1 { - [TestMethod] - public void TestMethod1() + public void Main(string[] args) { - LGgen.Program.Main(new string[] { "-i", "C:/Users/t-hahan/Desktop/Newfolder/mytest1.lg", "-l", "-cs" }); + LGgenTool.Main(args); } } } From 7f84fcda5f3eb9240974051f0a48a84af6af08e8 Mon Sep 17 00:00:00 2001 From: t-hahan Date: Tue, 27 Aug 2019 19:52:01 +0800 Subject: [PATCH 08/11] bug fix and add test --- packages/LGgen/LGgen.sln | 10 +++---- packages/LGgen/LGgen/CommandHandler.cs | 30 ++++++++----------- packages/LGgen/LGgen/CommandHandlerBase.cs | 3 +- packages/LGgen/LGgen/ILanguage.cs | 3 +- packages/LGgen/LGgen/LanguageRegister.cs | 13 ++++---- packages/LGgen/LGgen/LgTemplate.cs | 10 ------- packages/LGgen/LGgen/Program.cs | 6 ++-- packages/LGgen/LGgen/README.md | 2 +- packages/LGgen/LGgen/Writer.cs | 5 ---- packages/LGgen/LGgen/csharp.cs | 14 ++++----- packages/LGgen/LGgen/typescript.cs | 8 ++--- packages/LGgen/LGgen_Test/LGgen_Test.csproj | 9 +----- packages/LGgen/LGgen_Test/LGtest.cs | 9 ++++++ packages/LGgen/LGgen_Test/LGtest.lg | 8 +++++ packages/LGgen/LGgen_Test/LGtest.ts | 6 ++++ .../LGtest_ClassNameChoice/LGtest.cs | 9 ++++++ .../LGtest_Folder/LGchildfolder/test_2.lg | 8 +++++ .../LGgen/LGgen_Test/LGtest_Folder/common.cs | 12 ++++++++ .../LGgen/LGgen_Test/LGtest_Folder/test.lg | 8 +++++ .../LGgen_Test/LGtest_OutputChoice/LGtest.ts | 6 ++++ packages/LGgen/LGgen_Test/Program.cs | 17 +++++++++++ packages/LGgen/LGgen_Test/UnitTest1.cs | 12 -------- 22 files changed, 124 insertions(+), 84 deletions(-) delete mode 100644 packages/LGgen/LGgen/LgTemplate.cs create mode 100644 packages/LGgen/LGgen_Test/LGtest.cs create mode 100644 packages/LGgen/LGgen_Test/LGtest.lg create mode 100644 packages/LGgen/LGgen_Test/LGtest.ts create mode 100644 packages/LGgen/LGgen_Test/LGtest_ClassNameChoice/LGtest.cs create mode 100644 packages/LGgen/LGgen_Test/LGtest_Folder/LGchildfolder/test_2.lg create mode 100644 packages/LGgen/LGgen_Test/LGtest_Folder/common.cs create mode 100644 packages/LGgen/LGgen_Test/LGtest_Folder/test.lg create mode 100644 packages/LGgen/LGgen_Test/LGtest_OutputChoice/LGtest.ts create mode 100644 packages/LGgen/LGgen_Test/Program.cs delete mode 100644 packages/LGgen/LGgen_Test/UnitTest1.cs diff --git a/packages/LGgen/LGgen.sln b/packages/LGgen/LGgen.sln index 0d1b4e521..1992259a9 100644 --- a/packages/LGgen/LGgen.sln +++ b/packages/LGgen/LGgen.sln @@ -5,7 +5,7 @@ VisualStudioVersion = 16.0.29215.179 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LGgen", "LGgen\LGgen.csproj", "{E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LGgen_Test", "LGgen_Test\LGgen_Test.csproj", "{2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LGgen_test", "LGgen_test\LGgen_test.csproj", "{CCDBF0EC-B5B0-4ADF-BC30-95AB13C8A7B7}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -17,10 +17,10 @@ Global {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Debug|Any CPU.Build.0 = Debug|Any CPU {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Release|Any CPU.ActiveCfg = Release|Any CPU {E2C1ED1B-3B9C-460F-A686-BFE583FD85AB}.Release|Any CPU.Build.0 = Release|Any CPU - {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2DFEA06F-C6A5-46E9-AAB1-D2E8087BD915}.Release|Any CPU.Build.0 = Release|Any CPU + {CCDBF0EC-B5B0-4ADF-BC30-95AB13C8A7B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CCDBF0EC-B5B0-4ADF-BC30-95AB13C8A7B7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CCDBF0EC-B5B0-4ADF-BC30-95AB13C8A7B7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CCDBF0EC-B5B0-4ADF-BC30-95AB13C8A7B7}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/packages/LGgen/LGgen/CommandHandler.cs b/packages/LGgen/LGgen/CommandHandler.cs index deff4ee78..f507c47f1 100644 --- a/packages/LGgen/LGgen/CommandHandler.cs +++ b/packages/LGgen/LGgen/CommandHandler.cs @@ -1,9 +1,7 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.IO; using System.Linq; -using System.Net.Http; using Microsoft.Bot.Builder.LanguageGeneration; namespace LGgen @@ -13,17 +11,13 @@ public class CommandHandler : CommandHandlerBase private string inputPath = null; private string lang = null; private string outputPath = null; - private new List args = new List(); + private string className = null; private List LGFiles = new List(); private bool Dire = false; private bool GrammarCheckMode = false; - LgTemplate template = new LgTemplate(); public static List Message = new List(); - public CommandHandler(List args) : base(args) - { - this.args = args; - } + public CommandHandler(List args) : base(args) { } public CommandHandler UseLangHandler() { @@ -69,33 +63,34 @@ public CommandHandler UseInputHandler() return this; } - public CommandHandler UseOutputHandler() + + public CommandHandler UseNameHandler() { if (GrammarCheckMode) return this; - if (args.Contains("-o")) + if (args.Contains("-n")) { - outputPath = CommandGrammarCheck("-o"); + className = CommandGrammarCheck("-n"); } else { - outputPath = Dire ? Path.Join(inputPath, "common" + LanguageRegister.GetSuffix(lang)) : Path.ChangeExtension(inputPath, LanguageRegister.GetSuffix(lang)); + className = Dire ? "common" : Path.GetFileNameWithoutExtension(inputPath); } return this; } - public CommandHandler UseNameHandler() + public CommandHandler UseOutputHandler() { if (GrammarCheckMode) return this; - if (args.Contains("-n")) + if (args.Contains("-o")) { - template.className = CommandGrammarCheck("-n"); + outputPath = Dire ? Path.Join(CommandGrammarCheck("-o"), "common" + LanguageRegister.GetSuffix(lang)) : Path.Join(CommandGrammarCheck("-o"), Path.GetFileNameWithoutExtension(inputPath) + LanguageRegister.GetSuffix(lang)); } else { - template.className = Dire ? "common" : Path.GetFileNameWithoutExtension(inputPath); + outputPath = Dire ? Path.Join(inputPath, "common" + LanguageRegister.GetSuffix(lang)) : Path.ChangeExtension(inputPath, LanguageRegister.GetSuffix(lang)); } return this; @@ -136,11 +131,10 @@ public CommandHandler Generate() TemplateEngine lgEngine = new TemplateEngine(); lgEngine.AddFiles(LGFiles); - lgEngine.Templates.ForEach(num => template.lgTemplateName.Add(num.Name)); Message.Add($"generating class file {outputPath}"); ILanguage languagebase = LanguageRegister.GetGenerate(lang); - languagebase.Generate(outputPath, template); + languagebase.Generate(outputPath, className, lgEngine.Templates); return this; } diff --git a/packages/LGgen/LGgen/CommandHandlerBase.cs b/packages/LGgen/LGgen/CommandHandlerBase.cs index 8eb34a44f..730ea9674 100644 --- a/packages/LGgen/LGgen/CommandHandlerBase.cs +++ b/packages/LGgen/LGgen/CommandHandlerBase.cs @@ -13,7 +13,7 @@ public CommandHandlerBase(List args) this.args = args; LanguageRegister.RegisterAllLanguages(); Usage_Init(); - } + } protected void Usage_Init() { @@ -25,7 +25,6 @@ protected void Usage_Init() Usage.Add("-o : output path, defaults to directory where LG file is and the same name with LG file"); Usage.Add("-n : designate class name, defaults to the same name of LG file"); Usage.Add("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); - } protected string CommandGrammarCheck(string arg) diff --git a/packages/LGgen/LGgen/ILanguage.cs b/packages/LGgen/LGgen/ILanguage.cs index fb31e9838..6fddc8d5a 100644 --- a/packages/LGgen/LGgen/ILanguage.cs +++ b/packages/LGgen/LGgen/ILanguage.cs @@ -1,9 +1,10 @@ using System.Collections.Generic; +using Microsoft.Bot.Builder.LanguageGeneration; namespace LGgen { public interface ILanguage { - void Generate(string outPath, LgTemplate temp); + void Generate(string outPath, string clssName, List temp); } } diff --git a/packages/LGgen/LGgen/LanguageRegister.cs b/packages/LGgen/LGgen/LanguageRegister.cs index 446ecb64b..e24c7d77c 100644 --- a/packages/LGgen/LGgen/LanguageRegister.cs +++ b/packages/LGgen/LGgen/LanguageRegister.cs @@ -1,17 +1,16 @@ using System; using System.Collections.Generic; -using System.Runtime.CompilerServices; namespace LGgen { public static class LanguageRegister { - private static Dictionary generateDict = new Dictionary(); + private static Dictionary generateDict = new Dictionary(); private static Dictionary suffixDict = new Dictionary(); public static List languageList = new List(); - private static void Register(string name, string suffix, ILanguage Language) + private static void Register(string name, string suffix, Type type) { - generateDict.Add(name, Language); + generateDict.Add(name, type); suffixDict.Add(name, suffix); languageList.Add(name); } @@ -23,7 +22,7 @@ public static bool IsLanguage(string name) public static ILanguage GetGenerate(string name) { - return generateDict[name]; + return (ILanguage)Activator.CreateInstance(generateDict[name]); } public static string GetSuffix(string name) @@ -33,8 +32,8 @@ public static string GetSuffix(string name) public static void RegisterAllLanguages() { - Register("cs", ".cs", new CSharp()); - Register("ts", ".ts", new Typescript()); + Register("cs", ".cs", typeof(CSharp)); + Register("ts", ".ts", typeof(Typescript)); } } diff --git a/packages/LGgen/LGgen/LgTemplate.cs b/packages/LGgen/LGgen/LgTemplate.cs deleted file mode 100644 index 8005cd9af..000000000 --- a/packages/LGgen/LGgen/LgTemplate.cs +++ /dev/null @@ -1,10 +0,0 @@ -using System.Collections.Generic; - -namespace LGgen -{ - public class LgTemplate - { - public string className; - public List lgTemplateName = new List(); - } -} diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index d3f424307..303fcc3a1 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -1,6 +1,4 @@ using System; -using System.IO; -using System.Collections.Generic; using System.Linq; @@ -16,8 +14,8 @@ public static void Main(string[] args) .UseInputHandler() .UseCheckHandler() .UseLangHandler() - .UseOutputHandler() .UseNameHandler() + .UseOutputHandler() .Generate(); CommandHandler.Message.ForEach(num => Console.WriteLine(num)); @@ -28,7 +26,7 @@ public static void Main(string[] args) CommandHandlerBase.Usage.ForEach(num => Console.Error.WriteLine(num)); Environment.Exit(-1); } - + } } diff --git a/packages/LGgen/LGgen/README.md b/packages/LGgen/LGgen/README.md index f9bc0e612..91db55aed 100644 --- a/packages/LGgen/LGgen/README.md +++ b/packages/LGgen/LGgen/README.md @@ -1,6 +1,6 @@ # README -LGgen is a tool for generating strongly typed C# and typescript class file from a LG file. +LGgen is a tool for generating strongly typed C# and typescript class file from a LG file or a folder. ## Usage diff --git a/packages/LGgen/LGgen/Writer.cs b/packages/LGgen/LGgen/Writer.cs index 5320f7114..607196695 100644 --- a/packages/LGgen/LGgen/Writer.cs +++ b/packages/LGgen/LGgen/Writer.cs @@ -1,9 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. -using System; -using System.Collections.Generic; using System.IO; -using System.Text; namespace LGgen { diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs index 8118ff7a9..263f2147c 100644 --- a/packages/LGgen/LGgen/csharp.cs +++ b/packages/LGgen/LGgen/csharp.cs @@ -1,25 +1,23 @@ -using System; using System.Collections.Generic; -using System.Globalization; -using System.IO; +using Microsoft.Bot.Builder.LanguageGeneration; + namespace LGgen { class CSharp:ILanguage { - public void Generate(string outPath, LgTemplate temp) + public void Generate(string outPath, string className, List temp) { var w = new Writer(outPath); w.WriteLine("namespace LGgen"); w.WriteLine("{"); w.Indent(); - w.IndentLine($"public class {temp.className}"); + w.IndentLine($"public class {className}"); w.IndentLine("{"); w.Indent(); - foreach (var name in temp.lgTemplateName) - w.IndentLine($"public const string {name} = \"{name}\";"); + temp.ForEach(num => w.IndentLine($"public const string {num.Name} = \"{num.Name}\";")); w.Outdent(); w.IndentLine("}"); w.Outdent(); @@ -30,3 +28,5 @@ public void Generate(string outPath, LgTemplate temp) } } } + + diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs index 1b7ba1b68..d708819e9 100644 --- a/packages/LGgen/LGgen/typescript.cs +++ b/packages/LGgen/LGgen/typescript.cs @@ -1,18 +1,18 @@ +using Microsoft.Bot.Builder.LanguageGeneration; using System.Collections.Generic; namespace LGgen { class Typescript:ILanguage { - public void Generate(string outPath, LgTemplate temp) + public void Generate(string outPath, string className, List temp) { var w = new Writer(outPath); - w.WriteLine($"export default class {temp.className}"); + w.WriteLine($"export default class {className}"); w.WriteLine("{"); w.Indent(); - foreach (var name in temp.lgTemplateName) - w.IndentLine($"static {name}:string = \"{name}\";"); + temp.ForEach(num => w.IndentLine($"static {num.Name}:string = \"{num.Name}\";")); w.Outdent(); w.IndentLine("}"); diff --git a/packages/LGgen/LGgen_Test/LGgen_Test.csproj b/packages/LGgen/LGgen_Test/LGgen_Test.csproj index 4838eef10..fbe055261 100644 --- a/packages/LGgen/LGgen_Test/LGgen_Test.csproj +++ b/packages/LGgen/LGgen_Test/LGgen_Test.csproj @@ -1,17 +1,10 @@  + Exe netcoreapp2.1 - - false - - - - - - diff --git a/packages/LGgen/LGgen_Test/LGtest.cs b/packages/LGgen/LGgen_Test/LGtest.cs new file mode 100644 index 000000000..542b54184 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest.cs @@ -0,0 +1,9 @@ +namespace LGgen +{ + public class LGtest + { + public const string tempalte_1 = "tempalte_1"; + public const string tempalte_2 = "tempalte_2"; + public const string tempalte_3 = "tempalte_3"; + } +} diff --git a/packages/LGgen/LGgen_Test/LGtest.lg b/packages/LGgen/LGgen_Test/LGtest.lg new file mode 100644 index 000000000..a36d1c9cc --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest.lg @@ -0,0 +1,8 @@ +# tempalte_1 +- Body_1 + +# tempalte_2 +- Body_2 + +# tempalte_3 +- Body_3 diff --git a/packages/LGgen/LGgen_Test/LGtest.ts b/packages/LGgen/LGgen_Test/LGtest.ts new file mode 100644 index 000000000..3f1d7c380 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest.ts @@ -0,0 +1,6 @@ +export default class LGtest +{ + static tempalte_1:string = "tempalte_1"; + static tempalte_2:string = "tempalte_2"; + static tempalte_3:string = "tempalte_3"; +} diff --git a/packages/LGgen/LGgen_Test/LGtest_ClassNameChoice/LGtest.cs b/packages/LGgen/LGgen_Test/LGtest_ClassNameChoice/LGtest.cs new file mode 100644 index 000000000..3cf9fb529 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest_ClassNameChoice/LGtest.cs @@ -0,0 +1,9 @@ +namespace LGgen +{ + public class LG + { + public const string tempalte_1 = "tempalte_1"; + public const string tempalte_2 = "tempalte_2"; + public const string tempalte_3 = "tempalte_3"; + } +} diff --git a/packages/LGgen/LGgen_Test/LGtest_Folder/LGchildfolder/test_2.lg b/packages/LGgen/LGgen_Test/LGtest_Folder/LGchildfolder/test_2.lg new file mode 100644 index 000000000..98dcec08d --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest_Folder/LGchildfolder/test_2.lg @@ -0,0 +1,8 @@ +# tempalte_4 +- Body_4 + +# tempalte_5 +- Body_5 + +# tempalte_6 +- Body_6 diff --git a/packages/LGgen/LGgen_Test/LGtest_Folder/common.cs b/packages/LGgen/LGgen_Test/LGtest_Folder/common.cs new file mode 100644 index 000000000..d3fc336ab --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest_Folder/common.cs @@ -0,0 +1,12 @@ +namespace LGgen +{ + public class common + { + public const string tempalte_4 = "tempalte_4"; + public const string tempalte_5 = "tempalte_5"; + public const string tempalte_6 = "tempalte_6"; + public const string tempalte_1 = "tempalte_1"; + public const string tempalte_2 = "tempalte_2"; + public const string tempalte_3 = "tempalte_3"; + } +} diff --git a/packages/LGgen/LGgen_Test/LGtest_Folder/test.lg b/packages/LGgen/LGgen_Test/LGtest_Folder/test.lg new file mode 100644 index 000000000..a36d1c9cc --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest_Folder/test.lg @@ -0,0 +1,8 @@ +# tempalte_1 +- Body_1 + +# tempalte_2 +- Body_2 + +# tempalte_3 +- Body_3 diff --git a/packages/LGgen/LGgen_Test/LGtest_OutputChoice/LGtest.ts b/packages/LGgen/LGgen_Test/LGtest_OutputChoice/LGtest.ts new file mode 100644 index 000000000..3f1d7c380 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest_OutputChoice/LGtest.ts @@ -0,0 +1,6 @@ +export default class LGtest +{ + static tempalte_1:string = "tempalte_1"; + static tempalte_2:string = "tempalte_2"; + static tempalte_3:string = "tempalte_3"; +} diff --git a/packages/LGgen/LGgen_Test/Program.cs b/packages/LGgen/LGgen_Test/Program.cs new file mode 100644 index 000000000..a6d4ff6f7 --- /dev/null +++ b/packages/LGgen/LGgen_Test/Program.cs @@ -0,0 +1,17 @@ +using System; + +namespace LGgen +{ + class Program + { + static void Main(string[] args) + { + //LGgenTool.Main(new string[] { "-c", "-i" , "../../../LGtest.lg"}); + //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); + //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg" }); + //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest_Folder" }); + //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg", "-o", "../../../LGtest_OutputChoice/"}); + LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); + } + } +} diff --git a/packages/LGgen/LGgen_Test/UnitTest1.cs b/packages/LGgen/LGgen_Test/UnitTest1.cs deleted file mode 100644 index 70640bac9..000000000 --- a/packages/LGgen/LGgen_Test/UnitTest1.cs +++ /dev/null @@ -1,12 +0,0 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace LGgen -{ - public class UnitTest1 - { - public void Main(string[] args) - { - LGgenTool.Main(args); - } - } -} From f6956c63c3115a6aee31e8bc4fe33d96e2ff67cf Mon Sep 17 00:00:00 2001 From: t-hahan Date: Wed, 28 Aug 2019 17:43:41 +0800 Subject: [PATCH 09/11] decouple commands --- packages/LGgen/LGgen/Command.cs | 149 +++++++++++++++++++++ packages/LGgen/LGgen/CommandHandler.cs | 148 +++++--------------- packages/LGgen/LGgen/CommandHandlerBase.cs | 36 ++--- packages/LGgen/LGgen/ICommandMiddleware.cs | 11 ++ packages/LGgen/LGgen/LanguageRegister.cs | 18 +-- packages/LGgen/LGgen/Program.cs | 33 ++--- packages/LGgen/LGgen/Util.cs | 2 +- packages/LGgen/LGgen_Test/Program.cs | 13 +- 8 files changed, 247 insertions(+), 163 deletions(-) create mode 100644 packages/LGgen/LGgen/Command.cs create mode 100644 packages/LGgen/LGgen/ICommandMiddleware.cs diff --git a/packages/LGgen/LGgen/Command.cs b/packages/LGgen/LGgen/Command.cs new file mode 100644 index 000000000..1b5231735 --- /dev/null +++ b/packages/LGgen/LGgen/Command.cs @@ -0,0 +1,149 @@ +using System; +using System.IO; +using System.Collections.Generic; +using Microsoft.Bot.Builder.LanguageGeneration; +using System.Linq; + +namespace LGgen +{ + public class InputHandler : ICommandMiddleware + { + public string Usage { get; set; } = "-i : LG file path or file folder. "; + public string UsageSample { get; set; } = "-i LG_FILE_PATH OR FOLDER"; + public string Command { get; set; } = "-i"; + public bool SingleCommand { get; set; } = false; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + + if (temp == "") return; + + context.InputPath = temp; + + if (Directory.Exists(context.InputPath)) + { + context.Dire = true; + Utils.GetAllFiles(context.InputPath, context.LGFiles); + } + else if (File.Exists(context.InputPath) && Path.GetExtension(context.InputPath) == ".lg") + { + context.LGFiles.Add(context.InputPath); + } + else + { + throw new Exception("Can't Read your Input. "); + } + } + } + + class CheckHandler : ICommandMiddleware + { + public string Usage { get; set; } = "-c : LG file Grammar Check Mode. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "; + public string UsageSample { get; set; } = "-c"; + public string Command { get; set; } = "-c"; + public bool SingleCommand { get; set; } = true; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + if (temp == "") return; + + if (context.InputPath == "") throw new Exception("-i command is complosory for Grammar Check Mode. "); + if (context.LGFiles == null) throw new Exception("Fail to Read any LG File. "); + + TemplateEngine lgEngine = new TemplateEngine(); + try + { + lgEngine.AddFiles(context.LGFiles); + context.Message.Add("Congratulations! No error in this LG file! "); + } + catch (Exception e) + { + List errors = e.Message.Split('\n').ToList(); + context.Message.Add($"This LG file has {errors.Count} errors: "); + errors.ForEach(i => context.Message.Add(i)); + } + + context.ExitBeforeGenerate = true; + } + } + + class LangHandler : ICommandMiddleware + { + public string Usage { get; set; } = $"-l : Generate Class File Mode. Please Choose Language. {Utils.SupportLanguage()}"; + public string UsageSample { get; set; } = $"-l {Utils.SupportLanguage()}"; + public string Command { get; set; } = "-l"; + public bool SingleCommand { get; set; } = false; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + if (temp == "") return; + + if (context.InputPath == "") throw new Exception("-i command is complosory for Class File Generation Mode. "); + + if (!LanguageRegister.IsLanguage(temp)) throw new Exception("Not Support this Language. " + Utils.SupportLanguage()); + context.Language = temp; + } + } + + class OutputHandler : ICommandMiddleware + { + public string Usage { get; set; } = "-o : designate output path, defaults to directory where LG file is and the same name with LG file"; + public string UsageSample { get; set; } = "-o OUTPUT_PATH"; + public string Command { get; set; } = "-o"; + public bool SingleCommand { get; set; } = false; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + + if (context.InputPath == "" || context.Language == "") return; + + if (temp != "") context.OutputPath = context.Dire ? + Path.Join(temp, "common" + LanguageRegister.GetSuffix(context.Language)) : + Path.Join(temp, Path.GetFileNameWithoutExtension(context.InputPath) + LanguageRegister.GetSuffix(context.Language)); + else context.OutputPath = context.Dire ? + Path.Join(context.InputPath, "common" + LanguageRegister.GetSuffix(context.Language)) : + Path.ChangeExtension(context.InputPath, LanguageRegister.GetSuffix(context.Language)); + } + } + + class NameHandler : ICommandMiddleware + { + public string Usage { get; set; } = "-n : designate class name, defaults to the same name of LG file"; + public string UsageSample { get; set; } = "-n CLASS_NAME"; + public string Command { get; set; } = "-n"; + public bool SingleCommand { get; set; } = false; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + + if (context.InputPath == "" || context.Language == "") return; + + if (temp != "") context.ClassName = temp; + else context.ClassName = context.Dire ? "common" : Path.GetFileNameWithoutExtension(context.InputPath); + } + } + + class VersionHandler : ICommandMiddleware + { + public string Usage { get; set; } = "-v : version"; + public string UsageSample { get; set; } = "-v"; + public string Command { get; set; } = "-v"; + public bool SingleCommand { get; set; } = true; + + public void Compile(CommandHandler context) + { + var temp = CommandHandlerBase.CommandInputGrammarCheck(this); + if (temp == "") return; + + Console.WriteLine("LGgen version 1.0 "); + + context.ExitBeforeGenerate = true; + } + } + +} diff --git a/packages/LGgen/LGgen/CommandHandler.cs b/packages/LGgen/LGgen/CommandHandler.cs index f507c47f1..94d82aa70 100644 --- a/packages/LGgen/LGgen/CommandHandler.cs +++ b/packages/LGgen/LGgen/CommandHandler.cs @@ -1,146 +1,72 @@ -using System; using System.Collections.Generic; -using System.IO; -using System.Linq; +using System.Text; using Microsoft.Bot.Builder.LanguageGeneration; +using System.Linq; +using System; namespace LGgen { public class CommandHandler : CommandHandlerBase { - private string inputPath = null; - private string lang = null; - private string outputPath = null; - private string className = null; - private List LGFiles = new List(); - private bool Dire = false; - private bool GrammarCheckMode = false; - public static List Message = new List(); + public string InputPath { get; set; } = null; + public string Language { get; set; } = null; + public string OutputPath { get; set; } = null; + public string ClassName { get; set; } = null; + public bool Dire { get; set; } = false; + public bool ExitBeforeGenerate { get; set; } = false; + public List Message { get; set; } = new List(); + public List LGFiles { get; set; } = new List(); + public List MiddleWares { get; set; } = new List(); public CommandHandler(List args) : base(args) { } - public CommandHandler UseLangHandler() + public CommandHandler AddCommand (ICommandMiddleware middleWare) { - if (GrammarCheckMode) return this; + MiddleWares.Add(middleWare); - if (args.Contains("-l")) - { - lang = CommandGrammarCheck("-l"); - if (!LanguageRegister.IsLanguage(lang)) throw new Exception("Not Support this Language. " + Utils.SupportLanguage()); - } - else - { - throw new Exception("-l Command is Complosory. "); - } return this; } - public CommandHandler UseInputHandler() + public string GetUsage() { - if (args.Contains("-i")) - { - inputPath = CommandGrammarCheck("-i"); - - if (Directory.Exists(inputPath)) - { - Dire = true; - Utils.GetAllFiles(inputPath, LGFiles); - } - else if (File.Exists(inputPath) && Path.GetExtension(inputPath) == ".lg") - { - LGFiles.Add(inputPath); - } - else - { - throw new Exception("Can't Read your Input. "); - } - } - else + var stringbuilder = new StringBuilder(); + var usagebuilder = new StringBuilder(); + var usagesamplebuilder = new StringBuilder(); + usagesamplebuilder.Append("LGgen "); + foreach (var handler in MiddleWares) { - throw new Exception("-i Command is Complosory. "); + usagesamplebuilder.Append($"[{handler.UsageSample}] "); + usagebuilder.Append(handler.Usage); + usagebuilder.Append("\r\n"); } - - return this; - + stringbuilder.Append(usagesamplebuilder.ToString()); + stringbuilder.Append("\n\rGenerate a strongly typed class from a LG file \n\rOptions: \n\r"); + stringbuilder.Append(usagebuilder); + return stringbuilder.ToString(); } - public CommandHandler UseNameHandler() + private void Compile() { - if (GrammarCheckMode) return this; - - if (args.Contains("-n")) + foreach (var command in MiddleWares) { - className = CommandGrammarCheck("-n"); + command.Compile(this); + if (ExitBeforeGenerate) return; } - else - { - className = Dire ? "common" : Path.GetFileNameWithoutExtension(inputPath); - } - - return this; + if (InputPath == "" || OutputPath == "" || !LGFiles.Any() || ClassName == "" || Language == "") throw new Exception("Fail to Enter Generate Class File Mode. Check your Input."); } - public CommandHandler UseOutputHandler() + public void Generate() { - if (GrammarCheckMode) return this; - - if (args.Contains("-o")) - { - outputPath = Dire ? Path.Join(CommandGrammarCheck("-o"), "common" + LanguageRegister.GetSuffix(lang)) : Path.Join(CommandGrammarCheck("-o"), Path.GetFileNameWithoutExtension(inputPath) + LanguageRegister.GetSuffix(lang)); - } - else - { - outputPath = Dire ? Path.Join(inputPath, "common" + LanguageRegister.GetSuffix(lang)) : Path.ChangeExtension(inputPath, LanguageRegister.GetSuffix(lang)); - } - - return this; - } - - public CommandHandler UseCheckHandler() - { - if (args.Contains("-c")) - { - if (LGFiles == null) throw new Exception("Fail to Read any LG File. "); - - TemplateEngine lgEngine = new TemplateEngine(); - try - { - lgEngine.AddFiles(LGFiles); - Message.Add("Congratulations! No error in this LG file! "); - } - catch (Exception e) - { - List errors = e.Message.Split('\n').ToList(); - Message.Add($"This LG file has {errors.Count} errors: "); - errors.ForEach(i => Message.Add(i)); - } - - GrammarCheckMode = true; - } - - return this; - - } - - public CommandHandler Generate() - { - if (GrammarCheckMode) return this; - - if (LGFiles == null) throw new Exception("Fail to Read any LG File. "); + Compile(); + if (ExitBeforeGenerate) return; TemplateEngine lgEngine = new TemplateEngine(); lgEngine.AddFiles(LGFiles); - Message.Add($"generating class file {outputPath}"); + Message.Add($"generating class file {OutputPath}"); - ILanguage languagebase = LanguageRegister.GetGenerate(lang); - languagebase.Generate(outputPath, className, lgEngine.Templates); - - return this; + LanguageRegister.GetGenerate(Language).Generate(OutputPath, ClassName, lgEngine.Templates); } - } - - } diff --git a/packages/LGgen/LGgen/CommandHandlerBase.cs b/packages/LGgen/LGgen/CommandHandlerBase.cs index 730ea9674..e0d144db4 100644 --- a/packages/LGgen/LGgen/CommandHandlerBase.cs +++ b/packages/LGgen/LGgen/CommandHandlerBase.cs @@ -5,43 +5,29 @@ namespace LGgen { public class CommandHandlerBase { - protected List args = new List(); - public static List Usage = new List(); + protected static List Args { get; set; } = new List(); + public static List Usage { get; set; } = new List(); public CommandHandlerBase(List args) { - this.args = args; + Args = args; LanguageRegister.RegisterAllLanguages(); - Usage_Init(); } - protected void Usage_Init() + public static string CommandInputGrammarCheck(ICommandMiddleware middleware) { - Usage.Add("LGgen [-l cs/ts] [-i LG_FILE_PATH] [-o OUTPUT_PATH] [-n CLASS_NAME]"); - Usage.Add("Generate a strongly typed class from a LG file"); - Usage.Add("Options: "); - Usage.Add("-l : choose language. " + Utils.SupportLanguage()); - Usage.Add("-i : LG file path or file folder. "); - Usage.Add("-o : output path, defaults to directory where LG file is and the same name with LG file"); - Usage.Add("-n : designate class name, defaults to the same name of LG file"); - Usage.Add("-c : LG file grammar check. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "); - } + if (!Args.Contains(middleware.Command)) return new string(""); - protected string CommandGrammarCheck(string arg) - { - if (args.Count == args.IndexOf(arg) + 1) + if (middleware.SingleCommand) return new string(" "); + else if (Args.Count == Args.IndexOf(middleware.Command) + 1) { - throw new Exception("End with a Command without Value. "); + throw new Exception($"End with Command{middleware.Command} without Value. "); } else { - var temp = args[args.IndexOf(arg) + 1]; - if (!temp.StartsWith('-')) - return temp; - else - { - throw new Exception("No Corresponding Value with the Command. "); - } + var temp = Args[Args.IndexOf(middleware.Command) + 1]; + if (!temp.StartsWith('-') && temp != "") return temp; + else throw new Exception($"No Corresponding Value with the Command {middleware.Command}. "); } } } diff --git a/packages/LGgen/LGgen/ICommandMiddleware.cs b/packages/LGgen/LGgen/ICommandMiddleware.cs new file mode 100644 index 000000000..3f9a66edd --- /dev/null +++ b/packages/LGgen/LGgen/ICommandMiddleware.cs @@ -0,0 +1,11 @@ +namespace LGgen +{ + public interface ICommandMiddleware + { + string Usage { get; set; } + string UsageSample { get; set; } + string Command { get; set; } + bool SingleCommand { get; set; } + void Compile(CommandHandler context); + } +} \ No newline at end of file diff --git a/packages/LGgen/LGgen/LanguageRegister.cs b/packages/LGgen/LGgen/LanguageRegister.cs index e24c7d77c..c0085a695 100644 --- a/packages/LGgen/LGgen/LanguageRegister.cs +++ b/packages/LGgen/LGgen/LanguageRegister.cs @@ -5,29 +5,29 @@ namespace LGgen { public static class LanguageRegister { - private static Dictionary generateDict = new Dictionary(); - private static Dictionary suffixDict = new Dictionary(); - public static List languageList = new List(); + private static Dictionary GenerateDict { get; set; } = new Dictionary(); + private static Dictionary SuffixDict { get; set; } = new Dictionary(); + public static List LanguageList { get; set; } = new List(); private static void Register(string name, string suffix, Type type) { - generateDict.Add(name, type); - suffixDict.Add(name, suffix); - languageList.Add(name); + GenerateDict.Add(name, type); + SuffixDict.Add(name, suffix); + LanguageList.Add(name); } public static bool IsLanguage(string name) { - return languageList.Contains(name); + return LanguageList.Contains(name); } public static ILanguage GetGenerate(string name) { - return (ILanguage)Activator.CreateInstance(generateDict[name]); + return (ILanguage)Activator.CreateInstance(GenerateDict[name]); } public static string GetSuffix(string name) { - return suffixDict[name]; + return SuffixDict[name]; } public static void RegisterAllLanguages() diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs index 303fcc3a1..109e6e56e 100644 --- a/packages/LGgen/LGgen/Program.cs +++ b/packages/LGgen/LGgen/Program.cs @@ -1,6 +1,7 @@ using System; +using System.ComponentModel.Design.Serialization; using System.Linq; - +using System.Runtime.InteropServices; namespace LGgen { @@ -8,27 +9,27 @@ public class LGgenTool { public static void Main(string[] args) { - try - { - _ = new CommandHandler(args.ToList()) - .UseInputHandler() - .UseCheckHandler() - .UseLangHandler() - .UseNameHandler() - .UseOutputHandler() - .Generate(); + var handler = new CommandHandler(args.ToList()) + .AddCommand(new InputHandler()) + .AddCommand(new CheckHandler()) + .AddCommand(new LangHandler()) + .AddCommand(new OutputHandler()) + .AddCommand(new NameHandler()) + .AddCommand(new VersionHandler()); + + var usage = handler.GetUsage(); - CommandHandler.Message.ForEach(num => Console.WriteLine(num)); + try + { + handler.Generate(); + handler.Message.ForEach(num => Console.WriteLine(num)); } catch(Exception e) { Console.WriteLine(e.Message); - CommandHandlerBase.Usage.ForEach(num => Console.Error.WriteLine(num)); + Console.WriteLine(usage); Environment.Exit(-1); - } - + } } - } - } diff --git a/packages/LGgen/LGgen/Util.cs b/packages/LGgen/LGgen/Util.cs index a09811d73..5f7223202 100644 --- a/packages/LGgen/LGgen/Util.cs +++ b/packages/LGgen/LGgen/Util.cs @@ -32,7 +32,7 @@ public static void GetAllFiles(string dir, List LGfiles) public static string SupportLanguage() { string s = "Support Language: "; - foreach (var temp in LanguageRegister.languageList) + foreach (var temp in LanguageRegister.LanguageList) { s += temp; s += " "; diff --git a/packages/LGgen/LGgen_Test/Program.cs b/packages/LGgen/LGgen_Test/Program.cs index a6d4ff6f7..8758ec9d8 100644 --- a/packages/LGgen/LGgen_Test/Program.cs +++ b/packages/LGgen/LGgen_Test/Program.cs @@ -6,12 +6,23 @@ class Program { static void Main(string[] args) { + //FunctionTest + + //LGgenTool.Main(new string[] { "-c", "-i" , "../../../LGtest.lg"}); //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg" }); //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest_Folder" }); //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg", "-o", "../../../LGtest_OutputChoice/"}); - LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); + //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); + //LGgenTool.Main(new string[] { "-o", "cs" }); + //LGgenTool.Main(new string[] { "-v" }); + + //Error Test + + //LGgenTool.Main(new string[] { "-a" }); + //LGgenTool.Main(new string[] { "-c" }); + //LGgenTool.Main(new string[] { "-l" ,"-i", "../../../LGtest.lg"}); } } } From 879765fcfadde7c02669e4b7043d475b46773e4c Mon Sep 17 00:00:00 2001 From: hond Date: Thu, 29 Aug 2019 14:40:41 +0800 Subject: [PATCH 10/11] make some change --- packages/LGgen/LGgen/BaseCommand.cs | 46 +++++ packages/LGgen/LGgen/CSharpGenerator.cs | 32 ++++ packages/LGgen/LGgen/Command.cs | 149 --------------- packages/LGgen/LGgen/CommandHandler.cs | 73 +++++--- packages/LGgen/LGgen/CommandHandlerBase.cs | 34 ---- packages/LGgen/LGgen/Commands.cs | 170 ++++++++++++++++++ packages/LGgen/LGgen/ICommandMiddleware.cs | 11 -- .../{ILanguage.cs => ILanguageGenerator.cs} | 2 +- packages/LGgen/LGgen/LGGenTool.cs | 53 ++++++ packages/LGgen/LGgen/LGgen.csproj | 4 +- packages/LGgen/LGgen/LanguageRegister.cs | 10 +- packages/LGgen/LGgen/Program.cs | 35 ---- packages/LGgen/LGgen/TypescriptGenerator.cs | 23 +++ packages/LGgen/LGgen/Util.cs | 45 ----- packages/LGgen/LGgen/Writer.cs | 2 +- packages/LGgen/LGgen/csharp.cs | 32 ---- packages/LGgen/LGgen/typescript.cs | 23 --- packages/LGgen/LGgen_Test/LGgen_Test.csproj | 4 + packages/LGgen/LGgen_Test/LGtest.ts | 6 - packages/LGgen/LGgen_Test/Program.cs | 24 +-- 20 files changed, 397 insertions(+), 381 deletions(-) create mode 100644 packages/LGgen/LGgen/BaseCommand.cs create mode 100644 packages/LGgen/LGgen/CSharpGenerator.cs delete mode 100644 packages/LGgen/LGgen/Command.cs delete mode 100644 packages/LGgen/LGgen/CommandHandlerBase.cs create mode 100644 packages/LGgen/LGgen/Commands.cs delete mode 100644 packages/LGgen/LGgen/ICommandMiddleware.cs rename packages/LGgen/LGgen/{ILanguage.cs => ILanguageGenerator.cs} (82%) create mode 100644 packages/LGgen/LGgen/LGGenTool.cs delete mode 100644 packages/LGgen/LGgen/Program.cs create mode 100644 packages/LGgen/LGgen/TypescriptGenerator.cs delete mode 100644 packages/LGgen/LGgen/Util.cs delete mode 100644 packages/LGgen/LGgen/csharp.cs delete mode 100644 packages/LGgen/LGgen/typescript.cs delete mode 100644 packages/LGgen/LGgen_Test/LGtest.ts diff --git a/packages/LGgen/LGgen/BaseCommand.cs b/packages/LGgen/LGgen/BaseCommand.cs new file mode 100644 index 000000000..2b52afe84 --- /dev/null +++ b/packages/LGgen/LGgen/BaseCommand.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace LGgen +{ + public abstract class BaseCommand + { + public BaseCommand(string usage, string usageSample, string command, bool singleCommand = true) + { + Usage = usage; + UsageSample = usageSample; + Command = command; + SingleCommand = singleCommand; + } + + public string Usage { get; set; } + public string UsageSample { get; set; } + public string Command { get; set; } + public bool SingleCommand { get; set; } + public abstract void Compile(CommandHandler context); + + public bool TryGetCommandValue(List args, out string commandValue) + { + commandValue = ""; + + if (!args.Contains(Command)) return false; + + if (SingleCommand) return false; + else if (args.Count == args.IndexOf(Command) + 1) + { + throw new Exception($"End with Command {Command} without Value. "); + } + else + { + var temp = args[args.IndexOf(Command) + 1]; + if (!temp.StartsWith('-') && temp != "") + { + commandValue = temp; + return true; + } + else throw new Exception($"No Corresponding Value with the Command {Command}. "); + } + } + } +} diff --git a/packages/LGgen/LGgen/CSharpGenerator.cs b/packages/LGgen/LGgen/CSharpGenerator.cs new file mode 100644 index 000000000..f75955d5f --- /dev/null +++ b/packages/LGgen/LGgen/CSharpGenerator.cs @@ -0,0 +1,32 @@ +using System.Collections.Generic; +using Microsoft.Bot.Builder.LanguageGeneration; + + +namespace LGgen +{ + class CSharpGenerator : ILanguageGenerator + { + + public void Generate(string outPath, string className, List temp) + { + var generatorWriter = new Writer(outPath); + generatorWriter.WriteLine("namespace LGgen"); + generatorWriter.WriteLine("{"); + generatorWriter.Indent(); + generatorWriter.IndentLine($"public class {className}"); + generatorWriter.IndentLine("{"); + generatorWriter.Indent(); + + temp.ForEach(num => generatorWriter.IndentLine($"public const string {num.Name} = \"{num.Name}\";")); + generatorWriter.Outdent(); + generatorWriter.IndentLine("}"); + generatorWriter.Outdent(); + generatorWriter.IndentLine("}"); + + generatorWriter.Flush(); + generatorWriter.Close(); + } + } +} + + diff --git a/packages/LGgen/LGgen/Command.cs b/packages/LGgen/LGgen/Command.cs deleted file mode 100644 index 1b5231735..000000000 --- a/packages/LGgen/LGgen/Command.cs +++ /dev/null @@ -1,149 +0,0 @@ -using System; -using System.IO; -using System.Collections.Generic; -using Microsoft.Bot.Builder.LanguageGeneration; -using System.Linq; - -namespace LGgen -{ - public class InputHandler : ICommandMiddleware - { - public string Usage { get; set; } = "-i : LG file path or file folder. "; - public string UsageSample { get; set; } = "-i LG_FILE_PATH OR FOLDER"; - public string Command { get; set; } = "-i"; - public bool SingleCommand { get; set; } = false; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - - if (temp == "") return; - - context.InputPath = temp; - - if (Directory.Exists(context.InputPath)) - { - context.Dire = true; - Utils.GetAllFiles(context.InputPath, context.LGFiles); - } - else if (File.Exists(context.InputPath) && Path.GetExtension(context.InputPath) == ".lg") - { - context.LGFiles.Add(context.InputPath); - } - else - { - throw new Exception("Can't Read your Input. "); - } - } - } - - class CheckHandler : ICommandMiddleware - { - public string Usage { get; set; } = "-c : LG file Grammar Check Mode. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' "; - public string UsageSample { get; set; } = "-c"; - public string Command { get; set; } = "-c"; - public bool SingleCommand { get; set; } = true; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - if (temp == "") return; - - if (context.InputPath == "") throw new Exception("-i command is complosory for Grammar Check Mode. "); - if (context.LGFiles == null) throw new Exception("Fail to Read any LG File. "); - - TemplateEngine lgEngine = new TemplateEngine(); - try - { - lgEngine.AddFiles(context.LGFiles); - context.Message.Add("Congratulations! No error in this LG file! "); - } - catch (Exception e) - { - List errors = e.Message.Split('\n').ToList(); - context.Message.Add($"This LG file has {errors.Count} errors: "); - errors.ForEach(i => context.Message.Add(i)); - } - - context.ExitBeforeGenerate = true; - } - } - - class LangHandler : ICommandMiddleware - { - public string Usage { get; set; } = $"-l : Generate Class File Mode. Please Choose Language. {Utils.SupportLanguage()}"; - public string UsageSample { get; set; } = $"-l {Utils.SupportLanguage()}"; - public string Command { get; set; } = "-l"; - public bool SingleCommand { get; set; } = false; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - if (temp == "") return; - - if (context.InputPath == "") throw new Exception("-i command is complosory for Class File Generation Mode. "); - - if (!LanguageRegister.IsLanguage(temp)) throw new Exception("Not Support this Language. " + Utils.SupportLanguage()); - context.Language = temp; - } - } - - class OutputHandler : ICommandMiddleware - { - public string Usage { get; set; } = "-o : designate output path, defaults to directory where LG file is and the same name with LG file"; - public string UsageSample { get; set; } = "-o OUTPUT_PATH"; - public string Command { get; set; } = "-o"; - public bool SingleCommand { get; set; } = false; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - - if (context.InputPath == "" || context.Language == "") return; - - if (temp != "") context.OutputPath = context.Dire ? - Path.Join(temp, "common" + LanguageRegister.GetSuffix(context.Language)) : - Path.Join(temp, Path.GetFileNameWithoutExtension(context.InputPath) + LanguageRegister.GetSuffix(context.Language)); - else context.OutputPath = context.Dire ? - Path.Join(context.InputPath, "common" + LanguageRegister.GetSuffix(context.Language)) : - Path.ChangeExtension(context.InputPath, LanguageRegister.GetSuffix(context.Language)); - } - } - - class NameHandler : ICommandMiddleware - { - public string Usage { get; set; } = "-n : designate class name, defaults to the same name of LG file"; - public string UsageSample { get; set; } = "-n CLASS_NAME"; - public string Command { get; set; } = "-n"; - public bool SingleCommand { get; set; } = false; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - - if (context.InputPath == "" || context.Language == "") return; - - if (temp != "") context.ClassName = temp; - else context.ClassName = context.Dire ? "common" : Path.GetFileNameWithoutExtension(context.InputPath); - } - } - - class VersionHandler : ICommandMiddleware - { - public string Usage { get; set; } = "-v : version"; - public string UsageSample { get; set; } = "-v"; - public string Command { get; set; } = "-v"; - public bool SingleCommand { get; set; } = true; - - public void Compile(CommandHandler context) - { - var temp = CommandHandlerBase.CommandInputGrammarCheck(this); - if (temp == "") return; - - Console.WriteLine("LGgen version 1.0 "); - - context.ExitBeforeGenerate = true; - } - } - -} diff --git a/packages/LGgen/LGgen/CommandHandler.cs b/packages/LGgen/LGgen/CommandHandler.cs index 94d82aa70..12fcbdd7e 100644 --- a/packages/LGgen/LGgen/CommandHandler.cs +++ b/packages/LGgen/LGgen/CommandHandler.cs @@ -1,29 +1,38 @@ -using System.Collections.Generic; -using System.Text; using Microsoft.Bot.Builder.LanguageGeneration; -using System.Linq; using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; namespace LGgen { - public class CommandHandler : CommandHandlerBase + public class CommandHandler { - public string InputPath { get; set; } = null; - public string Language { get; set; } = null; - public string OutputPath { get; set; } = null; - public string ClassName { get; set; } = null; - public bool Dire { get; set; } = false; - public bool ExitBeforeGenerate { get; set; } = false; - public List Message { get; set; } = new List(); - public List LGFiles { get; set; } = new List(); - public List MiddleWares { get; set; } = new List(); + public List Args { get; set; } + public string InputPath { get; set; } + public string Language { get; set; } + public string OutputPath { get; set; } + public string ClassName { get; set; } + public bool Dire { get; set; } + public bool ExitBeforeGenerate { get; set; } + public List Messages { get; set; } + public List LGFiles { get; set; } + public List Commands { get; set; } - public CommandHandler(List args) : base(args) { } - - public CommandHandler AddCommand (ICommandMiddleware middleWare) + public CommandHandler() { - MiddleWares.Add(middleWare); + Messages = new List(); + LGFiles = new List(); + Commands = new List(); + Language = "cs"; // default cs + LanguageRegister.RegisterAllLanguages(); + } + + public CommandHandler AddCommand (BaseCommand command) + { + Commands.Add(command); return this; } @@ -33,12 +42,14 @@ public string GetUsage() var usagebuilder = new StringBuilder(); var usagesamplebuilder = new StringBuilder(); usagesamplebuilder.Append("LGgen "); - foreach (var handler in MiddleWares) + + foreach (var command in Commands) { - usagesamplebuilder.Append($"[{handler.UsageSample}] "); - usagebuilder.Append(handler.Usage); + usagesamplebuilder.Append($"[{command.UsageSample}] "); + usagebuilder.Append(command.Usage); usagebuilder.Append("\r\n"); } + stringbuilder.Append(usagesamplebuilder.ToString()); stringbuilder.Append("\n\rGenerate a strongly typed class from a LG file \n\rOptions: \n\r"); stringbuilder.Append(usagebuilder); @@ -47,7 +58,7 @@ public string GetUsage() private void Compile() { - foreach (var command in MiddleWares) + foreach (var command in Commands) { command.Compile(this); if (ExitBeforeGenerate) return; @@ -55,17 +66,25 @@ private void Compile() if (InputPath == "" || OutputPath == "" || !LGFiles.Any() || ClassName == "" || Language == "") throw new Exception("Fail to Enter Generate Class File Mode. Check your Input."); } - public void Generate() + public void Execute() { - Compile(); if (ExitBeforeGenerate) return; - TemplateEngine lgEngine = new TemplateEngine(); - lgEngine.AddFiles(LGFiles); + var lgEngine = new TemplateEngine().AddFiles(LGFiles); + Messages.Add($"generating class file {OutputPath}"); + LanguageRegister.GetGenerate(Language).Generate(OutputPath, ClassName, lgEngine.Templates); + } - Message.Add($"generating class file {OutputPath}"); + public void Build(List args) + { + Args = args; + Compile(); + } - LanguageRegister.GetGenerate(Language).Generate(OutputPath, ClassName, lgEngine.Templates); + public void Build(string argsStr) + { + Args = new List(Regex.Split(argsStr, @"\s{1,}")); + Compile(); } } } diff --git a/packages/LGgen/LGgen/CommandHandlerBase.cs b/packages/LGgen/LGgen/CommandHandlerBase.cs deleted file mode 100644 index e0d144db4..000000000 --- a/packages/LGgen/LGgen/CommandHandlerBase.cs +++ /dev/null @@ -1,34 +0,0 @@ -using System; -using System.Collections.Generic; - -namespace LGgen -{ - public class CommandHandlerBase - { - protected static List Args { get; set; } = new List(); - public static List Usage { get; set; } = new List(); - - public CommandHandlerBase(List args) - { - Args = args; - LanguageRegister.RegisterAllLanguages(); - } - - public static string CommandInputGrammarCheck(ICommandMiddleware middleware) - { - if (!Args.Contains(middleware.Command)) return new string(""); - - if (middleware.SingleCommand) return new string(" "); - else if (Args.Count == Args.IndexOf(middleware.Command) + 1) - { - throw new Exception($"End with Command{middleware.Command} without Value. "); - } - else - { - var temp = Args[Args.IndexOf(middleware.Command) + 1]; - if (!temp.StartsWith('-') && temp != "") return temp; - else throw new Exception($"No Corresponding Value with the Command {middleware.Command}. "); - } - } - } -} diff --git a/packages/LGgen/LGgen/Commands.cs b/packages/LGgen/LGgen/Commands.cs new file mode 100644 index 000000000..ea68a7f07 --- /dev/null +++ b/packages/LGgen/LGgen/Commands.cs @@ -0,0 +1,170 @@ +using System; +using System.IO; +using System.Collections.Generic; +using Microsoft.Bot.Builder.LanguageGeneration; +using System.Linq; + +namespace LGgen +{ + public class InputCommand : BaseCommand + { + public InputCommand(): base("-i : LG file path or file folder. ", "-i LG_FILE_PATH OR FOLDER", "-i", false) + {} + + public override void Compile(CommandHandler context) + { + if (!TryGetCommandValue(context.Args, out string commandValue)) + { + return; + } + context.InputPath = commandValue; + + if (Directory.Exists(context.InputPath)) + { + context.Dire = true; + GetAllFiles(context.InputPath, context.LGFiles); + } + else if (File.Exists(context.InputPath) && Path.GetExtension(context.InputPath) == ".lg") + { + context.LGFiles.Add(context.InputPath); + } + else + { + throw new Exception("Can't Read your Input. "); + } + } + + private void GetAllFiles(string dir, List LGfiles) + { + DirectoryInfo d = new DirectoryInfo(dir); + FileSystemInfo[] fsinfos = d.GetFileSystemInfos(); + foreach (var fsinfo in fsinfos) + { + if (fsinfo is DirectoryInfo) + { + GetAllFiles(fsinfo.FullName, LGfiles); + } + else + { + if (Path.GetExtension(fsinfo.FullName) == ".lg") + { + LGfiles.Add(fsinfo.FullName); + } + } + } + } + } + + class CheckCommand : BaseCommand + { + public CheckCommand() : base("-c : LG file Grammar Check Mode. In this mode, you only need to input '-c' and '[-i LG_FILE_PATH]' ", "-c", "-c", true) + { } + + public override void Compile(CommandHandler context) + { + if (!TryGetCommandValue(context.Args, out string commandValue)) + { + return; + } + + if (context.InputPath == "") throw new Exception("-i command is complosory for Grammar Check Mode. "); + if (context.LGFiles == null) throw new Exception("Fail to Read any LG File. "); + + TemplateEngine lgEngine = new TemplateEngine(); + try + { + lgEngine.AddFiles(context.LGFiles); + context.Messages.Add("Congratulations! No error in this LG file! "); + } + catch (Exception e) + { + List errors = e.Message.Split('\n').ToList(); + context.Messages.Add($"This LG file has {errors.Count} errors: "); + errors.ForEach(i => context.Messages.Add(i)); + } + + context.ExitBeforeGenerate = true; + } + } + + class LangCommand : BaseCommand + { + public LangCommand() : base("-l : Generate Class File Mode. Please Choose Language. {Utils.SupportLanguage()}", "-l {Utils.SupportLanguage()}", "-l", false) + { } + + public override void Compile(CommandHandler context) + { + if (!TryGetCommandValue(context.Args, out string commandValue)) + { + return; + } + + if (context.InputPath == "") throw new Exception("-i command is complosory for Class File Generation Mode. "); + + if (!LanguageRegister.CheckLanguage(commandValue)) throw new Exception("Not Support this Language. " + SupportLanguage()); + context.Language = commandValue; + } + + private string SupportLanguage() + { + string s = "Support Language: "; + s += string.Join(" ", LanguageRegister.LanguageList); + s += ". "; + return s; + } + } + + class OutputCommand : BaseCommand + { + public OutputCommand() : base("-o : designate output path, defaults to directory where LG file is and the same name with LG file", "-o OUTPUT_PATH", "-o", false) + { } + + public override void Compile(CommandHandler context) + { + var hasCommandValue = TryGetCommandValue(context.Args, out string commandValue); + + if (context.InputPath == "" || context.Language == "") return; + + if (hasCommandValue) context.OutputPath = context.Dire ? + Path.Join(commandValue, "common" + LanguageRegister.GetSuffix(context.Language)) : + Path.Join(commandValue, Path.GetFileNameWithoutExtension(context.InputPath) + LanguageRegister.GetSuffix(context.Language)); + else context.OutputPath = context.Dire ? + Path.Join(context.InputPath, "common" + LanguageRegister.GetSuffix(context.Language)) : + Path.ChangeExtension(context.InputPath, LanguageRegister.GetSuffix(context.Language)); + } + } + + class NameCommand : BaseCommand + { + public NameCommand() : base("-n : designate class name, defaults to the same name of LG file", "-n CLASS_NAME", "-n", false) + { } + + public override void Compile(CommandHandler context) + { + var hasCommandValue = TryGetCommandValue(context.Args, out string commandValue); + + if (context.InputPath == "" || context.Language == "") return; + + if (hasCommandValue) context.ClassName = commandValue; + else context.ClassName = context.Dire ? "common" : Path.GetFileNameWithoutExtension(context.InputPath); + } + } + + class VersionCommand : BaseCommand + { + public VersionCommand() : base("-v : version", "-v", "-v", true) + { } + + public override void Compile(CommandHandler context) + { + if (!TryGetCommandValue(context.Args, out string commandValue)) + { + return; + } + + Console.WriteLine("LGgen version 1.0 "); + + context.ExitBeforeGenerate = true; + } + } +} diff --git a/packages/LGgen/LGgen/ICommandMiddleware.cs b/packages/LGgen/LGgen/ICommandMiddleware.cs deleted file mode 100644 index 3f9a66edd..000000000 --- a/packages/LGgen/LGgen/ICommandMiddleware.cs +++ /dev/null @@ -1,11 +0,0 @@ -namespace LGgen -{ - public interface ICommandMiddleware - { - string Usage { get; set; } - string UsageSample { get; set; } - string Command { get; set; } - bool SingleCommand { get; set; } - void Compile(CommandHandler context); - } -} \ No newline at end of file diff --git a/packages/LGgen/LGgen/ILanguage.cs b/packages/LGgen/LGgen/ILanguageGenerator.cs similarity index 82% rename from packages/LGgen/LGgen/ILanguage.cs rename to packages/LGgen/LGgen/ILanguageGenerator.cs index 6fddc8d5a..34bd9b7b2 100644 --- a/packages/LGgen/LGgen/ILanguage.cs +++ b/packages/LGgen/LGgen/ILanguageGenerator.cs @@ -3,7 +3,7 @@ namespace LGgen { - public interface ILanguage + public interface ILanguageGenerator { void Generate(string outPath, string clssName, List temp); } diff --git a/packages/LGgen/LGgen/LGGenTool.cs b/packages/LGgen/LGgen/LGGenTool.cs new file mode 100644 index 000000000..376aa4697 --- /dev/null +++ b/packages/LGgen/LGgen/LGGenTool.cs @@ -0,0 +1,53 @@ +using System; +using System.Collections.Generic; + +namespace LGgen +{ + public class LGGenTool + { + private CommandHandler commandHandler; + + public LGGenTool() + { + InitHandler(); + } + + public void Generate(string[] args) + { + commandHandler.Build(new List(args)); + Execute(); + } + + public void Generate(string argsStr) + { + commandHandler.Build(argsStr); + Execute(); + } + + private void Execute() + { + try + { + commandHandler.Execute(); + commandHandler.Messages.ForEach(num => Console.WriteLine(num)); + } + catch (Exception e) + { + Console.WriteLine(e.Message); + Console.WriteLine(commandHandler.GetUsage()); + Environment.Exit(-1); + } + } + + private void InitHandler() + { + commandHandler = new CommandHandler() + .AddCommand(new InputCommand()) + .AddCommand(new CheckCommand()) + .AddCommand(new LangCommand()) + .AddCommand(new OutputCommand()) + .AddCommand(new NameCommand()) + .AddCommand(new VersionCommand()); + } + } +} diff --git a/packages/LGgen/LGgen/LGgen.csproj b/packages/LGgen/LGgen/LGgen.csproj index 0fe9fa076..e561cb2ae 100644 --- a/packages/LGgen/LGgen/LGgen.csproj +++ b/packages/LGgen/LGgen/LGgen.csproj @@ -1,8 +1,10 @@  - Exe + Library netcoreapp2.1 + + diff --git a/packages/LGgen/LGgen/LanguageRegister.cs b/packages/LGgen/LGgen/LanguageRegister.cs index c0085a695..e7be90ba0 100644 --- a/packages/LGgen/LGgen/LanguageRegister.cs +++ b/packages/LGgen/LGgen/LanguageRegister.cs @@ -15,14 +15,14 @@ private static void Register(string name, string suffix, Type type) LanguageList.Add(name); } - public static bool IsLanguage(string name) + public static bool CheckLanguage(string name) { return LanguageList.Contains(name); } - public static ILanguage GetGenerate(string name) + public static ILanguageGenerator GetGenerate(string name) { - return (ILanguage)Activator.CreateInstance(GenerateDict[name]); + return (ILanguageGenerator)Activator.CreateInstance(GenerateDict[name]); } public static string GetSuffix(string name) @@ -32,8 +32,8 @@ public static string GetSuffix(string name) public static void RegisterAllLanguages() { - Register("cs", ".cs", typeof(CSharp)); - Register("ts", ".ts", typeof(Typescript)); + Register("cs", ".cs", typeof(CSharpGenerator)); + Register("ts", ".ts", typeof(TypescriptGenerator)); } } diff --git a/packages/LGgen/LGgen/Program.cs b/packages/LGgen/LGgen/Program.cs deleted file mode 100644 index 109e6e56e..000000000 --- a/packages/LGgen/LGgen/Program.cs +++ /dev/null @@ -1,35 +0,0 @@ -using System; -using System.ComponentModel.Design.Serialization; -using System.Linq; -using System.Runtime.InteropServices; - -namespace LGgen -{ - public class LGgenTool - { - public static void Main(string[] args) - { - var handler = new CommandHandler(args.ToList()) - .AddCommand(new InputHandler()) - .AddCommand(new CheckHandler()) - .AddCommand(new LangHandler()) - .AddCommand(new OutputHandler()) - .AddCommand(new NameHandler()) - .AddCommand(new VersionHandler()); - - var usage = handler.GetUsage(); - - try - { - handler.Generate(); - handler.Message.ForEach(num => Console.WriteLine(num)); - } - catch(Exception e) - { - Console.WriteLine(e.Message); - Console.WriteLine(usage); - Environment.Exit(-1); - } - } - } -} diff --git a/packages/LGgen/LGgen/TypescriptGenerator.cs b/packages/LGgen/LGgen/TypescriptGenerator.cs new file mode 100644 index 000000000..001630dea --- /dev/null +++ b/packages/LGgen/LGgen/TypescriptGenerator.cs @@ -0,0 +1,23 @@ +using Microsoft.Bot.Builder.LanguageGeneration; +using System.Collections.Generic; + +namespace LGgen +{ + class TypescriptGenerator : ILanguageGenerator + { + public void Generate(string outPath, string className, List temp) + { + var generatorWriter = new Writer(outPath); + generatorWriter.WriteLine($"export default class {className}"); + generatorWriter.WriteLine("{"); + generatorWriter.Indent(); + + temp.ForEach(num => generatorWriter.IndentLine($"static {num.Name}:string = \"{num.Name}\";")); + generatorWriter.Outdent(); + generatorWriter.IndentLine("}"); + + generatorWriter.Flush(); + generatorWriter.Close(); + } + } +} diff --git a/packages/LGgen/LGgen/Util.cs b/packages/LGgen/LGgen/Util.cs deleted file mode 100644 index 5f7223202..000000000 --- a/packages/LGgen/LGgen/Util.cs +++ /dev/null @@ -1,45 +0,0 @@ -using AdaptiveCards.Rendering; -using System; -using Microsoft.Bot.Builder.LanguageGeneration; -using System.Collections.Generic; -using System.Linq; -using System.IO; - -namespace LGgen -{ - class Utils - { - public static void GetAllFiles(string dir, List LGfiles) - { - DirectoryInfo d = new DirectoryInfo(dir); - FileSystemInfo[] fsinfos = d.GetFileSystemInfos(); - foreach (var fsinfo in fsinfos) - { - if(fsinfo is DirectoryInfo) - { - GetAllFiles(fsinfo.FullName, LGfiles); - } - else - { - if(Path.GetExtension(fsinfo.FullName) == ".lg") - { - LGfiles.Add(fsinfo.FullName); - } - } - } - } - - public static string SupportLanguage() - { - string s = "Support Language: "; - foreach (var temp in LanguageRegister.LanguageList) - { - s += temp; - s += " "; - } - s += ". "; - - return s; - } - } -} diff --git a/packages/LGgen/LGgen/Writer.cs b/packages/LGgen/LGgen/Writer.cs index 607196695..e8d4c3c4b 100644 --- a/packages/LGgen/LGgen/Writer.cs +++ b/packages/LGgen/LGgen/Writer.cs @@ -6,7 +6,7 @@ public class Writer { public int IndentSize = 4; public int IndentLevel = 0; - private StreamWriter _output; + private readonly StreamWriter _output; public void Indent() { diff --git a/packages/LGgen/LGgen/csharp.cs b/packages/LGgen/LGgen/csharp.cs deleted file mode 100644 index 263f2147c..000000000 --- a/packages/LGgen/LGgen/csharp.cs +++ /dev/null @@ -1,32 +0,0 @@ -using System.Collections.Generic; -using Microsoft.Bot.Builder.LanguageGeneration; - - -namespace LGgen -{ - class CSharp:ILanguage - { - - public void Generate(string outPath, string className, List temp) - { - var w = new Writer(outPath); - w.WriteLine("namespace LGgen"); - w.WriteLine("{"); - w.Indent(); - w.IndentLine($"public class {className}"); - w.IndentLine("{"); - w.Indent(); - - temp.ForEach(num => w.IndentLine($"public const string {num.Name} = \"{num.Name}\";")); - w.Outdent(); - w.IndentLine("}"); - w.Outdent(); - w.IndentLine("}"); - - w.Flush(); - w.Close(); - } - } -} - - diff --git a/packages/LGgen/LGgen/typescript.cs b/packages/LGgen/LGgen/typescript.cs deleted file mode 100644 index d708819e9..000000000 --- a/packages/LGgen/LGgen/typescript.cs +++ /dev/null @@ -1,23 +0,0 @@ -using Microsoft.Bot.Builder.LanguageGeneration; -using System.Collections.Generic; - -namespace LGgen -{ - class Typescript:ILanguage - { - public void Generate(string outPath, string className, List temp) - { - var w = new Writer(outPath); - w.WriteLine($"export default class {className}"); - w.WriteLine("{"); - w.Indent(); - - temp.ForEach(num => w.IndentLine($"static {num.Name}:string = \"{num.Name}\";")); - w.Outdent(); - w.IndentLine("}"); - - w.Flush(); - w.Close(); - } - } -} diff --git a/packages/LGgen/LGgen_Test/LGgen_Test.csproj b/packages/LGgen/LGgen_Test/LGgen_Test.csproj index fbe055261..fe31a1aab 100644 --- a/packages/LGgen/LGgen_Test/LGgen_Test.csproj +++ b/packages/LGgen/LGgen_Test/LGgen_Test.csproj @@ -9,4 +9,8 @@ + + + + diff --git a/packages/LGgen/LGgen_Test/LGtest.ts b/packages/LGgen/LGgen_Test/LGtest.ts deleted file mode 100644 index 3f1d7c380..000000000 --- a/packages/LGgen/LGgen_Test/LGtest.ts +++ /dev/null @@ -1,6 +0,0 @@ -export default class LGtest -{ - static tempalte_1:string = "tempalte_1"; - static tempalte_2:string = "tempalte_2"; - static tempalte_3:string = "tempalte_3"; -} diff --git a/packages/LGgen/LGgen_Test/Program.cs b/packages/LGgen/LGgen_Test/Program.cs index 8758ec9d8..6e38d6707 100644 --- a/packages/LGgen/LGgen_Test/Program.cs +++ b/packages/LGgen/LGgen_Test/Program.cs @@ -6,23 +6,25 @@ class Program { static void Main(string[] args) { + var lGGenTool = new LGGenTool(); //FunctionTest - //LGgenTool.Main(new string[] { "-c", "-i" , "../../../LGtest.lg"}); - //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); - //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg" }); - //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest_Folder" }); - //LGgenTool.Main(new string[] { "-l", "ts", "-i", "../../../LGtest.lg", "-o", "../../../LGtest_OutputChoice/"}); - //LGgenTool.Main(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); - //LGgenTool.Main(new string[] { "-o", "cs" }); - //LGgenTool.Main(new string[] { "-v" }); + //lGGenTool.Generate(new string[] { "-c", "-i" , "../../../LGtest.lg"}); + //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); + lGGenTool.Generate("-l cs -i ../../../LGtest.lg"); + //lGGenTool.Generate(new string[] { "-l", "ts", "-i", "../../../LGtest.lg" }); + //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest_Folder" }); + //lGGenTool.Generate(new string[] { "-l", "ts", "-i", "../../../LGtest.lg", "-o", "../../../LGtest_OutputChoice/"}); + //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); + //lGGenTool.Generate(new string[] { "-o", "cs" }); + //lGGenTool.Generate(new string[] { "-v" }); //Error Test - //LGgenTool.Main(new string[] { "-a" }); - //LGgenTool.Main(new string[] { "-c" }); - //LGgenTool.Main(new string[] { "-l" ,"-i", "../../../LGtest.lg"}); + //lGGenTool.Generate(new string[] { "-a" }); + //lGGenTool.Generate(new string[] { "-c" }); + //lGGenTool.Generate(new string[] { "-l" ,"-i", "../../../LGtest.lg"}); } } } From ae828812fdca776b941830a1d328884980505dea Mon Sep 17 00:00:00 2001 From: t-hahan Date: Thu, 29 Aug 2019 18:03:45 +0800 Subject: [PATCH 11/11] bug fix --- packages/LGgen/LGgen/BaseCommand.cs | 2 +- packages/LGgen/LGgen/CommandHandler.cs | 2 +- packages/LGgen/LGgen/Commands.cs | 14 ++++++------ packages/LGgen/LGgen/LGGenTool.cs | 30 +++++++++++++++++--------- packages/LGgen/LGgen/README.md | 12 ++++++++--- packages/LGgen/LGgen_Test/LGtest.lg | 2 +- packages/LGgen/LGgen_Test/LGtest.ts | 6 ++++++ packages/LGgen/LGgen_Test/Program.cs | 11 ++++++---- 8 files changed, 52 insertions(+), 27 deletions(-) create mode 100644 packages/LGgen/LGgen_Test/LGtest.ts diff --git a/packages/LGgen/LGgen/BaseCommand.cs b/packages/LGgen/LGgen/BaseCommand.cs index 2b52afe84..6603964b5 100644 --- a/packages/LGgen/LGgen/BaseCommand.cs +++ b/packages/LGgen/LGgen/BaseCommand.cs @@ -26,7 +26,7 @@ public bool TryGetCommandValue(List args, out string commandValue) if (!args.Contains(Command)) return false; - if (SingleCommand) return false; + if (SingleCommand) return true; else if (args.Count == args.IndexOf(Command) + 1) { throw new Exception($"End with Command {Command} without Value. "); diff --git a/packages/LGgen/LGgen/CommandHandler.cs b/packages/LGgen/LGgen/CommandHandler.cs index 12fcbdd7e..b5e19f1f9 100644 --- a/packages/LGgen/LGgen/CommandHandler.cs +++ b/packages/LGgen/LGgen/CommandHandler.cs @@ -63,7 +63,7 @@ private void Compile() command.Compile(this); if (ExitBeforeGenerate) return; } - if (InputPath == "" || OutputPath == "" || !LGFiles.Any() || ClassName == "" || Language == "") throw new Exception("Fail to Enter Generate Class File Mode. Check your Input."); + if (InputPath == "" || OutputPath == "" || !LGFiles.Any() || ClassName == "" || Language == "") throw new Exception("Fail to Do Anything. Check your Input."); } public void Execute() diff --git a/packages/LGgen/LGgen/Commands.cs b/packages/LGgen/LGgen/Commands.cs index ea68a7f07..33c4b6b5a 100644 --- a/packages/LGgen/LGgen/Commands.cs +++ b/packages/LGgen/LGgen/Commands.cs @@ -67,7 +67,7 @@ public override void Compile(CommandHandler context) return; } - if (context.InputPath == "") throw new Exception("-i command is complosory for Grammar Check Mode. "); + if (context.InputPath == null) throw new Exception("-i command is complosory for Grammar Check Mode. "); if (context.LGFiles == null) throw new Exception("Fail to Read any LG File. "); TemplateEngine lgEngine = new TemplateEngine(); @@ -89,7 +89,7 @@ public override void Compile(CommandHandler context) class LangCommand : BaseCommand { - public LangCommand() : base("-l : Generate Class File Mode. Please Choose Language. {Utils.SupportLanguage()}", "-l {Utils.SupportLanguage()}", "-l", false) + public LangCommand() : base($"-l : Generate Class File Mode. Default to C#. Please Choose Language. {SupportLanguage()}", $"-l {SupportLanguage()}", "-l", false) { } public override void Compile(CommandHandler context) @@ -99,17 +99,17 @@ public override void Compile(CommandHandler context) return; } - if (context.InputPath == "") throw new Exception("-i command is complosory for Class File Generation Mode. "); + if (context.InputPath == null) throw new Exception("-i command is complosory for Class File Generation Mode. "); if (!LanguageRegister.CheckLanguage(commandValue)) throw new Exception("Not Support this Language. " + SupportLanguage()); context.Language = commandValue; } - private string SupportLanguage() + private static string SupportLanguage() { string s = "Support Language: "; s += string.Join(" ", LanguageRegister.LanguageList); - s += ". "; + s += "."; return s; } } @@ -123,7 +123,7 @@ public override void Compile(CommandHandler context) { var hasCommandValue = TryGetCommandValue(context.Args, out string commandValue); - if (context.InputPath == "" || context.Language == "") return; + if (context.InputPath == null || context.Language == null) return; if (hasCommandValue) context.OutputPath = context.Dire ? Path.Join(commandValue, "common" + LanguageRegister.GetSuffix(context.Language)) : @@ -143,7 +143,7 @@ public override void Compile(CommandHandler context) { var hasCommandValue = TryGetCommandValue(context.Args, out string commandValue); - if (context.InputPath == "" || context.Language == "") return; + if (context.InputPath == null || context.Language == null ) return; if (hasCommandValue) context.ClassName = commandValue; else context.ClassName = context.Dire ? "common" : Path.GetFileNameWithoutExtension(context.InputPath); diff --git a/packages/LGgen/LGgen/LGGenTool.cs b/packages/LGgen/LGgen/LGGenTool.cs index 376aa4697..38f10a96b 100644 --- a/packages/LGgen/LGgen/LGGenTool.cs +++ b/packages/LGgen/LGgen/LGGenTool.cs @@ -14,22 +14,25 @@ public LGGenTool() public void Generate(string[] args) { - commandHandler.Build(new List(args)); - Execute(); + try + { + commandHandler.Build(new List(args)); + Execute(); + } + catch (Exception e) + { + Console.WriteLine(e.Message); + Console.WriteLine(commandHandler.GetUsage()); + Environment.Exit(-1); + } } public void Generate(string argsStr) - { - commandHandler.Build(argsStr); - Execute(); - } - - private void Execute() { try { - commandHandler.Execute(); - commandHandler.Messages.ForEach(num => Console.WriteLine(num)); + commandHandler.Build(argsStr); + Execute(); } catch (Exception e) { @@ -39,6 +42,13 @@ private void Execute() } } + + private void Execute() + { + commandHandler.Execute(); + commandHandler.Messages.ForEach(num => Console.WriteLine(num)); + } + private void InitHandler() { commandHandler = new CommandHandler() diff --git a/packages/LGgen/LGgen/README.md b/packages/LGgen/LGgen/README.md index 91db55aed..f4629be84 100644 --- a/packages/LGgen/LGgen/README.md +++ b/packages/LGgen/LGgen/README.md @@ -4,11 +4,12 @@ LGgen is a tool for generating strongly typed C# and typescript class file from ## Usage +### Command Line Tool 1. build the project. 2. navigate to 'bin/Debug/netcoreapp2.1'. 3. run the command `dotnet LGgen.dll [-l cs/ts] [-n CLASS_NAME] [-c] [-i LG_FILE_PATH] [-o OUTPUT_PATH]` - * `-l cs/ts` : Select C# or Typescript. + * `-l cs/ts` : Select C# or Typescript, default to C#. * `-i` : LG file path or folder. * `-o` : Output path, defaults to directory where LG file is and the same name with LG file * `-n` : Designate class name, defaults to the same name of LG file @@ -18,12 +19,17 @@ LGgen is a tool for generating strongly typed C# and typescript class file from For Typescript file, use "import CLASS_NAME from './FILENAME'. 6. Then you can reference your LG template name by typing CLASSNAME.TEMPLATENAME and enjoy the auto-completing. +### Function In Project +1. Use the LGgenTool in your project like + `lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" });` +2. For more usage, pls check the LGgen_test project. + ## EXTEND ### Add command line arguments -Implement the method in the "CommandHandler" class and add to Main function. +Implement the method in "Command.cs" and add to "LGgenTool.cs", inheriting to "BaseCommand" class. ### Add language support -Build a class base on interface "ILanguage" and update the "RegisterAllLanguage" method in "LanguageRegister" class. +Build a class base on interface "ILanguageGenerator" and update the "RegisterAllLanguage" method in "LanguageRegister" class. diff --git a/packages/LGgen/LGgen_Test/LGtest.lg b/packages/LGgen/LGgen_Test/LGtest.lg index a36d1c9cc..0a29ed8fd 100644 --- a/packages/LGgen/LGgen_Test/LGtest.lg +++ b/packages/LGgen/LGgen_Test/LGtest.lg @@ -5,4 +5,4 @@ - Body_2 # tempalte_3 -- Body_3 +- Body_3 \ No newline at end of file diff --git a/packages/LGgen/LGgen_Test/LGtest.ts b/packages/LGgen/LGgen_Test/LGtest.ts new file mode 100644 index 000000000..3f1d7c380 --- /dev/null +++ b/packages/LGgen/LGgen_Test/LGtest.ts @@ -0,0 +1,6 @@ +export default class LGtest +{ + static tempalte_1:string = "tempalte_1"; + static tempalte_2:string = "tempalte_2"; + static tempalte_3:string = "tempalte_3"; +} diff --git a/packages/LGgen/LGgen_Test/Program.cs b/packages/LGgen/LGgen_Test/Program.cs index 6e38d6707..06c6f234f 100644 --- a/packages/LGgen/LGgen_Test/Program.cs +++ b/packages/LGgen/LGgen_Test/Program.cs @@ -11,20 +11,23 @@ static void Main(string[] args) //lGGenTool.Generate(new string[] { "-c", "-i" , "../../../LGtest.lg"}); - //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); - lGGenTool.Generate("-l cs -i ../../../LGtest.lg"); + lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg" }); + //lGGenTool.Generate("-l cs -i ../../../LGtest.lg"); //lGGenTool.Generate(new string[] { "-l", "ts", "-i", "../../../LGtest.lg" }); //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest_Folder" }); //lGGenTool.Generate(new string[] { "-l", "ts", "-i", "../../../LGtest.lg", "-o", "../../../LGtest_OutputChoice/"}); //lGGenTool.Generate(new string[] { "-l", "cs", "-i", "../../../LGtest.lg", "-n", "LG", "-o" , "../../../LGtest_ClassNameChoice/"}); - //lGGenTool.Generate(new string[] { "-o", "cs" }); //lGGenTool.Generate(new string[] { "-v" }); //Error Test + //lGGenTool.Generate(new string[] { "-o", "cs" }); //lGGenTool.Generate(new string[] { "-a" }); //lGGenTool.Generate(new string[] { "-c" }); - //lGGenTool.Generate(new string[] { "-l" ,"-i", "../../../LGtest.lg"}); + //lGGenTool.Generate(new string[] { "-i" , "../../../LGtest.lg" }); + //lGGenTool.Generate(new string[] { " - i", ".. / .. / .. / LGtest.lg" }); + //lGGenTool.Generate(new string[] { "-l", "py", "-i", "../../../LGtest.lg"}); + //lGGenTool.Generate(new string[] { "-l", "cs", "-i" }); } } }