As well as opening up a text editor to be able to modify content, another common use case that I have when it comes to creating a command line application is being able to select over a list of options.

If you'll take a look at the code I have on screen, here we have a list of spells. Let's say in this case we're creating a CLI application to act like a wizard, for example. Maybe it's a CLI video game or something similar. Let's say we want to go ahead and actually add in the ability for our user to be able to select a file.

One way to achieve this is to make use of the scanf command, which allows us to prompt to read inputs from the standard input stream. For example, let's say we want to go ahead and do a scanline, which will allow us to easily scan into a string value. Let's go ahead and first say selection, which is going to be a string. We'll go ahead and print out, please select a spell. And we're passing in our selection as a pointer, which we'll scan into. Then afterwards we can go ahead and do format.println, spell selected, and we can go ahead and print out our selection.

Now, if I go ahead and run this code using the go run command, you can see we're prompting the user to select a spell. Let's say we can go ahead and do fireball. And you can see spell selected fireball. Whilst this approach works to being able to collect standard inputs, you'll notice I actually don't have a fireball spell. And therefore, by prompting the user to enter in standard inputs through the scan, through the scanline command, through this approach, we've not been able to allow a user to select from a list of options.

We could, of course, add in a simple for loop so that we're checking that the user is selecting an option that has been presented. But in all honesty, I think in the modern era of CLI development, there's actually better ways. One approach is to use a tool called FZF, or FZF if you happen to pronounce British English. FZF, or FZF, is a general purpose command line fuzzy finder tool for the terminal, which allows you to have an interactive filter prompt for any kind of list, be it files, command history, processes, host names, bookmarks, git commits, etc, etc. And implements a fuzzy matching algorithm so you can type in patterns in order to be able to use them.

To show how this works, if I head back on over to my terminal and run the FZF command, you can see it presents a list of options at the bottom of the screen that I can select from. By default, FZF will display a list of files inside of your current directory, of which I only have two. However, if I go to select one, you can see it prints out that selection to standard out.

If we take a look at my Dreams of Code directory, which is where all of the files live for my course platform, if we go ahead and run FZF in here, you can see there's many more options to choose from. However, in addition to this, FZF also supports the ability to do fuzzy finding. So I can go ahead and actually search for this. Let's say I search for all of my temple files or files ending in .temple, and it will show a list of these files available to me. As you can see, this is pretty powerful when it comes to searching and selecting with a terminal interface.

But FZF can actually be used for more than just selecting through a list of files. To do so, we just need to pass in the list to the standard input of the command, which we can do by using the echo command. And let's say we pass in Foo with a new line, then Bar with a new line, Baz, and we'll do one more called Wibble. Now, if we go ahead and pipe this to FZF, you can see that the four options I passed in are now selectable at the bottom of the screen. And of course, we can use fuzzy searching with these as well.

Therefore, we can go ahead and use FZF with its standard input in order to pass in a list of spells so that we can prompt our user to select from one of the list. So let's go ahead and change our code to make use of FZF. To begin, we're going to need to use the exec package as we saw before, and we'll go ahead and use the command function. Again, we could use command context, but for the meantime, we're just going to go ahead and use command to make things a little easier.

Next, we can then go ahead and pass in the FZF command in order to execute it. For this command to work, you'll need to make sure that you have FZF installed on your system, of which the actual FZF GitHub page does provide some instructions depending on your operating system. There's a link to the GitHub page in the lesson description down below. However, you can just find this by searching for FZF as well. As you can see, there's instructions for using Homebrew if you're using macOS or Linux. It's just the brew install FZF command, as well as the various different commands you can use for other Linux systems or Linux package managers, as well as some instructions for Windows as well. Additionally, there's also some binary releases and the ability to use Git.

