GoLang - 34 - Building a Command-Line Tool

Building a Command-Line Tool in Go: Creating a CLI Application from Scratch

Go is an excellent choice for building command-line tools and utilities due to its simplicity, efficiency, and performance. In this guide, we’ll walk through the steps to create a command-line application from scratch in Go. We’ll cover essential concepts, code examples, and best practices for building CLI tools.

1. Setting Up the Go Development Environment

Before you start building your command-line tool, ensure that you have Go installed on your system. You can download Go from the official website and follow the installation instructions for your platform.

2. Project Structure

Organizing your project is crucial for maintaining code clarity and structure. Create a directory for your CLI tool and structure it like this:


mycli/
    ├── main.go
    ├── cmd/
    │   └── root.go
    └── internal/
        └── logic.go

3. Defining Command Structure

In your “root.go” file, define the structure of your command-line tool using a package like “cobra” or “urfave/cli.” These packages help you define commands, flags, and arguments for your CLI application.

Here’s an example using “cobra” to create a simple CLI command:


package cmd

import (
    "github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{
    Use:   "mycli",
    Short: "My Command-Line Tool",
    Long:  "A simple command-line tool created in Go.",
}

func Execute() error {
    return rootCmd.Execute()
}

4. Implementing Command Logic

Create an “internal/logic.go” file to implement the actual logic of your CLI tool. This is where you’ll define the behavior of your application based on the provided flags and arguments.

Here’s an example of a function that could be called from your CLI command to perform some action:


package internal

import "fmt"

func DoSomething() {
    fmt.Println("Doing something interesting...")
}

5. Integrating Logic with CLI

Link your CLI command with the logic you’ve implemented. In your “cmd/root.go,” add the necessary flags and logic execution. When a user runs your command with specific flags or arguments, the associated logic should be executed.


package cmd

import (
    "github.com/spf13/cobra"
    "mycli/internal"
)

var myCmd = &cobra.Command{
    Use:   "mycmd",
    Short: "Perform some action",
    Long:  "This command performs some action using your CLI tool.",
    Run: func(cmd *cobra.Command, args []string) {
        internal.DoSomething()
    },
}

func init() {
    rootCmd.AddCommand(myCmd)
}

6. Testing

Writing tests for your CLI tool is essential to ensure it functions as expected. Use the standard Go testing package to create tests for both the logic and the CLI commands.

Here’s an example of a test for the “DoSomething” function in “internal/logic_test.go”:


package internal

import (
    "testing"
)

func TestDoSomething(t *testing.T) {
    t.Run("Doing something test", func(t *testing.T) {
        DoSomething()
        // Add test assertions here
    })
}

7. Building and Distributing

Once you’ve implemented and tested your CLI tool, you can build it into a binary. Use the “go build” command to create an executable binary for your tool. You can then distribute it to users or publish it on platforms like GitHub.

To build your CLI tool:


$ go build -o mycli

Users can run your CLI tool by executing the binary:


$ ./mycli

8. Documentation

Documenting your CLI tool is essential for helping users understand its functionality. You can generate documentation using tools like “cobra” or “godoc.” Provide usage examples, command descriptions, and flags in your documentation to make it user-friendly.

Conclusion

Creating a command-line tool in Go is a rewarding experience, and it allows you to automate tasks, simplify processes, and share your work with others. By following these steps and best practices, you can develop a robust and user-friendly CLI application that meets your specific needs.

GoLang – 34 – Building a Command-Line Tool