evidence

type File ¶

type File struct {
	// Namespace is empty outside federated search. Two repositories can each
	// hold an internal/app/main.go, and those are two files, not one.
	Namespace string
	FilePath  string
	Hits      []Result
}

File is every hit one file answered the query with.

The file is the unit of a search answer because it is the unit of reading: a reader picks a file first and a declaration inside it second. Grouping also removes the old reason to hide hits — ten hits in one file cost one decision, not ten — so a shown file arrives whole.

@intent make the file, not the declaration, the thing a caller chooses between.

func (f File) HitCount() int

type List ¶

type List struct {
	Files        []File
	WeakFiltered int
	// OverflowFiles is how many further files this page did not reach, whether
	// the Limit or the page budget stopped it. It separates "this is
	// everything" from "this is the first ten files of thirty".
	OverflowFiles int
	// Note is set only when Files is empty, and says which kind of empty it is:
	// nothing retrieved, nothing explainable, or a page past the end.
	Note string
}

List is a whole search answer, including what it decided not to show. @intent make "nothing to show" a readable answer rather than an empty array.

func Build(query string, nodes []graph.Node, opts Options) List

func (l List) Hits() []Result

type Match ¶

type Match string

Match names one reason a candidate is in the list. @intent let a reader see which part of a result the query actually touched.

const (
	MatchName   Match = "name"
	MatchPath   Match = "path"
	MatchIntent Match = "intent"
)

type Options ¶

type Options struct {
	Limit  int
	Offset int
	// IncludeWeak keeps candidates no signal explains, after the explainable
	// ones. Off by default, because a list padded with unexplainable results
	// reads as "here are ten answers" when there were two.
	IncludeWeak bool
}

Options are the caller's choices about how wide the list may be. @domainRule Limit and Offset are both counted in files, never in hits, so paging never splits a file. @intent keep the bounds a caller controls — page size, page position, strictness — in one argument.

type Result ¶

type Result struct {
	Node   graph.Node
	Intent string
	// Matched lists every signal the query touched, in a fixed order: name,
	// path, intent. It is empty only for a weak result kept by IncludeWeak.
	Matched []Match
}

Result is one candidate and the case for it. @intent carry a search hit together with the evidence that justifies showing it.