Friday Fun: A Better Test-WsMan

I saw a question on Facebook about how to get Test-WsMan to return a simple Boolean result. The Test-Connection cmdlet has a -Quiet parameter that makes this possible. But Test-Wsman does not.  Certainly, you could script a comparable outcome. Here’s one way: Continue reading

Finding Git Repositories with PowerShell

As part of my ongoing improvement process this year I am starting to use Git much more. Yesterday I posted an article with my PowerShell script to create a new project folder which includes creating a Git repository. My challenge has been that I don’t always remember what I have set up with Git and what I have not. So I put together a little PowerShell function to identify folders with Git repositories.

The function, Find-GitRepository, takes a top-level path as a parameter. The function then searches all sub folders searching for hidden directories called .git. For each directory, the function creates a custom object that includes the path and details about the Git repository. To get those values the command jumps to each folder where I parse the results of git branch and git log.

find git repositories with PowerShell

There’s probably a bit more information I could pull with Git but for now this seems to be enough for me. You can find the function as a gist in my Github repository.

As with my previous script, I assume you have the git command line tools in your path.  If you use Git I hope you’ll try it out and let me know what you think.

Managing PowerShell Functions

Most of you probably know I’ve been using PowerShell since its beta days which now means I have about 10 years worth of PowerShell files. I find it hard to throw anything away. Over this time frame my PowerShell profile scripts have also grown, often loading functions that I’ve come up with. The effect has  been that it takes a little bit longer to bring up a new PowerShell console or ISE session. Since deep down I know there are functions I no longer use, I figured it was time for some profile cleanup. The first step was to identify my functions.

First, how many functions am I talking about? PowerShell stores currently defined and active functions in a PSDrive which means it is pretty easy to get a “directory” listing and count.


However, some of those functions are defined by Microsoft and other modules.


I don’t have any issues with functions defined from a given source. My problem is in that 100 that have no source.  Again some of those are defined by Microsoft which are fine. So I looked at one of them in more detail.


I noticed that these functions included a HelpFile. I knew that none of my functions didn’t. With this information I can get a directory listing and filter with Where-Object.


These are functions that are loaded from dot sourcing a ps1 file. By the way, the list had 62 items.

As an alternative I could use Get-Command which would get rid of any filters

Know that this will search for functions in modules not currently loaded so it takes a bit longer to run. This gave me 61 items.

But now at least I can go through the list and identify functions that I haven’t used in years or are now obsolete. Unfortunately, there’s no way to tell from the Function PSDrive or with Get-Command where the function came from.   Luckily I keep all my files in a single drive and most likely the function will be defined in a .ps1 script. I can use Select-String to find it.

In my list there is a function called Show-Balloon that I probably haven’t used in years. What file is it in?

I’m wrapping the function name in a regular expression word boundary so that I don’t get a match on something like show-balloontip. The –List parameter gives me the first match which is all I really need.


Because I write all of my functions with the same format, I could have searched like this and gotten the same result.

The output from Select-String is an object which includes a property for the filename or path.


Now I can put it all together.

I don’t want to have to re-list all the script files for every function, so I’ll get it once and then use that variable in the Select-Object expression.


With this information I can modify my PowerShell profiles and remove the lines that are loading the functions I don’t want or edit the source file to comment out the function if there was something else in the same file I did want to keep.  Any function in this list without a matching source is most likely defined directly in the profile script or will require a manual search.

Time now for a little housekeeping, although I’d love to hear how you keep things tidy in your PowerShell world.

A Better PowerShell More

In PowerShell, when I have a lot of output, I can use the legacy command to page the results to the screen.

There’s not anything inherently wrong with this approach. Although one drawback is that it doesn’t work in the PowerShell ISE. For that reason alone I decided I needed a PowerShell version of More.  I wanted a command that would take pipelined input and write the output in “pages” of objects.  You can think of the page as a group of objects. The premise is simple enough: take the incoming objects, and pass them on to the pipeline when the number of objects meets the page limit.

My function, Out-More, is on GitHub.

The default page count is 50. I set a maximum value of 1000 which is totally arbitrary. I wanted to emulate the command the best I could so when you are prompted you can hit Enter or press M to get the next page or N to get the next object.  You can also Quit. One thing my command can do that cannot is to stop paging and simply display the rest of the objects.  This means you can page output for a few screens and then display the remaining objects.

Here’s an example:

More PowerShell Output

Using Out-More

To be clear here, this is writing output to the pipeline not to the console.  My expectation is that  Out-More would be the last command in your expression,  but you could save the results to a variable using Tee-Object.

out-more to variable

Out-More to a variable

The script file will also define an alias of om.  I debated using More, but that is actually a built-in PowerShell function that wraps so I decided to leave it alone. A few of the command parameters also have aliases so take a few minutes to read the help.

I hope you find this as useful as I do.

Friday Fun: Size Me Up

Part of day job involves creating training material, often in the form of video training for Pluralsight or articles for Since I usually am covering PowerShell I often need to capture a PowerShell session. And sometimes I want the screen to be a particular size. So over time I’ve created a few PowerShell tools to resize console and application windows. The PowerShell console window stores its dimension under $host.ui.rawui.windowsize.

These are the same settings you would see here:

As long as you use a value less than the buffer dimensions, you can modify the console window from a prompt. But it takes a step you might not realize. You can’t do this:

Instead, you can create a new type of object with your intended dimensions.

Then you can use this object as a value for the WindowSize property.

Naturally, I created a function to do this for me.

My function also includes code to support –WhatIf.

Of course now that I’ve shown you that I have an alternative. You can use the .NET class [System.Console] which has properties for width and height. And you can set these values independently.

You can’t discover this unless you know something of the .NET Framework, but you could have discovered $host which is why I showed you that first. Since I often need to record video at 1280×720 dimensions, I wrote a quick and dirty script to set my PowerShell console window to those dimensions.

Everything I’ve shown you so far is for the PowerShell console. But what about the ISE? You can’t use the techniques I’ve covered. Application windows are bit more complicated and I’m not going to go into the details. But I came across some code on GitHub ( I don’t do Minecraft but it didn’t take much to turn it into a re-usable function.

The code supports –WhatIf and defaults to the current application, which is presumably the PowerShell ISE.

But this is what actually gets set.

So if you wanted to include the title bar you would need to adjust accordingly.

All of this may not really be applicable to your work, but if you find a good use I hope you’ll let me know. Have a great weekend.