QNTM-5870: When searching weights should be taken into account before string matching

src/DynamoCore/Models/DynamoModel.cs

@@ -654,7 +654,7 @@ protected DynamoModel(IStartConfiguration config)
 
             pathManager.Preferences = PreferenceSettings;
 
-            SearchModel = new NodeSearchModel();
+            SearchModel = new NodeSearchModel(Logger);
             SearchModel.ItemProduced +=
                 node => ExecuteCommand(new CreateNodeCommand(node, 0, 0, true, true));
 

src/DynamoCore/Search/NodeSearchModel.cs

@@ -6,6 +6,7 @@
 using Dynamo.Graph.Nodes;
 using Dynamo.Search.SearchElements;
 using DynamoUtilities;
+using Dynamo.Logging;
 
 namespace Dynamo.Search
 {
@@ -14,6 +15,10 @@ namespace Dynamo.Search
     /// </summary>
     public class NodeSearchModel : SearchLibrary<NodeSearchElement, NodeModel>
     {
+        internal NodeSearchModel(ILogger logger = null) : base(logger)
+        {
+        }
+
         internal override void Add(NodeSearchElement entry)
         {
             SearchElementGroup group = SearchElementGroup.None;

src/DynamoCore/Search/SearchDictionary.cs

@@ -1,9 +1,9 @@
-using System.Diagnostics;
-using Dynamo.Utilities;
+using Dynamo.Utilities;
+using Dynamo.Logging;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
+using System.Diagnostics;
 
 namespace Dynamo.Search
 {
@@ -12,9 +12,16 @@ namespace Dynamo.Search
     /// </summary>
     public class SearchDictionary<V>
     {
+        private ILogger logger;
+
+        internal SearchDictionary(ILogger logger = null)
+        {
+            this.logger = logger;
+        }
+
         protected readonly Dictionary<V, Dictionary<string, double>> entryDictionary =
             new Dictionary<V, Dictionary<string, double>>();
-        
+
         private List<IGrouping<string, Tuple<V, double>>> tagDictionary;
 
         /// <summary>
@@ -307,14 +314,23 @@ internal void RebuildTagDictionary()
                     tagWeightAndEntry =>
                         Tuple.Create(tagWeightAndEntry.Entry, tagWeightAndEntry.Weight)).ToList();
         }
-        
+
         /// <summary>
         /// Search for elements in the dictionary based on the query
         /// </summary>
         /// <param name="query"> The query </param>
         /// <param name="minResultsForTolerantSearch">Minimum number of results in the original search strategy to justify doing more tolerant search</param>
         internal IEnumerable<V> Search(string query, int minResultsForTolerantSearch = 0)
         {
+#if DEBUG
+            Stopwatch stopwatch = null;
+            if (this.logger != null)
+            {
+                stopwatch = new Stopwatch();
+                stopwatch.Start();
+            }
+#endif
+
             var searchDict = new Dictionary<V, double>();
 
             if (tagDictionary == null)
@@ -330,13 +346,53 @@ internal IEnumerable<V> Search(string query, int minResultsForTolerantSearch = 0
                 ComputeWeightAndAddToDictionary(query, pair, searchDict);
             }
 
-            return searchDict
-                .OrderByDescending(x => x.Value)
-                .Select(x => x.Key);
+            var orderedSearchDict = searchDict.OrderByDescending(x => x.Value);
+#if DEBUG
+            //if (this.logger != null)
+            //{
+            //    int index = 0;
+            //    foreach (var pair in orderedSearchDict)
+            //    {
+            //        var message =
+            //            string.Format(
+            //                "{0} -> Key = {1}, Value = {2}",
+            //                    index,
+            //                    pair.Key,
+            //                    pair.Value);
+            //        this.logger.Log(message);
+            //    }
+            //}
+#endif
+
+            var searchResults = orderedSearchDict.Select(x => x.Key);
+
+            // TODO: DYN-1326 - Place this behind a debug mode (after running CI in a preliminary test)
+            searchResults = searchResults.Take(20);
+
+#if DEBUG
+            if (this.logger != null)
+            {
+                stopwatch.Stop();
+
+                var message = 
+                    string.Format(
+                        "Searching for: \"{0}\", [Entries:{1}, Tags:{2}] : {3}ms -> {4}", 
+                            query,
+                            entryDictionary.Count,
+                            tagDictionary.Count,
+                            stopwatch.ElapsedMilliseconds,
+                            searchResults.Count());
+                this.logger.Log(message);
+            }
+#endif
+
+            return searchResults;
         }
 
-        private static void ComputeWeightAndAddToDictionary(string query,
-            IGrouping<string, Tuple<V, double>> pair, Dictionary<V, double> searchDict)
+        private static void ComputeWeightAndAddToDictionary(
+            string query,
+            IGrouping<string, Tuple<V, double>> pair, 
+            Dictionary<V, double> searchDict)
         {
             // it has a match, how close is it to matching the entire string?
             double matchCloseness = ((double)query.Length) / pair.Key.Length;

src/DynamoCore/Search/SearchLibrary.cs

@@ -1,4 +1,5 @@
 using Dynamo.Utilities;
+using Dynamo.Logging;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,6 +14,10 @@ namespace Dynamo.Search
     public class SearchLibrary<TEntry, TItem> : SearchDictionary<TEntry>, ISource<TItem> 
         where TEntry : ISearchEntry, ISource<TItem>
     {
+        internal SearchLibrary(ILogger logger) : base(logger)
+        {
+        }
+
         /// <summary>
         ///     Adds an entry to search.
         /// </summary>