option_example_test.go

package verbs_test

import (
	"fmt"
	"os"
	"strconv"

	"github.com/revl/verbs"
)

const (
	TagAdd = "add"
	TagSub = "sub"
	TagMul = "mul"
	TagDiv = "div"
)

var rpnCalcCLI = &verbs.CLI{
	ProgramName: "rpncalc",
	Summary:     "Reverse Polish Notation calculator",
	Description: "A simple RPN calculator that processes numbers and " +
		"operations from the command line. Numbers are pushed onto " +
		"a stack, and operations pop operands from the stack and " +
		"push the result.\n\n" +
		"Example:\n" +
		"  $ rpncalc 3 4 -a 2 -m  # This computes (3 + 4) * 2 = 14",
	Options: []*verbs.Option{
		{
			Name:        "a|add",
			Description: "Add the top two numbers on the stack",
			Tag:         TagAdd,
		},
		{
			Name:        "s|sub",
			Description: "Subtract the top two numbers on the stack (second - first)",
			Tag:         TagSub,
		},
		{
			Name:        "m|mul",
			Description: "Multiply the top two numbers on the stack",
			Tag:         TagMul,
		},
		{
			Name:        "d|div",
			Description: "Divide the top two numbers on the stack (second / first)",
			Tag:         TagDiv,
		},
	},
	Args: []*verbs.Arg{
		{
			Name:        "NUMBER",
			Occurrence:  verbs.ZeroOrMore,
			Description: "Numbers to push onto the stack",
		},
	},
	OptionDescriptionIndent: 14,
}

// This example demonstrates argument-only mode, where the program accepts
// only options and positional arguments without requiring a command.
func ExampleOption() {
	result := verbs.NewParser(rpnCalcCLI).Parse(os.Args)

	stack := []float64{}

	// Process parsed options and arguments in order
	for _, item := range result.OptsAndArgs {
		if item.Tag == "NUMBER" {
			// Parse number and push onto stack
			num, err := strconv.ParseFloat(item.Value, 64)
			if err != nil {
				result.HandleError(fmt.Errorf(
					"invalid number: %s", item.Value))
			}
			stack = append(stack, num)
		} else if len(stack) < 2 {
			result.HandleError(fmt.Errorf("operation %s "+
				"requires at least 2 numbers on stack",
				item.Token))
		} else {
			// Pop two operands
			b := stack[len(stack)-1]
			a := stack[len(stack)-2]
			stack = stack[:len(stack)-2]

			// Perform operation
			var res float64
			switch item.Tag {
			case TagAdd:
				res = a + b
			case TagSub:
				res = a - b
			case TagMul:
				res = a * b
			case TagDiv:
				if b == 0 {
					fmt.Fprintln(os.Stderr,
						"Error: division by zero")
					os.Exit(1)
				}
				res = a / b
			}
			stack = append(stack, res)
		}
	}

	// Print result
	switch len(stack) {
	case 0:
		fmt.Println("0")
	case 1:
		fmt.Println(stack[0])
	default:
		fmt.Fprintf(os.Stderr,
			"Error: %d numbers remaining on stack: %v\n",
			len(stack), stack)
		os.Exit(1)
	}
}