Esempio n. 1
0
        public void ShouldReadWhenBIsPrioritaryAndIntersectType3()
        {
            InlineParser parser;
            Column       column;

            Inline[] inlines;


            column = new Column()
            {
                Name = "C1"
            };
            column.InlineFormats.Add("B");
            column.InlineFormats.Add("A");

            parser = new InlineParser(Utils.EmptyRegexBuilder);
            parser.Add("NS", new InlineFormat()
            {
                Name = "B", Pattern = "6789"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "A", Pattern = "2345678"
            });

            inlines = parser.Parse("01234567890").ToArray();
            Assert.AreEqual(3, inlines.Length);
            Assert.AreEqual("012345", inlines[0].Value);
            Assert.AreEqual("6789", inlines[1].Value);
            Assert.AreEqual("0", inlines[2].Value);
        }
Esempio n. 2
0
        public void ShouldReadHoleAtEnd()
        {
            InlineParser parser;
            Column       column;

            Inline[] inlines;


            column = new Column()
            {
                Name = "C1"
            };
            column.InlineFormats.Add("Red");
            column.InlineFormats.Add("Green");
            column.InlineFormats.Add("Blue");
            column.InlineFormats.Add("White");
            column.InlineFormats.Add("Black");

            parser = new InlineParser(Utils.EmptyRegexBuilder);
            parser.Add("NS", new InlineFormat()
            {
                Name = "Red", Pattern = "Red"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Green", Pattern = "Green"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Blue", Pattern = "Blue"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "White", Pattern = "White"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Black", Pattern = "Black"
            });

            inlines = parser.Parse("Red_Green_Blue_Black_White__").ToArray();
            Assert.AreEqual(10, inlines.Length);
            Assert.AreEqual("Red", inlines[0].Value);
            Assert.AreEqual("_", inlines[1].Value);
            Assert.AreEqual("Green", inlines[2].Value);
            Assert.AreEqual("_", inlines[3].Value);
            Assert.AreEqual("Blue", inlines[4].Value);
            Assert.AreEqual("_", inlines[5].Value);
            Assert.AreEqual("Black", inlines[6].Value);
            Assert.AreEqual("_", inlines[7].Value);
            Assert.AreEqual("White", inlines[8].Value);
            Assert.AreEqual("__", inlines[9].Value);
        }
Esempio n. 3
0
        public void ShouldIgnoreCase()
        {
            InlineParser parser;
            Column       column;

            Inline[] inlines;


            column = new Column()
            {
                Name = "C1"
            };
            column.InlineFormats.Add("Red");
            column.InlineFormats.Add("Green");
            column.InlineFormats.Add("Blue");
            column.InlineFormats.Add("White");
            column.InlineFormats.Add("Black");

            parser = new InlineParser(Utils.EmptyRegexBuilder);
            parser.Add("NS", new InlineFormat()
            {
                Name = "Red", Pattern = "red", IgnoreCase = true
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Green", Pattern = "grEen", IgnoreCase = true
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Blue", Pattern = "blUE", IgnoreCase = true
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "White", Pattern = "wHitE", IgnoreCase = true
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Black", Pattern = "BLACK", IgnoreCase = true
            });

            inlines = parser.Parse("RedGreenBlueBlackWhite").ToArray();
            Assert.AreEqual(5, inlines.Length);
            Assert.AreEqual("Red", inlines[0].Value);
            Assert.AreEqual("Green", inlines[1].Value);
            Assert.AreEqual("Blue", inlines[2].Value);
            Assert.AreEqual("Black", inlines[3].Value);
            Assert.AreEqual("White", inlines[4].Value);
        }
Esempio n. 4
0
        public void ShouldReadOrderedContiguous()
        {
            InlineParser parser;
            Column       column;

            Inline[] inlines;


            column = new Column()
            {
                Name = "C1"
            };
            column.InlineFormats.Add("Red");
            column.InlineFormats.Add("Green");
            column.InlineFormats.Add("Blue");
            column.InlineFormats.Add("White");
            column.InlineFormats.Add("Black");

            parser = new InlineParser(Utils.EmptyRegexBuilder);
            parser.Add("NS", new InlineFormat()
            {
                Name = "Red", Pattern = "Red"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Green", Pattern = "Green"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Blue", Pattern = "Blue"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "White", Pattern = "White"
            });
            parser.Add("NS", new InlineFormat()
            {
                Name = "Black", Pattern = "Black"
            });

            inlines = parser.Parse("RedGreenBlueBlackWhite").ToArray();
            Assert.AreEqual(5, inlines.Length);
            Assert.AreEqual("Red", inlines[0].Value);
            Assert.AreEqual("Green", inlines[1].Value);
            Assert.AreEqual("Blue", inlines[2].Value);
            Assert.AreEqual("Black", inlines[3].Value);
            Assert.AreEqual("White", inlines[4].Value);
        }
Esempio n. 5
0
        public IInlineParser CreateParser(string DefaultNameSpace, Column Column)
        {
            InlineParser inlineParser;
            InlineFormat inlineColoringRule;

            if (!AssertParameterNotNull(DefaultNameSpace, "DefaultNameSpace"))
            {
                return(null);
            }
            if (!AssertParameterNotNull(Column, "Column"))
            {
                return(null);
            }

            inlineParser = new InlineParser(regexBuilder);
            foreach (string ruleName in Column.InlineFormats)
            {
                try
                {
                    inlineColoringRule = inlineFormatLibraryModule.GetItem(DefaultNameSpace, ruleName);
                }
                catch (Exception ex)
                {
                    Log(LogLevels.Warning, ex.Message);
                    continue;
                }
                try
                {
                    inlineParser.Add(DefaultNameSpace, inlineColoringRule);
                }
                catch (Exception ex)
                {
                    Log(LogLevels.Warning, ex.Message);
                    continue;
                }
            }

            return(inlineParser);
        }