예제 #1
0
        static void Main(string[] args)
        {
            var set         = new RegexSet(BadWords);
            var expressions = BadWords.Select(p => new Regex(p)).ToList();

            string line;

            while ((line = Console.ReadLine()) != null)
            {
                var match = set.Matches(line);
                if (match.Matched)
                {
                    for (int i = 0; i < match.Matches.Length; i++)
                    {
                        if (match.Matches[i])
                        {
                            foreach (var found in expressions[i].FindAll(line))
                            {
                                line = line.Replace(found.ExtractedString, new string('*', found.ExtractedString.Length));
                            }
                        }
                    }
                }
                Console.WriteLine(line);
            }
        }
예제 #2
0
        public void RegexSet_AsIDisposable_ImplementsInterface()
        {
            var set   = new RegexSet("");
            var dispo = set as IDisposable;

            Assert.NotNull(dispo);
        }
예제 #3
0
 public void RegexSet_IsMatch_ReturnsTrueIfAnyRegexMatches()
 {
     using (var regs = new RegexSet("fo+", "[0-9]+"))
     {
         Assert.True(regs.IsMatch("fooooo"));
         Assert.True(regs.IsMatch("bar 1"));
         Assert.False(regs.IsMatch("no match here"));
     }
 }
예제 #4
0
 public void RegexSet_MatchWithFlags_RespectsFlags()
 {
     using (var regs = new RegexSet(RureFlags.Casei, "a", "e", "i", "o", "u"))
     {
         Assert.True(regs.IsMatch("a"));
         Assert.True(regs.IsMatch("E"));
         var match = regs.Matches("Union");
         Assert.True(match.Matched);
         Assert.Equal(new [] { false, false, true, true, true }, match.Matches);
     }
 }
예제 #5
0
 public void RegexSet_Matches_ExposesMatchingPatterns()
 {
     using (var regs = new RegexSet("hel+o", "regex", "world"))
     {
         var match = regs.Matches("hello world");
         Assert.True(match.Matched);
         Assert.True(match.Matches[0]);
         Assert.False(match.Matches[1]);
         Assert.True(match.Matches[2]);
         Assert.Equal(new [] { true, false, true }, match.Matches);
     }
 }
예제 #6
0
        public void RegexSet_Match_WithOptions()
        {
            var opts = new Options()
                       .WithDfaSize(100);

            using (var regs = new RegexSet(Regex.DefaultFlags, opts, "foo+", "ba?r"))
            {
                Assert.True(regs.IsMatch("foooooooooooo"));
                var match = regs.Matches("br");
                Assert.True(match.Matched);
                Assert.Equal(new[] { false, true }, match.Matches);
            }
        }
예제 #7
0
 public void RegexSet_Matches_DigitsAndLetters()
 {
     using (var regs = new RegexSet("[a-z]+", "[0-9]+"))
     {
         Assert.True(regs.IsMatch("hello"));
         Assert.True(regs.IsMatch("1234"));
         Assert.True(regs.IsMatch("l33t"));
         var match = regs.Matches("hello");
         Assert.Equal(new[] { true, false }, match.Matches);
         match = regs.Matches("123");
         Assert.Equal(new[] { false, true }, match.Matches);
     }
 }
예제 #8
0
        public void RegexSetCreate()
        {
            //Given
            var patterns = new[] {
                @"hello world",
                @".+",
                @"(\d{2,4})"
            };

            //When
            var set = new RegexSet(patterns);

            //Then
            Assert.Equal(3, set.Count);
        }
예제 #9
0
        public void RegexSetMatch()
        {
            //Given
            var set = new RegexSet(new[] {
                @"\w+",               // words
                @"\d+",               // digits
                @"\d{4}-\d{2}-\d{2}", // dates
            });

            //When
            var matches = set.Match("I have 1 date: 1969-07-11");

            //Then
            Assert.True(matches.Matched);
            Assert.Equal(3, matches.MatchCount);
            Assert.Collection(
                matches.MatchingPatterns,
                p => Assert.Equal(0, p),
                p => Assert.Equal(1, p),
                p => Assert.Equal(2, p));
        }
예제 #10
0
        public void CreateSetWithBytesOptions()
        {
            //Given
            var set = new RegexSet(new[] {
                Encoding.UTF8.GetBytes("()"),
                Encoding.UTF8.GetBytes("[]"),
                Encoding.UTF8.GetBytes("."),
            }, new Options
            {
                Literal = true,
            });

            //When
            var parenMatches = set.Match("I have some () in");
            var dotMatches   = set.Match("I am the container of a . dot");
            var bland        = set.Match("boring");

            //Then
            Assert.True(parenMatches.Matched);
            Assert.True(dotMatches.Matched);
            Assert.False(bland.Matched);
        }
예제 #11
0
        public ContentFilter(Stream inputStream, RegexSet regexSet)
            : base(inputStream)
        {
            switch (regexSet)
            {
            case RegexSet.AspNet:
                selectedReplacers = aspNetSpecializedReplacers;
                break;

            case RegexSet.JavaScript:
                selectedReplacers = javascriptSpecializedReplacers;
                break;

            case RegexSet.Cleanup:
                selectedReplacers = cleanupSpecializedReplacers;
                break;

            default:
                throw new ArgumentException("RegexSet inválido.");
            }

            responseHtml = new StringBuilder();
        }
예제 #12
0
 public void RegexSet_CreateWithMultiplePatterns_Succeeds()
 {
     var set = new RegexSet("hel+o", "world", "0x[a-zA-Z0-9]{4,8}");
 }
예제 #13
0
 public void RegexSet_CreateWithSingleRegex_Succeeds()
 {
     var set = new RegexSet(".+");
 }
예제 #14
0
 public RegexAtomSet(RegexSet set)
 {
     Set = set;
 }