func edgeKindLess(kind1, kind2 string) bool { // General ordering: // anchor edge kinds before non-anchor edge kinds // forward edges before reverse edges // edgeOrdering[i] (and variants) before edgeOrdering[i+1:] // edge variants after root edge kind (ordered lexicographically) // otherwise, order lexicographically if kind1 == kind2 { return false } else if a1, a2 := edges.IsAnchorEdge(kind1), edges.IsAnchorEdge(kind2); a1 != a2 { return a1 } else if d1, d2 := edges.IsForward(kind1), edges.IsForward(kind2); d1 != d2 { return d1 } kind1, kind2 = edges.Canonical(kind1), edges.Canonical(kind2) for _, kind := range edgeOrdering { if kind1 == kind { return true } else if kind2 == kind { return false } else if v1, v2 := edges.IsVariant(kind1, kind), edges.IsVariant(kind2, kind); v1 != v2 { return v1 } else if v1 { return kind1 < kind2 } } return kind1 < kind2 }
// expandEdgeKind prefixes unrooted (not starting with "/") edge kinds with the // standard Kythe edge prefix ("/kythe/edge/"). func expandEdgeKind(kind string) string { ck := edges.Canonical(kind) if strings.HasPrefix(ck, "/") { return kind } expansion := edges.Prefix + ck if edges.IsReverse(kind) { return edges.Mirror(expansion) } return expansion }
func a2a(a *srvpb.ExpandedAnchor, anchorText bool) *xpb.Anchor { var text string if anchorText { text = a.Text } return &xpb.Anchor{ Ticket: a.Ticket, Kind: edges.Canonical(a.Kind), Parent: a.Parent, Text: text, Start: p2p(a.Span.Start), End: p2p(a.Span.End), Snippet: a.Snippet, SnippetStart: p2p(a.SnippetSpan.Start), SnippetEnd: p2p(a.SnippetSpan.End), } }
func completeAnchors(ctx context.Context, xs xrefs.GraphService, retrieveText bool, files map[string]*fileNode, edgeKind string, anchors []string) ([]*xpb.CrossReferencesReply_RelatedAnchor, error) { edgeKind = edges.Canonical(edgeKind) // AllEdges is relatively safe because each anchor will have very few parents (almost always 1) reply, err := xrefs.AllEdges(ctx, xs, &gpb.EdgesRequest{ Ticket: anchors, Kind: []string{edges.ChildOf}, Filter: []string{ facts.NodeKind, schema.AnchorLocFilter, schema.SnippetLocFilter, }, }) if err != nil { return nil, err } allNodes := xrefs.NodesMap(reply.Nodes) var result []*xpb.CrossReferencesReply_RelatedAnchor for ticket, es := range reply.EdgeSets { if nodeKind := string(allNodes[ticket][facts.NodeKind]); nodeKind != nodes.Anchor { log.Printf("Found non-anchor target to %q edge: %q (kind: %q)", edgeKind, ticket, nodeKind) continue } // Parse anchor location start/end facts so, eo, err := getSpan(allNodes[ticket], facts.AnchorStart, facts.AnchorEnd) if err != nil { log.Printf("Invalid anchor span for %q: %v", ticket, err) continue } // For each file parent to the anchor, add an Anchor to the result. for kind, g := range es.Groups { if kind != edges.ChildOf { continue } for _, edge := range g.Edge { parent := edge.TargetTicket if parentKind := string(allNodes[parent][facts.NodeKind]); parentKind != nodes.File { log.Printf("Found non-file parent to anchor: %q (kind: %q)", parent, parentKind) continue } a := &xpb.Anchor{ Ticket: ticket, Kind: edgeKind, Parent: parent, } file, ok := files[a.Parent] if !ok { nReply, err := xs.Nodes(ctx, &gpb.NodesRequest{Ticket: []string{a.Parent}}) if err != nil { return nil, fmt.Errorf("error getting file contents for %q: %v", a.Parent, err) } nMap := xrefs.NodesMap(nReply.Nodes) text := nMap[a.Parent][facts.Text] file = &fileNode{ text: text, encoding: string(nMap[a.Parent][facts.TextEncoding]), norm: xrefs.NewNormalizer(text), } files[a.Parent] = file } a.Start, a.End, err = normalizeSpan(file.norm, int32(so), int32(eo)) if err != nil { log.Printf("Invalid anchor span %q in file %q: %v", ticket, a.Parent, err) continue } if retrieveText && a.Start.ByteOffset < a.End.ByteOffset { a.Text, err = text.ToUTF8(file.encoding, file.text[a.Start.ByteOffset:a.End.ByteOffset]) if err != nil { log.Printf("Error decoding anchor text: %v", err) } } if snippetStart, snippetEnd, err := getSpan(allNodes[ticket], facts.SnippetStart, facts.SnippetEnd); err == nil { startPoint, endPoint, err := normalizeSpan(file.norm, int32(snippetStart), int32(snippetEnd)) if err != nil { log.Printf("Invalid snippet span %q in file %q: %v", ticket, a.Parent, err) } else { a.Snippet, err = text.ToUTF8(file.encoding, file.text[startPoint.ByteOffset:endPoint.ByteOffset]) if err != nil { log.Printf("Error decoding snippet text: %v", err) } a.SnippetStart = startPoint a.SnippetEnd = endPoint } } // fallback to a line-based snippet if the indexer did not provide its own snippet offsets if a.Snippet == "" { a.SnippetStart = &xpb.Location_Point{ ByteOffset: a.Start.ByteOffset - a.Start.ColumnOffset, LineNumber: a.Start.LineNumber, } nextLine := file.norm.Point(&xpb.Location_Point{LineNumber: a.Start.LineNumber + 1}) a.SnippetEnd = &xpb.Location_Point{ ByteOffset: nextLine.ByteOffset - 1, LineNumber: a.Start.LineNumber, ColumnOffset: a.Start.ColumnOffset + (nextLine.ByteOffset - a.Start.ByteOffset - 1), } a.Snippet, err = text.ToUTF8(file.encoding, file.text[a.SnippetStart.ByteOffset:a.SnippetEnd.ByteOffset]) if err != nil { log.Printf("Error decoding snippet text: %v", err) } } result = append(result, &xpb.CrossReferencesReply_RelatedAnchor{Anchor: a}) } break // we've handled the only /kythe/edge/childof group } } return result, nil }