PowerShell provider relative path tab-completion issue

Question

I've implemented a simple PowerShell NavigationCmdletProvider.

For those who don't know, this means I can create a snap-in with a cmdlet which is effectively a virtual filesystem drive; this drive can be mounted and navigated into from PowerShell like any normal folder. Each action against the drive (e.g., check if a path points to a valid item, get a list of names of child items in a folder, etc.) is mapped to a method of the .NET class inherited from the NavigationCmdletProvider class.

I'm facing a problem with tab-completion, and would like to find a solution. I've found that tab-completion gives incorrect results when using relative paths. For absolute paths, it works fine.

For those who don't know, tab completion for a NavigationCmdletProvider works through PowerShell calling the GetChildNames method, which is overridden from the NavigationCmdletProvider class.

--Demonstration of the issue--

Assume I have a provider, 'TEST', with the following folder hierarchy:

TEST::child1
TEST::child1\child1a
TEST::child1\child1b
TEST::child2
TEST::child2\child2a
TEST::child2\child2b
TEST::child3
TEST::child3\child3a
TEST::child3\child3b

Absolute paths:

If I type "dir TEST::child1\" and press tab a few times, it gives me the expected results:

> dir TEST::child1\child1a
> dir TEST::child1\child1b

Relative paths:

First, I navigate to "TEST::child1":

> cd TEST::child1

Then, if I type "dirspace" and press tab a few times, it gives me incorrect results:

> dir .\child1\child1a
> dir .\child1\child1b

I expect to see these instead:

> dir .\child1a
> dir .\child1b

Is this a bug in PowerShell, or am I doing something wrong?

Here's the complete, self-contained code for the provider:

[CmdletProvider("TEST", ProviderCapabilities.None)]
public class MyTestProvider : NavigationCmdletProvider
{
    private Node m_Root;
    private void ConstructTestHierarchy()
    {
        //
        // Create the nodes
        //
        Node root = new Node("");
            Node child1 = new Node("child1");
                Node child1a = new Node("child1a");
                Node child1b = new Node("child1b");
            Node child2 = new Node("child2");
                Node child2a = new Node("child2a");
                Node child2b = new Node("child2b");
            Node child3 = new Node("child3");
                Node child3a = new Node("child3a");
                Node child3b = new Node("child3b");

        //
        // Construct node hierarchy
        //
        m_Root = root;
            root.AddChild(child1);
                child1.AddChild(child1a);
                child1.AddChild(child1b);
            root.AddChild(child2);
                child2.AddChild(child2a);
                child2.AddChild(child2b);
            root.AddChild(child3);
                child3.AddChild(child3a);
                child3.AddChild(child3b);
    }

    public MyTestProvider()
    {
        ConstructTestHierarchy();
    }

    protected override bool IsValidPath(string path)
    {
        return m_Root.ItemExistsAtPath(path);
    }

    protected override bool ItemExists(string path)
    {
        return m_Root.ItemExistsAtPath(path);
    }

    protected override void GetChildNames(string path, ReturnContainers returnContainers)
    {
        var children = m_Root.GetItemAtPath(path).Children;
        foreach (var child in children)
        {
            WriteItemObject(child.Name, child.Name, true);
        }
    }
    protected override bool IsItemContainer(string path)
    {
        return true;
    }
    protected override void GetChildItems(string path, bool recurse)
    {
        var children = m_Root.GetItemAtPath(path).Children;
        foreach (var child in children)
        {
            WriteItemObject(child.Name, child.Name, true);
        }
    }
}

/// <summary>
/// This is a node used to represent a folder inside a PowerShell provider
/// </summary>
public class Node
{
    private string m_Name;
    private List<Node> m_Children;

    public string Name { get { return m_Name; } }
    public ICollection<Node> Children { get { return m_Children; } }

    public Node(string name)
    {
        m_Name = name;
        m_Children = new List<Node>();
    }

    /// <summary>
    /// Adds a node to this node's list of children
    /// </summary>
    public void AddChild(Node node)
    {
        m_Children.Add(node);
    }
    /// <summary>
    /// Test whether a string matches a wildcard string ('*' must be at end of wildcardstring)
    /// </summary>
    private bool WildcardMatch(string basestring, string wildcardstring)
    {
        //
        // If wildcardstring has no *, just do a string comparison
        //
        if (!wildcardstring.Contains('*'))
        {
            return String.Equals(basestring, wildcardstring);
        }
        else
        {
            //
            // If wildcardstring is really just '*', then any name works
            //
            if (String.Equals(wildcardstring, "*"))
                return true;

            //
            // Given the wildcardstring "abc*", we just need to test if basestring starts with "abc"
            //
            string leftOfAsterisk = wildcardstring.Split(new char[] { '*' })[0];
            return basestring.StartsWith(leftOfAsterisk);

        }
    }

