enbas/internal/executor/flags.go

package executor

import (
	"fmt"
	"strconv"
	"strings"
	"time"
)

const (
	flagAccountName  = "account-name"
	flagAttachmentID = "attachment-id"
	flagContent      = "content"
	flagFrom         = "from"
	flagFromFile     = "from-file"
	flagInstance     = "instance"
	flagListID       = "list-id"
	flagListTitle    = "list-title"
	flagPollID       = "poll-id"
	flagPollOption   = "poll-option"
	flagStatusID     = "status-id"
	flagTag          = "tag"
	flagTo           = "to"
	flagType         = "type"
	flagVote         = "vote"
)

type MultiStringFlagValue []string

func NewMultiStringFlagValue() MultiStringFlagValue {
	arr := make([]string, 0, 3)

	return MultiStringFlagValue(arr)
}

func (v MultiStringFlagValue) String() string {
	return strings.Join(v, ", ")
}

func (v *MultiStringFlagValue) Set(value string) error {
	if len(value) > 0 {
		*v = append(*v, value)
	}

	return nil
}

type MultiIntFlagValue []int

func NewMultiIntFlagValue() MultiIntFlagValue {
	arr := make([]int, 0, 3)

	return MultiIntFlagValue(arr)
}

func (v MultiIntFlagValue) String() string {
	value := "Choices: "

	for ind, vote := range v {
		if ind == len(v)-1 {
			value += strconv.Itoa(vote)
		} else {
			value += strconv.Itoa(vote) + ", "
		}
	}

	return value
}

func (v *MultiIntFlagValue) Set(text string) error {
	value, err := strconv.Atoi(text)
	if err != nil {
		return fmt.Errorf("unable to parse the value to an integer: %w", err)
	}

	*v = append(*v, value)

	return nil
}

type TimeDurationFlagValue struct {
	Duration time.Duration
}

func NewTimeDurationFlagValue() TimeDurationFlagValue {
	return TimeDurationFlagValue{
		Duration: 0 * time.Second,
	}
}

func (v TimeDurationFlagValue) String() string {
	return "Time duration: " + v.Duration.String()
}

func (v *TimeDurationFlagValue) Set(text string) error {
	duration, err := time.ParseDuration(text)
	if err != nil {
		return fmt.Errorf("unable to parse the value as time duration: %w", err)
	}

	v.Duration = duration

	return nil
}

type BoolPtrFlagValue struct {
	Value *bool
}

func NewBoolPtrFlagValue() BoolPtrFlagValue {
	return BoolPtrFlagValue{
		Value: nil,
	}
}

func (b BoolPtrFlagValue) String() string {
	if b.Value == nil {
		return "NOT SET"
	}

	return strconv.FormatBool(*b.Value)
}

func (b *BoolPtrFlagValue) Set(value string) error {
	boolVar, err := strconv.ParseBool(value)
	if err != nil {
		return fmt.Errorf("unable to parse %q as a boolean value: %w", value, err)
	}

	b.Value = new(bool)
	*b.Value = boolVar

	return nil
}