static void Main(string[] args)
{
MarkdownGenerator markdownGenerator = new MarkdownGenerator();
JsonRpcGenerator rpcGenerator = new JsonRpcGenerator(markdownGenerator);
rpcGenerator.Generate();
}
public void Generate()
{
WriteAllText(
@"Analyzers\README.md",
MarkdownGenerator.CreateAnalyzersReadMe(Analyzers.Where(f => !f.IsObsolete), Comparer));
WriteAllText(
@"Analyzers\AnalyzersByCategory.md",
MarkdownGenerator.CreateAnalyzersByCategoryMarkDown(Analyzers.Where(f => !f.IsObsolete), Comparer));
foreach (AnalyzerDescriptor analyzer in Analyzers)
{
WriteAllText(
$@"..\docs\analyzers\{analyzer.Id}.md",
MarkdownGenerator.CreateAnalyzerMarkDown(analyzer),
fileMustExists: false);
}
WriteAllText(
@"..\docs\refactorings\Refactorings.md",
MarkdownGenerator.CreateRefactoringsMarkDown(Refactorings, Comparer));
WriteAllText(
@"Refactorings\README.md",
MarkdownGenerator.CreateRefactoringsReadMe(Refactorings, Comparer));
foreach (RefactoringDescriptor refactoring in Refactorings)
{
WriteAllText(
$@"..\docs\refactorings\{refactoring.Id}.md",
MarkdownGenerator.CreateRefactoringMarkDown(refactoring),
fileMustExists: false);
}
WriteAllText(
@"CodeFixes\README.md",
MarkdownGenerator.CreateCodeFixesReadMe(CodeFixes, CompilerDiagnostics, Comparer));
WriteAllText(
@"CodeFixes\CodeFixesByDiagnosticId.md",
MarkdownGenerator.CreateCodeFixesByDiagnosticId(CodeFixes, CompilerDiagnostics));
WriteAllText(
@"..\README.md",
File.ReadAllText(@"..\text\ReadMe.txt", Encoding.UTF8));
WriteAllText(
"DefaultConfigFile.xml",
XmlGenerator.CreateDefaultConfigFile(Refactorings, CodeFixes));
WriteAllText(
@"VisualStudio\description.txt",
File.ReadAllText(@"..\text\RoslynatorDescription.txt", Encoding.UTF8));
WriteAllText(
@"VisualStudio.Refactorings\description.txt",
File.ReadAllText(@"..\text\RoslynatorRefactoringsDescription.txt", Encoding.UTF8));
}
static void Main(string[] args)
{
try
{
GenerationOptions options = new GenerationOptions(args);
var types = MarkdownGenerator.BuildFrom(options.Target, options.NamespaceMatch, options.AccessibilityLevel);
if (types.Length == 0)
{
return;
}
if (!Directory.Exists(options.Output))
{
Directory.CreateDirectory(options.Output);
}
else
{
DirectoryInfo directory = new DirectoryInfo(options.Output);
foreach (FileInfo file in directory.GetFiles())
{
file.Delete();
}
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
subDirectory.Delete(true);
}
}
var homeBuilder = new MarkdownBuilder();
homeBuilder.Header(1, "Contents");
homeBuilder.AppendLine();
switch (options.Mode)
{
case GenerationMode.FilePerClass:
GenerateFilePerClass(homeBuilder, options.Output, types);
break;
case GenerationMode.FilePerNamespace:
GenerateFilePerNamespace(homeBuilder, options.Output, types);
break;
default:
throw new Exception("Unknown generation mode");
}
File.WriteAllText(Path.Combine(options.Output, "Contents.md"), homeBuilder.ToString());
}
catch (Exception ex)
{
Console.WriteLine("An exception is thrown: " + GetFullExceptionMessage(ex));
Console.ReadKey();
}
}
public void Generate()
{
WriteAllText(
@"Analyzers\README.md",
MarkdownGenerator.CreateAnalyzersReadMe(Analyzers.Where(f => !f.IsObsolete), Comparer));
WriteAllText(
@"Analyzers\AnalyzersByCategory.md",
MarkdownGenerator.CreateAnalyzersByCategoryMarkdown(Analyzers.Where(f => !f.IsObsolete), Comparer));
foreach (AnalyzerDescriptor analyzer in Analyzers)
{
WriteAllText(
$@"..\docs\analyzers\{analyzer.Id}.md",
MarkdownGenerator.CreateAnalyzerMarkdown(analyzer),
fileMustExists: false);
}
WriteAllText(
@"..\docs\refactorings\Refactorings.md",
MarkdownGenerator.CreateRefactoringsMarkdown(Refactorings, Comparer));
WriteAllText(
@"Refactorings\README.md",
MarkdownGenerator.CreateRefactoringsReadMe(Refactorings.Where(f => !f.IsObsolete), Comparer));
foreach (RefactoringDescriptor refactoring in Refactorings)
{
WriteAllText(
$@"..\docs\refactorings\{refactoring.Id}.md",
MarkdownGenerator.CreateRefactoringMarkdown(refactoring),
fileMustExists: false);
}
WriteAllText(
@"CodeFixes\README.md",
MarkdownGenerator.CreateCodeFixesReadMe(CompilerDiagnostics, Comparer));
foreach (CompilerDiagnosticDescriptor diagnostic in CompilerDiagnostics)
{
WriteAllText(
$@"..\docs\cs\{diagnostic.Id}.md",
MarkdownGenerator.CreateCompilerDiagnosticMarkdown(diagnostic, CodeFixes, Comparer),
fileMustExists: false);
}
WriteAllText(
"DefaultConfigFile.xml",
XmlGenerator.CreateDefaultConfigFile(Refactorings, CodeFixes));
WriteAllText(
"DefaultRuleSet.ruleset",
XmlGenerator.CreateDefaultRuleSet(Analyzers));
}
private static void Main(string[] args)
{
_shortcuts = Pihrtsoft.Records.Document.ReadRecords(@"..\..\Data\Shortcuts.xml")
.Where(f => !f.HasTag(KnownTags.Disabled))
.Select(Mapper.MapShortcutInfo)
.ToArray();
SnippetDirectory[] directories = LoadDirectories(@"..\..\Data\Directories.xml");
ShortcutInfo.SerializeToXml(Path.Combine(VisualStudioExtensionProjectPath, "Shortcuts.xml"), _shortcuts);
LoadLanguages();
SaveChangedSnippets(directories);
var visualStudio = new VisualStudioEnvironment();
(List <SnippetGeneratorResult> visualStudioResults, List <Snippet> visualStudioSnippets) = GenerateSnippets(
visualStudio,
directories,
VisualStudioExtensionProjectPath);
var visualStudioCode = new VisualStudioCodeEnvironment();
(List <SnippetGeneratorResult> visualStudioCodeResults, List <Snippet> visualStudioCodeSnippets) = GenerateSnippets(
visualStudioCode,
directories,
VisualStudioCodeExtensionProjectPath);
CheckDuplicateShortcuts(visualStudioSnippets, visualStudio);
CheckDuplicateShortcuts(visualStudioCodeSnippets, visualStudioCode);
IEnumerable <Language> languages = visualStudioResults
.Concat(visualStudioCodeResults)
.Select(f => f.Language)
.Distinct();
var document = new MDocument(
Heading1(ProductName),
BulletList(
CodeGenerationUtility.GetProjectSubtitle(languages),
BulletItem(Link("Release Notes", $"{MasterGitHubUrl}/{ChangeLogFileName}"), ".")));
#if !DEBUG
MarkdownGenerator.GenerateProjectReadme(visualStudioResults, document, visualStudio.CreateProjectReadmeSettings(), addFootnote: false);
MarkdownGenerator.GenerateProjectReadme(visualStudioCodeResults, document, visualStudioCode.CreateProjectReadmeSettings());
IOUtility.WriteAllText(Path.Combine(SolutionDirectoryPath, ReadMeFileName), document.ToString(MarkdownFormat.Default.WithTableOptions(TableOptions.FormatHeader)), IOUtility.UTF8NoBom);
#endif
Console.WriteLine("*** END ***");
Console.ReadKey();
}
private static void Main(string[] args)
{
var settings = new GeneralSettings()
{
SolutionDirectoryPath = @"..\..\..\..\.."
};
SnippetDirectory[] snippetDirectories = SnippetDirectory.LoadFromFile(@"..\..\SnippetDirectories.xml").ToArray();
CharacterSequence[] characterSequences = CharacterSequence.LoadFromFile(@"..\..\CharacterSequences.xml").ToArray();
LanguageDefinition[] languageDefinitions = LanguageDefinition.LoadFromFile(@"..\..\LanguageDefinitions.xml").ToArray();
CharacterSequence.SerializeToXml(Path.Combine(settings.ExtensionProjectPath, "CharacterSequences.xml"), characterSequences);
SnippetGenerator.GenerateSnippets(snippetDirectories, languageDefinitions);
SnippetGenerator.GenerateHtmlSnippets(snippetDirectories);
SnippetGenerator.GenerateXamlSnippets(snippetDirectories);
SnippetGenerator.GenerateXmlSnippets(snippetDirectories);
SnippetDirectory[] releaseDirectories = snippetDirectories
.Where(f => f.HasTag(KnownTags.Release) && !f.HasTag(KnownTags.Dev))
.ToArray();
MarkdownGenerator.WriteSolutionReadMe(releaseDirectories, settings);
MarkdownGenerator.WriteProjectReadMe(releaseDirectories, Path.GetFullPath(settings.ProjectPath));
MarkdownGenerator.WriteDirectoryReadMe(
snippetDirectories
.Where(f => f.HasAnyTag(KnownTags.Release, KnownTags.Dev) && !f.HasAnyTag(KnownTags.AutoGenerationSource, KnownTags.AutoGenerationDestination))
.ToArray(),
characterSequences,
settings);
SnippetPackageGenerator.GenerateVisualStudioPackageFiles(
releaseDirectories: releaseDirectories,
characterSequences: characterSequences,
settings: settings);
settings.ExtensionProjectName += ".Dev";
SnippetPackageGenerator.GenerateVisualStudioPackageFiles(
releaseDirectories: snippetDirectories
.Where(f => f.HasTags(KnownTags.Release, KnownTags.Dev))
.ToArray(),
characterSequences: null,
settings: settings);
SnippetChecker.CheckSnippets(snippetDirectories);
Console.WriteLine("*** END ***");
Console.ReadKey();
}
public void GenerateSimpleText()
{
var generator = new MarkdownGenerator();
string text = generator
.Heading1("Heading 1")
.Text("This is a demo of text in ").Bold("bold").Text(", ").Italic("italic").LineEnd()
.Text("and ").Code("mono-spaced").ParagraphEnd()
.Heading2("Subheading: lists")
.Paragraph("First a numbered list:")
.Numbered("Some text", "other text", 42).Numbered("A new numbered list")
.Paragraph("Then a bullet list:")
.Bullet(1, "another bullet")
.ToString();
TestDataUtility.AreEqual(text, ".md");
}
public override List <Snippet> GeneratePackageFiles(string directoryPath, IEnumerable <SnippetGeneratorResult> results)
{
List <Snippet> snippets = base.GeneratePackageFiles(directoryPath, results);
#if !DEBUG
IOUtility.WriteAllText(
Path.Combine(directoryPath, "Overview.md"),
MarkdownGenerator.GenerateVisualStudioMarketplaceOverview(results));
#endif
IOUtility.WriteAllText(
Path.Combine(directoryPath, "regedit.pkgdef"),
PkgDefGenerator.GeneratePkgDefFile(results));
return(snippets);
}
public static void GenerateVisualStudioPackageFiles(
SnippetDirectory[] releaseDirectories,
CharacterSequence[] characterSequences,
GeneralSettings settings)
{
CopySnippetsToVisualStudioProject(settings.ExtensionProjectPath, releaseDirectories);
releaseDirectories = releaseDirectories
.Select(f => f.WithPath(Path.Combine(settings.ExtensionProjectPath, f.DirectoryName)))
.ToArray();
MarkdownGenerator.WriteProjectReadMe(releaseDirectories, settings.ExtensionProjectPath);
MarkdownGenerator.WriteDirectoryReadMe(releaseDirectories, characterSequences, settings);
WriteVisualStudioGalleryDescription(releaseDirectories, settings);
WritePkgDefFile(releaseDirectories, settings);
}
private static void Main(string[] args)
{
var settings = new GeneralSettings();
settings.SolutionDirectoryPath = @"..\..\..\..\..";
SnippetDirectory[] snippetDirectories = LoadSnippetDirectories().ToArray();
CharacterSequence[] characterSequences = LoadCharacterSequences(settings).ToArray();
GenerateSnippets(snippetDirectories);
GenerateHtmlSnippets(snippetDirectories);
GenerateXamlSnippets(snippetDirectories);
GenerateXmlSnippets(snippetDirectories);
SnippetDirectory[] releaseDirectories = snippetDirectories
.Where(f => f.HasTag(KnownTags.Release))
.ToArray();
MarkdownGenerator.WriteSolutionReadMe(releaseDirectories, settings);
MarkdownGenerator.WriteProjectMarkdownFiles(releaseDirectories, Path.GetFullPath(settings.ProjectPath));
MarkdownGenerator.WriteDirectoryMarkdownFiles(
snippetDirectories
.Where(f => f.HasAnyTag(KnownTags.Release, KnownTags.Dev) && !f.HasAnyTag(KnownTags.AutoGenerationSource, KnownTags.AutoGenerationDestination))
.ToArray(),
characterSequences);
CopySnippetsToVisualStudioProject(settings.ExtensionProjectPath, releaseDirectories);
releaseDirectories = releaseDirectories
.Select(f => f.WithPath(Path.Combine(settings.ExtensionProjectPath, f.DirectoryName)))
.ToArray();
MarkdownGenerator.WriteProjectMarkdownFiles(releaseDirectories, settings.ExtensionProjectPath);
MarkdownGenerator.WriteDirectoryMarkdownFiles(releaseDirectories, characterSequences);
WriteVisualStudioGalleryDescription(releaseDirectories, settings);
WritePkgDefFile(releaseDirectories, settings);
CheckSnippets(snippetDirectories);
Console.WriteLine("*** END ***");
Console.ReadKey();
}
public async Task <IActionResult> ExecuteBenchmarkAsync(
[FromServices] IMediator mediator,
[FromBody] BenchmarkRequestDto benchmarkRequest)
{
var targetExecutionCommand = new ExecuteBenchmarkCommand(benchmarkRequest.Benchmark,
new Repository(benchmarkRequest.TargetRepository.Ref, benchmarkRequest.TargetRepository.Url),
RepositoryTarget.Target);
var targetResult = await mediator.Send(targetExecutionCommand);
var sourceExecutionCommand = new ExecuteBenchmarkCommand(benchmarkRequest.Benchmark,
new Repository(benchmarkRequest.SourceRepository.Ref, benchmarkRequest.SourceRepository.Url),
RepositoryTarget.Source);
var sourceResult = await mediator.Send(sourceExecutionCommand);
var bytes = MarkdownGenerator.Generate(benchmarkRequest.Benchmark, targetResult, sourceResult);
return(File(Encoding.UTF8.GetBytes(bytes), "text/html"));
}
static void Main(string[] args)
{
Console.WriteLine("CHARACTERFORGE - A D&D Character Generator");
Console.WriteLine("==========================================");
Console.WriteLine("This application currently only used as a");
Console.WriteLine("test driver application and will generate a");
Console.WriteLine("pre-defined character sheet");
ICharacter character = BuildCharacter();
CharacterSheetBuilder builder = new CharacterSheetBuilder();
CharacterSheet sheet = builder.Build(character);
IRulebook rules = new Rulebook(new RulesFactory());
IEnumerable <IViolation> violations = rules.CheckRules(character);
MarkdownGenerator generator = new MarkdownGenerator();
string output = generator.Generate(sheet, violations);
File.WriteAllText("charactersheet.md", output);
}
public void GenerateExampleApiSuccess()
{
ServiceInfo service;
const string fileName = "Facility.CodeGen.Markdown.UnitTests.ConformanceApi.fsd";
var parser = new FsdParser();
var stream = GetType().GetTypeInfo().Assembly.GetManifestResourceStream(fileName);
Assert.IsNotNull(stream);
using (var reader = new StreamReader(stream !))
service = parser.ParseDefinition(new ServiceDefinitionText(Path.GetFileName(fileName), reader.ReadToEnd()));
var generator = new MarkdownGenerator
{
GeneratorName = "MarkdownGeneratorTests",
};
generator.GenerateOutput(service);
generator.NoHttp = true;
generator.GenerateOutput(service);
}
static void Main(string[] args)
{
MarkdownGenerator markdownGenerator = new MarkdownGenerator();
SharedContent sharedContent = new SharedContent();
JsonRpcGenerator rpcGenerator = new JsonRpcGenerator(markdownGenerator, sharedContent);
rpcGenerator.Generate();
CliGenerator cliGenerator = new CliGenerator(markdownGenerator, sharedContent);
cliGenerator.Generate();
MetricsGenerator metricsGenerator = new MetricsGenerator(sharedContent);
metricsGenerator.Generate();
ConfigGenerator configGenerator = new ConfigGenerator(sharedContent);
configGenerator.Generate();
}
static void Main(string[] args)
{
MarkdownGenerator markdownGenerator = new MarkdownGenerator();
SharedContent sharedContent = new SharedContent();
MetricsGenerator metricsGenerator = new MetricsGenerator(sharedContent);
metricsGenerator.Generate();
ConfigGenerator configGenerator = new ConfigGenerator(sharedContent);
configGenerator.Generate();
RpcAndCliGenerator rpcAndCliGenerator = new RpcAndCliGenerator(markdownGenerator, sharedContent);
rpcAndCliGenerator.Generate();
SampleConfigGenerator sampleConfigGenerator = new SampleConfigGenerator(markdownGenerator, sharedContent);
sampleConfigGenerator.Generate();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient <IRecipePresenter, RecipePresenter>();
services.AddTransient <IMetadataPresenter, MetadataPresenter>();
services.AddTransient <IParser, Parser>();
services.AddTransient <IDomainSelectorProvider, DomainSelectorProvider>();
var markdownGenerator = new MarkdownGenerator(new TemplateProvider("handlebars-templates/recipe-template.handlebars"));
var markdownProcessor = new MarkdownProcessor();
services.AddControllers((options) =>
{
options.RespectBrowserAcceptHeader = true;
options.ReturnHttpNotAcceptable = true;
options.OutputFormatters.Insert(0, new MarkdownOutputFormatter(markdownGenerator, markdownProcessor));
});
services.AddOpenApiDocument();
services.AddHealthChecks();
// In production, the React files will be served from this directory
// services.AddSpaStaticFiles(configuration => configuration.RootPath = "ClientApp/build");
}
private static async Task Main(string[] args)
{
if (args == null || args.Length == 0)
{
#if DEBUG
args = new string[] { @"..\..\..\..\.." };
#else
args = new string[] { Environment.CurrentDirectory };
#endif
}
string rootPath = args[0];
StringComparer comparer = StringComparer.InvariantCulture;
var metadata = new RoslynatorMetadata(rootPath);
ImmutableArray <AnalyzerMetadata> analyzers = metadata.Analyzers;
ImmutableArray <AnalyzerMetadata> codeAnalysisAnalyzers = metadata.CodeAnalysisAnalyzers;
ImmutableArray <AnalyzerMetadata> formattingAnalyzers = metadata.FormattingAnalyzers;
ImmutableArray <RefactoringMetadata> refactorings = metadata.Refactorings;
ImmutableArray <CodeFixMetadata> codeFixes = metadata.CodeFixes;
ImmutableArray <CompilerDiagnosticMetadata> compilerDiagnostics = metadata.CompilerDiagnostics;
WriteAnalyzersReadMe(@"Analyzers\README.md", analyzers);
WriteAnalyzersReadMe(@"CodeAnalysis.Analyzers\README.md", codeAnalysisAnalyzers);
WriteAnalyzersReadMe(@"Formatting.Analyzers\README.md", formattingAnalyzers);
WriteAnalyzersByCategory(@"Analyzers\AnalyzersByCategory.md", analyzers);
#if !DEBUG
VisualStudioInstance instance = MSBuildLocator.QueryVisualStudioInstances().First(f => f.Version.Major == 16);
MSBuildLocator.RegisterInstance(instance);
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create())
{
workspace.WorkspaceFailed += (o, e) => Console.WriteLine(e.Diagnostic.Message);
string solutionPath = Path.Combine(rootPath, "Roslynator.sln");
Console.WriteLine($"Loading solution '{solutionPath}'");
Solution solution = await workspace.OpenSolutionAsync(solutionPath).ConfigureAwait(false);
Console.WriteLine($"Finished loading solution '{solutionPath}'");
RoslynatorInfo roslynatorInfo = await RoslynatorInfo.Create(solution).ConfigureAwait(false);
IOrderedEnumerable <SourceFile> sourceFiles = analyzers
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetAnalyzerFilesAsync(f.Identifier).Result))
.Concat(refactorings
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetRefactoringFilesAsync(f.Identifier).Result)))
.OrderBy(f => f.Id);
MetadataFile.SaveSourceFiles(sourceFiles, @"..\SourceFiles.xml");
}
#endif
foreach (AnalyzerMetadata analyzer in codeAnalysisAnalyzers)
{
WriteAllText(
$@"..\docs\analyzers\{analyzer.Id}.md",
MarkdownGenerator.CreateAnalyzerMarkdown(analyzer, new (string, string)[] { ("Roslynator.CodeAnalysis.Analyzers", "https://www.nuget.org/packages/Roslynator.CodeAnalysis.Analyzers") }),
public async Task GenerateAsync()
{
WriteAllText(
@"Analyzers\README.md",
MarkdownGenerator.CreateAnalyzersReadMe(Analyzers.Where(f => !f.IsObsolete), Comparer));
WriteAllText(
@"Analyzers\AnalyzersByCategory.md",
MarkdownGenerator.CreateAnalyzersByCategoryMarkdown(Analyzers.Where(f => !f.IsObsolete), Comparer));
VisualStudioInstance instance = MSBuildLocator.QueryVisualStudioInstances().Single();
MSBuildLocator.RegisterInstance(instance);
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create())
{
workspace.WorkspaceFailed += (o, e) => Console.WriteLine(e.Diagnostic.Message);
string solutionPath = Path.Combine(RootPath, "Roslynator.sln");
Console.WriteLine($"Loading solution '{solutionPath}'");
Solution solution = await workspace.OpenSolutionAsync(solutionPath).ConfigureAwait(false);
Console.WriteLine($"Finished loading solution '{solutionPath}'");
RoslynatorInfo roslynatorInfo = await RoslynatorInfo.Create(solution).ConfigureAwait(false);
IOrderedEnumerable <SourceFile> sourceFiles = Analyzers
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetAnalyzerFilesAsync(f.Identifier).Result))
.Concat(Refactorings
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetRefactoringFilesAsync(f.Identifier).Result)))
.OrderBy(f => f.Id);
MetadataFile.SaveSourceFiles(sourceFiles, @"..\SourceFiles.xml");
foreach (AnalyzerDescriptor analyzer in Analyzers)
{
//IEnumerable<string> filePaths = await roslynatorInfo.GetAnalyzerFilesAsync(analyzer.Identifier).ConfigureAwait(false);
WriteAllText(
$@"..\docs\analyzers\{analyzer.Id}.md",
MarkdownGenerator.CreateAnalyzerMarkdown(analyzer, Array.Empty <string>()),
fileMustExists: false);
}
foreach (RefactoringDescriptor refactoring in Refactorings)
{
//IEnumerable<string> filePaths = await roslynatorInfo.GetRefactoringFilesAsync(refactoring.Identifier).ConfigureAwait(false);
WriteAllText(
$@"..\docs\refactorings\{refactoring.Id}.md",
MarkdownGenerator.CreateRefactoringMarkdown(refactoring, Array.Empty <string>()),
fileMustExists: false);
}
foreach (CompilerDiagnosticDescriptor diagnostic in CompilerDiagnostics)
{
//IEnumerable<string> filePaths = await roslynatorInfo.GetCompilerDiagnosticFilesAsync(diagnostic.Identifier).ConfigureAwait(false);
WriteAllText(
$@"..\docs\cs\{diagnostic.Id}.md",
MarkdownGenerator.CreateCompilerDiagnosticMarkdown(diagnostic, CodeFixes, Comparer, Array.Empty <string>()),
fileMustExists: false);
}
}
WriteAllText(
@"..\docs\refactorings\Refactorings.md",
MarkdownGenerator.CreateRefactoringsMarkdown(Refactorings, Comparer));
WriteAllText(
@"Refactorings\README.md",
MarkdownGenerator.CreateRefactoringsReadMe(Refactorings.Where(f => !f.IsObsolete), Comparer));
WriteAllText(
@"CodeFixes\README.md",
MarkdownGenerator.CreateCodeFixesReadMe(CompilerDiagnostics, Comparer));
WriteAllText(
"DefaultConfigFile.xml",
XmlGenerator.CreateDefaultConfigFile(Refactorings, CodeFixes));
WriteAllText(
"DefaultRuleSet.ruleset",
XmlGenerator.CreateDefaultRuleSet(Analyzers));
}
/// <summary>
/// Generates Markdown from .NET XML documentation comments.
/// </summary>
/// <param name="inputPath">The input assembly.</param>
/// <param name="outputPath">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <returns>The names of files that were added, changed, or removed.</returns>
public static XmlDocMarkdownResult Generate(string inputPath, string outputPath, XmlDocMarkdownSettings settings)
{
if (inputPath == null)
{
throw new ArgumentNullException(nameof(inputPath));
}
if (outputPath == null)
{
throw new ArgumentNullException(nameof(outputPath));
}
var result = new XmlDocMarkdownResult();
settings = settings ?? new XmlDocMarkdownSettings();
var generator = new MarkdownGenerator
{
SourceCodePath = settings.SourceCodePath,
RootNamespace = settings.RootNamespace,
IncludeObsolete = settings.IncludeObsolete,
Visibility = settings.VisibilityLevel ?? XmlDocVisibilityLevel.Protected,
ExternalDocs = settings.ExternalDocs,
};
if (settings.NewLine != null)
{
generator.NewLine = settings.NewLine;
}
var assembly = Assembly.LoadFrom(inputPath);
XmlDocAssembly xmlDocAssembly;
var xmlDocPath = Path.ChangeExtension(inputPath, ".xml");
if (!File.Exists(xmlDocPath))
{
xmlDocPath = Path.ChangeExtension(inputPath, ".XML");
}
if (File.Exists(xmlDocPath))
{
var xDocument = XDocument.Load(xmlDocPath);
xmlDocAssembly = new XmlDocAssembly(xDocument);
}
else
{
xmlDocAssembly = new XmlDocAssembly();
}
var namedTexts = generator.GenerateOutput(assembly, xmlDocAssembly);
var namedTextsToWrite = new List <NamedText>();
foreach (var namedText in namedTexts)
{
string existingFilePath = Path.Combine(outputPath, namedText.Name);
if (File.Exists(existingFilePath))
{
// ignore CR when comparing files
if (namedText.Text.Replace("\r", "") != File.ReadAllText(existingFilePath).Replace("\r", ""))
{
namedTextsToWrite.Add(namedText);
result.Changed.Add(namedText.Name);
if (!settings.IsQuiet)
{
result.Messages.Add("changed " + namedText.Name);
}
}
}
else
{
namedTextsToWrite.Add(namedText);
result.Added.Add(namedText.Name);
if (!settings.IsQuiet)
{
result.Messages.Add("added " + namedText.Name);
}
}
}
var namesToDelete = new List <string>();
if (settings.ShouldClean)
{
var directoryInfo = new DirectoryInfo(outputPath);
if (directoryInfo.Exists)
{
string assemblyName = assembly.GetName().Name;
string assemblyFilePath = assembly.Modules.FirstOrDefault()?.FullyQualifiedName;
string assemblyFileName = assemblyFilePath != null?Path.GetFileName(assemblyFilePath) : assemblyName;
string assemblyFolder = Path.GetFileNameWithoutExtension(assemblyFileName);
var patterns = new[] { $"{assemblyFolder}/*.md", $"{assemblyFolder}/*/*.md" };
string codeGenComment = MarkdownGenerator.GetCodeGenComment(assemblyFileName);
foreach (string nameMatchingPattern in FindNamesMatchingPatterns(directoryInfo, patterns, codeGenComment))
{
if (namedTexts.All(x => x.Name != nameMatchingPattern))
{
namesToDelete.Add(nameMatchingPattern);
result.Removed.Add(nameMatchingPattern);
if (!settings.IsQuiet)
{
result.Messages.Add("removed " + nameMatchingPattern);
}
}
}
}
}
if (!settings.IsDryRun)
{
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
foreach (var namedText in namedTextsToWrite)
{
string outputFilePath = Path.Combine(outputPath, namedText.Name);
string outputFileDirectoryPath = Path.GetDirectoryName(outputFilePath);
if (outputFileDirectoryPath != null && outputFileDirectoryPath != outputPath && !Directory.Exists(outputFileDirectoryPath))
{
Directory.CreateDirectory(outputFileDirectoryPath);
}
File.WriteAllText(outputFilePath, namedText.Text);
}
foreach (string nameToDelete in namesToDelete)
{
File.Delete(Path.Combine(outputPath, nameToDelete));
}
}
return(result);
}
public MarkdownGeneratorGlobals(MarkdownGenerator generator, ServiceInfo serviceInfo, HttpServiceInfo? httpServiceInfo)
{
Service = serviceInfo;
HttpService = httpServiceInfo;
CodeGenCommentText = CodeGenUtility.GetCodeGenComment(generator.GeneratorName ?? "");
}
private static async Task Main(string[] args)
{
if (args == null || args.Length == 0)
{
#if DEBUG
args = new string[] { @"..\..\..\..\.." };
#else
args = new string[] { Environment.CurrentDirectory };
#endif
}
string rootPath = args[0];
StringComparer comparer = StringComparer.InvariantCulture;
var metadata = new RoslynatorMetadata(rootPath);
ImmutableArray <AnalyzerMetadata> analyzers = metadata.Analyzers;
ImmutableArray <RefactoringMetadata> refactorings = metadata.Refactorings;
ImmutableArray <CodeFixMetadata> codeFixes = metadata.CodeFixes;
ImmutableArray <CompilerDiagnosticMetadata> compilerDiagnostics = metadata.CompilerDiagnostics;
WriteAnalyzersReadMe(@"Analyzers\README.md", analyzers);
WriteAnalyzersByCategory(@"Analyzers\AnalyzersByCategory.md", analyzers);
#if !DEBUG
VisualStudioInstance instance = MSBuildLocator.QueryVisualStudioInstances().First(f => f.Version.Major == 15);
MSBuildLocator.RegisterInstance(instance);
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create())
{
workspace.WorkspaceFailed += (o, e) => Console.WriteLine(e.Diagnostic.Message);
string solutionPath = Path.Combine(rootPath, "Roslynator.sln");
Console.WriteLine($"Loading solution '{solutionPath}'");
Solution solution = await workspace.OpenSolutionAsync(solutionPath).ConfigureAwait(false);
Console.WriteLine($"Finished loading solution '{solutionPath}'");
RoslynatorInfo roslynatorInfo = await RoslynatorInfo.Create(solution).ConfigureAwait(false);
IOrderedEnumerable <SourceFile> sourceFiles = analyzers
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetAnalyzerFilesAsync(f.Identifier).Result))
.Concat(refactorings
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetRefactoringFilesAsync(f.Identifier).Result)))
.OrderBy(f => f.Id);
MetadataFile.SaveSourceFiles(sourceFiles, @"..\SourceFiles.xml");
}
#endif
foreach (AnalyzerMetadata analyzer in analyzers)
{
WriteAllText(
$@"..\docs\analyzers\{analyzer.Id}.md",
MarkdownGenerator.CreateAnalyzerMarkdown(analyzer, Array.Empty <string>()),
fileMustExists: false);
}
foreach (RefactoringMetadata refactoring in refactorings)
{
WriteAllText(
$@"..\docs\refactorings\{refactoring.Id}.md",
MarkdownGenerator.CreateRefactoringMarkdown(refactoring, Array.Empty <string>()),
fileMustExists: false);
}
foreach (CompilerDiagnosticMetadata diagnostic in compilerDiagnostics)
{
WriteAllText(
$@"..\docs\cs\{diagnostic.Id}.md",
MarkdownGenerator.CreateCompilerDiagnosticMarkdown(diagnostic, codeFixes, comparer, Array.Empty <string>()),
fileMustExists: false);
}
WriteAllText(
@"..\docs\refactorings\Refactorings.md",
MarkdownGenerator.CreateRefactoringsMarkdown(refactorings, comparer));
WriteAllText(
@"Refactorings\README.md",
MarkdownGenerator.CreateRefactoringsReadMe(refactorings.Where(f => !f.IsObsolete), comparer));
WriteAllText(
@"CodeFixes\README.md",
MarkdownGenerator.CreateCodeFixesReadMe(compilerDiagnostics, comparer));
WriteAllText(
"DefaultConfigFile.xml",
XmlGenerator.CreateDefaultConfigFile(refactorings, codeFixes));
WriteAllText(
"default.ruleset",
XmlGenerator.CreateDefaultRuleSet(analyzers));
// find files to delete
foreach (string path in Directory.EnumerateFiles(GetPath(@"..\docs\refactorings")))
{
if (Path.GetFileName(path) != "Refactorings.md" &&
!refactorings.Any(f => f.Id == Path.GetFileNameWithoutExtension(path)))
{
Console.WriteLine($"FILE TO DELETE: {path}");
}
}
// find missing samples
foreach (RefactoringMetadata refactoring in refactorings)
{
if (refactoring.Samples.Count == 0)
{
foreach (ImageMetadata image in refactoring.ImagesOrDefaultImage())
{
string imagePath = Path.Combine(GetPath(@"..\images\refactorings"), image.Name + ".png");
if (!File.Exists(imagePath))
{
Console.WriteLine($"MISSING SAMPLE: {imagePath}");
}
}
}
}
void WriteAnalyzersReadMe(string path, ImmutableArray <AnalyzerMetadata> descriptors)
{
WriteAllText(
path,
MarkdownGenerator.CreateAnalyzersReadMe(descriptors.Where(f => !f.IsObsolete), comparer));
}
void WriteAnalyzersByCategory(string path, ImmutableArray <AnalyzerMetadata> descriptors)
{
WriteAllText(
path,
MarkdownGenerator.CreateAnalyzersByCategoryMarkdown(descriptors.Where(f => !f.IsObsolete), comparer));
}
void WriteAllText(string relativePath, string content, bool onlyIfChanges = true, bool fileMustExists = true)
{
string path = GetPath(relativePath);
Encoding encoding = (Path.GetExtension(path) == ".md") ? _utf8NoBom : Encoding.UTF8;
FileHelper.WriteAllText(path, content, encoding, onlyIfChanges, fileMustExists);
}
string GetPath(string path)
{
return(Path.Combine(rootPath, path));
}
}
static async Task <int> Main(string[] args)
{
var logCommand = new Command("azlogs", "Download portfolio backend diagnostic log files from an Azure Blob Storage Container")
{
new Option <int?>("--days", getDefaultValue: () => null, "Only output logs going back this number of days"),
new Option <bool>("--today", getDefaultValue: () => false, "Only output logs generated today"),
new Option <bool>("--web", getDefaultValue: () => false, "Get web server logs"),
new Option <string>("--env", getDefaultValue: () => "LIVE", "The environment to download from. Requires settings for each environment to be configured in appSettings e.g. AzureStorageConnectionString.LIVE & AzureStorageConnectionString.TEST.")
};
var fieldDocsCommand = new Command("markdown", "Generate markdown files")
{
new Option <string>("--file", getDefaultValue: () => "fields", "Generate markdown file for project fields.")
};
var rootCommand = new RootCommand("Portfolio utitlies")
{
logCommand, fieldDocsCommand
};
logCommand.Handler = CommandHandler.Create <int?, bool, bool, string>(async(days, today, web, env) => await AzureBlobClient.OutputBlobText(days, today, web, env));
fieldDocsCommand.Handler = CommandHandler.Create <string>(async(file) => await MarkdownGenerator.OutputFile(file));
return(await rootCommand.InvokeAsync(args));
}
/// <summary>
/// Generates Markdown from .NET XML documentation comments.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="outputPath">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <returns>The names of files that were added, changed, or removed.</returns>
public static XmlDocMarkdownResult Generate(XmlDocInput input, string outputPath, XmlDocMarkdownSettings settings)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (outputPath == null)
{
throw new ArgumentNullException(nameof(outputPath));
}
var result = new XmlDocMarkdownResult();
settings = settings ?? new XmlDocMarkdownSettings();
var generator = new MarkdownGenerator
{
SourceCodePath = settings.SourceCodePath,
RootNamespace = settings.RootNamespace,
IncludeObsolete = settings.IncludeObsolete,
SkipUnbrowsable = settings.SkipUnbrowsable,
Visibility = settings.VisibilityLevel ?? XmlDocVisibilityLevel.Protected,
ExternalDocs = settings.ExternalDocs,
NamespacePages = settings.NamespacePages,
FrontMatter = settings.FrontMatter,
};
if (settings.NewLine != null)
{
generator.NewLine = settings.NewLine;
}
if (string.Compare(settings.PermalinkStyle, "pretty", StringComparison.OrdinalIgnoreCase) == 0)
{
generator.PermalinkPretty = true;
}
XmlDocAssembly xmlDocAssembly;
var assembly = input.Assembly;
if (assembly == null)
{
assembly = Assembly.LoadFrom(input.AssemblyPath);
}
var xmlDocPath = input.XmlDocPath;
if (xmlDocPath == null)
{
var assemblyPath = input.AssemblyPath ?? assembly.Location;
xmlDocPath = Path.ChangeExtension(assemblyPath, ".xml");
if (!File.Exists(xmlDocPath))
{
xmlDocPath = Path.ChangeExtension(assemblyPath, ".XML");
}
}
if (xmlDocPath != null && File.Exists(xmlDocPath))
{
var xDocument = XDocument.Load(xmlDocPath);
xmlDocAssembly = new XmlDocAssembly(xDocument);
}
else
{
xmlDocAssembly = new XmlDocAssembly();
}
var namedTexts = generator.GenerateOutput(assembly, xmlDocAssembly);
var namedTextsToWrite = new List <NamedText>();
foreach (var namedText in namedTexts)
{
string existingFilePath = Path.Combine(outputPath, namedText.Name);
if (File.Exists(existingFilePath))
{
// ignore CR when comparing files
if (namedText.Text.Replace("\r", "") != File.ReadAllText(existingFilePath).Replace("\r", ""))
{
namedTextsToWrite.Add(namedText);
result.Changed.Add(namedText.Name);
if (!settings.IsQuiet)
{
result.Messages.Add("changed " + namedText.Name);
}
}
}
else
{
namedTextsToWrite.Add(namedText);
result.Added.Add(namedText.Name);
if (!settings.IsQuiet)
{
result.Messages.Add("added " + namedText.Name);
}
}
}
if (settings.GenerateToc)
{
string tocPath = Path.Combine(outputPath, "toc.yml");
NamedText root = namedTexts.FirstOrDefault();
if (root != null)
{
XmlDocToc toc = new XmlDocToc()
{
Path = root.Name, Title = root.Title, Prefix = settings.TocPrefix
};
foreach (var namedText in namedTexts.Skip(1))
{
toc.AddChild(namedText.Name, namedText.Parent, namedText.Title);
}
toc.Save(tocPath);
}
}
var namesToDelete = new List <string>();
if (settings.ShouldClean)
{
var directoryInfo = new DirectoryInfo(outputPath);
if (directoryInfo.Exists)
{
string assemblyName = assembly.GetName().Name;
string assemblyFilePath = assembly.Modules.FirstOrDefault()?.FullyQualifiedName;
string assemblyFileName = assemblyFilePath != null?Path.GetFileName(assemblyFilePath) : assemblyName;
string assemblyFolder = Path.GetFileNameWithoutExtension(assemblyFileName);
var patterns = new[] { $"{assemblyFolder}/*.md", $"{assemblyFolder}/*/*.md" };
string codeGenComment = MarkdownGenerator.GetCodeGenComment(assemblyFileName);
foreach (string nameMatchingPattern in FindNamesMatchingPatterns(directoryInfo, patterns, codeGenComment))
{
if (namedTexts.All(x => x.Name != nameMatchingPattern))
{
namesToDelete.Add(nameMatchingPattern);
result.Removed.Add(nameMatchingPattern);
if (!settings.IsQuiet)
{
result.Messages.Add("removed " + nameMatchingPattern);
}
}
}
}
}
if (!settings.IsDryRun)
{
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
foreach (var namedText in namedTextsToWrite)
{
string outputFilePath = Path.Combine(outputPath, namedText.Name);
string outputFileDirectoryPath = Path.GetDirectoryName(outputFilePath);
if (outputFileDirectoryPath != null && outputFileDirectoryPath != outputPath && !Directory.Exists(outputFileDirectoryPath))
{
Directory.CreateDirectory(outputFileDirectoryPath);
}
File.WriteAllText(outputFilePath, namedText.Text);
}
foreach (string nameToDelete in namesToDelete)
{
File.Delete(Path.Combine(outputPath, nameToDelete));
}
}
return(result);
}
