Function materialsTable

app/cli/cmd/attestation_status.go:188–249

(status *action.AttestationStatusResult, w io.Writer, full bool)

	return nil
}
func materialsTable(status *action.AttestationStatusResult, w io.Writer, full bool) error {
	if len(status.Materials) == 0 {
		return nil
	}

	// Partition materials into standalone (ungrouped) ones and choke groups.
	// Grouped materials are rendered together under a group header so it is
	// clear they form an "at least one of" set rather than independent materials.
	var ungrouped []action.AttestationStatusMaterial
	groupedBy := make(map[string][]action.AttestationStatusMaterial)
	var groupOrder []string
	for _, m := range status.Materials {
		if m.Group == "" {
			ungrouped = append(ungrouped, m)
			continue
		}
		if _, ok := groupedBy[m.Group]; !ok {
			groupOrder = append(groupOrder, m.Group)
		}
		groupedBy[m.Group] = append(groupedBy[m.Group], m)
	}

	byName := func(a, b action.AttestationStatusMaterial) int { return strings.Compare(a.Name, b.Name) }
	slices.SortFunc(ungrouped, byName)
	slices.Sort(groupOrder)

	mt := output.NewTableWriterWithWriter(w)
	mt.SetTitle("Materials")

	for _, m := range ungrouped {
		appendMaterialRows(mt, m, status, full, false)
		mt.AppendSeparator()
	}

	for _, g := range groupOrder {
		members := groupedBy[g]
		slices.SortFunc(members, byName)

		// A choke group is satisfied as soon as one of its members is set.
		satisfied := false
		for _, m := range members {
			if m.Set {
				satisfied = true
				break
			}
		}

		mt.AppendRow(table.Row{"Group", g})
		mt.AppendRow(table.Row{"Rule", fmt.Sprintf("at least one of %d required", len(members))})
		mt.AppendRow(table.Row{"Satisfied", hBool(satisfied)})
		mt.AppendSeparator()

		for _, m := range members {
			appendMaterialRows(mt, m, status, full, true)
			mt.AppendSeparator()
		}
	}