golang.org/x/pkgsite/internal.UnitMeta.Path (field)

90 uses

	golang.org/x/pkgsite/internal (current package)
		unit.go#L15: 	Path              string
		unit.go#L38: 	return um.ModulePath == um.Path

	golang.org/x/pkgsite/internal/fetch
		unit.go#L56: 				Path:              dirPath,

	golang.org/x/pkgsite/internal/frontend
		breadcrumb.go#L17: 	bc := breadcrumbPath(um.Path, um.ModulePath, requestedVersion)
		breadcrumb.go#L18: 	if um.ModulePath == stdlib.ModulePath && um.Path != stdlib.ModulePath {
		directory.go#L111: 		if !strings.HasPrefix(m.ModulePath, um.Path+"/") {
		directory.go#L114: 		suffix := internal.Suffix(m.SeriesPath(), um.Path)
		directory.go#L130: 		if um.Path == pm.Path {
		directory.go#L133: 		if um.Path == stdlib.ModulePath && strings.HasPrefix(pm.Path, "cmd/") {
		directory.go#L141: 			Suffix:   internal.Suffix(pm.Path, um.Path),
		doc.go#L35: 		innerPath = u.Path
		doc.go#L36: 	} else if u.Path != u.ModulePath {
		doc.go#L37: 		innerPath = u.Path[len(u.ModulePath)+1:]
		doc.go#L51: 			URL:  u.SourceInfo.FileURL(path.Join(internal.Suffix(u.Path, u.ModulePath), f.Name)),
		header.go#L29: 	case um.Path == stdlib.ModulePath:
		header.go#L32: 		return effectiveName(um.Path, um.Name)
		header.go#L36: 		prefix, _, _ := module.SplitPathVersion(um.Path)
		header.go#L39: 		return path.Base(um.Path) + "/"
		header.go#L45: 	if um.Path == stdlib.ModulePath {
		header.go#L64: 	if um.Path == stdlib.ModulePath {
		header.go#L78: 	if stdlib.Contains(um.Path) {
		imports.go#L40: 		Path: pkgPath,
		main.go#L154: 				log.Errorf(ctx, "fetchMainDetails(%q, %q, %q): %v", um.Path, um.ModulePath, um.Version, err)
		main.go#L176: 	if unit.Path != unit.ModulePath && unit.IsRedistributable {
		main.go#L214: 		SourceURL:         um.SourceInfo.DirectoryURL(internal.Suffix(um.Path, um.ModulePath)),
		main.go#L252: 	defer derrors.Wrap(&err, "readmeContent(%q, %q, %q)", u.Path, u.ModulePath, u.Version)
		main.go#L264: 	defer derrors.Wrap(&err, "getHTML(%s)", u.Path)
		main.go#L269: 	log.Errorf(ctx, "unit %s (%s@%s) missing documentation source", u.Path, u.ModulePath, u.Version)
		readme.go#L67: 	defer derrors.WrapAndReport(&err, "ProcessReadme(%q, %q, %q)", u.Path, u.ModulePath, u.Version)
		tabs.go#L79: 	defer derrors.Wrap(&err, "fetchDetailsForUnit(r, %q, ds, um=%q,%q,%q)", tab, um.Path, um.ModulePath, um.Version)
		tabs.go#L85: 		return fetchVersionsDetails(ctx, ds, um.Path, um.ModulePath)
		tabs.go#L87: 		return fetchImportsDetails(ctx, ds, um.Path, um.ModulePath, um.Version)
		tabs.go#L89: 		return fetchImportedByDetails(ctx, ds, um.Path, um.ModulePath)
		unit.go#L171: 	latestInfo := s.GetLatestInfo(ctx, um.Path, um.ModulePath, latestUnitMeta)
		unit.go#L189: 		URLPath:               constructUnitURL(um.Path, um.ModulePath, info.requestedVersion),
		unit.go#L193: 		LatestURL:             constructUnitURL(um.Path, um.ModulePath, internal.LatestVersion),
		unit.go#L275: 	return constructUnitURL(um.Path, um.ModulePath, linkVersion(um.Version, um.ModulePath))

	golang.org/x/pkgsite/internal/godoc
		render.go#L222: 		innerPath = u.Path
		render.go#L223: 	} else if u.Path != u.ModulePath {
		render.go#L224: 		innerPath = u.Path[len(u.ModulePath)+1:]

	golang.org/x/pkgsite/internal/localdatasource
		datasource.go#L112: 	defer derrors.Wrap(&err, "GetUnit(%q, %q)", pathInfo.Path, pathInfo.ModulePath)
		datasource.go#L115: 	path := pathInfo.Path
		datasource.go#L125: 		if unit.Path == path {
		datasource.go#L152: 		Path: path,
		datasource.go#L162: 		if u.Path == path {

	golang.org/x/pkgsite/internal/postgres
		insert_module.go#L315: 			values = append(values, u.Path, m.ModulePath, i)
		insert_module.go#L338: 		return m.Units[i].Path < m.Units[j].Path
		insert_module.go#L368: 		v1path := internal.V1Path(u.Path, m.ModulePath)
		insert_module.go#L369: 		pathID, ok := pathToID[u.Path]
		insert_module.go#L371: 			return fmt.Errorf("no entry in paths table for %q; should be impossible", u.Path)
		insert_module.go#L373: 		pathIDToPath[pathID] = u.Path
		insert_module.go#L384: 			pathToReadme[u.Path] = u.Readme
		insert_module.go#L388: 				return fmt.Errorf("insertUnits: unit %q missing source files for %q, %q", u.Path, d.GOOS, d.GOARCH)
		insert_module.go#L391: 		pathToDocs[u.Path] = u.Documentation
		insert_module.go#L393: 			pathToImports[u.Path] = u.Imports
		insert_module.go#L395: 		paths = append(paths, u.Path)
		insert_module.go#L439: 		curPathsSet[u.Path] = true
		insert_module.go#L440: 		curPathsSet[internal.V1Path(u.Path, m.ModulePath)] = true
		insert_module.go#L835: 		set[p.Path] = true
		search.go#L634: 		if isInternalPackage(pkg.Path) {
		search.go#L638: 			PackagePath: pkg.Path,
		search.go#L653: 		if err := upsertSearchDocumentSymbols(ctx, ddb, pkg.Path, mod.ModulePath, mod.Version); err != nil {
		unit.go#L95: 		um           = internal.UnitMeta{Path: fullPath}
		unit.go#L246: 	defer derrors.WrapStack(&err, "GetUnit(ctx, %q, %q, %q, %v)", um.Path, um.ModulePath, um.Version, bc)
		unit.go#L261: 	unitID, err := db.getUnitID(ctx, um.Path, um.ModulePath, um.Version)
		unit.go#L277: 		lics, err := db.getLicenses(ctx, u.Path, u.ModulePath, unitID)
		unit.go#L426: 	defer derrors.WrapStack(&err, "getUnitWithAllFields(ctx, %q, %q, %q)", um.Path, um.ModulePath, um.Version)
		unit.go#L454: 	}, um.Path, um.ModulePath, um.Version)
		unit.go#L510: 	err = db.db.QueryRow(ctx, query, um.Path, unitID, goos, goarch).Scan(
		unit.go#L533: 	pkgs, err := db.getPackagesInUnit(ctx, um.Path, moduleID)
		unit.go#L558: 		sh, err := GetSymbolHistoryWithPackageSymbols(ctx, db.db, um.Path,

	golang.org/x/pkgsite/internal/proxydatasource
		datasource.go#L147: 			mps = ds.packagePathToModules[pkg.Path]
		datasource.go#L155: 			ds.packagePathToModules[pkg.Path] = append(mps[:i], append([]string{modulePath}, mps[i:]...)...)
		datasource.go#L189: 		if d.Path == fullPath {
		details.go#L19: 	defer derrors.Wrap(&err, "GetUnit(%q, %q, %q)", um.Path, um.ModulePath, um.Version)
		details.go#L20: 	return ds.getUnit(ctx, um.Path, um.ModulePath, um.Version, bc)
		details.go#L51: 		Path: path,
		details.go#L59: 		if d.Path == path {

	golang.org/x/pkgsite/internal/testing/sample
		sample.go#L195: 			u := UnitForPackage(lp.Path, modulePath, version, lp.Name, lp.IsRedistributable)
		sample.go#L243: 	if m.ModulePath != stdlib.ModulePath && !strings.HasPrefix(pkg.Path, m.ModulePath) {
		sample.go#L245: 			pkg.Path, m.ModulePath))
		sample.go#L247: 	AddUnit(m, UnitForPackage(pkg.Path, m.ModulePath, m.Version, pkg.Name, pkg.IsRedistributable))
		sample.go#L252: 	for pth := pkg.Path; len(pth) > minLen; pth = path.Dir(pth) {
		sample.go#L255: 			if u.Path == pth {
		sample.go#L302: 		if e.Path == u.Path {
		sample.go#L303: 			panic(fmt.Sprintf("module already has path %q", e.Path))
		sample.go#L316: 		if strings.TrimPrefix(u.Path, m.ModulePath+"/") == dir {
		sample.go#L352: 		Path:              path,