validation

type ChainedLicenseResolver struct {
	LicenseResolvers []LicenseResolver
}

type ChainedTranslator struct {
	Translators []Translator
}

type ErrBlacklistedModule struct {
	Module  LicensedModule
	Matcher ModuleMatcher
}

type ErrDeniedLicense struct {
	Module LicensedModule
}

type License struct {
	// Name is a human-readable name
	Name string

	// SPDXID is a SPDX license id
	SPDXID string
}

type LicenseResolver interface {
	// ResolveLicense resolves license for module
	// It should return ErrUnknownLicense if module contains unknown license (not found in db-s)
	ResolveLicense(ctx context.Context, m Module) (License, error)
}

type LicenseResolverMock struct {
	mock.Mock
}

type LicensedModule struct {
	Module
	License License
}

type Module struct {
	Name    string
	Version *semver.Version
}

type ModuleMatcher struct {
	Name    *regexp.Regexp
	Version *semver.Constraints
}

type NotifyingValidator struct {
	NotifyingValidatorParams
	// contains filtered or unexported fields
}

type NotifyingValidatorParams struct {
	Validator              Validator
	UnknownLicenseAction   UnknownLicenseAction
	UnknownLicenseNotifier UnknownLicenseNotifier
}

type RuleSet struct {
	// WhitelistedModules always gives positive validation result
	WhitelistedModules []ModuleMatcher

	// BlacklistedModules always gives negative validation result
	BlacklistedModules []ModuleMatcher

	// AllowedLicenses contains set of allowed licenses
	// If provided only modules with matched license will be allowed
	AllowedLicenses []License

	// DeniedLicenses contains set of denied licenses
	DeniedLicenses []License
}

type RuleSetValidator struct {
	RuleSetValidatorParams
	// contains filtered or unexported fields
}

type RuleSetValidatorParams struct {
	Translator      Translator
	LicenseResolver LicenseResolver
	RuleSet         RuleSet
}

type Translator interface {
	// Translate attempts to remap module name
	// Example case rsc.io/pdf -> github.com/rsc/pdf
	// Implementation should return original Module if translation wasn't made
	Translate(ctx context.Context, m Module) (translated Module, err error)
}

type TranslatorMock struct {
	mock.Mock
}

type UnknownLicenseAction int

type UnknownLicenseNotifier interface {
	// NotifyUnknownLicense triggered if unknown license found and UnknownLicenseWarn is set
	NotifyUnknownLicense(ctx context.Context, m Module) error
}

type UnknownLicenseNotifierMock struct {
	mock.Mock
}

type Validator interface {
	Validate(ctx context.Context, m Module) error
}

type ValidatorMock struct {
	mock.Mock
}