Merge branch 'dev' into SearchProgramsInPATH

Author: VictoriousRaptor

Flow.Launcher.Infrastructure/StringMatcher.cs

@@ -202,7 +202,11 @@ public MatchResult FuzzyMatch(string query, string stringToCompare, MatchOption
             if (allQuerySubstringsMatched)
             {
                 var nearestSpaceIndex = CalculateClosestSpaceIndex(spaceIndices, firstMatchIndex);
-                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1,
+
+                // firstMatchIndex - nearestSpaceIndex - 1 is to set the firstIndex as the index of the first matched char
+                // preceded by a space e.g. 'world' matching 'hello world' firstIndex would be 0 not 6 
+                // giving more weight than 'we or donald' by allowing the distance calculation to treat the starting position at after the space.
+                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1, spaceIndices,
                     lastMatchIndex - firstMatchIndex, allSubstringsContainedInCompareString);
 
                 var resultList = indexList.Select(x => translationMapping?.MapToOriginalIndex(x) ?? x).Distinct().ToList();
@@ -296,14 +300,22 @@ private static bool AllQuerySubstringsMatched(int currentQuerySubstringIndex, in
             return currentQuerySubstringIndex >= querySubstringsLength;
         }
 
-        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, int matchLen,
+        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, List<int> spaceIndices, int matchLen,
             bool allSubstringsContainedInCompareString)
         {
             // A match found near the beginning of a string is scored more than a match found near the end
             // A match is scored more if the characters in the patterns are closer to each other, 
             // while the score is lower if they are more spread out
             var score = 100 * (query.Length + 1) / ((1 + firstIndex) + (matchLen + 1));
 
+            // Give more weight to a match that is closer to the start of the string. 
+            // if the first matched char is immediately before space and all strings are contained in the compare string e.g. 'world' matching 'hello world'
+            // and 'world hello', because both have 'world' immediately preceded by space, their firstIndex will be 0 when distance is calculated,
+            // to prevent them scoring the same, we adjust the score by deducting the number of spaces it has from the start of the string, so 'world hello'
+            // will score slightly higher than 'hello world' because 'hello world' has one additional space.
+            if (firstIndex == 0 && allSubstringsContainedInCompareString)
+                score -= spaceIndices.Count;
+
             // A match with less characters assigning more weights
             if (stringToCompare.Length - query.Length < 5)
             {

Flow.Launcher.Test/FuzzyMatcherTest.cs

@@ -129,14 +129,20 @@ public void GivenQueryString_WhenAppliedPrecisionFiltering_ThenShouldReturnGreat
             }
         }
 
+
+        /// <summary>
+        /// These are standard match scenarios
+        /// The intention of this test is provide a bench mark for how much the score has increased from a change.
+        /// Usually the increase in scoring should not be drastic, increase of less than 10 is acceptable.
+        /// </summary>
         [TestCase(Chrome, Chrome, 157)]
-        [TestCase(Chrome, LastIsChrome, 147)]
+        [TestCase(Chrome, LastIsChrome, 145)]
         [TestCase("chro", HelpCureHopeRaiseOnMindEntityChrome, 50)]
         [TestCase("chr", HelpCureHopeRaiseOnMindEntityChrome, 30)]
         [TestCase(Chrome, UninstallOrChangeProgramsOnYourComputer, 21)]
         [TestCase(Chrome, CandyCrushSagaFromKing, 0)]
-        [TestCase("sql", MicrosoftSqlServerManagementStudio, 110)]
-        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 121)] //double spacing intended
+        [TestCase("sql", MicrosoftSqlServerManagementStudio, 109)]
+        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 120)] //double spacing intended
         public void WhenGivenQueryString_ThenShouldReturn_TheDesiredScoring(
             string queryString, string compareString, int expectedScore)
         {
@@ -275,7 +281,40 @@ public void WhenGivenAQuery_Scoring_ShouldGiveMoreWeightToStartOfNewWord(
                 $"Query: \"{queryString}\"{Environment.NewLine} " +
                 $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}" +
                 $"Should be greater than{Environment.NewLine}" +
-                $"CompareString2: \"{compareString2}\", Score: {compareString1Result.Score}{Environment.NewLine}");
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
+        }
+
+        [TestCase("red", "red colour", "metro red")]
+        [TestCase("red", "this red colour", "this colour red")]
+        [TestCase("red", "this red colour", "this colour is very red")]
+        [TestCase("red", "this red colour", "this colour is surprisingly super awesome red and cool")]
+        [TestCase("red", "this colour is surprisingly super red very and cool", "this colour is surprisingly super very red and cool")]
+        public void WhenGivenTwoStrings_Scoring_ShouldGiveMoreWeightToTheStringCloserToIndexZero(
+            string queryString, string compareString1, string compareString2)
+        {
+            // When
+            var matcher = new StringMatcher { UserSettingSearchPrecision = SearchPrecisionScore.Regular };
+
+            // Given
+            var compareString1Result = matcher.FuzzyMatch(queryString, compareString1);
+            var compareString2Result = matcher.FuzzyMatch(queryString, compareString2);
+
+            Debug.WriteLine("");
+            Debug.WriteLine("###############################################");
+            Debug.WriteLine($"QueryString: \"{queryString}\"{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
+            Debug.WriteLine("###############################################");
+            Debug.WriteLine("");
+
+            // Should
+            Assert.True(compareString1Result.Score > compareString2Result.Score,
+                $"Query: \"{queryString}\"{Environment.NewLine} " +
+                $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}" +
+                $"Should be greater than{Environment.NewLine}" +
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
         }
 
         [TestCase("vim", "Vim", "ignoreDescription", "ignore.exe", "Vim Diff", "ignoreDescription", "ignore.exe")]

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

@@ -37,7 +37,7 @@ public async Task InitAsync(PluginInitContext context)
             contextMenu = new ContextMenu(Context);
             pluginManager = new PluginsManager(Context, Settings);
 
-            await pluginManager.UpdateManifestAsync();
+            _ = pluginManager.UpdateManifestAsync();
         }
 
         public List<Result> LoadContextMenus(Result selectedResult)
@@ -74,4 +74,4 @@ public string GetTranslatedPluginDescription()
             return Context.API.GetTranslation("plugin_pluginsmanager_plugin_description");
         }
     }
-}
+}

Plugins/Flow.Launcher.Plugin.Program/Programs/Win32.cs

@@ -395,7 +395,6 @@ private static IEnumerable<Win32> UnregisteredPrograms(List<Settings.ProgramSour
                 _ => Win32Program(x)
             });
 
-
             return programs;
         }
 
@@ -415,7 +414,7 @@ private static IEnumerable<Win32> StartMenuPrograms(string[] suffixes)
                     ShortcutExtension => LnkProgram(x),
                     UrlExtension => UrlProgram(x),
                     _ => Win32Program(x)
-                }).Where(x => x.Valid);
+                });
             return programs;
         }
 
@@ -602,7 +601,7 @@ public static Win32[] All(Settings settings)
 
                 autoIndexPrograms = ProgramsHasher(autoIndexPrograms);
 
-                return programs.Concat(autoIndexPrograms).Distinct().ToArray();
+                return programs.Concat(autoIndexPrograms).Where(x => x.Valid).Distinct().ToArray();
             }
 #if DEBUG //This is to make developer aware of any unhandled exception and add in handling.
             catch (Exception)