gobase64.go

package main

import (
	"encoding/base64"
	"fmt"
	"io"
	"os"

	"github.com/pkg/errors"
	"github.com/spf13/cobra"
)

func main() {
	if err := rootCmd().Execute(); err != nil {
		fatal(errors.Wrap(err, "command failed"))
		return
	}
}

func fatal(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
		os.Exit(1)
	}
}

func rootCmd() *cobra.Command {
	var encoding string
	var raw, decode bool
	rcmd := &cobra.Command{
		Use:   "gobase64",
		Short: "go-specific base64 toolkit",
		Args:  cobra.NoArgs,
		Run: func(_ *cobra.Command, _ []string) {
			var enc *base64.Encoding
			switch encoding {
			case "std":
				if raw {
					enc = base64.RawStdEncoding
				} else {
					enc = base64.StdEncoding
				}
			case "url":
				if raw {
					enc = base64.RawURLEncoding
				} else {
					enc = base64.URLEncoding
				}
			default:
				fatal(fmt.Errorf(`invalid encoding: "%s"`, encoding))
				return
			}

			data, err := io.ReadAll(os.Stdin)
			if err != nil {
				fatal(errors.Wrap(err, "failed to read stdin"))
				return
			}

			if decode {
				out := make([]byte, enc.DecodedLen(len(data)))
				if _, err := enc.Decode(out, data); err != nil {
					fatal(errors.Wrap(err, "failed to decode input"))
					return
				}
				_, _ = os.Stdout.Write(out)
				_ = os.Stdout.Sync()
			} else {
				out := make([]byte, enc.EncodedLen(len(data)))
				enc.Encode(out, data)
				_, _ = os.Stdout.Write(out)
				_ = os.Stdout.Sync()
			}
		},
	}
	rcmd.Flags().BoolVarP(&decode, "decode", "d", false, "decoding mode")
	rcmd.Flags().StringVarP(&encoding, "encoding", "e", "std", `the encoding ("url" or "std")`)
	rcmd.Flags().BoolVarP(&raw, "raw", "r", false, "raw mode")
	return rcmd
}