コード例 #1
0
        public void TestToString()
        {
            var table = new MarkdownTable(
                new MarkdownTableHeader(
                    new MarkdownTableHeaderCell[]
            {
                new MarkdownTableHeaderCell("Header"),
                new MarkdownTableHeaderCell("Header")
            }
                    ),
                new MarkdownTableRow[]
            {
                new MarkdownTableRow("cell", "cell"),
                new MarkdownTableRow("cell", "cell")
            }
                );

            Assert.Equal(
                "| Header | Header |" + Environment.NewLine +
                "| --- | --- |" + Environment.NewLine +
                "| cell | cell |" + Environment.NewLine +
                "| cell | cell |" + Environment.NewLine,
                table.ToString()
                );
        }
コード例 #2
0
        static void CreateMainMarkdown()
        {
            var template = File.ReadAllText(Data.TemplateDir + "/github.md");

            var table = new MarkdownTable("Article / Interview", "Date", "Publisher", "Sources / Mirrors");

            foreach (var a in articles)
            {
                table.Row(Markdown.Link(a.title, a.primarySource), a.date, a.publisher ?? "", Markdown.LinksString(a.sources));
            }
            template = template.Replace("{ARTICLES_TABLE}", table.ToString());

            table = new MarkdownTable("Event", "Date", "Sources");
            foreach (var e in events)
            {
                table.Row(e.linkOrTitle, e.date, e.sourceLinks);
            }
            template = template.Replace("{EVENTS_TABLE}", table.ToString());

            table = new MarkdownTable("Video", "Date");
            foreach (var v in videos)
            {
                table.Row(Markdown.Link(v.title, v.primarySource), v.dateMarkdownLinks);
            }

            template = template.Replace("{VIDEO_TABLE}", table.ToString());

            table = new MarkdownTable("Audio", "Date");
            foreach (var a in audio)
            {
                table.Row(Markdown.Link(a.title, a.primarySource), a.dateMarkdownLinks);
            }
            template = template.Replace("{AUDIO_TABLE}", table.ToString());

            table = new MarkdownTable("Game", "Year of game release");
            foreach (var s in source)
            {
                table.Row(Markdown.Link(s.game, s.url), s.year);
            }
            template = template.Replace("{SOURCE_TABLE}", table.ToString());

            File.WriteAllText(Data.BaseDir + "/README.md", template);
        }
コード例 #3
0
        public override string ToString()
        {
            var composer = new MarkdownComposer();

            composer
            .AppendHeader("Source Text:", 2)
            .AppendLine(SourceText)
            .AppendLine();

            composer
            .AppendHeader($"Contains messages: {ContainsMessages}", 2);

            if (ContainsMessages)
            {
                composer
                .IncreaseIndentation()
                .AppendLine(MessagesText)
                .DecreaseIndentation()
                .AppendLine();
            }

            composer
            .AppendHeader($"Contains tree root: {ContainsParseTreeRoot}", 2)
            .AppendLine();

            if (ContainsParseTreeRoot)
            {
                var nodesStack = new Stack <ParseTreeNode>();
                nodesStack.Push(ParseTreeRoot);

                var levelsStack = new Stack <int>();
                levelsStack.Push(0);

                var indexStack = new Stack <List <int> >();
                indexStack.Push(new List <int>());

                var mdTableComposer = new MarkdownTable();
                mdTableComposer.AddColumn("Path Index", MarkdownTableColumnAlignment.Left, "Path Index");
                mdTableComposer.AddColumn("Node", MarkdownTableColumnAlignment.Left, "Node");
                mdTableComposer.AddColumn("Token", MarkdownTableColumnAlignment.Left, "Token");

                while (nodesStack.Count > 0)
                {
                    var node      = nodesStack.Pop();
                    var level     = levelsStack.Pop();
                    var indexList = indexStack.Pop();

                    var indexText =
                        indexList.Concatenate(",", "[", "]");

                    var sourceTextStart  = node.Span.Location.Position;
                    var sourceTextLength = node.Span.Length;
                    var sourceText       = SourceText.Substring(sourceTextStart, sourceTextLength);

                    mdTableComposer[0].Add(indexText);
                    mdTableComposer[1].Add("".PadLeft(level * 2) + node);
                    mdTableComposer[2].Add(node.FindTokenAndGetText());
                    //mdTableComposer[2].Add(sourceText);

                    if (node.ChildNodes.Count == 0)
                    {
                        continue;
                    }

                    var childLevel = level + 1;
                    var childNodes =
                        ((IEnumerable <ParseTreeNode>)node.ChildNodes).Reverse();

                    var childIndex = node.ChildNodes.Count - 1;
                    foreach (var childNode in childNodes)
                    {
                        nodesStack.Push(childNode);
                        levelsStack.Push(childLevel);

                        var childIndexList = new List <int>(indexList)
                        {
                            childIndex
                        };
                        indexStack.Push(childIndexList);

                        childIndex--;
                    }
                }

                composer.AppendAtNewLine(mdTableComposer.ToString());
            }

            return(composer.ToString());
        }