public void TestTranslations()
        {
            ArticleLexer parser = new ArticleLexer();
            List<Token> tokens;

            tokens = parser.Parse("abc");
            Assert.That(tokens.Select(t => t.Type).ToList(), Is.EqualTo(new List<TokenType> {TokenType.Translation}));
            Assert.That(tokens.Select(t => t.Value).ToList(), Is.EqualTo(new List<string> {"abc"}));

            tokens = parser.Parse("abc\n\ncde");
            Assert.That(tokens.Select(t => t.Type).ToList(), Is.EqualTo(new List<TokenType> {TokenType.Translation, TokenType.NewLine, TokenType.NewLine, TokenType.Translation}));
            Assert.That(tokens.Select(t => t.Value).ToList(), Is.EqualTo(new List<string> {"abc", "\n", "\n", "cde"}));
        }
Exemple #2
0
        public WordArticle Parse(string word, string description)
        {
            List <Token> tokens = lexer.Parse(description);

            WordArticle article = new WordArticle();

            WordFormGroup formGroup = new WordFormGroup();

            article.FormGroups.Add(formGroup);
            formGroup.Forms.Add(word);

            WordTranslationGroup translationGroup = null;

            TokenType lastTokenType1 = TokenType.WordForm;
            TokenType lastTokenType2 = TokenType.NewLine;

            foreach (Token token in tokens)
            {
                switch (token.Type)
                {
                case TokenType.Example:
                    if (translationGroup == null)
                    {
                        translationGroup = new WordTranslationGroup();
                        formGroup.TranslationGroups.Add(translationGroup);
                    }
                    else
                    {
                        translationGroup.Examples.Add(token.Value);
                    }
                    break;

                case TokenType.Translation:
                    if (translationGroup == null || translationGroup.Examples.Any() || (lastTokenType1 == TokenType.NewLine && lastTokenType2 == TokenType.NewLine))
                    {
                        translationGroup = new WordTranslationGroup();
                        formGroup.TranslationGroups.Add(translationGroup);
                    }
                    translationGroup.Translations.Add(token.Value);
                    break;

                case TokenType.WordForm:
                    if (formGroup.TranslationGroups.Any())
                    {
                        formGroup = new WordFormGroup();
                        article.FormGroups.Add(formGroup);
                        translationGroup = null;
                    }
                    formGroup.Forms.Add(token.Value);
                    break;
                }
                lastTokenType2 = lastTokenType1;
                lastTokenType1 = token.Type;
            }

            return(article);
        }
        private static FlowDocument FormatWord(Word word)
        {
            FlowDocument document = new FlowDocument();

            if (word == null)
            {
                return document;
            }

            Paragraph paragraph = FlowDocumentStyles.CreateParagraph();
            document.Blocks.Add(paragraph);

            {
                Run run = new Run(word.Name);
                paragraph.Inlines.Add(run);
                FlowDocumentStyles.FormatWord(run);
                paragraph.Inlines.Add(new LineBreak());
            }

            ArticleLexer parser = new ArticleLexer();
            List<Token> tokens = parser.Parse(word.Description);

            foreach (Token token in tokens)
            {
                string text = token.Value;
                if (token.Type == TokenType.Translation)
                {
                    text = "\u2022 " + text;
                }
                if (token.Type == TokenType.Example)
                {
                    text = "Example: " + text;
                }
                Run run = new Run(text);
                paragraph.Inlines.Add(run);
                FormatText(run, token.Type);
            }

            //todo: handle different number of new lines in the end of the artcle
            if (!string.IsNullOrEmpty(word.Tags))
            {
                Paragraph tagsParagraph = new Paragraph();
                document.Blocks.Add(tagsParagraph);
                tagsParagraph.Margin = new Thickness(0, 5, 0, 0);

                Run run = new Run("Tags: ");
                tagsParagraph.Inlines.Add(run);
                run.FontWeight = FontWeights.Bold;

                run = new Run(word.Tags);
                tagsParagraph.Inlines.Add(run);
            }

            return document;
        }
Exemple #4
0
        private void WriteWordForm(HtmlTextWriter writer, WordForm wordForm)
        {
            writer.AddAttribute(HtmlTextWriterAttribute.Class, CssWordArticle);
            if (wordForm.Name == wordForm.WordInfo.Word.Name)
            {
                writer.AddAttribute("id", CreateId(WordIdPrefix, wordForm.WordInfo.Word.Name));
            }
            writer.RenderBeginTag(HtmlTextWriterTag.Div);

            writer.AddAttribute(HtmlTextWriterAttribute.Class, CssWordForm);
            writer.RenderBeginTag(HtmlTextWriterTag.Div);

            writer.WriteLine(wordForm.Title);

            writer.RenderEndTag();

            if (wordForm.Name != wordForm.WordInfo.Word.Name)
            {
                writer.AddAttribute(HtmlTextWriterAttribute.Class, CssWordRef);
                writer.RenderBeginTag(HtmlTextWriterTag.Div);

                writer.Write("see: ");

                writer.AddAttribute(HtmlTextWriterAttribute.Href, "#" + CreateId(WordIdPrefix, wordForm.WordInfo.Word.Name));
                writer.RenderBeginTag(HtmlTextWriterTag.A);
                writer.Write(wordForm.WordInfo.Word.Name);
                writer.RenderEndTag();

                writer.RenderEndTag();
            }
            else
            {
                ArticleLexer parser = new ArticleLexer();
                List<Token> tokens = parser.Parse(wordForm.WordInfo.Word.Description);
                bool afterNewLine = false;
                foreach (Token token in tokens)
                {
                    if (token.Type == TokenType.NewLine)
                    {
                        if (afterNewLine)
                        {
                            writer.WriteLine("<br/>");
                        }
                        afterNewLine = true;
                    }
                    else
                    {
                        afterNewLine = false;
                        WriteToken(writer, token);
                    }
                }
            }

            writer.RenderEndTag();
        }