Translate into english

Author: owehmer

DateiNode.cs

@@ -7,20 +7,20 @@
 
 namespace DependencieResolver
 {
-   static class DateiHelper
+   static class FileHelper
    {
-      public static Dictionary<string, IList<string>> DepsAufDatei = new Dictionary<string, IList<string>>();
+      public static Dictionary<string, IList<string>> DepsToFile = new Dictionary<string, IList<string>>();
 
-      public static string LiesGanzeImportZeile(string aktuelleZeile, StreamReader sr)
+      public static string ReadFullImportLine(string aktuelleZeile, StreamReader sr)
       {
-         var istEinzeiligerImport = DateiHelper.IstImportZeile(aktuelleZeile) && DateiHelper.IstImportZeileEnde(aktuelleZeile) || IstZeileUnspezifischerImport(aktuelleZeile);
+         var istEinzeiligerImport = FileHelper.IsImportLine(aktuelleZeile) && FileHelper.IstImportZeileEnde(aktuelleZeile) || IstZeileUnspezifischerImport(aktuelleZeile);
          if (istEinzeiligerImport)
          {
             return aktuelleZeile;
          }
 
          var zusammengesetzteZeile = new StringBuilder();
-         while (aktuelleZeile != null && !DateiHelper.IstImportZeileEnde(aktuelleZeile))
+         while (aktuelleZeile != null && !FileHelper.IstImportZeileEnde(aktuelleZeile))
          {
             zusammengesetzteZeile.Append(aktuelleZeile);
             try
@@ -37,7 +37,7 @@ public static string LiesGanzeImportZeile(string aktuelleZeile, StreamReader sr)
          return zusammengesetzteZeile.ToString();
       }
 
-      public static bool IstImportZeile(string zeile)
+      public static bool IsImportLine(string zeile)
       {
          return zeile?.Trim().StartsWith("import ") ?? false;
       }
@@ -55,7 +55,7 @@ public static bool IstZeileUnspezifischerImport(string zeile)
          return importRegel.IsMatch(zeile);
       }
 
-      public static string LiesImportZielAus(string zeile)
+      public static string ReadImportDestination(string zeile)
       {
          if (IstZeileUnspezifischerImport(zeile))
          {
@@ -72,7 +72,7 @@ public static string LiesImportZielAus(string zeile)
          return fromPfad;
       }
 
-      public static string ErsetzeRelativePfade(string zeile, IList<string> orderBisZurDatei)
+      public static string ReplaceRelativePaths(string zeile, IList<string> orderBisZurDatei)
       {
          var zeileEnthaeltRelativePfade = zeile.Contains('.') || zeile.Contains("..");
          if (!zeileEnthaeltRelativePfade)

DateiHelper.cs renamed to FileHelper.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace DependencieResolver
+{
+   class FileNode
+   {
+      public string PathToFile { get; }
+      public IList<string> DependencyPaths { get; set; } // => [root/Foo/Bar.ts]
+
+      private IList<string> FolderHierarchie
+      {
+         get
+         {
+            var pathInclFile = PathToFile.Split(Path.DirectorySeparatorChar).ToList();
+            pathInclFile.RemoveAt(pathInclFile.Count - 1); // Delete current file
+            return pathInclFile;
+         }
+      }
+
+      public FileNode(string path)
+      {
+         DependencyPaths = new List<string>();
+         PathToFile = path;
+
+         if (!File.Exists(PathToFile))
+         {
+            throw new IOException("Path doesn't exist!");
+         }
+      }
+
+      public void AnalyzeImportPaths()
+      {
+         DependencyPaths = new List<string>();
+
+         using StreamReader sr = new StreamReader(PathToFile);
+         var line = sr.ReadLine();
+
+         while (line != null)
+         {
+            var lineIsEmpty = String.IsNullOrEmpty(line.Trim());
+            if (lineIsEmpty)
+            {
+               line = sr.ReadLine();
+               continue;
+            }
+
+            if (!FileHelper.IsImportLine(line))
+            {
+               break;
+            }
+
+            var importLine = FileHelper.ReadFullImportLine(line, sr);
+            var importDestination = FileHelper.ReadImportDestination(importLine);
+
+            importDestination = FileHelper.ReplaceRelativePaths(importDestination, FolderHierarchie);
+            
+            DependencyPaths.Add(importDestination);
+
+            line = sr.ReadLine();
+         }
+      }
+
+      public void BuildDepGraph(bool loadRecursive = false)
+      {
+         if (!DependencyPaths.Any())
+         {
+            AnalyzeImportPaths();
+         }
+
+         FillDepGraph();
+
+         if (!loadRecursive)
+         {
+            return;
+         }
+
+         foreach (var dependencyPfad in DependencyPaths)
+         {
+            var depAsFile = new FileNode(dependencyPfad);
+            depAsFile.BuildDepGraph(true);
+         }
+      }
+
+      private void FillDepGraph()
+      {
+         foreach (var dependency in DependencyPaths)
+         {
+            if (FileHelper.DepsToFile.TryGetValue(dependency, out var externalDep))
+            {
+               if (!externalDep.Contains(PathToFile))
+               {
+                  externalDep.Add(PathToFile);
+               }
+            }
+            else
+            {
+               FileHelper.DepsToFile.Add(dependency, new List<string> { PathToFile });
+            }
+         }
+         
+      }
+   }
+}

FileNode.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace DependencieResolver
+{
+   class FolderNode
+   {
+      public string FolderPath { get; set; }
+      public List<FileNode> Files { get; set; }
+      public List<FolderNode> SubDictionaries { get; set; }
+
+      public IList<string> AllDependencies
+      {
+         get
+         {
+            var list = new List<string>();
+            list.AddRange(Files.SelectMany(d => d.DependencyPaths).ToList());
+            list.AddRange(SubDictionaries.SelectMany(u => u.AllDependencies.ToList()));
+            return list;
+         }
+      }
+
+      public IList<FileNode> AllFilesRecursive
+      {
+         get
+         {
+            var list = new List<FileNode>();
+            list.AddRange(Files.ToList());
+            list.AddRange(SubDictionaries.SelectMany(u => u.AllFilesRecursive.ToList()));
+            return list;
+         }
+      }
+
+      public FolderNode(string path)
+      {
+         FolderPath = path;
+         Files = new List<FileNode>();
+         SubDictionaries = new List<FolderNode>();
+
+         if (!Directory.Exists(path))
+         {
+            throw new IOException("Path to folder doesn't exist.");
+         }
+      }
+
+      public void AnalyzeFiles(bool readSubDictionaries = true)
+      {
+         string[] fileEntries = Directory.GetFiles(FolderPath);
+
+         var fileNodes = fileEntries
+            .Select(filePath =>
+            {
+               var node = new FileNode(filePath);
+               node.BuildDepGraph();
+               return node;
+            })
+            .ToList();
+
+         Files.AddRange(fileNodes);
+
+         if (!readSubDictionaries)
+         {
+            return;
+         }
+
+         IList<string> subdirectoryEntries = Directory.GetDirectories(FolderPath)
+            .Where(e => !e.Contains('.') && !e.Contains("node_modules"))
+            .ToList();
+
+         var subFolderNodes = subdirectoryEntries.Select(subDirPath =>
+         {
+            var node = new FolderNode(subDirPath);
+            node.AnalyzeFiles();
+            return node;
+         }).ToList();
+
+         SubDictionaries.AddRange(subFolderNodes);
+      }
+   }
+}