Go with Cobra + Viper CLI for Parsing Text Files

Part 1 of 3 - Coding Session in Go - Cobra + Viper CLI for Parsing Text Files, Retrieval of Twitter Data, Exports to various file formats, and export to Apache Cassandra.

UPDATED PARTS: (Goes to original Composite Code blog posts)

1. Twitz Coding Session in Go - Cobra + Viper CLI for Parsing Text Files (this post)
2. Twitz Coding Session in Go - Cobra + Viper CLI with Initial Twitter + Cassandra Installation
3. Twitz Coding Session in Go - Cobra + Viper CLI Wrap Up + Twitter Data Retrieval

3:40 Stated goals of application. I go through a number of features that I intend to build into this application, typing them up in a text doc. The following are the items I added to the list.

1. The ability to import a text file of Twitter handles that are mixed in among a bunch of other text.
2. The ability to clean up that list.
3. The ability to export the cleaned up list of handles to a text, csv, JSON, xml, or plain text file.
4. The ability, using the Twitter API, to pull data form the bio, latest tweets, and other related information.

8:26 Creating a new Github Repo. A few tips and tricks with creating a new repo with the Github.

• Github Repo: Twitz
• License: Apache-2.0
• Issue Filing Options: Feature Request or Bug Report.
• README.md
• The Jeckyll yml file that provides the skinning for the project page at https://adron.github.io/twitz/.

9:46 Twitz is brought into existence! Woo
~~ Have to reset up my SSH key real quick. This is a quick tutorial if you aren't sure how to do it, otherwise skip forward to the part where I continue with project setup and initial coding.

12:40 Call out for @justForFunc and Francesc's episode on Cobra!

Check out @francesc's "Just for Func". It's a great video/podcast series of lots and lots of Go!

• @JustforFunc on Twitter.
• Just for Func on Youtube.
• The episode I mentioned regarding the Cobra CLI Library.

13:02 Back to project setup. Cloning repo, getting initial README.emd, .gitignore file setup, and related collateral for the basic project. I also add Github's "issues" files via the Github interface and rebase these changes in later.
14:20 Adding some options to the .gitignore file.
15:20 Set dates and copyright in license file.
16:00 Further setup of project, removing WIKIs, projects, and reasoning for keeping issues.
16:53 Opening Goland up after an update. Here I start going through the specific details of how I setup a Go Project in Goland, setting configuration and related collateral.
17:14 Setup of Goland's golang Command Line Launcher.
25:45 Introduction to Cobra (and first mention of Viper by association).
26:43 Installation of Cobra with go get github.com/spf13/cobra/cobra/ and the gotchas (remember to have your paths set, etc).
29:50 Using Cobra CLI to build out the command line interface app's various commands.
35:03 Looking over the generated code and commenting on the comments and their usefulness.
36:00 Wiring up the last bits of Cobra with some code, via main func, for CLI execution.
48:07 I start wiring up the Viper configuration at this point. Onward from here it's coding, coding, and configuration, and more coding.

Implementing the `twitz config` Command

1:07:20 Confirming config and working up the twitz config command implementation.
1:10:40 First execution of twitz config and I describe where and how Cobra's documentation strings work through the --help flag and is put into other help files based on the need for the short or long description.

The basic config code when implemented looked something like this end of session. This snippet of code doesn't do much beyond provide the displace of the configuration variables from the configuration file. Eventually I'll add more to this file so the CLI can be easier to debug when setting it up.

package cmd

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

// configCmd represents the config command
var configCmd = &cobra.Command{
    Use:   "config",
    Short: "A brief description of your command",
    Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For the custom example:
Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Twitterers File: %s\n", viper.GetString("file"))
        fmt.Printf("Export File: %s\n", viper.GetString("fileExport"))
        fmt.Printf("Export Format: %s\n", viper.GetString("fileFormat"))<span data-mce-type="bookmark" id="mce_SELREST_start" data-mce-style="overflow:hidden;line-height:0" style="overflow:hidden;line-height:0;"></span>
    },
}

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

Implementing the `twitz parse` Command

1:14:10 Starting on the implementation of the twitz parse command.
1:16:24 Inception of my "helpers.go" file to consolidate and clean up some of the code.
1:26:22 REDEX Implementation time!
1:32:12 Trying out the REGEX101.com site.

I'll post the finished code and write up some details on the thinking behind it when I post video two of this application development sessions.

That's really it for this last session. Hope the summary helps for anybody working through building CLI apps with Go and Cobra. Until next session, happy thrashing code.

I'm on Twitter @Adron and Twitch @adronhall listening to metal all the time and coding, writing about coding, learning, and teaching all sorts of topics from database tech to coding chops. Thanks for reading!