ggen

type CommandFilter string

type Comment struct {
	Doc *ast.CommentGroup

	Comment *ast.CommentGroup

	Directives []Directive
}

type Config struct {
	Plugins []Plugin

	// Map of enabled plugins. Leave this nil to enable all plugins.
	EnabledPlugins map[string]bool

	// default to "zz_generated.{{.Name}}.go"
	GenerateFileName func(GenerateFileNameInput) string

	CleanOnly bool

	Namespace string

	GoimportsArgs []string

	BuildTags []string

	LogLevel   LogLevel
	LogHandler LogHandler
}

type DefaultQualifier struct{}

type Directive struct {
	Raw string // +foo:pkg:foo this is a string
	Cmd string // foo:pkg
	Arg string // sample,baz

	Item Positioner // the item that the directive is attached to
}

type Directives []Directive

type Engine interface {

	// Plugin should use the embedded logger to log messages.
	Logger

	// GenerateEachPackage loops through the list of GeneratingPackages and call the given function.
	GenerateEachPackage(func(Engine, *packages.Package, Printer) error) error

	// GeneratingPackages returns a list of packages available for generating.
	GeneratingPackages() []*GeneratingPackage

	// GeneratePackage generates file at given package path with the given file name. The file name must not include any slash character (/). If fileName is empty, use default file name.
	GeneratePackage(pkg *packages.Package, fileName string) (Printer, error)

	// GenerateFile generates file at given path. It should be an absolute path, can include slash character (/). If the path ends with /, use default file name.
	GenerateFile(pkgName, filePath string) (Printer, error)

	GetComment(Positioner) Comment
	GetDirectives(Positioner) Directives
	GetDirectivesByPackage(*packages.Package) Directives
	GetIdent(Positioner) *ast.Ident
	GetObject(Positioner) types.Object
	GetObjectByName(pkgPath, name string) types.Object
	GetBuiltinType(name string) types.Type
	GetObjectsByPackage(*packages.Package) []types.Object
	GetObjectsByScope(*types.Scope) []types.Object
	GetPackage(Positioner) *packages.Package
	GetPackageByPath(string) *packages.Package

	LogDebugNode(node ast.Node) error
}

type FilterEngine interface {

	// Plugin should use the embedded logger to log messages.
	Logger

	// IncludePackage indicates that the given package will be included for generating. It will be returned later in
	// Engine.GeneratingPackages(). If it does not exist, an error with be returned later.
	IncludePackage(pkgPath string)

	// ParsePackage indicates that the given package should be parsed. If it does not exist, an error with be returned
	// later.
	//
	// Sometimes, the plugin depends on some specific package that are not transitive imported by IncludePackage. In
	// this case, the plugin can call ParsePackage to parse these packages. This should happen sparsely and not all
	// plugins need to call this function.
	ParsePackage(pkgPath string)

	// ParsePackages takes a pattern and add the matched packages to ParsingPackages. Pattern is the go package pattern:
	//
	//     example.com/...
	//     github.com/path/...
	//
	// ParsePackages indicates that the given package pattern should be parsed. If the pattern does not match any
	// package, an error with be returned later.
	//
	// Sometimes, the plugin depends on some specific package that are not transitive imported by IncludePackage. In
	// this case, the plugin can call ParsePackage to parse these packages. This should happen sparsely and not all
	// plugins need to call this function.
	//
	// A program may require many packages. So it's best to only include packages related to your work. For example if
	// all your packages are put under github.com/yourcompany, it's recommended to call
	// ParsePackages("github.com/yourcompany/...") to avoid parsing unnecessary packages. Or if your plugin only care
	// about protobuf files, you can call ParsePackages("github.com/yourcompany/models/protobuf/...") to include only
	// protobuf generated packages.
	ParsePackages(patterns ...string)

	// ParsingPackages returns a list of packages that are processing. The plugin can can use
	// FilteringPackage.Directives or FilteringPackage.Imports to determine which packages should be available to
	// Generate, then calls IncludePackage on those packages.
	ParsingPackages() []*FilteringPackage
}

type Filterer interface {
	Filter(FilterEngine) error
}

type FilteringPackage struct {
	PkgPath          string
	Imports          map[string]*packages.Package
	Directives       Directives
	InlineDirectives Directives
	// contains filtered or unexported fields
}

type GenerateFileNameInput struct {
	PluginName string
}

type GeneratingPackage struct {
	*packages.Package
	// contains filtered or unexported fields
}

type LogAttr = logging.Attr

type LogHandler = logging.Handler

type LogLevel = logging.Level

type Logger = logging.Logger

type Plugin interface {

	// Name returns name of the plugin. Each plugin must have a different name.
	Name() string

	// Filter is called to determine which packages will be parsed and which will be skipped. It will be called before
	// Generate. It received a FilterEngine and need to call the following methods:
	//
	//     ParsingPackages: Get a list of all packages available for IncludePackage.
	//                      The plugin can only include packages in this list.
	//     IncludePackage:  Make the package available for Generate.
	Filter(FilterEngine) error

	// Generate is called to actually generate code for the given packages. Only packages passed to
	// FilterEngine.IncludePackage are available for Generate.
	Generate(Engine) error
}

type Positioner interface {
	Pos() token.Pos
}

type Printer interface {
	FilePath() string
	Import(name, path string)
	Qualifier(pkg *types.Package) string
	TypeString(types.Type) string
	Bytes() []byte

	io.WriteCloser
}

type Qualifier interface {
	Qualify(*types.Package) string
}