enumizer

déumiseur

L'énuniseur est un outil de ligne de commande pour Golang afin de générer des aides ENUM et de vérifier la couverture de l'énum dans les instructions de commutation.

Installation

 $ go install github.com/neglect-yp/enumizer@latest

Usage

Vous devez ajouter des commentaires de marqueur avant de l'essayer. Voir la section Examples .

 $ enumizer help
enumizer is a command-line tool to generate enum helpers and check enum coverage.

Usage:
  enumizer [command]

Examples:
* Generate enum helpers
  enumizer generate ./...

* Check enum coverage
  enumizer cover ./...

Available Commands:
  completion  Generate the autocompletion script for the specified shell
  cover       Check that switch statements cover all variants of passed enum
  generate    Generate enum helpers that include stringer and validation methods
  help        Help about any command

Flags:
  -h, --help   help for enumizer

Use "enumizer [command] --help" for more information about a command.

Exemples

Ajoutez des commentaires de marqueur comme // enumizer:target au-dessus de vos blocs const pour les variantes de l'énumération.

 package myenum

type MyEnum int

// enumizer:target
const (
	A MyEnum = iota
	B
	C
)

Ensuite, vous pouvez générer des aides en énumération avec enumizer generate ./... Le nom de fichier généré est enumizer.gen.go par défaut. enumizer.gen.go est le suivant:

 // Code generated by enumizer; DO NOT EDIT.
package myenum

import "fmt"

var myEnumSet = map [ MyEnum ] struct {}{
	A : {},
	B : {},
	C : {},
}

func MyEnumList () [] MyEnum {
	ret := make ([] MyEnum , 0 , len ( myEnumSet ))
	for v := range myEnumSet {
		ret = append ( ret , v )
	}
	return ret
}

func ( m MyEnum ) String () string {
	switch m {
	case A :
		return "A"
	case B :
		return "B"
	case C :
		return "C"
	default :
		return "<unknown MyEnum>"
	}
}

func ( m MyEnum ) IsValid () bool {
	_ , ok := myEnumSet [ m ]
	return ok
}

func ( m MyEnum ) Validate () error {
	if ! m . IsValid () {
		return fmt . Errorf ( "MyEnum(%v) is invalid" , m )
	}
	return nil
}

Et vous pouvez vérifier que les instructions de commutation couvrent toutes les variantes de l'énumération passée. Si vous avez du code qui utilise MyEnum , comme les suivants, vous serez averti car il n'y a pas de cas A et C dans l'instruction Switch.

 package myenumuser

import "github.com/neglect-yp/enumizer/examples/myenum"

func Foo ( a myenum. MyEnum ) {
	switch a {
	case myenum . B :
	}
}

$ enumizer cover ./examples/...
/<path to homedir>/enumizer/examples/myenumuser/myenumuser.go:6:2: this switch statement doesn't cover enum variants. missing cases: A, C