Exemple #1
0
        public void Test_IsMatch_36()
        {
            const string EXPECTED = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";

            var pattern = new RegExpPattern()
                          .AtStartOfStringOrLine()
                          .ZeroOrOneOf(
                false, true,
                p => p.ZeroOrOneOf(
                    false, false,
                    p2 => p2.Character('('))
                .Time(3, p2 => p2.AnyOneDigit())
                .ZeroOrOneOf(
                    false, false,
                    p2 => p2.Character(')'))
                .AnyCharacter(
                    RegExpEscapeCharacter.Build(EscapeCharacter.EscapeCharacterType.WhiteSpace),
                    RegExpCharacter.Build('-')))
                          .Time(3, p => p.AnyOneDigit())
                          .Text("-")
                          .Time(4, p => p.AnyOneDigit())
                          .AtEndOfStringOrLine();

            pattern.ToString().Should().Be(EXPECTED);
        }
Exemple #2
0
        public static RegExpPattern Character(
            this RegExpPattern pattern,
            EscapeCharacter.EscapeCharacterType character)
        {
            pattern.AddRule(new RegExpValue($"{RegExpEscapeCharacter.Build(character)}"));

            return(pattern);
        }
Exemple #3
0
        public void Test_Negative_Any_Of_One_Character_4_Pattern()
        {
            const string EXPECTED = "[^\\t\\u002A]";

            var pattern = new RegExpPattern()
                          .AnyCharacterOtherThan(
                RegExpEscapeCharacter.Build(EscapeCharacter.EscapeCharacterType.Tab),
                RegExpCharacter.Build('*', true));

            pattern.ToString().Should().Be(EXPECTED);
        }
Exemple #4
0
        public void Test_Any_Of_One_Character_3_Pattern()
        {
            const string EXPECTED = "[\\t*]";

            var pattern = new RegExpPattern()
                          .AnyCharacter(
                RegExpEscapeCharacter.Build(EscapeCharacter.EscapeCharacterType.Tab),
                RegExpCharacter.Build('*'));

            pattern.ToString().Should().Be(EXPECTED);
        }
Exemple #5
0
        public void Test_IsMatch_29()
        {
            const string EXPECTED_REGEX_PATTERN = @"\G(.+)[\t\u007C](.+)\r?\n";

            var pattern = new RegExpPattern()
                          .ByOnlyMatchingWherePreviousMatchEnded()
                          .GroupOf(
                true,
                p => p.OneOrMoreOf(
                    false, false,
                    p2 => p2.AnyCharacter())
                )
                          .AnyCharacter(
                RegExpEscapeCharacter.Build(EscapeCharacter.EscapeCharacterType.Tab),
                RegExpCharacter.Build('|', true))
                          .GroupOf(
                true,
                p => p
                .OneOrMoreOf(
                    false, false,
                    p2 => p2.AnyCharacter()))
                          .ZeroOrOneOf(
                false, false,
                p => p.Character(EscapeCharacter.EscapeCharacterType.CarriageReturn))
                          .Character(EscapeCharacter.EscapeCharacterType.NewLine);

            pattern.ToString().Should().Be(EXPECTED_REGEX_PATTERN);

            const string INPUT = "Mumbai, India|13,922,125\t\n" +
                                 "Shanghai, China\t13,831,900\n" +
                                 "Karachi, Pakistan|12,991,000\n" +
                                 "Delhi, India\t12,259,230\n" +
                                 "Istanbul, Turkey|11,372,613\n";

            Console.WriteLine("Population of the World's Largest Cities, 2009");
            Console.WriteLine();
            Console.WriteLine("{0,-20} {1,10}", "City", "Population");
            Console.WriteLine();

            foreach (Match match in pattern.Matches(INPUT))
            {
                Console.WriteLine("{0,-20} {1,10}",
                                  match.Groups[1].Value,
                                  match.Groups[2].Value);
            }
        }
Exemple #6
0
        public void Test_IsMatch_30()
        {
            const string EXPECTED = @"gr[ae]y\s\S+?[\s\p{P}]";

            var pattern = new RegExpPattern()
                          .Text("gr")
                          .AnyCharacter("ae")
                          .Text("y")
                          .Character(EscapeCharacter.EscapeCharacterType.WhiteSpace)
                          .OneOrMoreOf(
                true, false,
                p => p.Character(EscapeCharacter.EscapeCharacterType.NonWhiteSpace)
                )
                          .AnyCharacter(
                RegExpEscapeCharacter.Build(EscapeCharacter.EscapeCharacterType.WhiteSpace),
                RegExpWordCharacter.Build(WordCharacter.WordCharacterType.Punctuation, true));

            pattern.ToString().Should().Be(EXPECTED);
        }