gophers VS cobra

fn get_gopher(gopher: String) -> Result { println!("Try to get {} Gopher...", gopher); let url = format!("https://github.com/scraly/gophers/raw/main/{}.png", gopher); let response = minreq::get(url) .send() .expect("Fail to get response from server"); if response.status_code == 200 { let file_name = format!("{}.png", gopher); let mut output_file = File::create(&file_name).expect("Fail to create file"); output_file .write_all(response.as_bytes()) .expect("Fail to write file"); Ok(format!("Perfect! Just saved in {}", &file_name)) } else { Err(Error::GopherNotFound(format!( "Gopher {} not exists", gopher ))) } }

use std::fs::File; use std::io::stdout; use std::io::Write; use structopt::clap::{crate_name, crate_version, Shell}; use structopt::StructOpt; #[derive(StructOpt, Debug)] #[structopt(name = "rust-gopher-friend-cli", version = crate_version!(), about = "Gopher CLI application written in Rust.")] enum Command { /// This command will get the desired Gopher Get { /// Gopher type #[structopt()] gopher: String, }, /// Generate completion script Completion { /// Shell type #[structopt(possible_values = &["bash", "fish", "zsh", "powershell", "elvish"])] shell: Shell, }, } fn get_gopher(gopher: String) { println!("Try to get {} Gopher...", gopher); let url = format!("https://github.com/scraly/gophers/raw/main/{}.png", gopher); let response = minreq::get(url) .send() .expect("Fail to get response from server"); if response.status_code == 200 { let file_name = format!("{}.png", gopher); let mut output_file = File::create(&file_name).expect("Fail to create file"); output_file .write_all(response.as_bytes()) .expect("Fail to write file"); println!("Perfect! Just saved in {}", &file_name); } else { eprintln!("Gopher {} not exists", gopher); } } fn main() { let cmd = Command::from_args(); match cmd { Command::Get { gopher } => get_gopher(gopher), Command::Completion { shell } => { Command::clap().gen_completions_to(crate_name!(), shell, &mut stdout()) } } }

var getCmd = &cobra.Command{ Use: "get", Short: "This command will get the desired Gopher", Long: `This get command will call GitHub respository in order to return the desired Gopher.`, Run: func(cmd *cobra.Command, args []string) { var gopherName = "dr-who.png" if len(args) >= 1 && args[0] != "" { gopherName = args[0] } URL := "https://github.com/scraly/gophers/raw/main/" + gopherName + ".png" fmt.Println("Try to get '" + gopherName + "' Gopher...") // Get the data response, err := http.Get(URL) if err != nil { fmt.Println(err) } defer response.Body.Close() if response.StatusCode == 200 { // Create the file out, err := os.Create(gopherName + ".png") if err != nil { fmt.Println(err) } defer out.Close() // Writer the body to file _, err = io.Copy(out, response.Body) if err != nil { fmt.Println(err) } fmt.Println("Perfect! Just saved in " + out.Name() + "!") } else { fmt.Println("Error: " + gopherName + " not exists! :-(") } }, }

package main import ( "fmt" "log" "net/http" "github.com/go-openapi/loads" "github.com/go-openapi/runtime/middleware" "github.com/scraly/learning-go-by-examples/go-rest-api/pkg/swagger/server/restapi" "github.com/scraly/learning-go-by-examples/go-rest-api/pkg/swagger/server/restapi/operations" ) func main() { // Initialize Swagger swaggerSpec, err := loads.Analyzed(restapi.SwaggerJSON, "") if err != nil { log.Fatalln(err) } api := operations.NewHelloAPIAPI(swaggerSpec) server := restapi.NewServer(api) defer func() { if err := server.Shutdown(); err != nil { // error handle log.Fatalln(err) } }() server.Port = 8080 api.CheckHealthHandler = operations.CheckHealthHandlerFunc(Health) api.GetHelloUserHandler = operations.GetHelloUserHandlerFunc(GetHelloUser) api.GetGopherNameHandler = operations.GetGopherNameHandlerFunc(GetGopherByName) // Start server which listening if err := server.Serve(); err != nil { log.Fatalln(err) } } //Health route returns OK func Health(operations.CheckHealthParams) middleware.Responder { return operations.NewCheckHealthOK().WithPayload("OK") } //GetHelloUser returns Hello + your name func GetHelloUser(user operations.GetHelloUserParams) middleware.Responder { return operations.NewGetHelloUserOK().WithPayload("Hello " + user.User + "!") } //GetGopherByName returns a gopher in png func GetGopherByName(gopher operations.GetGopherNameParams) middleware.Responder { var URL string if gopher.Name != "" { URL = "https://github.com/scraly/gophers/raw/main/" + gopher.Name + ".png" } else { //by default we return dr who gopher URL = "https://github.com/scraly/gophers/raw/main/dr-who.png" } response, err := http.Get(URL) if err != nil { fmt.Println("error") } return operations.NewGetGopherNameOK().WithPayload(response.Body) }

We can use the flag with --date or -date, Go already does the automatic check. We can make our entire boilerplate with this approach, but let's make it a little easier and use the Cobra CLI package.

In this tutorial, we'll walk through the process of creating a simple command-line tool similar to curl using Go and Cobra, a CLI library for Go.

I use https://github.com/spf13/cobra religiously for this kind of thing - it handles all the annoying corner cases of parsing flags, and also has an intuitive notion of subcommands (with basic usage/help text generated) for picking which task you want to run with positional arguments.

We recently chose cobra[1] to create a cli application. It comes with so many best practices already packaged like autocompletions, help texts etc. etc.

[1]: https://github.com/spf13/cobra

github.com/spf13/cobra

I looked at the docs: https://cobra.dev/ ... and there are only examples on how to add new flags.

For installing Cobra-CLI you can go to Cobraor run go install github.com/spf13/cobra-cli@latest in the terminal.

In my build phase, I compile the source to create a k3sup binary and I also run the binary to generate shell script completions. Give kudos to this functionality which comes from spf13/cobra Go library for CLIs.

NWA is a command-line tool built on cobra. Here's an overview of NWA's commands: