requirementsourcemodel

Documentation

Index

• func ErrorCode(err error) string
• func ValidateLimits(value Limits) error
• type AtomicProjection
• type AtomicRequirement
• type ByteRange
• type ClaimLevel
• type Deferral
• type Derivation
• type Draft
• type EntityKind
• type Example
• type Field
  • func Own[T any](value T) Field[T]
• type FieldOwner
• type GitBlobRef
• type Group
• type LayoutProjection
• type Lifecycle
• type LifecycleState
• type Limits
  • func DefaultLimits() Limits
• type Member
• type MetadataFieldID
• type MetadataFields
• type MetadataOwnerKind
• type Model
  • func Normalize(draft Draft) (Model, error)
  • func NormalizeWithLimits(draft Draft, limits Limits) (Model, error)
  • func (model Model) Atomic() AtomicProjection
  • func (model Model) Layout() LayoutProjection
  • func (model Model) References() ReferenceProjection
• type NonClaimDefinition
• type ObjectFormat
• type Origin
• type Profile
• type ReferenceEdge
• type ReferenceEndpoint
• type ReferenceKind
• type ReferenceProjection
• type RiskClass
• type Scenario
• type ScenarioValue
• type SourceKind
• type TermKind
• type UpdatePolicy
• type ValidationError
  • func (err *ValidationError) Error() string
• type VocabularyTerm

Functions

func ErrorCode

func ErrorCode(err error) string

func ValidateLimits

func ValidateLimits(value Limits) error

Types

type AtomicProjection

type AtomicProjection struct {
	SourceID            string
	SpecPackagePath     string
	SourceNonClaimRefs  []string
	NonClaimDefinitions []NonClaimDefinition
	Vocabulary          []VocabularyTerm
	Requirements        []AtomicRequirement
	Scenarios           []Scenario
}

type AtomicRequirement

type AtomicRequirement struct {
	RequirementID  string
	Invariant      string
	SharedPremises []string
	OwnerID        string
	ClaimLevel     ClaimLevel
	RiskClass      RiskClass
	NonClaimRefs   []string
	Lifecycle      Lifecycle
	Deferral       *Deferral
	UpdatePolicy   UpdatePolicy
}

type ByteRange

type ByteRange struct {
	Start int64
	End   int64
}

type ClaimLevel

type ClaimLevel string

const (
	ClaimAdvisory ClaimLevel = "advisory"
	ClaimBlocking ClaimLevel = "blocking"
	ClaimDeferred ClaimLevel = "deferred"
)

type Deferral

type Deferral struct {
	OwnerID         string
	RiskAcceptedBy  string
	ReviewCondition string
	ExpiryRef       string
	MergePolicy     string
	EvidenceRefs    []string
}

type Derivation

type Derivation struct {
	DerivationID   string
	SourceKind     SourceKind
	SourceRef      GitBlobRef
	Selector       ByteRange
	RequirementIDs []string
	NonClaimRefs   []string
}

type Draft

type Draft struct {
	SourceID            string
	SpecPackagePath     string
	SourceNonClaimRefs  []string
	NonClaimDefinitions []NonClaimDefinition
	Vocabulary          []VocabularyTerm
	Derivations         []Derivation
	Profiles            []Profile
	Groups              []Group
	Scenarios           []Scenario
}

type EntityKind

type EntityKind string

const (
	EntityDerivation  EntityKind = "derivation"
	EntityGroup       EntityKind = "group"
	EntityNonClaim    EntityKind = "nonclaim"
	EntityProfile     EntityKind = "profile"
	EntityRequirement EntityKind = "requirement"
	EntityScenario    EntityKind = "scenario"
	EntitySource      EntityKind = "source"
	EntityTerm        EntityKind = "term"
)

type Example

type Example struct {
	ExampleID string
	Values    map[string]ScenarioValue
}

type Field

type Field[T any] struct {
	Present bool
	Value   T
}

Field represents one lexical owner of an effective metadata value. Present distinguishes an omitted field from a present zero or nullable value.

func Own

func Own[T any](value T) Field[T]

type FieldOwner

type FieldOwner struct {
	FieldID   MetadataFieldID
	OwnerKind MetadataOwnerKind
	OwnerID   string
}

type GitBlobRef

type GitBlobRef struct {
	ObjectFormat ObjectFormat
	CommitOID    string
	Path         string
	SHA256       string
}

type Group

type Group struct {
	GroupID        string
	ProfileID      string
	StatementStem  string
	SharedPremises []string
	Members        []Member
}

type LayoutProjection

type LayoutProjection struct {
	SourceID string
	Profiles []Profile
	Groups   []Group
	Origins  []Origin
}

type Lifecycle

type Lifecycle struct {
	State                     LifecycleState
	ReplacementRequirementIDs []string
	EvidenceRefs              []string
}

type LifecycleState

type LifecycleState string

const (
	LifecycleActive     LifecycleState = "active"
	LifecycleDeprecated LifecycleState = "deprecated"
	LifecycleRemoved    LifecycleState = "removed"
	LifecycleSuperseded LifecycleState = "superseded"
)

type Limits

