added find flag

Author: zeb33n

cmd/bom/cmd/document_outline.go

@@ -54,6 +54,9 @@ set the --spdx-ids to only output the IDs of the entities.
 			if err != nil {
 				return fmt.Errorf("opening doc: %w", err)
 			}
+			if outlineOpts.Find != "" {
+				doc.FilterReverseDependencies(outlineOpts.Find, outlineOpts.Recursion)
+			}
 			output, err := doc.Outline(outlineOpts)
 			if err != nil {
 				return fmt.Errorf("generating document outline: %w", err)
@@ -89,6 +92,13 @@ set the --spdx-ids to only output the IDs of the entities.
 		false,
 		"show package urls instead of name@version",
 	)
+	outlineCmd.PersistentFlags().StringVarP(
+		&outlineOpts.Find,
+		"find",
+		"f",
+		"",
+		"Find node in DAG",
+	)
 
 	parent.AddCommand(outlineCmd)
 }

pkg/spdx/document.go

@@ -131,6 +131,7 @@ type DrawingOptions struct {
 	ASCIIOnly   bool
 	Purls       bool
 	Version     bool
+	Find        string
 }
 
 // String returns the SPDX string of the external document ref.
@@ -313,6 +314,19 @@ func treeLines(o *DrawingOptions, depth int, connector string) string {
 	return res
 }
 
