Fixes acoording to code review.

1. Use limit settings instead of constants.
2. Removed constants, moved explanation to the property initialization
3. Performe dependency depth check as last check, since it is slowest one.

Author: kant2002

Nodejs/Product/Analysis/Analysis/AnalysisLimits.cs

@@ -34,7 +34,32 @@ public AnalysisLimits() {
             MaxObjectLiteralProperties = 50;
             MaxObjectKeysTypes = 5;
             MaxMergeTypes = 5;
-            NestedModulesLimit = AnalysisConstants.MaxAnalysisDepthQualty;
+
+            // There no practical reasons to go deeper in dependencies analysis.
+            // Number 4 is very practical. Here the examples which hightlight idea.
+            // 
+            // Example 1
+            // 
+            // Level 0 - Large system. Some code should use properties of the object on level 4 here. 
+            // Level 1 - Subsystem - pass data from level 4
+            // Level 2 - Internal dependency for company - Do some work and pass data to level 1
+            // Level 3 - Framework on top of which created Internal dependency.
+            // Level 4 - Dependency of the framework. Objects from here still should be available.
+            // Level 5 - Dependency of the framework provide some usefull primitive which would be used very often on the level of whole system. Hmmm.
+            // 
+            // Example 2 (reason why I could increase to 5)
+            // 
+            // Level 0 - Large system. Some code should use properties of the object on level 4 here. 
+            // Level 1 - Subsystem - pass data from level 4
+            // Level 2 - Internal dependency for company - Wrap access to internal library and perform business logic. Do some work and pass data to level 1
+            // Level 3 - Internal library which wrap access to API.
+            // Level 4 - Http library.
+            // Level 5 - Promise Polyfill.
+            //
+            // All these examples are highly speculative and I specifically try to create such deep level. 
+            // If you develop on windows with such deep level you already close to your limit, your maximum is probably 10. 
+            // </remarks>
+            NestedModulesLimit = 4;
         }
 
         /// <summary>
@@ -43,7 +68,9 @@ public AnalysisLimits() {
         /// <returns>An <see cref="AnalysisLimits"/> object representing medium level Initellisense settings.</returns>
         public static AnalysisLimits MakeMediumAnalysisLimits() {
             return new AnalysisLimits() {
-                NestedModulesLimit = AnalysisConstants.MaxAnalysisDepthFast
+
+                // Maximum practical limit for the dependencies analysis oriented on producing faster results.
+                NestedModulesLimit = 2
             };
         }
 

Nodejs/Product/Analysis/AnalysisConstants.cs

@@ -22,40 +22,5 @@
 namespace Microsoft.NodejsTools {
     internal sealed class AnalysisConstants {
         internal const string NodeModulesFolder = "node_modules";
-
-        /// <summary>
-        /// Maximum practical limit for the dependencies analysis.
-        /// </summary>
-        /// <remarks>
-        /// There no practical reasons to go deeper in dependencies analysis.
-        /// Number 4 is very practical. Here the examples which hightlight idea.
-        /// 
-        /// Example 1
-        /// 
-        /// Level 0 - Large system. Some code should use properties of the object on level 4 here. 
-        /// Level 1 - Subsystem - pass data from level 4
-        /// Level 2 - Internal dependency for company - Do some work and pass data to level 1
-        /// Level 3 - Framework on top of which created Internal dependency.
-        /// Level 4 - Dependency of the framework. Objects from here still should be available.
-        /// Level 5 - Dependency of the framework provide some usefull primitive which would be used very often on the level of whole system. Hmmm.
-        /// 
-        /// Example 2 (reason why I could increase to 5)
-        /// 
-        /// Level 0 - Large system. Some code should use properties of the object on level 4 here. 
-        /// Level 1 - Subsystem - pass data from level 4
-        /// Level 2 - Internal dependency for company - Wrap access to internal library and perform business logic. Do some work and pass data to level 1
-        /// Level 3 - Internal library which wrap access to API.
-        /// Level 4 - Http library.
-        /// Level 5 - Promise Polyfill.
-        ///
-        /// All these examples are highly speculative and I specifically try to create such deep level. 
-        /// If you develop on windows with such deep level you already close to your limit, your maximum is probably 10. 
-        /// </remarks>
-        internal const int MaxAnalysisDepthQualty = 4;
-
-        /// <summary>
-        /// Maximum practical limit for the dependencies analysis oriented on producing faster results.
-        /// </summary>
-        internal const int MaxAnalysisDepthFast = 2;
     }
 }

Nodejs/Product/Nodejs/Project/NodejsProjectNode.cs

@@ -491,11 +491,17 @@ internal bool IncludeNodejsFile(NodejsFileNode fileNode) {
                 return false;
             }
 
-            int maxModulesDepth = AnalysisConstants.MaxAnalysisDepthQualty;
-            if (this._analyzer.AnalysisLevel == Options.AnalysisLevel.Medium) {
-                maxModulesDepth = AnalysisConstants.MaxAnalysisDepthFast;
+            foreach (var path in _analysisIgnoredDirs) {
+                if (url.IndexOf(path, 0, StringComparison.OrdinalIgnoreCase) != -1) {
+                    return false;
+                }
+            }
+            if (new FileInfo(fileNode.Url).Length > _maxFileSize) {
+                // skip obviously generated files...
+                return false;
             }
 
+            int maxModulesDepth = this._analyzer.Project.Limits.NestedModulesLimit;
             var relativeFile = CommonUtils.GetRelativeFilePath(this.FullPathToChildren, fileNode.Url);
             int nestedModulesCount = 0;
             int startIndex = 0;
@@ -506,19 +512,10 @@ internal bool IncludeNodejsFile(NodejsFileNode fileNode) {
                     return false;
                 }
 
-                startIndex = index + 1;
+                startIndex = index + AnalysisConstants.NodeModulesFolder.Length;
                 index = relativeFile.IndexOf(AnalysisConstants.NodeModulesFolder, startIndex, StringComparison.OrdinalIgnoreCase);
             }
 
-            foreach (var path in _analysisIgnoredDirs) {
-                if (url.IndexOf(path, 0, StringComparison.OrdinalIgnoreCase) != -1) {
-                    return false;
-                }
-            }
-            if (new FileInfo(fileNode.Url).Length > _maxFileSize) {
-                // skip obviously generated files...
-                return false;
-            }
             return true;
         }
 