type Limits struct {
	MaxDefinitions             int
	MaxDerivations             int
	MaxExamples                int
	MaxExamplesPerScenario     int
	MaxCollectionItems         int
	MaxExpandedItems           int
	MaxExpandedTextBytes       int
	MaxGroups                  int
	MaxMembers                 int
	MaxMembersPerGroup         int
	MaxProfiles                int
	MaxScenarioEvaluations     int
	MaxScenarioEvaluationBytes int
	MaxScenarios               int
	MaxTerms                   int
	MaxTotalTextBytes          int
}

func DefaultLimits

func DefaultLimits() Limits

type Member

type Member struct {
	RequirementID       string
	StatementCompletion string
	Fields              MetadataFields
}

type MetadataFieldID

type MetadataFieldID string

type MetadataFields

type MetadataFields struct {
	OwnerID      Field[string]
	ClaimLevel   Field[ClaimLevel]
	RiskClass    Field[RiskClass]
	NonClaimRefs Field[[]string]
	Lifecycle    Field[Lifecycle]
	Deferral     Field[*Deferral]
	UpdatePolicy Field[UpdatePolicy]
}

type MetadataOwnerKind

type MetadataOwnerKind string

const (
	MetadataOwnerMember  MetadataOwnerKind = "member"
	MetadataOwnerProfile MetadataOwnerKind = "profile"
)

type Model

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

Model owns the admitted normalized value. Its fields remain private so a caller cannot mutate the owner snapshot through a returned slice or map.

func Normalize

func Normalize(draft Draft) (Model, error)

func NormalizeWithLimits

func NormalizeWithLimits(draft Draft, limits Limits) (Model, error)

func (Model) Atomic

func (model Model) Atomic() AtomicProjection

func (Model) Layout

func (model Model) Layout() LayoutProjection

func (Model) References

func (model Model) References() ReferenceProjection

type NonClaimDefinition

type NonClaimDefinition struct {
	NonClaimID string
	Statement  string
}

type ObjectFormat

type ObjectFormat string

const (
	ObjectSHA1   ObjectFormat = "sha1"
	ObjectSHA256 ObjectFormat = "sha256"
)

type Origin

type Origin struct {
	RequirementID string
	GroupID       string
	ProfileID     string
	FieldOwners   []FieldOwner
}

type Profile

type Profile struct {
	ProfileID string
	Fields    MetadataFields
}

type ReferenceEdge

type ReferenceEdge struct {
	Kind ReferenceKind
	From ReferenceEndpoint
	To   ReferenceEndpoint
}

type ReferenceEndpoint

type ReferenceEndpoint struct {
	Kind EntityKind
	ID   string
}

type ReferenceKind

type ReferenceKind string

const (
	ReferenceDerivationNonClaim    ReferenceKind = "derivation_nonclaim"
	ReferenceDerivationRequirement ReferenceKind = "derivation_requirement"
	ReferenceGroupMember           ReferenceKind = "group_member"
	ReferenceGroupProfile          ReferenceKind = "group_profile"
	ReferenceLifecycleReplacement  ReferenceKind = "lifecycle_replacement"
	ReferenceRequirementNonClaim   ReferenceKind = "requirement_nonclaim"
	ReferenceScenarioNonClaim      ReferenceKind = "scenario_nonclaim"
	ReferenceScenarioRequirement   ReferenceKind = "scenario_requirement"
	ReferenceScenarioVocabulary    ReferenceKind = "scenario_vocabulary"
	ReferenceSourceNonClaim        ReferenceKind = "source_nonclaim"
)

type ReferenceProjection

type ReferenceProjection struct {
	SourceID    string
	Derivations []Derivation
	Edges       []ReferenceEdge
}

type RiskClass

type RiskClass string

const (
	RiskCritical RiskClass = "critical"
	RiskHigh     RiskClass = "high"
	RiskLow      RiskClass = "low"
	RiskMedium   RiskClass = "medium"
)

type Scenario

type Scenario struct {
	ScenarioID            string
	RequirementIDs        []string
	Parameters            []string
	Preconditions         []string
	ActionSequence        []string
	ExpectedObservations  []string
	ForbiddenObservations []string
	Examples              []Example
	VocabularyRefs        []string
	NonClaimRefs          []string
}

type ScenarioValue

type ScenarioValue string

type SourceKind

type SourceKind string

const (
	SourceClarification SourceKind = "clarification"
	SourceCodeSnapshot  SourceKind = "code_snapshot"
	SourceDesign        SourceKind = "design"
	SourceOwnerDecision SourceKind = "owner_decision"
	SourcePlan          SourceKind = "plan"
)

type TermKind

type TermKind string

const (
	TermAction     TermKind = "action"
	TermObservable TermKind = "observable"
	TermState      TermKind = "state"
	TermSubject    TermKind = "subject"
	TermValue      TermKind = "value"
)

type UpdatePolicy

type UpdatePolicy struct {
	ReviewOwnerID              string
	RequiresImpactDeclaration  bool
	RequiresProofBindingReview bool
}

type ValidationError

type ValidationError struct {
	Code string
	Path string
}

func (*ValidationError) Error

func (err *ValidationError) Error() string

type VocabularyTerm

type VocabularyTerm struct {
	TermID     string
	Kind       TermKind
	Label      string
	Definition string
}