Whilst being able to execute commands in order to create a process guard is really cool, there are other use cases that I find for the exec command that are really useful for building command line applications. One of the common things that I use the exec command for, as well as many other applications, is to open up a text editor. For example, if we take a look at this new repo that I've created, which we're going to be using throughout this lesson, you can see I've initialized a blank git repository with no commits yet.

If I go ahead and use the git add command to add in the files, followed by using git commit, but this time not passing in a message using the -m flag, you can see it opens up my text editor near them, where I can go about adding in the commit message that I want. Let's say initial commit. Then you can see once I save and commit this file, it goes ahead and creates a commit with the message that I typed in via my text editor.

Opening up a text editor is a very common approach in order to be able to capture user input when it comes to CLI applications, and it's a really good interface to use. In fact, when it comes to my own course website, I built the entire content management system as a CLI application, which we will take a look at how to do later on throughout this course. However, one component of that CMS system was when it came to updating course and lesson content.

For example, if I go ahead and build this code using the go build command, and then execute the dreams of code executable, passing in the courses and content subcommands, which we'll take a look at more in the upcoming module, you can see I'm able to select my course, and it will open up the actual content for me to edit inside of my text editor, which in this case you can see is a markdown file. Here I can go ahead and make changes to my course contents, and it will go ahead and update the database where all of my course content lives. This makes it incredibly easy for me to be able to update large text content without having to deal with a CLI interface, instead deferring to my text editor.

So how do we do this? Well, here I have a very simple project, which just obtains some content using a get content function. In a real-world application, this could be obtaining it from a web address or obtaining it from a file or even a database, all of which we'll take a look at in some future modules. However, for the moment, we're just returning it as a hardcoded string and printing it to the console. If we go ahead and run this, you can see this is what it looks like.

Therefore, let's go about actually making it so that we can edit this content and then print the edited version out to the console. In order to be able to edit this content, the first thing we're going to need to do is to create a file. There are a couple of ways we can actually do this when it comes to Go. However, the easiest way for us to do this in our case is to use the create temp function, which will create a new temporary file in the directory that we pass in. Or if we just leave this directory argument blank, it will create it in the /tmp directory, which is where we want to create our file in.

Additionally, the second parameter allows us to specify a pattern for this file, which we'll talk about more in a minute. In any case, the first argument is the directory we want to create this temporary file in. In our case, we're going to go ahead and set this to be blank because this means that the file will be created in the temporary directory of our system, which will eventually be cleared up either on reset or on some distributions of Ubuntu and other Linux systems after a period of time.

In any case, this directory is going to be /tmp on Linux, and I'm not too sure what it is on macOS and Windows. Let's have a quick look. On macOS, you would have to echo the temp environment variable, which will give you the folder of the temporary directory, long name. Windows, again, I'm not too sure what it is. You'll have to check your operating system manual for that. In any case, no matter what operating system you're on, go ahead and pass this in as an empty string.

Next, we then need to pass in the pattern that we want for our file. In this case, the file name is generated by taking the pattern and adding a random string to the end. In our case, we want the end of this file to actually have the .md extension, so that we get some nice syntax highlighting if we have a syntax highlighter installed on our editor for markdown, which I do in my case.

Therefore, rather than having the random string added to the end, instead, we want to have the random string placed in the middle, which we can do by using the asterisk. Therefore, let's go ahead and change our file name to be content-, then we pass in the asterisk, which will be the random string, then we can do the .md extension.

Okay, with that, we can go ahead and capture the file and the error, and we should do an if error handling here. I'm just going to go ahead and ignore it just for conciseness, and we'll make this just a little bigger as well.

Okay, with that, we are now creating our file, or our temporary file. The next thing we want to do is go ahead and actually write our content to this, which we could do just by using the write string function of the actual file itself. And we'll go ahead and pass in the content string as follows. Again, we're not going to be checking the errors here. However, in a production system, you would be. Next, all that remains is to go ahead and close the file using the close method.

