public void ParseUnbalancedMarkdownGridTableToDataTest()
{
string md = @"
+------------------------------------------+----------------+------------+
| Header 1 | Header 2 |
+==========================================+================+============+
| Column 1 | Column 2 Text | Column 3 |
+------------------------------------------+----------------+------------+
| Column 4 | Column 5 Text |
| and a bottle of Russian rum | |
| with broken glass | |
+------------------------------------------+----------------+------------+
| Column 6 | Column 7 Text | Column 8 |
+------------------------------------------+----------------+------------+
| Column 9 | Column 10 Text | Column 11 |
| ho ho and a bottle of rum | | |
+------------------------------------------+----------------+------------+
";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count);
Console.WriteLine(parser.ToGridTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 4, "Table should have returned 4 rows");
Assert.IsTrue(data.Headers[0] == "Header 1"); // header filled
Assert.IsTrue(data.Rows[1][1] == "Column 5 Text", data.Rows[1][1] + "!"); // 2nd row filled
Assert.IsTrue(data.Rows[1][0].Contains("\nand a bottle of"));
}
public void FormatHtmlTableTest()
{
string md = @"
<table>
<tbody>
<tr> <td>Column1</td> <td style='text-align: right'>Column2</td> <td>Column3</td> </tr>
<tr>
<td>Column1 Row 1</td><td>Column2 Row 1</td><td>Column3 Row 1</td>
</tr>
<tr> <td>Column1 Row 2</td>
<td>Column2 Row 2</td><td>Column3 Row 2</td>
</tr>
<tr>
<td>Column1 Row 3</td>
<td>Column2 Row 3</td>
<td>Column3 Row 3</td>
</tr></tbody></table></html>
";
var parser = new TableParserHtml();
var niceMd = parser.FormatMarkdownTable(md);
Console.WriteLine(niceMd);
Assert.IsTrue(niceMd.Contains(" <td>Column3 Row 3</td>"), "Pipe is not formatted as expected");
}
public void ParseMarkdownGridTableToDataTest()
{
string md = @"
+------------------------------------------+----------------+------------+
| Header 1 | Header 2 | Header 3 |
+==========================================+================+============+
| Column 1 | Column 2 Text | Column 3 |
+------------------------------------------+----------------+------------+
| Column 1 Row 2 | Column 5 Text | Column 5.5 |
| and a bottle of Russian rum | | |
| with broken glass | | |
+------------------------------------------+----------------+------------+
| Column 6 | Column 7 Text | Column 8 |
+------------------------------------------+----------------+------------+
| Column 9 | Column 10 Text | Column 11 |
| ho ho and a bottle of rum | | |
+------------------------------------------+----------------+------------+
";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count + " Rows Parsed:");
Console.WriteLine(parser.ToGridTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 4, "Table should have returned 4 rows");
Assert.IsTrue(data.Rows[1][0].Contains("\nand a bottle of"));
}
void EmbedTable()
{
EmbedTableCommand = new CommandBase((parameter, command) =>
{
Window.TableData = Window.Interop.GetJsonTableData();
var parser = new TableParserHtml();
if (Window.TableMode == "Grid Table")
{
Window.TableHtml = parser.ToGridTableMarkdown(Window.TableData);
}
else if (Window.TableMode == "HTML Table")
{
Window.TableHtml = parser.ToTableHtml(Window.TableData);
}
else
{
Window.TableHtml = parser.ToPipeTableMarkdown(Window.TableData);
}
mmApp.Model.ActiveEditor.SetSelectionAndFocus(Window.TableHtml);
Window.Close();
}, (p, c) => true);
}
public void ColumnInfoTest()
{
var data = GetTableData();
var parser = new TableParserHtml();
var colInfo = parser.GetColumnInfo(data);
Assert.IsNotNull(colInfo);
Console.WriteLine(JsonSerializationUtils.Serialize(colInfo));
}
public void DataToMarkdownGridTableMultiLineTest()
{
var data = GetTableMultiLineData();
var parser = new TableParserHtml();
string html = parser.ToGridTableMarkdown(data);
Console.WriteLine(html);
Assert.IsTrue(html.Contains("| Row 8 Column 1 |"));
}
public void DataToHtmlTableMultiLineTest()
{
var data = GetTableMultiLineData();
var parser = new TableParserHtml();
string html = parser.ToTableHtml(data);
Console.WriteLine(html);
Assert.IsTrue(html.Contains("<td style=\"text-align: center\">Row 7 Column 2</td>"));
}
public void CsvTableParserFromStringTest()
{
string data = @"Name,Company,city,Test
Rick,West Wind,Paia,4
Markus,EPS,Kihei,20,11
Kevin,Oak Leaf,Bumstuck VA,4
";
var parser = new TableParserHtml();
var tableData = parser.ParseCsvStringToData(data, ",");
Console.WriteLine(parser.ToGridTableMarkdown(tableData));
}
public void FormatPipeTableTest()
{
string md = @"
| Header1 | Header 2 | Header 3 |
|--------------------------------------------|
| column 1 | Column 2 | Column 3 |
| Custom Table Content | Column 5 | Column 6 |
| Column 7 | Column 8 | Column 9 |
";
var parser = new TableParserHtml();
var niceMd = parser.FormatMarkdownTable(md);
Console.WriteLine(niceMd);
Assert.IsTrue(niceMd.Contains("| Column 7 |"), "Pipe is not formatted as expected");
}
public void UnbalancedPipeTableParsingTest()
{
var md = @"| Header 1 | Header 2 |
|------------|------------|------------|
| Column 1 | Column 2 | More Stuff |
| Column 1.1 | Column 2.1 | More Stuff |";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count);
Console.WriteLine(parser.ToPipeTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 2, "Table should have returned 2 rows");
Assert.IsTrue(data.Rows[0][1] == "Column 2");
}
public void ParseMarkdownPipeTableToDataTest2()
{
string md = @"
a | b
--|--
0 | 1
3 | 4
";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count);
Console.WriteLine(parser.ToPipeTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 2, "Table should have returned 2 rows");
Assert.IsTrue(data.Rows[0][1] == "1");
}
public void ParseMarkdownPipeTableToDataTest()
{
string md = @"
| Header1 | Header 2 | Header 3 |
|--------------------:|----------|----------|
| column 1 | Column 2 | Column 3 |
| Custom Table Content | Column 5 | Column 6 |
| Column 7 | Column 8 | Column 9 |
";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count);
Console.WriteLine(parser.ToPipeTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 3, "Table should have returned 3 rows");
Assert.IsTrue(data.Rows[0][1] == "Column 2");
}
public void ExtraUnbalancedPipeTableParsingTest()
{
var md = @"| Header 1 | Header 2 |
|------------|------------|------------|
| Column 1 | Column 2 |
| Column 1.1 | Column 2.1 | More Stuff | Even More Stuff |";
Console.WriteLine($"Original: \n{md}\n\n");
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count + " Rows Parsed:");
Console.WriteLine(parser.ToPipeTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 2, "Table should have returned 2 rows");
Assert.IsTrue(string.IsNullOrWhiteSpace(data.Rows[0][2])); // header
Assert.IsTrue(!string.IsNullOrWhiteSpace(data.Rows[1][2]));
Assert.IsTrue(data.Rows[0][1] == "Column 2");
Assert.IsTrue(data.Rows[1][2] == "More Stuff");
}
public void SimpleHtmlTableToData()
{
string html = @"
<table>
<thead>
<tr>
<th>Column1</th>
<th>Column2</th>
<th>Column3</th>
</tr>
</thead>
<tbody>
<tr>
<td>Column1 Row 1</td>
<td>Column2 Row 1</td>
<td>Column3 Row 1</td>
</tr>
<tr>
<td>Column1 Row 2</td>
<td>Column2 Row 2</td>
<td>Column3 Row 2</td>
</tr>
<tr>
<td>Column1 Row 3</td>
<td>Column2 Row 3</td>
<td>Column3 Row 3</td>
</tr>
</tbody>
</html>
";
var parser = new TableParserHtml();
var data = parser.ParseHtmlToData(html);
Assert.IsNotNull(data);
Console.WriteLine(data.Rows.Count + " Rows Parsed:");
Console.WriteLine(parser.ToGridTableMarkdown(data));
}
public void SimpleHtmlTableWithBasicMarkupToData()
{
string html = @"
<table>
<tr>
<th>Column1</th>
<th>Column2</th>
<th>Column3</th>
</tr>
</thead>
<tbody>
<tr>
<td>Column1 Row 1</td>
<td>Column2 Row 1</td>
<td>Column3 Row 1</td>
</tr>
<tr>
<td><img src=""https://markdownmonster.west-wind.com/Images/MarkdownMonster_Icon_32.png"" />Column1 <b>RowBold</b></td>
<td><a href=""https://west-wind.com"">Column2</a> <a href=""http://google.com"">Row 2</a></td>
<td>Column3 Row 2</td>
</tr>
<tr>
<td>Column1 Row 3</td>
<td>Column2 Row 3</td>
<td>Column3 Row 3</td>
</tr>
</table>
";
var parser = new TableParserHtml();
var data = parser.ParseHtmlToData(html);
Assert.IsNotNull(data);
Console.WriteLine(data.Rows.Count + " Rows Parsed:");
Console.WriteLine(parser.ToGridTableMarkdown(data));
}
public void FormatGridTableTest()
{
string md = @"
+------------------------+----------------+------------+
| Header 1 | Header 2 | Header 3 |
+==========================================+================+============+
| Column 1 | Column 2 Text | Column 3 |
+------------------------------------------+----------------+------------+
| Column 4 | Column 5 Text | Column 5.5 |
| and a bottle of Russian rum | | |
| with broken glass | | |
+------------------------------------------+----------------+------------+
| Column 6 | Column 7 Text | Column 8 |
+------------------------------------------+----------------+------------+
| Column 9 | Column 10 Text | Column 11 |
| ho ho and a bottle of rum | | |
+------------------------------------------+----------------+------------+
";
var parser = new TableParserHtml();
var niceMd = parser.FormatMarkdownTable(md);
Console.WriteLine(niceMd);
Assert.IsTrue(niceMd.Contains("| Column 1 |"), "Grid is not formatted as expected");
}
private bool CheckForTable(string line, AcePosition pos)
{
if (string.IsNullOrEmpty(line))
{
return(false);
}
line = line.Trim();
if (line.Contains("|") ||
line.StartsWith("+-") ||
line.StartsWith("+="))
{
var mi = new MenuItem
{
Header = "Edit Table"
};
mi.Click += (o, args) =>
{
var tableMarkdown = SelectPipeAndGridTableMarkdown();
Model.ActiveEditor.EditorSelectionOperation("table", tableMarkdown);
};
ContextMenu.Items.Add(mi);
mi = new MenuItem
{
Header = "Format Table"
};
mi.Click += (o, args) =>
{
string mdTableHtml = SelectPipeAndGridTableMarkdown();
if (string.IsNullOrEmpty(mdTableHtml))
{
return;
}
var parser = new TableParserHtml();
var formatted = parser.FormatMarkdownTable(mdTableHtml);
if (formatted == null)
{
return;
}
Model.ActiveEditor.SetSelectionAndFocus(formatted);
Model.ActiveEditor.PreviewMarkdownCallback();
};
ContextMenu.Items.Add(mi);
return(true);
}
else if (line.StartsWith("<td", StringComparison.InvariantCultureIgnoreCase) ||
line.StartsWith("<tr", StringComparison.InvariantCultureIgnoreCase) ||
line.StartsWith("<th", StringComparison.InvariantCultureIgnoreCase) ||
line.StartsWith("<table>", StringComparison.InvariantCultureIgnoreCase) ||
line.StartsWith("<table ", StringComparison.InvariantCultureIgnoreCase) ||
line.Equals("<thead>", StringComparison.InvariantCultureIgnoreCase) ||
line.Equals("<tbody>", StringComparison.InvariantCultureIgnoreCase))
{
StringBuilder sbTableMarkdown = new StringBuilder();
var mi = new MenuItem
{
Header = "Edit Table"
};
mi.Click += (o, args) =>
{
string mdTableHtml = SelectHtmlTableMarkdown();
if (string.IsNullOrEmpty(mdTableHtml))
{
return;
}
Model.ActiveEditor.EditorSelectionOperation("table", mdTableHtml);
};
ContextMenu.Items.Add(mi);
mi = new MenuItem
{
Header = "Format Table"
};
mi.Click += (o, args) =>
{
string mdTableHtml = SelectHtmlTableMarkdown();
if (string.IsNullOrEmpty(mdTableHtml))
{
return;
}
var parser = new TableParserHtml();
var formatted = parser.FormatMarkdownTable(mdTableHtml);
if (formatted == null)
{
return;
}
Model.ActiveEditor.SetSelectionAndFocus(formatted);
Model.ActiveEditor.PreviewMarkdownCallback();
};
ContextMenu.Items.Add(mi);
return(true);
}
return(false);
}
public void ParseComplexMarkdownGridTableToDataTest()
{
var md = @"
+-----------------------------------+-----------------------------------+
| Attribute | Function |
+===================================+===================================+
| **display: flex** | Top level attribute that enables |
| | Flexbox formatting on the |
| | container it is applied to. |
| | |
| | **display:flex** |
+-----------------------------------+-----------------------------------+
| **flex-direction** | Determines horizontal (row) or |
| | vertical (column) flow direction |
| | elements in the container. |
| | |
| | **row,column** |
+-----------------------------------+-----------------------------------+
| **flex-wrap** | Determines how content wraps when |
| | the content overflows the |
| | container. |
| | |
| | **wrap, nowrap, wrap-reverse** |
+-----------------------------------+-----------------------------------+
| **flex-flow** | Combination of flex-direction and |
| | flex-wrap as a single attribute. |
| | |
| | **flex-flow: row nowrap** |
+-----------------------------------+-----------------------------------+
| **justify-content** | Aligns content along the flex |
| | flow direction. |
| | |
| | **flex-start, flex-end, center, |
| | space-between, space-around** |
+-----------------------------------+-----------------------------------+
| **align-items** | Like align-content but aligns |
| | content along the perpendicular |
| | axis. |
| | |
| | **flex-start, flex-end, center, |
| | stretch, baseline** |
+-----------------------------------+-----------------------------------+
| **align-content** | Aligns multi-line content so that |
| | multiple lines of content line up |
| | when wrapping. |
| | |
| | **flex-start, flex-end, center, |
| | space-between, space-around, |
| | stretch** |
+-----------------------------------+-----------------------------------+
";
var parser = new TableParserHtml();
var data = parser.ParseMarkdownToData(md);
Console.WriteLine(data.Rows.Count + " Rows Parsed:");
Console.WriteLine(parser.ToGridTableMarkdown(data));
Assert.IsTrue(data.Rows.Count == 7, "Table should have returned 7 rows");
Assert.IsTrue(data.Rows[1][0].Contains("**flex-direction**"));
}
public void DetectTableTypeTest()
{
string mdPipe = @"
| Header1 | Header 2 | Header 3 |
|--------------------------------------------|
| column 1 | Column 2 | Column 3 |
| Custom Table Content | Column 5 | Column 6 |
| Column 7 | Column 8 | Column 9 |
";
var parser = new TableParserHtml();
var type = parser.DetectTableType(mdPipe);
Assert.IsTrue(type == MarkdownTableType.Pipe, "Not a Pipe Table");
string mdHtml = @"
<table>
<tbody>
<tr>
<td>Column1</td>
<td>Column2</td>
<td>Column3</td>
</tr>
<tr>
<td>Column1 Row 1</td>
<td>Column2 Row 1</td>
<td>Column3 Row 1</td>
</tr>
<tr>
<td>Column1 Row 2</td>
<td>Column2 Row 2</td>
<td>Column3 Row 2</td>
</tr>
<tr>
<td>Column1 Row 3</td>
<td>Column2 Row 3</td>
<td>Column3 Row 3</td>
</tr>
</tbody>
</table>
";
type = parser.DetectTableType(mdHtml);
Assert.IsTrue(type == MarkdownTableType.Html, "Not an HTML table");
string mdGrid = @"
+------------------------------------------+----------------+------------+
| Header 1 | Header 2 | Header 3 |
+==========================================+================+============+
| Column 1 | Column 2 Text | Column 3 |
+------------------------------------------+----------------+------------+
| Column 4 | Column 5 Text | Column 5.5 |
| and a bottle of Russian rum | | |
| with broken glass | | |
+------------------------------------------+----------------+------------+
| Column 6 | Column 7 Text | Column 8 |
+------------------------------------------+----------------+------------+
| Column 9 | Column 10 Text | Column 11 |
| ho ho and a bottle of rum | | |
+------------------------------------------+----------------+------------+
";
type = parser.DetectTableType(mdGrid);
Assert.IsTrue(type == MarkdownTableType.Grid, "Not a Grid Table");
}
