Get-PSTreeRegistry no longer ignores (Default) (empty Values)

src/PSTree/Commands/GetPSTreeCommand.cs

@@ -64,7 +64,7 @@ protected override void ProcessRecord()
     private TreeFileSystemInfo[] Traverse(TreeDirectory directory)
     {
         _cache.Clear();
-        _stack.Push(directory);
+        directory.PushToStack(_stack);
         string source = directory.FullName;
 
         while (_stack.Count > 0)
@@ -105,12 +105,11 @@ private TreeFileSystemInfo[] Traverse(TreeDirectory directory)
 
                         if (keepProcessing)
                         {
-                            TreeFile file = TreeFile
+                            TreeFile
                                 .Create(fileInfo, source, level)
                                 .AddParent<TreeFile>(next)
-                                .SetIncludeFlagIf(WithInclude);
-
-                            _cache.Add(file);
+                                .SetIncludeFlagIf(WithInclude)
+                                .AddToCache(_cache);
                         }
 
                         continue;
@@ -121,16 +120,11 @@ private TreeFileSystemInfo[] Traverse(TreeDirectory directory)
                         continue;
                     }
 
-                    TreeDirectory dir = TreeDirectory
+                    TreeDirectory
                         .Create((DirectoryInfo)item, source, level)
-                        .AddParent<TreeDirectory>(next);
-
-                    if (keepProcessing && Directory || !WithInclude)
-                    {
-                        dir.Include = true;
-                    }
-
-                    _stack.Push(dir);
+                        .AddParent<TreeDirectory>(next)
+                        .SetIncludeFlagIf(keepProcessing && Directory || !WithInclude)
+                        .PushToStack(_stack);
                 }
 
                 next.Length = totalLength;
@@ -160,8 +154,7 @@ private TreeFileSystemInfo[] Traverse(TreeDirectory directory)
         return GetTree(WithInclude && !Directory);
     }
 
-    private static bool IsHidden(FileSystemInfo item) =>
-        item.Attributes.HasFlag(FileAttributes.Hidden);
+    private static bool IsHidden(FileSystemInfo item) => item.Attributes.HasFlag(FileAttributes.Hidden);
 
     private TreeFileSystemInfo[] GetTree(bool includeCondition)
     {

src/PSTree/Commands/GetPSTreeRegistryCommand.cs

@@ -52,18 +52,22 @@
         }
     }
 
