protoc

type DepsResolver func(c *config.Config, ix *resolve.RuleIndex, r *rule.Rule, imports []string, from label.Label)

type File struct {
	Dir      string // e.g. "path/to/package/"
	Basename string // e.g. "foo.proto"
	Name     string // e.g. "foo"
	// contains filtered or unexported fields
}

type FileVisitor interface {
	VisitFile(*rule.File) *rule.File
}

type ImportCrossResolver interface {
	resolve.CrossResolver
	ImportResolver
	ImportProvider

	// LoadFile loads csv file to populate the resolver
	LoadFile(filename string) error
	// SaveFile writes a csv file
	SaveFile(filename, repoName string) error
	// Install adds configured resolve entries into the resolve config.
	Install(c *config.Config)
}

type ImportProvider interface {
	// Provided returns all known provided symbols, by label
	Provided(lang, impLang string) map[label.Label][]string
}

type ImportResolver interface {
	// Resolve returns any previously provided labels associated with the given
	// kind and import.
	Resolve(lang, impLang, imp string) []resolve.FindResult
	// Provide records the association between a rule kind+attr, the value of
	// the attr, and the label that provides the value.
	Provide(lang string, impLang, imp string, location label.Label)
	// Imports takes a callback and iterates all known imports for the given
	// lang/impLang. True should be returned to continue iteration.
	Imports(lang, impLang string, visitor func(imp string, location []label.Label) bool)
}

type ImportResolverOptions struct {
	Printf func(format string, args ...interface{})
	Debug  bool
}

type LanguageConfig struct {
	Name    string
	Protoc  string
	Enabled bool
	Plugins map[string]bool
	Rules   map[string]bool
}

type LanguagePluginConfig struct {
	// Name is the identifier for the configuration object
	Name string
	// Implementation is the identifier for the implementation
	Implementation string
	// Label is the bazel label of the PluginInfo provider
	Label label.Label
	// Options is a set of option strings.
	Options map[string]bool
	// Flags is a set of flag strings.
	Flags map[string]bool
	// Deps is a set of dep labels.  For example, consider a plugin config for
	// 'protoc-gen-go'.  That plugin produces .go files.  The 'Deps' field can
	// be used by downstream Rule implementations to gather necessary
	// dependencies for the .go files produced by that plugin.
	Deps map[string]bool
	// Enabled flag
	Enabled bool
}

type LanguageRule interface {
	// Name returns the name of the rule
	Name() string
	// LoadInfo returns the gazelle LoadInfo.
	LoadInfo() rule.LoadInfo
	// KindInfo returns the gazelle KindInfo.
	KindInfo() rule.KindInfo
	// ProvideRule takes the given configration and compilation and emits a
	// RuleProvider.  If the state of the ProtocConfiguration is such that the
	// rule should not be emitted, implementation should return nil.
	ProvideRule(rc *LanguageRuleConfig, pc *ProtocConfiguration) RuleProvider
}

type LanguageRuleConfig struct {
	// Config is the parent gazelle Config
	Config *config.Config
	// Deps is a mapping from label to +/- intent.
	Deps map[string]bool
	// Attr is a mapping from string to intent map.
	Attrs map[string]map[string]bool
	// Options is a generic key -> value string mapping.  Various rule
	// implementations are free to document/interpret options in an
	// implementation-dependent manner.  TODO: deprecate this and rename to 'Flags'
	Options map[string]bool
	// Resolves is a mapping from resolve mapping spec to rewrite.  Negative
	// intent is represented by the empty rewrite value.
	Resolves []Rewrite
	// Enabled is a flag that marks language generation as enabled or not
	Enabled bool
	// Implementation is the registry identifier for the Rule
	Implementation string
	// Impl is the actual implementation
	Impl LanguageRule
	// Name is the name of the Rule config
	Name string
	// Deps is a mapping from visibility label to +/- intent.
	Visibility map[string]bool
}

type OtherProtoLibrary struct {
	// contains filtered or unexported fields
}

type Package struct {
	// contains filtered or unexported fields
}

type PackageConfig struct {
	// config is the parent gazelle config.
	Config *config.Config
	// contains filtered or unexported fields
}

type Plugin interface {
	// Name is the name of the plugin and its associated configuration.
	Name() string
	// Configure creates the plugin configuration.  If nil is returned, the
	// plugin should be skipped for the current package/library.
	Configure(ctx *PluginContext) *PluginConfiguration
}

type PluginConfiguration struct {
	// Config is the associated plugin configuration.
	Config *LanguagePluginConfig
	// Label is the bazel label for the corresponding proto_plugin rule.
	Label label.Label
	// Mappings is a dictionary that maps filenames listed in Outputs to
	// 'Out'-relative filepaths.  This is used when the plugin writes to a
	// location outside the bazel package and needs to be relocated (copied) to
	// the Output location.
	Mappings map[string]string
	// Options is the list of options that the plugin expects
	Options []string
	// Out is the output directory the plugin is predicted to write to
	Out string
	// Outputs is the list of output files the plugin generates
	Outputs []string
	// Plugin the Plugin implementation that created the configuration.
	Plugin Plugin
}

type PluginContext struct {
	// Rel is the relative path of the package.
	Rel string
	// ProtoLibrary is the proto_library under observation.
	ProtoLibrary ProtoLibrary
	// PackageConfig is the configuration for the package.
	PackageConfig PackageConfig
	// PluginConfig is the configuration object associated with the plugin.
	PluginConfig LanguagePluginConfig
	// Plugin is a reference to the plugin implementation
	Plugin Plugin
}

