public void ProduceRelatedLinks()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
##RELATED LINKS
[Online Version:](http://go.microsoft.com/fwlink/p/?linkid=289795)
[Checkpoint-Computer]()
[Remove-Computer]()
[Restart-Computer]()
[Rename-Computer]()
[Restore-Computer]()
[Stop-Computer]()
[Test-Connection]()
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 1);
var links = mamlCommand[0].Links.ToArray();
Assert.Equal(links.Count(), 8);
Assert.Equal(links[0].LinkName, "Online Version:");
Assert.Equal(links[0].LinkUri, "http://go.microsoft.com/fwlink/p/?linkid=289795");
Assert.Equal(links[1].LinkName, "Checkpoint-Computer");
Assert.Empty(links[1].LinkUri);
}
public void Produce2Examples()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## NOTES
## EXAMPLES
### --EXAMPLE1--
```
# PS code here
```
Remarks
### --EXAMPLE2--
```
# PS code here
```
Remarks
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 1);
var examples = mamlCommand[0].Examples.ToArray();
Assert.Equal(examples.Count(), 2);
Assert.Equal(examples[0].Title, "--EXAMPLE1--");
Assert.Equal(examples[0].Code, "# PS code here");
Assert.Equal(examples[0].Remarks, "Remarks");
}
private void ValidateHelpMarkdown(string helpFolder, IList <string> helpRecords, ReportLogger <HelpIssue> helpLogger)
{
foreach (var helpMarkdown in helpRecords)
{
var file = Path.Combine(helpFolder, helpMarkdown + ".md");
var content = File.ReadAllText(file);
try
{
var parser = new MarkdownParser();
var transformer = new ModelTransformerVersion2();
var markdownModel = parser.ParseString(new[] { content });
var model = transformer.NodeModelToMamlModel(markdownModel).FirstOrDefault();
}
catch (Exception ex)
{
HelpIssue issue = new HelpIssue
{
Target = helpMarkdown,
Severity = 1,
ProblemId = PlatyPSSchemaViolation,
Description = "Help content doesn't conform to PlatyPS Schema definition",
Remediation = string.Format("No.")
};
helpLogger.LogRecord(issue);
Console.Error.WriteLine($"Failed to parse {file} by PlatyPS, {ex.Message}");
}
}
}
public void InputAndOutput()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## INPUTS
### System.String
You can pipe computer names and new names to the Add-ComputerCmdlet.
## OUTPUTS
### Microsoft.PowerShell.Commands.ComputerChangeInfo
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 1);
var inputs = mamlCommand[0].Inputs.ToArray();
var outputs = mamlCommand[0].Outputs.ToArray();
Assert.Equal(inputs.Count(), 1);
Assert.Equal(outputs.Count(), 1);
Assert.Equal(inputs[0].TypeName, "System.String");
Assert.Equal(outputs[0].TypeName, "Microsoft.PowerShell.Commands.ComputerChangeInfo");
Assert.Equal(inputs[0].Description, "You can pipe computer names and new names to the Add-ComputerCmdlet.");
Assert.Empty(outputs[0].Description);
}
public void UsesSupportsWildCardsToMarkGlobbing()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### Name [String]
```
[SupportsWildCards()]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(1, mamlCommand.Parameters.Count);
var parameter = mamlCommand.Parameters[0];
Assert.True(parameter.Globbing);
Assert.Equal(parameter.Type, "String");
}
public void CanPaserEmptySourceBlock()
{
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(@"#### 1:
```powershell
```
```powershell
[Parameter(
ValueFromPipeline = $true,
ParameterSetName = 'Set 1')]
```
");
HeadingNode headingNode =
this.AssertNodeType <HeadingNode>(
documentNode.Children.ElementAtOrDefault(0),
MarkdownNodeType.Heading);
Assert.Equal(4, headingNode.HeadingLevel);
CodeBlockNode codeBlockNode =
this.AssertNodeType <CodeBlockNode>(
documentNode.Children.ElementAtOrDefault(1),
MarkdownNodeType.CodeBlock);
Assert.Equal("", codeBlockNode.Text);
}
private DocumentNode MarkdownStringToDocumentNodePreserveFormatting(string markdown)
{
var parser = new MarkdownParser();
return(parser.ParseString(new string[] { markdown },
ParserMode.FormattingPreserve, null));
}
public void ProduceDefaultValues()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### Name [String] = PowerShell
```powershell
[Parameter(ParameterSetName = 'Set 1')]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(1, mamlCommand.Parameters.Count);
var parameter = mamlCommand.Parameters[0];
Assert.Equal(parameter.DefaultValue, "PowerShell");
}
public void CanUseMultiplyInputStrings()
{
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(new string[] {
@"# Hello
", // TODO: bug: if there is no new-line after header, it fails to parse it.
@"This is new line",
@"```powershell
Code snippet
```"
});
Assert.Equal(3, documentNode.Children.Count());
HeadingNode node1 =
this.AssertNodeType <HeadingNode>(
documentNode.Children.ElementAtOrDefault(0),
MarkdownNodeType.Heading);
ParagraphNode node2 =
this.AssertNodeType <ParagraphNode>(
documentNode.Children.ElementAtOrDefault(1),
MarkdownNodeType.Paragraph);
CodeBlockNode node3 =
this.AssertNodeType <CodeBlockNode>(
documentNode.Children.ElementAtOrDefault(2),
MarkdownNodeType.CodeBlock);
}
public void ProducesParameterValueGroup()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### foo [string]
```powershell
[ValidateSet('a', 'b', 'c')]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(1, mamlCommand.Syntax.Count);
Assert.Equal(1, mamlCommand.Syntax[0].Parameters.Count);
var fooParam = mamlCommand.Syntax[0].Parameters[0];
Assert.Equal("foo", fooParam.Name);
Assert.Equal("string", fooParam.Type);
Assert.Equal(3, fooParam.ParameterValueGroup.Count);
Assert.Equal("a", fooParam.ParameterValueGroup[0]);
Assert.Equal("b", fooParam.ParameterValueGroup[1]);
Assert.Equal("c", fooParam.ParameterValueGroup[2]);
}
public void ProducesParameterForDefaultParameterName()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### informationVariable
### force [switch]
```powershell
[Parameter(Mandatory=$false)]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(2, mamlCommand.Parameters.Count);
var fooParam = mamlCommand.Parameters[0];
Assert.Equal("informationVariable", fooParam.Name);
Assert.Equal(null, fooParam.Type);
}
public void ParseEscapingSameWayAsGithub()
{
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(@"
\<
\\<
\\\<
\\\\<
\\\\\<
\\\\[
\
\\
\\\
\\\\
(
)
[
]
\(
\)
\[
\\[
\]
");
ParagraphNode paragraphNode =
this.AssertNodeType <ParagraphNode>(
documentNode.Children.ElementAtOrDefault(0),
MarkdownNodeType.Paragraph);
// NOTE: to update this example, create a gist on github to check out how it's parsed.
Assert.Equal(@"< \< \< \\< \\< \\[ \ \ \\ \\ ( ) [ ] ( ) [ \[ ]", paragraphNode.Spans.First().Text);
}
public void RecogniceTwoCommandsWithDifferentOrdersOfEntries()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## Synopsis
This is Synopsis, but it doesn't matter in this test
## DESCRIPTION
This is description
# Get-Bar
## DESCRIPTION
This is description
## Synopsis
This is Synopsis, but it doesn't matter in this test
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 2);
Assert.NotNull(mamlCommand[0].Description);
Assert.NotNull(mamlCommand[0].Synopsis);
Assert.NotNull(mamlCommand[1].Description);
Assert.NotNull(mamlCommand[1].Synopsis);
}
public void ParsesDocumentWithMultipleNodes()
{
string documentText =
string.Format(
@"
# {0}
{2}
```
{1}
```
## {0}
{2} [{3}]({4})
", headingText, codeBlockText, paragraphText, hyperlinkText, hyperlinkUri);
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(
documentText);
HeadingNode headingNode =
this.AssertNodeType <HeadingNode>(
documentNode.Children.ElementAtOrDefault(0),
MarkdownNodeType.Heading);
Assert.Equal(headingText, headingNode.Text);
Assert.Equal(1, headingNode.HeadingLevel);
CodeBlockNode codeBlockNode =
this.AssertNodeType <CodeBlockNode>(
documentNode.Children.ElementAtOrDefault(2),
MarkdownNodeType.CodeBlock);
Assert.Equal(codeBlockText, codeBlockNode.Text);
headingNode =
this.AssertNodeType <HeadingNode>(
documentNode.Children.ElementAtOrDefault(3),
MarkdownNodeType.Heading);
Assert.Equal(headingText, headingNode.Text);
Assert.Equal(2, headingNode.HeadingLevel);
ParagraphNode paragraphNode =
this.AssertNodeType <ParagraphNode>(
documentNode.Children.ElementAtOrDefault(4),
MarkdownNodeType.Paragraph);
Assert.Equal(paragraphText.Replace("\r\n", " "), paragraphNode.Spans.First().Text);
HyperlinkSpan hyperlinkSpan =
Assert.IsType <HyperlinkSpan>(
paragraphNode.Spans.ElementAt(1));
Assert.Equal(hyperlinkText, hyperlinkSpan.Text);
Assert.Equal(hyperlinkUri, hyperlinkSpan.Uri);
}
/// <summary>
/// This is a helper method to do all 3 steps.
/// </summary>
/// <param name="markdown"></param>
/// <returns></returns>
public static string MarkdownStringToMamlString(string markdown)
{
var parser = new MarkdownParser();
var transformer = new ModelTransformerVersion2();
var renderer = new MamlRenderer();
var markdownModel = parser.ParseString(new string[] { markdown });
var mamlModel = transformer.NodeModelToMamlModel(markdownModel);
string maml = renderer.MamlModelToString(mamlModel);
return(maml);
}
private TNode ParseAndGetExpectedChild <TNode>(
string markdownString,
MarkdownNodeType expectedNodeType)
{
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode = markdownParser.ParseString(markdownString);
return
(this.AssertNodeType <TNode>(
documentNode.Children.FirstOrDefault(),
expectedNodeType));
}
public void TransformSimpleCommand()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## Synopsis
This is Synopsis
");
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(mamlCommand.Synopsis, "This is Synopsis");
}
public void HandlesHyperLinksInsideText()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## SYNOPSIS
Runs the [Set-WSManQuickConfig]() cmdlet
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 1);
Assert.Equal(mamlCommand[0].Synopsis, "Runs the Set-WSManQuickConfig cmdlet");
}
private string MarkdownStringToMarkdownString(string markdown, ParserMode parserMode)
{
// Parse
var parser = new MarkdownParser();
var markdownModel = parser.ParseString(new string[] { markdown }, ParserMode.FormattingPreserve, null);
// Convert model to Maml
var transformer = new ModelTransformerVersion2();
var mamlModel = transformer.NodeModelToMamlModel(markdownModel).FirstOrDefault();
// Render as markdown
var renderer = new MarkdownV2Renderer(parserMode);
return(renderer.MamlModelToString(mamlModel, true));
}
static void Main(string[] args)
{
var fullFilePath = Path.Combine(Directory.GetCurrentDirectory(), "test.md");
var data = File.ReadAllText(fullFilePath);
var metadata = MarkdownParser.ParseMetadata(data);
var res = MarkdownParser.ParseString(data);
//var renderer = new TextRenderer();
IRenderer <string> renderer = new TextRenderer();
var lookup = FuncConvert.ToFSharpFunc <string, FSharpFunc <string, string> >(action => FuncConvert.ToFSharpFunc <string, string>(args => "Hello"));
var result = renderer.Render(res, lookup);
Console.WriteLine("Hello World!");
}
public void TransformCommandWithExtraLine()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
#Add-Member
##SYNOPSIS
Adds custom properties and methods to an instance of a Windows PowerShell object.
");
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Add-Member");
Assert.Equal(mamlCommand.Synopsis, "Adds custom properties and methods to an instance of a Windows PowerShell object.");
}
public void ProducesParameterEntriesForCornerCases()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### NonExistingTypeParam [NonExistingType]
```powershell
```
This is NonExistingTypeParam description.
### NoDescriptionParam [string]
### NoTypeParam
NoTypeParam description.
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(3, mamlCommand.Parameters.Count);
var nonExistinTypeParam = mamlCommand.Parameters[0];
Assert.Equal("NonExistingTypeParam", nonExistinTypeParam.Name);
Assert.Equal("NonExistingType", nonExistinTypeParam.Type);
Assert.Equal("This is NonExistingTypeParam description.", nonExistinTypeParam.Description);
var noDescriptionParam = mamlCommand.Parameters[1];
Assert.Equal("NoDescriptionParam", noDescriptionParam.Name);
Assert.Equal("string", noDescriptionParam.Type);
Assert.Equal("", noDescriptionParam.Description);
var noTypeParam = mamlCommand.Parameters[2];
Assert.Equal("NoTypeParam", noTypeParam.Name);
Assert.Equal(null, noTypeParam.Type);
Assert.Equal("NoTypeParam description.", noTypeParam.Description);
}
public void TextSpansCanContainSquareBrackets()
{
string documentText = @"
# Foo
Not a hyperlink [PSObject].
";
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(
documentText);
var children = documentNode.Children.ToArray();
Assert.Equal(2, children.Count());
var spans = Assert.IsType <ParagraphNode>(children[1]).Spans.ToArray();
Assert.Equal(@"Not a hyperlink [PSObject].", spans[0].Text);
}
public void TextSpansCanContainDoubleQuotes()
{
string documentText = @"
# Foo
This is a :""text"" with doublequotes
";
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(
documentText);
var children = documentNode.Children.ToArray();
Assert.Equal(2, children.Count());
var spans = Assert.IsType <ParagraphNode>(children[1]).Spans.ToArray();
Assert.Equal(@"This is a :""text"" with doublequotes", spans[0].Text);
}
public void TextSpansCanContainBrackets()
{
string documentText = @"
# Foo
about_Hash_Tables (http://go.microsoft.com/fwlink/?LinkID=135175).
";
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(
documentText);
var children = documentNode.Children.ToArray();
Assert.Equal(2, children.Count());
var spans = Assert.IsType <ParagraphNode>(children[1]).Spans.ToArray();
Assert.Equal(@"about_Hash_Tables (http://go.microsoft.com/fwlink/?LinkID=135175).", spans[0].Text);
}
public void SingleParameter()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## Parameters
### Bar
This is bar parameter
");
var mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).ToArray();
Assert.Equal(mamlCommand.Count(), 1);
var param = mamlCommand[0].Parameters.ToArray();
Assert.Equal(param.Count(), 1);
Assert.Equal(param[0].Name, "Bar");
Assert.Equal(param[0].Description, "This is bar parameter");
}
public void UnderstandsOneLineBreakVsTwoLineBreaks()
{
MarkdownParser markdownParser = new MarkdownParser();
DocumentNode documentNode =
markdownParser.ParseString(@"
1
2
3
");
ParagraphNode paragraphNode =
this.AssertNodeType <ParagraphNode>(
documentNode.Children.ElementAtOrDefault(0),
MarkdownNodeType.Paragraph);
Assert.Equal("1 2\r\n3", paragraphNode.Spans.First().Text);
}
public void TransformMultilineDescription()
{
var parser = new MarkdownParser();
var doc = parser.ParseString(@"
# Get-Foo
## Synopsis
This is Synopsis, but it doesn't matter in this test
## DESCRIPTION
Hello,
I'm a multiline description.
And this is my last line.
");
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
string[] description = mamlCommand.Description.Split('\n').Select(x => x.Trim()).ToArray();
Assert.Equal(3, description.Length);
Assert.Equal("Hello,", description[0]);
Assert.Equal("I'm a multiline description.", description[1]);
Assert.Equal("And this is my last line.", description[2]);
}
public void ProducesSyntaxForTwoSets()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### TypeName [String]
```powershell
[Parameter(Mandatory = $true, ParameterSetName = 'Set 1')]
[Parameter(ParameterSetName = 'Set 2')]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(2, mamlCommand.Syntax.Count);
var syntax1 = mamlCommand.Syntax[0];
var syntax2 = mamlCommand.Syntax[1];
Assert.Equal(syntax1.Parameters.Count, 1);
Assert.Equal(syntax2.Parameters.Count, 1);
Assert.Equal(syntax1.Parameters[0].Name, "TypeName");
Assert.Equal(syntax2.Parameters[0].Name, "TypeName");
Assert.Equal(syntax1.Parameters[0].Type, "String");
Assert.Equal(syntax2.Parameters[0].Type, "String");
Assert.Equal(syntax1.Parameters[0].Required, false);
Assert.Equal(syntax2.Parameters[0].Required, true);
}
public void ProducesSyntaxInTheRightOrder()
{
var parser = new MarkdownParser();
const string docFormatString = @"
# Get-Foo
## PARAMETERS
### SecondSetParam [String]
```powershell
[Parameter(ParameterSetName = 'Set 2')]
```
### FirstSetParam [String]
```powershell
[Parameter(ParameterSetName = 'Set 1')]
```
";
var doc = parser.ParseString(docFormatString);
MamlCommand mamlCommand = (new ModelTransformer()).NodeModelToMamlModel(doc).First();
Assert.Equal(mamlCommand.Name, "Get-Foo");
Assert.Equal(2, mamlCommand.Syntax.Count);
var syntax1 = mamlCommand.Syntax[0];
var syntax2 = mamlCommand.Syntax[1];
Assert.Equal(syntax1.Parameters.Count, 1);
Assert.Equal(syntax2.Parameters.Count, 1);
Assert.Equal(syntax1.Parameters[0].Name, "FirstSetParam");
Assert.Equal(syntax2.Parameters[0].Name, "SecondSetParam");
}