In any case, once you have FZF installed, we can then go about executing it. First, let's go ahead and capture this command in a variable called CMD. Then, we need to go ahead and actually pass in our options via standard input. In order to do so, it's pretty easy. The first thing we need to do is turn our slice of spells, or our slice of string, into a single string that has been separated with new lines. So, we can go ahead and define a spells string variable, which in this case is going to use the strings.join function, passing in the spells themselves, so we just call spells function, and we'll join these with a new line character. Pretty simple.

Next, we can then go ahead and set the standard input of the command to be a strings.newreader, and we'll just go ahead and pass our spells string to it. Then, all that remains is to go ahead and capture the output of this command, which we can do by going ahead and say selected spell, and we'll go ahead and set an underscore because we're going to ignore the error. We can do command.output, which should return the spell as a byte array. Lastly, we can just go ahead and print this out, say spell chosen, and we'll just go ahead and wrap the string of selected spell as follows, and that should be all we need.

Now, if I go ahead and run this code using the go run command, you can see that we're able to select all of these spells from our list, and when I go ahead and select one, say firebolt, you can see I get the output of spell chosen, firebolt. So far, so good. Although, we do need to make a couple of changes to our code. You'll notice here that there's actually a new line character, although this is hard to see. What we need to do is go ahead and use the strings.trim space function in order to just reduce that new line character. Now, if I run this code again, and we'll go ahead and select firebolt, you can see this time there's not an additional new line that we saw before.

As you can see, FZF makes it very easy for us to be able to select from a list of options inside of our code. However, there are some other things we can actually do when it comes to using the FZF command. If we take a look at the help for FZF, so we can go FZF --help, you'll see there are a number of different options that we can pass into this command, such as a header input selection, so a prompt list selection, so how we can actually perform this list so we can cycle through or enable list wrapping, even the height or the display mode that we want to display.

In this case, let's go ahead and make a couple of changes to make our FZF selection just that little bit easier. The first thing we're going to change is to go ahead and add in a title so that we can actually display to our user what we're asking them to do. Beforehand, when we were using scanf, you could see we were saying, please select a spell. So in this case, let's go ahead and do the same thing. In order to do so, we can go ahead and use the header flag, specifying the header we want to give. In this case, let's go ahead and say, please select a spell. Now, if we go ahead and run this code, you can see this time we're getting a header at the bottom of the screen.

Next, it would be nice if we could go ahead and limit the height of this so that it's not taking up the full height of the screen. Instead, we can set this to be the height of the number of elements we actually have. In this case, there are five elements, but we also need to consider that we also have three prompts as well. Therefore, let's go ahead and use the height flag in order to set the height, which in this case, we want it to be the length of our items. So we can go ahead and do height is equal to length of spells. And we'll also go ahead and plus three just so that we have some room for the prompts and the header as well.

Then we can just go ahead and pass this in using strconf. So converting it to a string, I'm going to need to separate this on cross different lines. And we can go ahead and do I2A. So we're going to change the height into a string. And we'll separate these across two lines just to make it a bit easier to see. Now, if we go ahead and run this code again, you can see this time all of our options are within the same height and we're not taking up the full screen. Again, heal wounds.

With that, we've taken a look at how we can use FZF in order to be able to select across a number of different options. However, this isn't the only way you can use FZF when it comes to your code. As I mentioned before, FZF by default will automatically display a list of files inside of your file system. And because FZF is a fuzzy finding tool, if you actually start typing out the string what you're looking for, it can allow you to search for these fields across all of the entries. It's actually a very powerful tool and a great user interface if you want to use it within your own programs and showcases some of the power of using the exec command in order to simplify other tooling.

With that being said, one of the drawbacks of FZF is that you need to make sure it's installed on the system where you want to use. But when it comes to building tools such as managing content or being able to select between environments, etc, etc, making use of this in your command line tools is a really powerful thing. Especially compared to using scanf, which whilst it does allow for unconstrained input, isn't great for selecting between a number of different options.

In the next module, we're going to take a deeper look at the file system and networking in order for us to understand how we can better work with files and the file system when it comes to our own CLI applications.