Add SnippetGenerator

eng/SnippetGenerator/MarkdownProcessor.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Text.RegularExpressions;
+
+namespace SnippetGenerator
+{
+    public class MarkdownProcessor
+    {
+        private static readonly string _snippetFormat = "```C# {0}{1}{2}```";
+        private static Regex _snippetRegex = new Regex("```\\s*?C#[ ]*?(?<name>[\\w:]+).*?```",
+            RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);
+
+        public static string Process(string markdown, Func<string, string> snippetProvider)
+        {
+            return _snippetRegex.Replace(markdown, match =>
+            {
+                var matchGroup = match.Groups["name"];
+                if (matchGroup.Success)
+                {
+                    return string.Format(_snippetFormat, matchGroup.Value, Environment.NewLine, snippetProvider(matchGroup.Value));
+                }
+
+                return match.Value;
+            });
+        }
+    }
+}

eng/SnippetGenerator/Program.cs

@@ -0,0 +1,166 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using McMaster.Extensions.CommandLineUtils;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SnippetGenerator
+{
+    public class Program
+    {
+        [Option(ShortName = "u")]
+        public string Markdown { get; set; }
+
+        [Option(ShortName = "s")]
+        public string Snippets { get; set; }
+
+        public static int Main(string[] args)
+        {
+            return CommandLineApplication.Execute<Program>(args);
+        }
+
+        public async Task OnExecuteAsync()
+        {
+            Console.WriteLine($"Processing {Markdown}");
+
+            var text = File.ReadAllText(Markdown);
+            var snippets = await GetSnippetsInDirectory(Snippets);
+            Console.WriteLine($"Discovered snippets:");
+
+            foreach (var snippet in snippets)
+            {
+                Console.WriteLine($" {snippet.Name}");
+            }
+
+            text = MarkdownProcessor.Process(text, s => {
+                var selectedSnippets = snippets.Where(snip => snip.Name == s).ToArray();
+                if (selectedSnippets.Length > 1)
+                {
+                    throw new InvalidOperationException($"Multiple snippets with the name '{s}' defined '{Snippets}'");
+                }
+                if (selectedSnippets.Length == 0)
+                {
+                    throw new InvalidOperationException($"Snippet '{s}' not found in directory '{Snippets}'");
+                }
+
+                var selectedSnippet = selectedSnippets.Single();
+                Console.WriteLine($"Replaced {selectedSnippet.Name}");
+                return FormatSnippet(selectedSnippet.Text);
+            });
+
+            File.WriteAllText(Markdown, text);
+        }
+
+        private string FormatSnippet(SourceText text)
+        {
+            int minIndent = int.MaxValue;
+            int firstLine = 0;
+            var lines = text.Lines.Select(l => l.ToString()).ToArray();
+
+            int lastLine = lines.Length - 1;
+
+            while (string.IsNullOrWhiteSpace(lines[firstLine]))
+            {
+                firstLine++;
+            }
+
+            while (string.IsNullOrWhiteSpace(lines[lastLine]))
+            {
+                lastLine--;
+            }
+
+            for (var index = firstLine; index <= lastLine; index++)
+            {
+                var textLine = lines[index];
+
+                if (string.IsNullOrWhiteSpace(textLine))
+                {
+                    continue;
+                }
+
+                int i;
+                for (i = 0; i < textLine.Length; i++)
+                {
+                    if (!char.IsWhiteSpace(textLine[i])) break;
+                }
+
+                minIndent = Math.Min(minIndent, i);
+            }
+
+            var stringBuilder = new StringBuilder();
+            for (var index = firstLine; index  <= lastLine; index++)
+            {
+                var line = lines[index];
+                line = string.IsNullOrWhiteSpace(line) ? string.Empty : line.Substring(minIndent);
+                stringBuilder.AppendLine(line);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        private async Task<List<Snippet>> GetSnippetsInDirectory(string baseDirectory)
+        {
+            var list = new List<Snippet>();
+            foreach (var file in Directory.GetFiles(baseDirectory, "*.cs", SearchOption.AllDirectories))
+            {
+                var syntaxTree = CSharpSyntaxTree.ParseText(
+                    File.ReadAllText(file),
+                    new CSharpParseOptions(LanguageVersion.Preview),
+                    path: file);
+                list.AddRange(await GetAllSnippetsAsync(syntaxTree));
+            }
+
+            return list;
+        }
+
+        private async Task<Snippet[]> GetAllSnippetsAsync(SyntaxTree syntaxTree)
+        {
+            var snippets = new List<Snippet>();
+            var directiveWalker = new DirectiveWalker();
+            directiveWalker.Visit(await syntaxTree.GetRootAsync());
+
+            foreach (var region in directiveWalker.Regions)
+            {
+                var syntaxTrivia = region.Item1.EndOfDirectiveToken.LeadingTrivia.First(t => t.IsKind(SyntaxKind.PreprocessingMessageTrivia));
+                var fromBounds = TextSpan.FromBounds(
+                    region.Item1.GetLocation().SourceSpan.End,
+                    region.Item2.GetLocation().SourceSpan.Start);
+
+                snippets.Add(new Snippet(syntaxTrivia.ToString(), syntaxTree.GetText().GetSubText(fromBounds)));
+            }
+
+            return snippets.ToArray();
+        }
+
+        class DirectiveWalker : CSharpSyntaxWalker
+        {
+            private Stack<RegionDirectiveTriviaSyntax> _regions = new Stack<RegionDirectiveTriviaSyntax>();
+            public List<(RegionDirectiveTriviaSyntax, EndRegionDirectiveTriviaSyntax)> Regions { get; } = new List<(RegionDirectiveTriviaSyntax, EndRegionDirectiveTriviaSyntax)>();
+
+            public DirectiveWalker() : base(SyntaxWalkerDepth.StructuredTrivia)
+            {
+            }
+
+            public override void VisitRegionDirectiveTrivia(RegionDirectiveTriviaSyntax node)
+            {
+                base.VisitRegionDirectiveTrivia(node);
+                _regions.Push(node);
+            }
+
+            public override void VisitEndRegionDirectiveTrivia(EndRegionDirectiveTriviaSyntax node)
+            {
+                base.VisitEndRegionDirectiveTrivia(node);
+                Regions.Add((_regions.Pop(), node));
+            }
+        }
+    }
+}

eng/SnippetGenerator/Snippet.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.CodeAnalysis.Text;
+
+namespace SnippetGenerator
+{
+    internal class Snippet
+    {
+        public string Name { get; }
+        public SourceText Text { get; }
+
+        public Snippet(string name, SourceText text)
+        {
+            Name = name;
+            Text = text;
+        }
+    }
+}

eng/SnippetGenerator/SnippetGenerator.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.3.4" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.2.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.2.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="3.2.1" />
+    <PackageReference Include="Microsoft.Build" Version="16.0.461" />
+    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="16.0.461" />
+  </ItemGroup>
+
+</Project>

eng/SnippetGenerator/SnippetGenerator.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29315.20
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SnippetGenerator", "SnippetGenerator.csproj", "{DC46BB54-17A2-471C-A21A-D7F329505955}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{DC46BB54-17A2-471C-A21A-D7F329505955}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DC46BB54-17A2-471C-A21A-D7F329505955}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DC46BB54-17A2-471C-A21A-D7F329505955}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DC46BB54-17A2-471C-A21A-D7F329505955}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8162DAAE-F789-44E8-8552-58A3581A0AF3}
+	EndGlobalSection
+EndGlobal

eng/Update-Snippets.ps1

@@ -0,0 +1,11 @@
+$generatorProject = "$PSScriptRoot\SnippetGenerator\SnippetGenerator.csproj";
+dotnet build $generatorProject
+
+foreach ($file in Get-ChildItem "$PSScriptRoot\..\sdk" -Filter README.md -Recurse)
+{
+    $samples = Join-Path $file.Directory "samples"
+    if (Test-Path $samples)
+    {
+        dotnet run -p $generatorProject --no-build -u $file.FullName -s $samples
+    }
+}