With our file now created, we can go about editing it. To do so, we can go ahead and use the command function of the exec package. In a production system, you'd use command context. Again, we're just going to go ahead and keep this simple. And we just need to pass in the name of the command we want to execute.

In this case, you can choose either to hardcode a text editor, such as NeoVim in my case, or Vim if you use Vim, or Nano if you're not too sure which one to use and you don't know what's installed on your system. However, when it comes to distributing this application, you don't want to hardcode this editor in. This is because you can't be too sure which editors are installed on a user's system.

Instead, you can actually use an environment variable in order to obtain this, as most Linux systems should have the EDITOR environment variable set up in order to communicate with applications what their chosen text editor is. For example, if I run the following command echoing my EDITOR, you can see it's set to NeoVim. Therefore, we can obtain this by using the os.Getenv, which allows us to get environment variables, passing in the EDITOR environment variable.

And we'll go ahead and just set this to be editor as follows. If editor isn't set, so we could do if editor equals equals equals, let's go ahead and just set this to be nano for the meantime. So if the editor doesn't exist, we're changing this to be nano. Now we can go ahead and just pass this in to our command instead of hardcoding the editor we want to use.

Lastly, we then need to go ahead and pass in the file that we want our editor to open. In this case, we can just go ahead and take the name from our file using the f.Name method. Let's go ahead and capture this command, and then we can go ahead and actually execute it.

In order for the editor to work, however, we need to go ahead and pipe in both standard input and standard output, which we can do using the following familiar syntax we've seen already. So command.StdIn is open to os.Stdin, and command.StdOut is equal to stdout. Pretty simple. You could also do standard error here as well, although it's not actually required. It may be depending on your editor, however, so it's probably actually a good idea to do it, just to be safe. There may be some editors that use standard error in these cases, although I'm not too sure.

Okay, next, we then want to go ahead and actually run this command, which we can do by using the command.Run method. Again, this returns an error. We're just going to go ahead and ignore it for the meantime.

Okay, with that, we should be able to open up a text editor and actually make modifications to our content, which, if I run this code, you can see is working as expected. Here, we could go ahead and save function, and we can go ahead and wrap this up as follows, and say we can save this file. As you can see, the file name is /tmp/content with the random string, and it's a markdown file.

Now, if I go ahead and exit it, however, when I go to exit this, as you can see, nothing else happens. However, if I go ahead and cat the file that we actually saw, or the cat file name that we saw at the bottom of our editor, you can see that our changes have now been made and saved to this file. So, as we can see, the editing did work.

Now, all we need to do in order to be able to capture these changes in our application is to just go ahead and read from the file. To do so, let's head back on over to our code. Then, we can go ahead and read the data from this file by using the readFile function of the os package, passing in the file's name, which we can obtain using the f.Name method.

Then, all we need to do is go ahead and say newContent, and again, we're going to ignore the error, and we can do fmt.Println, let's say new content, we'll pass it in as a string, and we'll just go ahead and do a prefix string beforehand, updated content, as so.

Now, when we run this code again, we can see it's opening up our file, and we can go ahead and do, say, wrapping this in a function, as follows, and I've now edited the content using my editor, let's say. Now, if I go ahead and save this and close it down, you can see we get the updated content.

I've now edited my content using my editor, as well as the changes I made to the code snippet. With that, we've managed to take a look at how we can execute our text editor from within our Go code in order to present an interface for us to be able to edit content, and we can then pull out that content or data or even the file's content using the readFile function.

As I mentioned, when it comes to our code, whilst you may feel tempted to hardcode the editor that you use inside of this exec command, the important thing to make note of is when executing an editor, you'll want to use the EDITOR environment variable, as this should be set to an individual's specific setup. It also allows us to do things like EDITOR=nano and then we can go run, and as you can see, I'm opening up the nano text editor, which personally I don't know how to use. Let's go ahead and exit this. Yep, that's fine. And as you can see, this works the same way.

In the next lesson, we're going to take a look at another way that I like to use the exec command, but this time, rather than for editing content or opening up a text editor, instead being able to fuzzy search for values in a list.