    /// <summary>
    /// Recursively check if "child1\child2\child3" exists
    /// </summary>
    public bool ItemExistsAtPath(string path)
    {
        //
        // If path is self, return self
        //
        if (String.Equals(path, "")) return true;

        //
        // If path has no slashes, test if it matches the child name
        //
        if(!path.Contains(@"\"))
        {
            //
            // See if any children have this name
            //
            foreach (var child in m_Children)
            {
                if (WildcardMatch(child.Name, path))
                    return true;
            }
            return false;
        }
        else
        {
            //
            // Split the path
            //
            string[] pathChunks = path.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);

            //
            // Take out the first chunk; this is the child we're going to search
            //
            string nextChild = pathChunks[0];

            //
            // Combine the rest of the path; this is the path we're going to provide to the child
            //
            string nextPath = String.Join(@"\", pathChunks.Skip(1).ToArray());

            //
            // Recurse into child
            //
            foreach (var child in m_Children)
            {
                if (String.Equals(child.Name, nextChild))
                    return child.ItemExistsAtPath(nextPath);
            }
            return false;
        }
    }

    /// <summary>
    /// Recursively fetch "child1\child2\child3" 
    /// </summary>
    public Node GetItemAtPath(string path)
    {
        //
        // If path is self, return self
        //
        if (String.Equals(path, "")) return this;

        //
        // If path has no slashes, test if it matches the child name
        //
        if (!path.Contains(@"\"))
        {
            //
            // See if any children have this name
            //
            foreach (var child in m_Children)
            {
                if (WildcardMatch(child.Name, path))
                    return child;
            }
            throw new ApplicationException("Child doesn't exist!");
        }
        else
        {
            //
            // Split the path
            //
            string[] pathChunks = path.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);

            //
            // Take out the first chunk; this is the child we're going to search
            //
            string nextChild = pathChunks[0];

            //
            // Combine the rest of the path; this is the path we're going to provide to the child
            //
            string nextPath = String.Join(@"\", pathChunks.Skip(1).ToArray());

            //
            // Recurse into child
            //
            foreach (var child in m_Children)
            {
                if (String.Equals(child.Name, nextChild))
                    return child.GetItemAtPath(nextPath);
            }
            throw new ApplicationException("Child doesn't exist!");
        }
    }
}

Answer 1

I've listed this as a PowerShell provider bug in Microsoft Connect: Issue with relative path tab-completion (via Get-ChildNames) for NavigationCmdletProvider

If anyone can reproduce this, please visit the link and say so, because Microsoft probably won't look into this if only one person is reporting it.

It looks like this is fixed in PowerShell 3.0. I don't know why Microsoft doesn't want to fix this in older versions, it's not something any code could possibly depend on.

Answer 2

Not sure this is a bug, I found this workaround that seems to "do the job". (small update, turns out my original code would "bug out" when working your way down multiple levels.

''' <summary>
''' Joins two strings with a provider specific path separator.
''' </summary>
''' <param name="parent">The parent segment of a path to be joined with the child.</param>
''' <param name="child">The child segment of a path to be joined with the parent.</param>
''' <returns>A string that contains the parent and child segments of the path joined by a path separator.</returns>
''' <remarks></remarks>
Protected Overrides Function MakePath(parent As String, child As String) As String
    Trace.WriteLine("::MakePath(parent:=" & parent & ",child:=" & child & ")")
    Dim res As String = MyBase.MakePath(parent, child)
    Trace.WriteLine("::MakePath(parent:=" & parent & ",child:=" & child & ") " & res)
    If parent = "." Then
        'res = ".\" & child.Split("\").Last
        If String.IsNullOrEmpty(Me.SessionState.Path.CurrentLocation.ProviderPath) Then
        res = parent & PATH_SEPARATOR & child
        Else
        res = parent & PATH_SEPARATOR & child.Substring(Me.SessionState.Path.CurrentLocation.ProviderPath.Length + 1)
        'res = parent & PATH_SEPARATOR & child.Replace(Me.SessionState.Path.CurrentLocation.ProviderPath & PATH_SEPARATOR, String.Empty)
        End If
        Trace.WriteLine("::**** TRANSFORM: " & res)
    End If
    Return res
End Function

Answer 3

You can work around this if you design you provider so that it expects entering a non-empty Root when you create a new drive. I noticed that the tab-completion mistakenly suggest the complete child path instead of just the child name if the Root property of PSDriveInfo has not been set.

It can be limiting for some providers to always require a non-empty root. The workaround above works well if you don't want to make the users always enter some Root when creating a new drive.

Answer 4

I was able to get it to work with overiding string[] ExpandPath(string path) and setting the ProviderCapabilities.ExpandWildcards capabilities.