Nodejs/Tests/AnalysisTests/AnalysisFile.cs

@@ -132,20 +132,9 @@ public static JsAnalyzer Analyze(string directory, AnalysisLimits limits = null,
             foreach (var file in Directory.GetFiles(directory, "*", SearchOption.AllDirectories)) {
                 if (String.Equals(Path.GetExtension(file), ".js", StringComparison.OrdinalIgnoreCase)) {
                     var relativeFile = file.Substring(directory.Length);
-                    int nestedModulesCount = 0;
-                    int startIndex = 0;
-                    int index = relativeFile.IndexOf("node_modules", startIndex, StringComparison.OrdinalIgnoreCase);
-                    while (index != -1) {
-                        nestedModulesCount++;
-                        if (nestedModulesCount > limits.NestedModulesLimit) {
-                            continue;
-                        }
-
-                        startIndex = index + 1;
-                        index = relativeFile.IndexOf("node_modules", startIndex, StringComparison.OrdinalIgnoreCase);
+                    if (!CheckExceedsNestedModulesLimit(relativeFile, limits.NestedModulesLimit)) {
+                        files.Add(new AnalysisFile(file, File.ReadAllText(file)));
                     }
-
-                    files.Add(new AnalysisFile(file, File.ReadAllText(file)));
                 } else if (String.Equals(Path.GetFileName(file), "package.json", StringComparison.OrdinalIgnoreCase)) {
                     JavaScriptSerializer serializer = new JavaScriptSerializer();
                     Dictionary<string, object> json;
@@ -164,5 +153,29 @@ public static JsAnalyzer Analyze(string directory, AnalysisLimits limits = null,
 
             return Analyze(limits, parseCallback, files.ToArray());
         }
+
+        /// <summary>
+        /// Check that relative file path does not exceed required 
+        /// </summary>
+        /// <param name="relativeFile">Relative file path to check.</param>
+        /// <param name="maxDepth">Max depth of node dependencies.</param>
+        /// <returns>True if file contains in the dependency which is too deep down dependency tree; false otherwise.</returns>
+        private static bool CheckExceedsNestedModulesLimit(string relativeFile, int maxDepth)
+        {
+            int nestedModulesCount = 0;
+            int startIndex = 0;
+            int index = relativeFile.IndexOf("node_modules", startIndex, StringComparison.OrdinalIgnoreCase);
+            while (index != -1) {
+                nestedModulesCount++;
+                if (nestedModulesCount > maxDepth) {
+                    return true;
+                }
+
+                startIndex = index + "node_modules".Length;
+                index = relativeFile.IndexOf("node_modules", startIndex, StringComparison.OrdinalIgnoreCase);
+            }
+
+            return false;
+        }
     }
 }