policy

type Classification struct {
	Import string
	Group  string

	// Pattern is the winning pattern as the policy author wrote it, and
	// PatternNumber its position in declaration order across the whole policy.
	Pattern       string
	PatternNumber int

	// AlsoMatched lists patterns declared after the winner that would also
	// have matched. Under first-match-wins these are shadowed, and being able
	// to see them is what makes an ordering mistake findable.
	AlsoMatched []PatternMatch
}

type Diagnostic struct {
	Message string
}

type Effective struct {
	PolicySource string
	Module       string
	RepoType     string
	TypeDetected bool
	ConfigPath   string
	Strict       bool

	Scopes      []ScopeVerdict
	LayerMode   Mode
	LayerOrder  string
	LayerForbid []ForbidEdge
}

type Expectation struct {
	Import string
	Module string
	Group  string
	Type   string
}

type ExpectationResult struct {
	Expectation Expectation
	Subject     string
	Want        string
	Got         string
	Passed      bool
	Err         string
}

type Explanation struct {
	Import         string
	Module         string
	RepoType       string
	TypeDetected   bool
	Classification Classification

	// Scopes reports the verdict in each scope, because the same import can
	// be legitimate in a test and forbidden in production code.
	Scopes []ScopeVerdict
}

type Finding struct {
	Rule string
	Mode Mode

	File     string
	Line     int
	Package  string
	Scope    string
	Import   string
	Manifest bool

	// Group is set for import findings.
	Group string
	// FromRole and ToRole are set for layer findings.
	FromRole string
	ToRole   string

	Message string
	// Fix names the shape of the remedy where one can be stated honestly.
	Fix string
}

type ForbidEdge struct {
	From   string
	To     string
	Reason string
}

type Format string

type Group struct {
	Name     string
	Patterns []Pattern
}

type Layers struct {
	Mode Mode
	// UnknownRole says what to do with a package whose name matches no role.
	// "ignore" is the sane default while a fleet still has packages that
	// predate the convention.
	UnknownRole string
	Roles       []RoleRule
	// Order runs from the outermost layer to the innermost. A package may
	// import its own layer and any layer below it, never above.
	Order [][]string
	// Forbid names individual role edges that are refused even though the
	// layer order permits them. The depth rule alone cannot express "delivery
	// must go through the facade", because api → dal does travel downward;
	// stating such edges explicitly keeps the exception visible in the policy
	// rather than hidden in the tool.
	Forbid []ForbidEdge
}

type Mode string

type Module struct {
	Path string
	Dir  string

	References []Reference

	// Unparseable lists files that could not be parsed. They are reported
	// rather than swallowed: a file the scanner cannot read is a hole in the
	// check, and a hole that stays quiet is worse than one that does not.
	Unparseable []string
}

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

type PatternMatch struct {
	Group   string
	Pattern string
	Number  int
}

type Policy struct {
	// Source records where the document was loaded from, so `show` can tell a
	// repository what it is actually being held to.
	Source string

	Groups []Group
	Types  []RepoType
	Layers Layers

	Expectations []Expectation
}

type Reference struct {
	// Import is the imported path, or the required module path for a manifest
	// requirement.
	Import string
	// File is slash-separated and relative to the module directory.
	File string
	// Line is 1-indexed; 0 for a manifest requirement with no useful position.
	Line int
	// Package is the directory the importing file lives in, relative to the
	// module directory. Empty means the module root.
	Package string
	// Scope is source or tests.
	Scope string
	// Manifest marks a go.mod requirement rather than a source import.
	Manifest bool
}

type RepoConfig struct {
	// Found is false when the repository has no config file at all.
	Found bool
	// Path is where the config was read from.
	Path string

	Policy string
	Type   string
	// Strict promotes report-mode rules to errors for this repository only.
	// It is the single permitted local change, and it can only tighten.
	Strict bool
}

type RepoType struct {
	Name   string
	Detect []Pattern
	Scopes map[string]Scope
}

type Result struct {
	Module Module
	Policy Policy
	// Type is the repository type the rules were taken from.
	Type string
	// TypeDetected records whether Type came from detection or was declared.
	TypeDetected bool

	Findings []Finding
}

type RoleRule struct {
	Role     string
	Patterns []Pattern
}

type Scope struct {
	Allow []string
}

type ScopeVerdict struct {
	Scope   string
	Allowed bool
	Allow   []string
}

type Source struct {
	Raw  string
	Kind SourceKind

	Owner string
	Repo  string
	Path  string
	URL   string
}

type SourceKind string