Better class-like matches

Author: Hexer10

Interop/TranslationProvider.cs

@@ -260,7 +260,7 @@ private void FillToEnglishDefaults()
             language.Add("RestartEdiFullEff", "Restart editor to take full effect...");
             language.Add("RestartEdiEff", "Restart editor to take effect...");
             language.Add("Program", "Program");
-            language.Add("HardwareAcc", "Use hardware acceleration (if availablessss)");
+            language.Add("HardwareAcc", "Use hardware acceleration (if available)");
             language.Add("UIAnim", "UI animations");
             language.Add("OpenInc", "Auto open includes");
             language.Add("OpenIncRec", "Open Includes Recursively");

SourcepawnCondenser/SourcepawnCondenser/SMDefinition/SMDefinition.cs

@@ -123,11 +123,12 @@ public void ProduceStringArrays()
             constantNames.Sort((a, b) => string.Compare(a, b));
             ConstantsStrings = constantNames.ToArray();
             var typeNames = new List<string>();
-            typeNames.Capacity = Enums.Count + Structs.Count + Methodmaps.Count;
+            typeNames.Capacity = Enums.Count + Structs.Count + Methodmaps.Count + EnumStructs.Count;
             typeNames.AddRange(Enums.Select(i => i.Name));
             typeNames.AddRange(Structs.Select(i => i.Name));
             typeNames.AddRange(Methodmaps.Select(i => i.Name));
             typeNames.AddRange(Typedefs.Select(i => i.Name));
+            typeNames.AddRange(EnumStructs.Select(i => i.Name));
             typeNames.Sort((a, b) => string.Compare(a, b));
             TypeStrings = typeNames.ToArray();
         }

UI/Components/EditorElementHighlighter.cs

