Refactor WordCensor and optimize offensive word handling

Refactored variable naming for better clarity and consistency. Optimized text processing by introducing a HashSet for offensive words to improve performance. Deprecated inefficient looping mechanisms and replaced them with a streamlined indexing approach for word detection.

Author: ivandrofly

source/WordCensor/EntryPoint.cs

@@ -11,7 +11,7 @@ public class WordCensor : IPlugin
 
         public string Text => "Word censor";
 
-        public decimal Version => 1m;
+        public decimal Version => 1.1m;
 
         public string Description => "Censor offensive words";
 

source/WordCensor/WordsHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
 using Nikse.SubtitleEdit.Core.Common;
@@ -7,10 +8,10 @@ namespace Nikse.SubtitleEdit.PluginLogic
 {
     class WordsHandler
     {
-        private static readonly Random _random = new Random();
-        private static readonly char[] _grawlixChars = { '@', '#', '!', '?', '$', '%', '&' };
+        private static readonly Random Random = new();
+        private static readonly char[] GrawlixChars = { '@', '#', '!', '?', '$', '%', '&' };
         private readonly WordsHandlerConfigs _configs;
-        private static readonly Regex _regexNonWord = new Regex("\\W", RegexOptions.Compiled);
+        private static readonly Regex RegexNonWord = new("\\W", RegexOptions.Compiled);
 
         public WordsHandler(WordsHandlerConfigs configs)
         {
@@ -19,37 +20,68 @@ public WordsHandler(WordsHandlerConfigs configs)
 
         public void CleanUpSubtitle(Subtitle subtitle)
         {
+            var offensiveWordsSet = new HashSet<string>(WordsHelper.GetWords());
             foreach (var p in subtitle.Paragraphs)
             {
-                p.Text = ProcessText(p.Text);
+                p.Text = ProcessText(p.Text, offensiveWordsSet);
             }
         }
 
-        public string ProcessText(string text)
+        public string ProcessText(string text, HashSet<string> ofensiveWords)
         {
-            foreach (var word in WordsHelper.GetWords())
+            var l = 0;
+            for (int r = 0; r < text.Length; r++)
             {
-                int idx = text.IndexOf(word, StringComparison.OrdinalIgnoreCase);
-                while (idx >= 0)
+                if (RegexNonWord.IsMatch(text[l].ToString()) && !RegexNonWord.IsMatch(text[r].ToString()))
                 {
-                    bool startsOkay = idx == 0 || _regexNonWord.IsMatch(text[idx - 1].ToString());
-                    bool allOkay = startsOkay && (idx + word.Length == text.Length || _regexNonWord.IsMatch(text[idx + word.Length].ToString()));
-                    if (allOkay)
+                    l = r;
+                }
+                else if (!char.IsLetterOrDigit(text[r]) || RegexNonWord.IsMatch(text[r].ToString()))
+                {
+                    if (r - l > 1)
                     {
-                        string procWord = ProcessWord(word);
-                        if (_configs.ColorRed)
+                        string word = text.Substring(l, r - l);
+                        if (ofensiveWords.Contains(word.ToLowerInvariant()))
                         {
-                            procWord = WordsHelper.ColorWordRed(procWord);
+                            text = text.Remove(l, r - l);
+                            var processWord = ProcessWord(word);
+                            if (_configs.ColorRed)
+                            {
+                                processWord = WordsHelper.ColorWordRed(processWord);
+                            }
+
+                            text = text.Insert(l, processWord);
+                            r = l + processWord.Length;
                         }
-                        // take out old word
-                        text = text.Remove(idx, word.Length);
-                        // insert new word/colored word.
-                        text = text.Insert(idx, procWord);
                     }
-                    // keep looking for more words in same text.
-                    idx = text.IndexOf(word, idx + word.Length, StringComparison.OrdinalIgnoreCase);
+
+                    l = r + 1;
                 }
             }
+            
+            // foreach (var word in WordsHelper.GetWords())
+            // {
+            //     int idx = text.IndexOf(word, StringComparison.OrdinalIgnoreCase);
+            //     while (idx >= 0)
+            //     {
+            //         bool startsOkay = idx == 0 || RegexNonWord.IsMatch(text[idx - 1].ToString());
+            //         bool allOkay = startsOkay && (idx + word.Length == text.Length || RegexNonWord.IsMatch(text[idx + word.Length].ToString()));
+            //         if (allOkay)
+            //         {
+            //             string procWord = ProcessWord(word);
+            //             if (_configs.ColorRed)
+            //             {
+            //                 procWord = WordsHelper.ColorWordRed(procWord);
+            //             }
+            //             // take out old word
+            //             text = text.Remove(idx, word.Length);
+            //             // insert new word/colored word.
+            //             text = text.Insert(idx, procWord);
+            //         }
+            //         // keep looking for more words in same text.
+            //         idx = text.IndexOf(word, idx + word.Length, StringComparison.OrdinalIgnoreCase);
+            //     }
+            // }
             return text;
         }
 
@@ -64,7 +96,7 @@ private static string ProcessWord(string curseWord)
             var sb = new StringBuilder(len);
             foreach (char ch in charsToCensor)
             {
-                char grawlix = _grawlixChars[_random.Next(0, _grawlixChars.Length)];
+                char grawlix = GrawlixChars[Random.Next(0, GrawlixChars.Length)];
                 sb.Append(grawlix);
             }
             // grawlixed word