示例#1
0
        private static bool AreMarksEqualed(int openedMarkIndex, int closingMarkIndex, string text)
        {
            var mark = MarkdownTags.GetMarkFromText(openedMarkIndex, text);

            return(text.Substring(openedMarkIndex, mark.Length) ==
                   text.Substring(closingMarkIndex - mark.Length + 1, mark.Length));
        }
        public void Process()
        {
            var resultBuilder = new StringBuilder();
            var screened      = false;

            while (currentIndex < text.Length || buffer.Count > 0)
            {
                switch (GetRenderStatus())
                {
                case RenderStatus.CheckScreening:
                    var slashCount = GetSlashesCount();
                    screened = slashCount % 2 != 0;
                    resultBuilder.Append(new string('\\', slashCount - slashCount % 2));
                    currentIndex += slashCount;
                    break;

                case RenderStatus.AppendClosingTag:
                    AppendFromBuffer(currentIndex, resultBuilder);
                    break;

                case RenderStatus.CheckMarkSymbol:
                    var tag = TagBuilder.BuildTag(text, currentIndex);
                    switch (GetTagStatus(tag, screened))
                    {
                    case TagStatus.Screened:
                        screened = false;
                        buffer[tag.OpenPosition] = tag.Mark;
                        buffer[tag.ClosePosition - tag.Mark.Length + 1] = tag.Mark;
                        break;

                    case TagStatus.Correct:
                        buffer[tag.OpenPosition] = $"<{tag.TagName}>";
                        buffer[tag.ClosePosition - tag.Mark.Length + 1] = $"</{tag.TagName}>";
                        openedTags.Add(tag.TagType);
                        break;

                    case TagStatus.Incorrect:
                        var mark = MarkdownTags.GetMarkFromText(currentIndex, text);
                        resultBuilder.Append(mark);
                        currentIndex += mark.Length;
                        break;
                    }

                    break;

                case RenderStatus.PlainText:
                    resultBuilder.Append(text[currentIndex]);
                    currentIndex++;
                    break;
                }
            }

            Result = resultBuilder.ToString();
        }
示例#3
0
        private static bool IsTagCorrect(int startIndex, int endIndex, string text)
        {
            var mark       = MarkdownTags.GetMarkFromText(startIndex, text);
            var tagContent = GetContent(startIndex, endIndex, text);

            return(mark == "#" ||
                   endIndex < text.Length &&
                   AreMarksEqualed(startIndex, endIndex, text) &&
                   !tagContent.Any(char.IsDigit) &&
                   !string.IsNullOrEmpty(tagContent) &&
                   !AreMarksInsideDifferentWords(startIndex, endIndex, text));
        }
示例#4
0
        private static string GetContent(int startIndex, int endIndex, string text)
        {
            var contentBuilder = new StringBuilder();
            var mark           = MarkdownTags.GetMarkFromText(startIndex, text);

            for (var i = startIndex + mark.Length; i <= endIndex - mark.Length; i++)
            {
                contentBuilder.Append(text[i]);
            }

            return(contentBuilder.ToString());
        }
示例#5
0
        public static Tag BuildTag(string text, int startIndex)
        {
            var mark = MarkdownTags.GetMarkFromText(startIndex, text);

            if (!MarkdownTags.IsMark(mark))
            {
                return(Tag.EmptyOn(startIndex));
            }

            var endPos  = FindClosePosition(text, startIndex, mark);
            var tagName = MarkdownTags.GetHtmlTagByMark(mark);


            return(IsTagCorrect(startIndex, endPos, text)
                ? Tag.Correct(tagName, startIndex, endPos)
                : Tag.Incorrect(tagName, startIndex, endPos));
        }
示例#6
0
        private static int FindClosePosition(string text, int startIndex, string openedMark)
        {
            var i        = startIndex + 1;
            var pairMark = MarkdownTags.GetMarkPair(openedMark);
            var mark     = MarkdownTags.GetMarkFromText(i, text);

            while (i < text.Length - openedMark.Length + 1)
            {
                mark = MarkdownTags.GetMarkFromText(i, text);
                if (mark == pairMark && !char.IsWhiteSpace(text[i - 1]))
                {
                    break;
                }

                i += mark.Length;
            }

            return(i == text.Length ? i : i + mark.Length - 1);
        }
        private RenderStatus GetRenderStatus()
        {
            if (buffer.ContainsKey(currentIndex))
            {
                return(RenderStatus.AppendClosingTag);
            }

            if (MarkdownTags.ExpectedToBeMark(currentIndex, text))
            {
                return(RenderStatus.CheckMarkSymbol);
            }

            if (currentIndex < text.Length && text[currentIndex] == '\\' &&
                MarkdownTags.ExpectedToBeMark(currentIndex + 1, text))
            {
                return(RenderStatus.CheckScreening);
            }

            return(RenderStatus.PlainText);
        }