v2

v2/dimcli.go

@@ -0,0 +1,107 @@
+package dimcli
+
+import (
+	"fmt"
+	"os"
+	"slices"
+	"strconv"
+)
+
+type Cli struct {
+	Args []string
+	Help bool
+	Indentation int
+}
+
+func NewCli() Cli {
+	var cli = Cli{
+		Args: os.Args[1:],
+		Indentation: 0,
+	}
+	cli.Help = cli.Flag("-h") || cli.Flag("--help")
+	return cli
+}
+
+func (c *Cli) Command(name string) bool {
+	if (c.Help) {
+		c.printIndentation()
+		fmt.Printf("[ cmd ] %v\n", name)
+	}
+	if len(c.Args) == 0 {
+		return false
+	}
+	if c.Args[0] == name {
+		c.Args = c.Args[1:]
+		c.Indentation++
+		return true
+	}
+	return false
+}
+
+func (c Cli) Flag(name string) bool {
+	if c.Help {
+		c.printIndentation()
+		fmt.Printf("[ flg ] %v\n", name)
+		return false
+	}
+	return slices.Contains(c.Args, name)
+}
+
+func (c Cli) printIndentation() {
+	for range c.Indentation {
+		fmt.Printf("\t")
+	}
+}
+
+func (c Cli) String(name string) (string, error) {
+	if c.Help {
+		c.printIndentation()
+		fmt.Printf("[ str ] %v\n", name)
+		return "", nil
+	}
+	var index int
+	for i, arg := range c.Args {
+		if name == arg {
+			index = i+1
+			break
+		}
+	}
+	if len(c.Args) <= index {
+		return "", fmt.Errorf("No value provided after %v", name)
+	}
+	return c.Args[index], nil
+}
+
+func (c Cli) Int(name string) (int64, error) {
+	if c.Help {
+		c.printIndentation()
+		fmt.Printf("[ int ] %v\n", name)
+		return 0, nil
+	}
+	s, err := c.String(name)
+	if err != nil {
+		return 0, err
+	}
+	i, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	return i, nil
+}
+
+func (c Cli) Float(name string) (float64, error) {
+	if c.Help {
+		c.printIndentation()
+		fmt.Printf("[ flt ] %v\n", name)
+		return 0, nil
+	}
+	s, err := c.String(name)
+	if err != nil {
+		return 0, err
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0, err
+	}
+	return f, nil
+}

v2/example/main.go

@@ -1,8 +1,38 @@
 package main
 
-import "github.com/roodletoof/dim-cli/v2"
+import (
+	"fmt"
+
+	"github.com/roodletoof/dim-cli/v2"
+)
 
 func main() {
-	println(dimcli.PackagePath())
-	println(dimcli.FullTypeNameFor[dimcli.Optional[dimcli.Optional[bool]]]())
+	var cli = dimcli.NewCli()
+
+	var fubar = cli.Flag("--fubar")
+	if fubar {
+		println("called with fubar flag")
+	}
+
+	if cli.Command("fu") {
+		f, err := cli.Float("--some-float")
+		if cli.Help { return }
+
+		if err != nil {
+			fmt.Printf("err: %v\n", err)
+			return
+		}
+		fmt.Println(f)
+	} else if cli.Command("bar") {
+		i, err := cli.Int("--some-int")
+		if cli.Help { return }
+		if err != nil {
+			fmt.Printf("err: %v\n", err)
+			return
+		}
+
+		fmt.Println(i)
+	}
+
+	if cli.Help { return }
 }

v2/optional.go

@@ -1,23 +0,0 @@
-package dimcli
-
-type Optional[T any] struct {
-	isSome bool
-	value T
-}
-
-func Some[T any](value T) Optional[T] {
-	return Optional[T]{
-		isSome: true,
-		value: value,
-	}
-}
-
-func None[T any]() Optional[T] {
-	return Optional[T]{
-		isSome: false,
-	}
-}
-
-func (o *Optional[T]) Get() (T, bool) {
-	return o.value, o.isSome
-}

v2/parse.go

@@ -1,70 +0,0 @@
-package dimcli
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"reflect"
-	"slices"
-)
-
-type dummy struct {}
-var thisPackage = reflect.TypeFor[dummy]().PkgPath()
-func PackagePath() string {
-	return thisPackage
-}
-
-var supportedTypesList = []reflect.Type{
-	// special. this is always defaulting to false, and becomes true if
-	// supplied.
-	reflect.TypeFor[bool](),
-	
-
-	// TODO: maybe don't put the optional types here. I think this mapping only
-	// has to exist precicely because of this type, so that you can find the
-	// reflect.Type based on the string within the fully qualified type name.
-	// Not sure though. Will think more about this.
-
-	reflect.TypeFor[int64](),
-	reflect.TypeFor[Optional[int64]](),
-
-	reflect.TypeFor[float64](),
-	reflect.TypeFor[Optional[float64]](),
-
-	reflect.TypeFor[string](),
-	reflect.TypeFor[Optional[string]](),
-}
-var supportedTypesMap = map[string]reflect.Type{}
-func init() {
-	for _, t := range supportedTypesList {
-		supportedTypesMap[FullTypeNameOf(t)] = t
-	}
-}
-
-func FullTypeNameOf(t reflect.Type) string {
-	return fmt.Sprintf("%s.%s", t.PkgPath(), t.Name())
-}
-
-func FullTypeNameFor[T any]() string {
-	return FullTypeNameOf(reflect.TypeFor[T]())
-}
-
-func Parse[T any]() func() error {
-	var args = os.Args[1:]
-	var curr = reflect.TypeFor[T]()
-	for _, arg := range args {
-		var currFields = reflect.VisibleFields(curr)
-		var idx = slices.IndexFunc( currFields, func(f reflect.StructField) bool {
-			return f.Name == arg
-		})
-		if idx == -1 {
-			panic("TODO")
-		}
-	}
-	// TODO print the names of the fields and a help-message
-
-
-	return func() error {
-		return errors.New("TODO")
-	}
-}