@@ -14,14 +14,18 @@ namespace Spedit.UI.Components
 {
     public class AeonEditorHighlighting : IHighlightingDefinition
     {
+        public AeonEditorHighlighting(IEnumerable<HighlightingColor> namedHighlightingColors)
+        {
+            NamedHighlightingColors = namedHighlightingColors;
+        }
+
         public string Name => "SM";
 
         public HighlightingRuleSet MainRuleSet
         {
             get
             {
-                var commentMarkerSet = new HighlightingRuleSet();
-                commentMarkerSet.Name = "CommentMarkerSet";
+                var commentMarkerSet = new HighlightingRuleSet {Name = "CommentMarkerSet"};
                 commentMarkerSet.Rules.Add(new HighlightingRule
                 {
                     Regex = RegexKeywordsHelper.GetRegexFromKeywords(new[]
@@ -197,41 +201,28 @@ public HighlightingRuleSet MainRuleSet
                 if (def.MethodsStrings.Length > 0)
                     rs.Rules.Add(new HighlightingRule //Methods
                     {
-                        Regex = RegexKeywordsHelper.GetRegexFromKeywords(def.MethodsStrings, true),
+                        Regex = RegexKeywordsHelper.GetRegexFromKeywords2(def.MethodsStrings),
                         Color = new HighlightingColor
                             {Foreground = new SimpleHighlightingBrush(Program.OptionsObject.SH_Methods)}
                     });
 
-                // TODO: Methodmaps are not implements in this way, but I couldnt find where they are defined
-                if (def.EnumStructStrings.Length > 0)
-                {
-                    rs.Rules.Add(new HighlightingRule //Methods
-                    {
-                        Regex = RegexKeywordsHelper.GetRegexFromKeywords(def.EnumStructStrings, true),
-                        Color = new HighlightingColor
-                            {Foreground = new SimpleHighlightingBrush(Program.OptionsObject.SH_Types)}
-                    });
-                }
-                
                 if (def.StructFieldStrings.Length > 0)
-                {
                     rs.Rules.Add(new HighlightingRule //Methods
                     {
-                        Regex = RegexKeywordsHelper.GetRegexFromKeywords(def.StructFieldStrings, true),
+                        Regex = RegexKeywordsHelper.GetRegexFromKeywords2(
+                            def.StructFieldStrings.Select(e => e).ToArray()),
                         Color = new HighlightingColor
                             {Foreground = new SimpleHighlightingBrush(Program.OptionsObject.SH_Methods)}
                     });
-                }
-                
+
                 if (def.StructMethodStrings.Length > 0)
-                {
                     rs.Rules.Add(new HighlightingRule //Methods
                     {
-                        Regex = RegexKeywordsHelper.GetRegexFromKeywords(def.StructMethodStrings, true),
+                        Regex = RegexKeywordsHelper.GetRegexFromKeywords2(
+                            def.StructMethodStrings.Select(e => e).ToArray()),
                         Color = new HighlightingColor
                             {Foreground = new SimpleHighlightingBrush(Program.OptionsObject.SH_Methods)}
                     });
-                }
 
                 rs.Rules.Add(new HighlightingRule //unknown function calls
                 {
@@ -256,14 +247,13 @@ public HighlightingColor GetNamedColor(string name)
             return null;
         }
 
-        public IEnumerable<HighlightingColor> NamedHighlightingColors { get; set; }
+        public IEnumerable<HighlightingColor> NamedHighlightingColors { get; }
 
         public IDictionary<string, string> Properties
         {
             get
             {
-                var propertiesDictionary = new Dictionary<string, string>();
-                propertiesDictionary.Add("DocCommentMarker", "///");
+                var propertiesDictionary = new Dictionary<string, string> {{"DocCommentMarker", "///"}};
                 return propertiesDictionary;
             }
         }
@@ -286,6 +276,7 @@ public SimpleHighlightingBrush(Color color) : this(new SolidColorBrush(color))
 
         private SimpleHighlightingBrush(SerializationInfo info, StreamingContext context)
         {
+            // ReSharper disable once PossibleNullReferenceException
             brush = new SolidColorBrush((Color) ColorConverter.ConvertFromString(info.GetString("color")));
             brush.Freeze();
         }
@@ -307,8 +298,7 @@ public override string ToString()
 
         public override bool Equals(object obj)
         {
-            var other = obj as SimpleHighlightingBrush;
-            if (other == null)
+            if (!(obj is SimpleHighlightingBrush other))
                 return false;
             return brush.Color.Equals(other.brush.Color);
         }
@@ -327,20 +317,10 @@ public static Regex GetRegexFromKeywords(string[] keywords, bool ForceAtomicRege
 
             if (keywords.Length == 0) return new Regex("SPEdit_Error"); //hehe 
 
-            var UseAtomicRegex = true;
-            for (var j = 0; j < keywords.Length; ++j)
-                if (!char.IsLetterOrDigit(keywords[j][0]) ||
-                    !char.IsLetterOrDigit(keywords[j][keywords[j].Length - 1]))
-                {
-                    UseAtomicRegex = false;
-                    break;
-                }
+            var UseAtomicRegex = keywords.All(t => char.IsLetterOrDigit(t[0]) && char.IsLetterOrDigit(t[t.Length - 1]));
 
             var regexBuilder = new StringBuilder();
-            if (UseAtomicRegex)
-                regexBuilder.Append(@"\b(?>");
-            else
-                regexBuilder.Append(@"(");
+            regexBuilder.Append(UseAtomicRegex ? @"\b(?>" : @"(");
 
             var orderedKeyWords = new List<string>(keywords);
             var i = 0;
@@ -361,24 +341,33 @@ public static Regex GetRegexFromKeywords(string[] keywords, bool ForceAtomicRege
                 }
             }
 
-            if (UseAtomicRegex)
-                regexBuilder.Append(@")\b");
-            else
-                regexBuilder.Append(@")");
+            regexBuilder.Append(UseAtomicRegex ? @")\b" : @")");
 
             return new Regex(regexBuilder.ToString(), RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);
         }
 
-        public static string[] ConvertToAtomicRegexAbleStringArray(string[] keywords)
+        private static string[] ConvertToAtomicRegexAbleStringArray(IReadOnlyList<string> keywords)
+        {
+            return keywords.Where(t => t.Length > 0)
+                .Where(t => char.IsLetterOrDigit(t[0]) && char.IsLetterOrDigit(t[t.Length - 1]))
+                .ToArray();
+        }
+
+        /// Use this for class like matches (methodmaps and enumstructs atm)
+        public static Regex GetRegexFromKeywords2(IEnumerable<string> keywords)
         {
-            var atomicRegexAbleList = new List<string>();
-            for (var j = 0; j < keywords.Length; ++j)
-                if (keywords[j].Length > 0)
-                    if (char.IsLetterOrDigit(keywords[j][0]) &&
-                        char.IsLetterOrDigit(keywords[j][keywords[j].Length - 1]))
-                        atomicRegexAbleList.Add(keywords[j]);
-
-            return atomicRegexAbleList.ToArray();
+            var regexBuilder = new StringBuilder(@"(?<=\b[^\s]+\.)(");
+            var i = 0;
+            foreach (var keyword in keywords)
+            {
+                if (i++ > 0)
+                    regexBuilder.Append("|");
+
+                regexBuilder.Append(keyword);
+            }
+
+            regexBuilder.Append(@")\b");
+            return new Regex(regexBuilder.ToString(), RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);
         }
     }
 }