type PluginOptionsResolver interface {
	ResolvePluginOptions(ctx *PluginConfiguration, r *rule.Rule, from label.Label) []string
}

type PluginRegistry interface {
	// PluginNames returns a sorted list of plugin names.
	PluginNames() []string
	// LookupPlugin returns the implementation under the given name.  If the
	// plugin is not found, ErrUnknownPlugin is returned.
	LookupPlugin(name string) (Plugin, error)
	// MustRegisterPlugin installs a Plugin implementation under the given name
	// in the global plugin registry.  Panic will occur if the same plugin is
	// registered multiple times.
	MustRegisterPlugin(plugin Plugin) PluginRegistry
	// RegisterPlugin installs a Plugin implementation under the given name.
	// Panic will occur if the same plugin is registered multiple times.  The
	// original PluginRegistry API had only the `MustRegisterPlugin` function
	// that always used the plugin.Name(), the newer `RegisterPlugin` allows one
	// to customize the name.
	RegisterPlugin(name string, plugin Plugin) PluginRegistry
}

type ProtoLibrary interface {
	// Name returns the name of the rule (e.g. foo_proto)
	Name() string
	// BaseName returns the name of the rule (e.g. foo).  This is typically
	// derived from the proto file package or name.
	BaseName() string
	// Rule returns the underlying rule
	Rule() *rule.Rule
	// Srcs() returns the relative path of srcs, including args.Rel
	Srcs() []string
	// Deps lists all direct library dependencies.
	Deps() []string
	// Imports lists all direct library proto import filenames.
	Imports() []string
	// StripImportPrefix returns the strip_import_prefix or the empty string.
	StripImportPrefix() string
	// Files returns the list of proto files in the rule.
	Files() []*File
}

type ProtocConfiguration struct {
	// PackageConfig parent
	PackageConfig *PackageConfig
	// The config for the p
	LanguageConfig *LanguageConfig
	// the workspace relative path of the BUILD file where this rule is being
	// generated.
	Rel string
	// the prefix for the rule (e.g. 'java')
	Prefix string
	// the library thar holds the proto files
	Library ProtoLibrary
	// the configuration for the plugins
	Plugins []*PluginConfiguration
	// The merged set of Source files for the compilations
	Outputs []string
	// The merged set of imports for the compilations
	Imports []string
	// The generated source mappings
	Mappings map[string]string
}

type Rewrite struct {
	Match   *regexp.Regexp
	Replace string
}

type RuleIndex interface {
	// Put records the association of the rule under the given label.
	Put(label.Label, *rule.Rule)
	// Get returns the rule under the given label, or nil if not known.
	Get(label.Label) *rule.Rule
}

type RuleProvider interface {
	// Kind of rule e.g. 'proto_library'
	Kind() string
	// Name provides the name of the rule.
	Name() string
	// Rule provides the gazelle rule implementation.  A list of other generating rules in
	// the package are provided.
	Rule(othergen ...*rule.Rule) *rule.Rule
	// Resolve performs deps resolution, similar to the gazelle Resolver
	// interface.  Imports here are always the proto_library file .proto
	// imports.
	Resolve(c *config.Config, ix *resolve.RuleIndex, r *rule.Rule, imports []string, from label.Label)
	// Imports implements part of the Resolver interface
	Imports(c *config.Config, r *rule.Rule, file *rule.File) []resolve.ImportSpec
}

type RuleRegistry interface {
	// RuleNames returns a sorted list of rule names.
	RuleNames() []string
	// LookupRule returns the implementation under the given name.  If the rule
	// is not found, ErrUnknownRule is returned.
	LookupRule(name string) (LanguageRule, error)
	// MustRegisterRule installs a LanguageRule implementation under the given
	// name in the global rule registry.  Panic will occur if the same rule is
	// registered multiple times.
	MustRegisterRule(name string, rule LanguageRule) RuleRegistry
}

type Symbol string

type YConfig struct {
	Plugin         []*YPlugin   `yaml:"plugins"`
	Rule           []*YRule     `yaml:"rules"`
	Language       []*YLanguage `yaml:"languages"`
	StarlarkPlugin []string     `yaml:"starlarkPlugins"`
	StarlarkRule   []string     `yaml:"starlarkRules"`
}

type YLanguage struct {
	Name           string   `yaml:"name"`
	Implementation string   `yaml:"implementation"`
	Enabled        *bool    `yaml:"enabled,omitempty"`
	Plugin         []string `yaml:"plugins"`
	Rule           []string `yaml:"rules"`
}

type YPlugin struct {
	Name           string   `yaml:"name"`
	Implementation string   `yaml:"implementation"`
	Enabled        *bool    `yaml:"enabled,omitempty"`
	Option         []string `yaml:"options"`
	Flag           []string `yaml:"flags"`
	Dep            []string `yaml:"deps"`
	Label          string   `yaml:"label"`
}

type YRule struct {
	Name           string   `yaml:"name"`
	Implementation string   `yaml:"implementation"`
	Enabled        *bool    `yaml:"enabled,omitempty"`
	Deps           []string `yaml:"deps"`
	Resolves       []string `yaml:"resolves"`
	Option         []string `yaml:"options"`
	Visibility     []string `yaml:"visibility"`
}