-    private TreeRegistryBase[] Traverse(RegistryKey key)
+    private TreeRegistryBase[] Traverse(RegistryKey registryKey)
     {
         _cache.Clear();
-        _stack.Push(key.CreateTreeKey(System.IO.Path.GetFileName(key.Name)));
-        string source = key.Name;
+
+        registryKey.
+            CreateTreeKey(System.IO.Path.GetFileName(registryKey.Name)).
+            PushToStack(_stack);
+
+        string source = registryKey.Name;
 
         while (_stack.Count > 0)
         {
-            (TreeRegistryKey tree, key) = _stack.Pop();
+            (TreeRegistryKey tree, registryKey) = _stack.Pop();
             int depth = tree.Depth + 1;
 
-            using (key)
+            using (registryKey)
             {
                 if (depth <= Depth)
                 {
@@ -72,22 +76,21 @@
                         goto PushKeys;
                     }
 
-                    foreach (string value in key.GetValueNames())
+                    foreach (string value in registryKey.GetValueNames())
                     {
                         if (ShouldSkipValue(value))
                         {
                             continue;
                         }
 
-                        TreeRegistryValue treevalue = new(key, value, source, depth);
-
-                        _cache.Add(treevalue
+                        new TreeRegistryValue(registryKey, value, source, depth)
                             .AddParent<TreeRegistryValue>(tree)
-                            .SetIncludeFlagIf(WithInclude));
+                            .SetIncludeFlagIf(WithInclude)
+                            .AddToCache(_cache);
                     }
 
                 PushKeys:
-                    foreach (string keyname in key.GetSubKeyNames())
+                    foreach (string keyname in registryKey.GetSubKeyNames())
                     {
                         if (ShouldExclude(keyname))
                         {
@@ -96,22 +99,21 @@
 
                         try
                         {
-                            RegistryKey? subkey = key.OpenSubKey(keyname);
+                            RegistryKey? subkey = registryKey.OpenSubKey(keyname);
 
                             if (subkey is null)
                             {
                                 continue;
                             }
 
-                            (TreeRegistryKey, RegistryKey) treekey = subkey
+                            subkey
                                 .CreateTreeKey(keyname, source, depth)
-                                .AddParent(tree);
-
-                            _stack.Push(treekey);
+                                .AddParent(tree)
+                                .PushToStack(_stack);
                         }
                         catch (SecurityException exception)
                         {
-                            string path = System.IO.Path.Combine(key.Name, keyname);
+                            string path = System.IO.Path.Combine(registryKey.Name, keyname);
                             WriteError(exception.ToSecurityError(path));
                         }
                     }
@@ -125,8 +127,7 @@
         return _cache.GetResult(WithInclude && !KeysOnly).Format();
     }
 
-    private bool ShouldSkipValue(string value) =>
-        string.IsNullOrEmpty(value) || ShouldExclude(value) || !ShouldInclude(value);
+    private bool ShouldSkipValue(string value) => ShouldExclude(value) || !ShouldInclude(value);
 
     private bool TryGetKey(string path, [NotNullWhen(true)] out RegistryKey? key)
     {

src/PSTree/Extensions/TreeExtensions.cs

@@ -84,6 +84,18 @@
         return tree;
     }
 
+    internal static void AddToCache<TBase, TLeaf>(this TLeaf leaf, Cache<TBase, TLeaf> cache)
+        where TLeaf : TBase
+        where TBase : ITree
+    {
+        cache.Add(leaf);
+    }
+
+    internal static void PushToStack(this TreeDirectory directory, Stack<TreeDirectory> stack)
+    {
+        stack.Push(directory);
+    }
+
 #if NETCOREAPP
     [SkipLocalsInit]
 #endif
@@ -188,6 +200,13 @@
         return treeKey;
     }
 
+    internal static void PushToStack(
+        this (TreeRegistryKey, RegistryKey) treeKey,
+        Stack<(TreeRegistryKey, RegistryKey)> stack)
+    {
+        stack.Push(treeKey);
+    }
+
     internal static void Deconstruct(
         this string[] strings,
         out string baseKey,

src/PSTree/TreeDirectory.cs

@@ -74,4 +74,14 @@ internal void IndexLength(long length)
             i.Length += length;
         }
     }
+
+    internal TreeDirectory SetIncludeFlagIf(bool condition)
+    {
+        if (condition)
+        {
+            Include = true;
+        }
+
+        return this;
+    }
 }

src/PSTree/TreeRegistryValue.cs

@@ -9,6 +9,8 @@
 {
     private readonly string _parentPath;
 
+    private readonly string _valueName;
+
     internal override bool Include { get; set; } = true;
 
     public RegistryValueKind Kind { get; }
@@ -22,14 +24,18 @@
         base(string.Empty, source)
     {
         _parentPath = key.Name;
-        Kind = key.GetValueKind(value);
-        Hierarchy = GetColoredName(value, Kind).Indent(depth);
+        _valueName = value;
         Depth = depth;
-        Name = value;
+        Name = GetNameOrDefault(value);
+        Kind = key.GetValueKind(value);
+        Hierarchy = GetColoredName(Name, Kind).Indent(depth);
         PSParentPath = $"{_providerPath}{_parentPath}";
     }
 
-    public object? GetValue() => Registry.GetValue(_parentPath, Name, null);
+    private static string GetNameOrDefault(string value) =>
+        string.IsNullOrEmpty(value) ? "(Default)" : value;
+
+    public object? GetValue() => Registry.GetValue(_parentPath, _valueName, null);
 
     private static string GetColoredName(string name, RegistryValueKind kind) =>
         TreeStyle.Instance.Registry.GetColoredValue(name, kind);