Backout 'smart' digit separation & Fix Mages functions for Calculator plugin

Plugins/Flow.Launcher.Plugin.Calculator/Main.cs

@@ -13,7 +13,6 @@
 {
     public class Main : IPlugin, IPluginI18n, ISettingProvider
     {
-        private static readonly Regex RegValidExpressChar = MainRegexHelper.GetRegValidExpressChar();
         private static readonly Regex RegBrackets = MainRegexHelper.GetRegBrackets();
         private static readonly Regex ThousandGroupRegex = MainRegexHelper.GetThousandGroupRegex();
         private static readonly Regex NumberRegex = MainRegexHelper.GetNumberRegex();
@@ -27,16 +26,6 @@
         private Settings _settings;
         private SettingsViewModel _viewModel;
 
-        /// <summary>
-        /// Holds the formatting information for a single query.
-        /// This is used to ensure thread safety by keeping query state local.
-        /// </summary>
-        private class ParsingContext
-        {
-            public string InputDecimalSeparator { get; set; }
-            public bool InputUsesGroupSeparators { get; set; }
-        }
-
         public void Init(PluginInitContext context)
         {
             Context = context;
@@ -59,24 +48,46 @@
                 return new List<Result>();
             }
 
-            var context = new ParsingContext();
-
             try
             {
-                var expression = NumberRegex.Replace(query.Search, m => NormalizeNumber(m.Value, context));
+                var expression = NumberRegex.Replace(query.Search, m => NormalizeNumber(m.Value));
+
+                // WORKAROUND START: The 'pow' function in Mages v3.0.0 is broken.
+                // https://github.com/FlorianRappl/Mages/issues/132
+                // We bypass it by rewriting any pow(x,y) expression to the equivalent (x^y) expression
+                // before the engine sees it. This loop handles nested calls.
+                string previous;
+                do
+                {
+                    previous = expression;
+                    expression = Regex.Replace(previous, @"\bpow\s*\(\s*([^,]+?)\s*,\s*([^)]+?)\s*\)", "($1^$2)");
+                } while (previous != expression);
+                // WORKAROUND END
 
                 var result = MagesEngine.Interpret(expression);
 
-                if (result?.ToString() == "NaN")
+                if (result == null || string.IsNullOrEmpty(result.ToString()))
+                {
+                    return new List<Result>
+                    {
+                        new Result
+                        {
+                            Title = Localize.flowlauncher_plugin_calculator_expression_not_complete(),
+                            IcoPath = "Images/calculator.png"
+                        }
+                    };
+                }
+
+                if (result.ToString() == "NaN")
                     result = Localize.flowlauncher_plugin_calculator_not_a_number();
 
                 if (result is Function)
                     result = Localize.flowlauncher_plugin_calculator_expression_not_complete();
 
-                if (!string.IsNullOrEmpty(result?.ToString()))
+                if (!string.IsNullOrEmpty(result.ToString()))
                 {
                     decimal roundedResult = Math.Round(Convert.ToDecimal(result), _settings.MaxDecimalPlaces, MidpointRounding.AwayFromZero);
-                    string newResult = FormatResult(roundedResult, context);
+                    string newResult = FormatResult(roundedResult);
 
                     return new List<Result>
                     {
@@ -106,113 +117,64 @@
             }
             catch (Exception)
             {
-                // ignored
+                // Mages engine can throw various exceptions, for simplicity we catch them all and show a generic message.
+                return new List<Result>
+                {
+                    new Result
+                    {
+                        Title = Localize.flowlauncher_plugin_calculator_expression_not_complete(),
+                        IcoPath = "Images/calculator.png"
+                    }
+                };
             }
 
             return new List<Result>();
         }
 
         /// <summary>
-        /// Parses a string representation of a number, detecting its format. It uses structural analysis
-        /// and falls back to system culture for truly ambiguous cases (e.g., "1,234").
-        /// It populates the provided ParsingContext with the detected format for later use.
+        /// Parses a string representation of a number using the system's current culture.
         /// </summary>
         /// <returns>A normalized number string with '.' as the decimal separator for the Mages engine.</returns>
-        private string NormalizeNumber(string numberStr, ParsingContext context)
+        private string NormalizeNumber(string numberStr)
         {
-            var systemGroupSep = CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;
-            int dotCount = numberStr.Count(f => f == '.');
-            int commaCount = numberStr.Count(f => f == ',');
+            var culture = CultureInfo.CurrentCulture;
+            var groupSep = culture.NumberFormat.NumberGroupSeparator;
+            var decimalSep = culture.NumberFormat.NumberDecimalSeparator;
 
-            // Case 1: Unambiguous mixed separators (e.g., "1.234,56")
-            if (dotCount > 0 && commaCount > 0)
+            // If the string contains the group separator, check if it's used correctly.
+            if (!string.IsNullOrEmpty(groupSep) && numberStr.Contains(groupSep))
             {
-                context.InputUsesGroupSeparators = true;
-                if (numberStr.LastIndexOf('.') > numberStr.LastIndexOf(','))
+                var parts = numberStr.Split(groupSep);
+                // If any part after the first (excluding a possible last part with a decimal)
+                // does not have 3 digits, then it's not a valid use of a thousand separator.
+                for (int i = 1; i < parts.Length; i++)
                 {
-                    context.InputDecimalSeparator = Dot;
-                    return numberStr.Replace(Comma, string.Empty);
-                }
-                else
-                {
-                    context.InputDecimalSeparator = Comma;
-                    return numberStr.Replace(Dot, string.Empty).Replace(Comma, Dot);
-                }
-            }
-
-            // Case 2: Only dots
-            if (dotCount > 0)
-            {
-                if (dotCount > 1)
-                {
-                    context.InputUsesGroupSeparators = true;
-                    return numberStr.Replace(Dot, string.Empty);
-                }
-                // A number is ambiguous if it has a single Dot in the thousands position,
-                // and does not start with a "0." or "."
-                bool isAmbiguous = numberStr.Length - numberStr.LastIndexOf('.') == 4
-                                   && !numberStr.StartsWith("0.")
-                                   && !numberStr.StartsWith(".");
-                if (isAmbiguous)
-                {
-                    if (systemGroupSep == Dot)
+                    var part = parts[i];
+                    // The last part might contain a decimal separator.
+                    if (i == parts.Length - 1 && part.Contains(culture.NumberFormat.NumberDecimalSeparator))
                     {
-                        context.InputUsesGroupSeparators = true;
-                        return numberStr.Replace(Dot, string.Empty);
+                        part = part.Split(culture.NumberFormat.NumberDecimalSeparator)[0];
                     }
-                    else
+
+                    if (part.Length != 3)
                     {
-                        context.InputDecimalSeparator = Dot;
+                        // This is not a number with valid thousand separators,
+                        // so it must be arguments to a function. Return it unmodified.
                         return numberStr;
                     }
                 }
-                else // Unambiguous decimal (e.g., "12.34" or "0.123" or ".123")
-                {
-                    context.InputDecimalSeparator = Dot;
-                    return numberStr;
-                }
             }
 
-            // Case 3: Only commas
-            if (commaCount > 0)
-            {
-                if (commaCount > 1)
-                {
-                    context.InputUsesGroupSeparators = true;
-                    return numberStr.Replace(Comma, string.Empty);
-                }
-                // A number is ambiguous if it has a single Comma in the thousands position,
-                // and does not start with a "0," or ","
-                bool isAmbiguous = numberStr.Length - numberStr.LastIndexOf(',') == 4
-                                   && !numberStr.StartsWith("0,")
-                                   && !numberStr.StartsWith(",");
-                if (isAmbiguous)
-                {
-                    if (systemGroupSep == Comma)
-                    {
-                        context.InputUsesGroupSeparators = true;
-                        return numberStr.Replace(Comma, string.Empty);
-                    }
-                    else
-                    {
-                        context.InputDecimalSeparator = Comma;
-                        return numberStr.Replace(Comma, Dot);
-                    }
-                }
-                else // Unambiguous decimal (e.g., "12,34" or "0,123" or ",123")
-                {
-                    context.InputDecimalSeparator = Comma;
-                    return numberStr.Replace(Comma, Dot);
-                }
-            }
+            // If validation passes, we can assume the separators are used correctly for numbers.
+            string processedStr = numberStr.Replace(groupSep, "");
+            processedStr = processedStr.Replace(decimalSep, ".");
 
-            // Case 4: No separators
-            return numberStr;
+            return processedStr;
         }
 
-        private string FormatResult(decimal roundedResult, ParsingContext context)
+        private string FormatResult(decimal roundedResult)
         {
-            string decimalSeparator = context.InputDecimalSeparator ?? GetDecimalSeparator();
+            string decimalSeparator = GetDecimalSeparator();
             string groupSeparator = GetGroupSeparator(decimalSeparator);
 
             string resultStr = roundedResult.ToString(CultureInfo.InvariantCulture);
@@ -221,7 +183,7 @@
             string integerPart = parts[0];
             string fractionalPart = parts.Length > 1 ? parts[1] : string.Empty;
 
-            if (context.InputUsesGroupSeparators && integerPart.Length > 3)
+            if (integerPart.Length > 3)
             {
                 integerPart = ThousandGroupRegex.Replace(integerPart, groupSeparator);
             }
@@ -236,19 +198,19 @@
 
         private string GetGroupSeparator(string decimalSeparator)
         {
+            if (_settings.DecimalSeparator == DecimalSeparator.UseSystemLocale)
+            {
+                return CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;
+            }
+
             // This logic is now independent of the system's group separator
-            // to ensure consistent output for unit testing.
+            // to ensure consistent output when a specific separator is chosen.
             return decimalSeparator == Dot ? Comma : Dot;
         }
 
         private bool CanCalculate(Query query)
         {
-            if (query.Search.Length < 2)
-            {
-                return false;
-            }
-
-            if (!RegValidExpressChar.IsMatch(query.Search))
+            if (string.IsNullOrWhiteSpace(query.Search))
             {
                 return false;
             }
@@ -275,9 +237,9 @@
 
         private static bool IsBracketComplete(string query)
         {
             var matchs = RegBrackets.Matches(query);
             var leftBracketCount = 0;
             foreach (Match match in matchs)
             {
                 if (match.Value == "(" || match.Value == "[")
                 {

Plugins/Flow.Launcher.Plugin.Calculator/MainRegexHelper.cs

@@ -8,10 +8,7 @@ internal static partial class MainRegexHelper
     [GeneratedRegex(@"[\(\)\[\]]", RegexOptions.Compiled)]
     public static partial Regex GetRegBrackets();
 
-    [GeneratedRegex(@"^(ceil|floor|exp|pi|e|max|min|det|abs|log|ln|sqrt|sin|cos|tan|arcsin|arccos|arctan|eigval|eigvec|eig|sum|polar|plot|round|sort|real|zeta|bin2dec|hex2dec|oct2dec|factorial|sign|isprime|isinfty|==|~=|&&|\|\||(?:\<|\>)=?|[ei]|[0-9]|0x[\da-fA-F]+|[\+\%\-\*\/\^\., ""]|[\(\)\|\!\[\]])+$", RegexOptions.Compiled)]
-    public static partial Regex GetRegValidExpressChar();
-
-    [GeneratedRegex(@"[\d\.,]+", RegexOptions.Compiled)]
+    [GeneratedRegex(@"-?[\d\.,]+", RegexOptions.Compiled)]
     public static partial Regex GetNumberRegex();
 
     [GeneratedRegex(@"\B(?=(\d{3})+(?!\d))", RegexOptions.Compiled)]

Plugins/Flow.Launcher.Plugin.Calculator/plugin.json

@@ -2,8 +2,8 @@
   "ID": "CEA0FDFC6D3B4085823D60DC76F28855",
   "ActionKeyword": "*",
   "Name": "Calculator",
-  "Description": "Perform mathematical calculations (including hexadecimal values). Use ',' or '.' as thousand separator or decimal place.",
+  "Description": "Perform mathematical calculations, including hex values and advanced math functions, such as 'min(1,2,3)', 'sqrt(123)', 'cos(123)', etc.. User locale determines thousand separator and decimal place.",
   "Author": "cxfksword, dcog989",
   "Version": "1.0.0",
   "Language": "csharp",
   "Website": "https://github.com/Flow-Launcher/Flow.Launcher",