+// FilterReverseDependencies filters the document to only include direct paths to
+// Objects with the name name. Hence finding that Object's reverse dependencies.
+func (d *Document) FilterReverseDependencies(name string, depth int) {
+	keepPackages := map[string]*Package{}
+	for packageName, p := range d.Packages {
+		if !recursiveNameFilter(name, p, depth, &map[string]bool{}) {
+			continue
+		}
+		keepPackages[packageName] = p
+	}
+	d.Packages = keepPackages
+}
+
 // Outline draws an outline of the relationships inside the doc.
 func (d *Document) Outline(o *DrawingOptions) (outline string, err error) {
 	seen := map[string]struct{}{}

pkg/spdx/object.go

@@ -46,9 +46,11 @@ type Object interface {
 	SetEntity(*Entity)
 	AddRelationship(*Relationship)
 	GetRelationships() *[]*Relationship
+	FilterRelationships(filter func(r *Relationship) bool)
 	ToProvenanceSubject() *intoto.Subject
 	getProvenanceSubjects(opts *ProvenanceOptions, seen *map[string]struct{}) []intoto.Subject
 	GetElementByID(string) Object
+	GetName() string
 }
 
 type Entity struct {
@@ -79,6 +81,11 @@ func (e *Entity) SPDXID() string {
 	return e.ID
 }
 
+// GetName returns the Objects name as a string.
+func (e *Entity) GetName() string {
+	return e.Name
+}
+
 // SPDXID returns the SPDX reference string for the object.
 func (e *Entity) SetSPDXID(id string) {
 	e.ID = id
@@ -155,6 +162,21 @@ func (e *Entity) GetRelationships() *[]*Relationship {
 	return &e.Relationships
 }
 
+// FilterRelationships filters relationships according to a filter function.
+// On a true the relationship is kept, on a false the relationship is dropped.
+func (e *Entity) FilterRelationships(filter func(r *Relationship) bool) {
+	keepRelationships := []*Relationship{}
+	for _, rel := range e.Relationships {
+		if filter(rel) {
+			keepRelationships = append(keepRelationships, rel)
+		}
+	}
+	if len(keepRelationships) == 0 {
+		keepRelationships = nil
+	}
+	e.Relationships = keepRelationships
+}
+
 // ToProvenanceSubject converts the element to an intoto subject, suitable
 // to use inprovenance attestaions.
 func (e *Entity) ToProvenanceSubject() *intoto.Subject {

pkg/spdx/package.go

@@ -401,7 +401,11 @@ func (p *Package) Draw(builder *strings.Builder, o *DrawingOptions, depth int, s
 		connector = connectorL
 	}
 
-	fmt.Fprintf(builder, treeLines(o, depth, connector)+"🔗 %d Relationships\n", len(p.Relationships))
+	// not printed when find is set since relationships will be filtered out from the graph.
+	if o.Find == "" {
+		fmt.Fprintf(builder, treeLines(o, depth, connector)+"🔗 %d Relationships\n", len(p.Relationships))
+	}
+
 	if depth >= o.Recursion && o.Recursion > 0 {
 		fmt.Fprintln(builder, treeLines(o, depth-1, ""))
 		return

pkg/spdx/spdx.go

@@ -264,6 +264,32 @@ func Banner() string {
 	return string(d)
 }
 
+// recursiveNameFilter is a function that recursivley filters an objects peers inplace
+// to include only those that are on a direct path to another object with the queried name.
+// If one or more path is found it returns true.
+//
+//nolint:gocritic // seen is a pointer recursively populated
+func recursiveNameFilter(name string, o Object, depth int, seen *map[string]bool) bool {
+	if o.GetName() == name {
+		o.FilterRelationships(func(_ *Relationship) bool { return false })
+		return true
+	}
+	// searched to the max depth and name not found
+	if depth == 1 {
+		return false
+	}
+	if out, ok := (*seen)[o.SPDXID()]; ok {
+		return out
+	}
+	filter := func(r *Relationship) bool {
+		return recursiveNameFilter(name, r.Peer, depth-1, seen)
+	}
+	o.FilterRelationships(filter)
+	out := len(*o.GetRelationships()) != 0
+	(*seen)[o.SPDXID()] = out
+	return out
+}
+
 // recursiveIDSearch is a function that recursively searches an object's peers
 // to find the specified SPDX ID. If found, returns a copy of the object.
 //

pkg/spdx/spdx_unit_test.go

@@ -25,6 +25,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -416,6 +417,90 @@ func TestIgnorePatterns(t *testing.T) {
 	require.Len(t, p, 4)
 }
 
+func TestRecursiveNameFilter(t *testing.T) {
+	/*
+		create the starting package structure
+
+		root-p
+		|
+		|-target-p-0
+		| |-sub-p-0
+		|
+		|-sub-p-1
+		| |-target-p-1
+		| |-sub-p-2
+		|
+		|-sub-p-3
+	*/
+	packageIDs := []string{"root-p"}
+	for i := range 3 {
+		packageIDs = append(packageIDs, fmt.Sprintf("target-p-%d", i))
+	}
+	for i := range 7 {
+		packageIDs = append(packageIDs, fmt.Sprintf("sub-p-%d", i))
+	}
+	edges := []struct {
+		p string
+		c string
+	}{
+		{"root-p", "target-p-0"},
+		{"root-p", "sub-p-1"},
+		{"root-p", "sub-p-3"},
+		{"target-p-0", "sub-p-0"},
+		{"sub-p-1", "target-p-1"},
+		{"sub-p-1", "sub-p-2"},
+	}
+	packages := map[string]*Package{}
+	for _, id := range packageIDs {
+		p := NewPackage()
+		p.SetSPDXID(id)
+		p.Name = strings.Join(strings.Split(id, "-")[:2], "-")
+		packages[id] = p
+	}
+
+	for _, edge := range edges {
+		require.NoError(t, packages[edge.p].AddPackage(packages[edge.c]))
+	}
+
+	/*
+		create the expected package structure
+
+		root-p
+		|
+		|-target-p-0
+	*/
+	ePackageIDs := []string{"root-p", "target-p-0"}
+	eEdges := []struct {
+		p string
+		c string
+	}{
+		{"root-p", "target-p-0"},
+	}
+	ePackages := map[string]*Package{}
+	for _, id := range ePackageIDs {
+		p := NewPackage()
+		p.SetSPDXID(id)
+		p.Name = strings.Join(strings.Split(id, "-")[:2], "-")
+		ePackages[id] = p
+	}
+
+	for _, edge := range eEdges {
+		require.NoError(t, ePackages[edge.p].AddPackage(ePackages[edge.c]))
+	}
+
+	// filter the starting packages
+	ok := recursiveNameFilter(
+		"target-p",
+		packages["root-p"],
+		2,
+		&map[string]bool{},
+	)
+	require.True(t, ok)
+
+	// check filtered == expected
+	require.Equal(t, ePackages["root-p"], packages["root-p"])
+}
+
 func TestRecursiveSearch(t *testing.T) {
 	p := NewPackage()
 	p.SetSPDXID("p-top")