golang.org/x/pkgsite/internal.ModuleInfo.ModulePath (field)
129 uses
golang.org/x/pkgsite/internal (current package)
discovery.go#L45: ModulePath string
discovery.go#L89: return SeriesPathForModule(v.ModulePath)
unit.go#L38: return um.ModulePath == um.Path
golang.org/x/pkgsite/internal/fetch
fetch.go#L320: ModulePath: modulePath,
unit.go#L52: ModulePath: modulePath,
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#L96: nestedModules, err := ds.GetNestedModules(ctx, um.ModulePath)
directory.go#L108: if m.SeriesPath() == internal.SeriesPathForModule(um.ModulePath) {
directory.go#L111: if !strings.HasPrefix(m.ModulePath, um.Path+"/") {
directory.go#L119: URL: constructUnitURL(m.ModulePath, m.ModulePath, internal.LatestVersion),
directory.go#L140: URL: constructUnitURL(pm.Path, um.ModulePath, linkVersion(um.Version, um.ModulePath)),
doc.go#L29: ModulePath: u.ModulePath,
doc.go#L34: if u.ModulePath == stdlib.ModulePath {
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)),
fetch.go#L503: return []string{um.ModulePath}, nil
imports.go#L42: ModulePath: modulePath,
license.go#L44: return &LicensesDetails{Licenses: transformLicenses(um.ModulePath, um.Version, u.LicenseContents)}, nil
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#L177: modReadme, err := ds.GetModuleReadme(ctx, unit.ModulePath, unit.Version)
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#L269: log.Errorf(ctx, "unit %s (%s@%s) missing documentation source", u.Path, u.ModulePath, u.Version)
overview.go#L76: defer derrors.Wrap(&err, "LegacyReadmeHTML(%s@%s)", mi.ModulePath, mi.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#L150: log.Infof(ctx, "serveUnitPage: Scheduling %q@%q to be fetched", um.ModulePath, info.requestedVersion)
unit.go#L151: if _, err := s.queue.ScheduleFetch(ctx, um.ModulePath, info.requestedVersion, "", false); err != nil {
unit.go#L153: r.URL.Path, um.ModulePath, info.requestedVersion, err)
unit.go#L171: latestInfo := s.GetLatestInfo(ctx, um.Path, um.ModulePath, latestUnitMeta)
unit.go#L182: lv := linkVersion(um.Version, um.ModulePath)
unit.go#L189: URLPath: constructUnitURL(um.Path, um.ModulePath, info.requestedVersion),
unit.go#L191: DisplayVersion: displayVersion(um.Version, um.ModulePath),
unit.go#L193: LatestURL: constructUnitURL(um.Path, um.ModulePath, internal.LatestVersion),
unit.go#L204: if latestMajor != "" && latestMajor != internal.MajorVersionForModule(um.ModulePath) {
unit.go#L275: return constructUnitURL(um.Path, um.ModulePath, linkVersion(um.Version, um.ModulePath))
versions.go#L106: if mi.ModulePath == stdlib.ModulePath {
versions.go#L111: return constructUnitURL(versionPath, mi.ModulePath, linkVersion(mi.Version, mi.ModulePath))
versions.go#L131: return mi.ModulePath
versions.go#L133: return path.Join(mi.ModulePath, suffix)
versions.go#L158: if mi.ModulePath == stdlib.ModulePath {
versions.go#L168: pathMajor := internal.MajorVersionForModule(mi.ModulePath)
versions.go#L177: ModulePath: mi.ModulePath,
versions.go#L184: Version: linkVersion(mi.Version, mi.ModulePath),
golang.org/x/pkgsite/internal/godoc
render.go#L216: ModulePath: u.ModulePath,
render.go#L221: if u.ModulePath == stdlib.ModulePath {
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#L114: modulepath := pathInfo.ModulePath
datasource.go#L154: ModulePath: requestedModulePath,
golang.org/x/pkgsite/internal/postgres
details.go#L52: isExcluded, err := db.IsExcluded(ctx, mi.ModulePath)
details.go#L195: if err := scan(&mi.ModulePath, &mi.Version, &mi.CommitTime,
insert_module.go#L41: derrors.WrapStack(&err, "DB.InsertModule(ctx, Module(%q, %q))", m.ModulePath, m.Version)
insert_module.go#L76: defer derrors.WrapStack(&err, "saveModule(ctx, tx, Module(%q, %q))", m.ModulePath, m.Version)
insert_module.go#L119: if err := lock(ctx, tx, m.ModulePath); err != nil {
insert_module.go#L127: latest, err := getLatestGoodVersion(ctx, tx, m.ModulePath, lmv)
insert_module.go#L134: if err := updateLatestGoodVersion(ctx, tx, m.ModulePath, latest); err != nil {
insert_module.go#L167: alt, err := isAlternativeModulePath(ctx, tx, m.ModulePath)
insert_module.go#L172: log.Infof(ctx, "%s@%s: not inserting into search documents", m.ModulePath, m.Version)
insert_module.go#L215: defer derrors.WrapStack(&err, "insertModule(ctx, %q, %q)", m.ModulePath, m.Version)
insert_module.go#L244: m.ModulePath,
insert_module.go#L264: defer derrors.WrapStack(&err, "insertLicenses(ctx, %q, %q)", m.ModulePath, m.Version)
insert_module.go#L302: defer derrors.WrapStack(&err, "insertImportsUnique(%q, %q)", m.ModulePath, m.Version)
insert_module.go#L308: m.ModulePath); err != nil {
insert_module.go#L315: values = append(values, u.Path, m.ModulePath, i)
insert_module.go#L330: defer derrors.WrapStack(&err, "insertUnits(ctx, tx, %q, %q)", m.ModulePath, m.Version)
insert_module.go#L368: v1path := internal.V1Path(u.Path, m.ModulePath)
insert_module.go#L425: return insertSymbols(ctx, db, m.ModulePath, m.Version, pathToID, pathToDocIDToDoc)
insert_module.go#L440: curPathsSet[internal.V1Path(u.Path, m.ModulePath)] = true
insert_module.go#L441: curPathsSet[internal.SeriesPathForModule(m.ModulePath)] = true
insert_module.go#L770: derrors.WrapStack(&err, "validateModule(%q, %q)", m.ModulePath, m.Version)
insert_module.go#L782: if m.ModulePath == "" {
insert_module.go#L785: if m.ModulePath != stdlib.ModulePath {
insert_module.go#L786: if err := module.CheckPath(m.ModulePath); err != nil {
insert_module.go#L828: defer derrors.WrapStack(&err, "comparePaths(ctx, %q, %q)", m.ModulePath, m.Version)
insert_module.go#L829: dbPaths, err := db.getPathsInModule(ctx, m.ModulePath, m.Version)
search.go#L630: defer derrors.WrapStack(&err, "upsertSearchDocuments(ctx, %q, %q)", mod.ModulePath, mod.Version)
search.go#L639: ModulePath: mod.ModulePath,
search.go#L653: if err := upsertSearchDocumentSymbols(ctx, ddb, pkg.Path, mod.ModulePath, mod.Version); err != nil {
test_helper.go#L220: if err := db.UpdateLatestModuleVersionsStatus(ctx, m.ModulePath, 404); err != nil {
test_helper.go#L224: lmv = addLatest(ctx, t, db, m.ModulePath, m.Version, goMod)
unit.go#L98: &um.ModulePath,
unit.go#L130: lmv, err = db.GetLatestModuleVersions(ctx, um.ModulePath)
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#L522: if r.Filepath != "" && um.ModulePath != stdlib.ModulePath {
unit.go#L541: if um.ModulePath == stdlib.ModulePath {
unit.go#L542: u.SymbolHistory, err = GetSymbolHistoryForBuildContext(ctx, db.db, pathID, um.ModulePath, bcMatched)
unit.go#L552: u.SymbolHistory, err = GetSymbolHistoryForBuildContext(ctx, db.db, pathID, um.ModulePath, bcMatched)
unit.go#L559: um.ModulePath)
version.go#L115: defer derrors.WrapStack(&err, "populateLatestInfo(%q)", mi.ModulePath)
version.go#L118: lmv, err := db.GetLatestModuleVersions(ctx, mi.ModulePath)
version.go#L134: if _, ok := lmvs[mi.ModulePath]; !ok {
version.go#L135: lmv, err := db.GetLatestModuleVersions(ctx, mi.ModulePath)
version.go#L139: lmvs[mi.ModulePath] = lmv
version.go#L144: lmv := lmvs[mi.ModulePath]
version.go#L164: latest.MinorModulePath = latestUnitMeta.ModulePath
version.go#L172: latest.MinorModulePath = um.ModulePath
golang.org/x/pkgsite/internal/proxydatasource
datasource.go#L193: return nil, fmt.Errorf("%q missing from module %s: %w", fullPath, m.ModulePath, derrors.NotFound)
datasource.go#L207: latest.MinorModulePath = latestUnitMeta.ModulePath
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#L53: ModulePath: inModulePath,
golang.org/x/pkgsite/internal/testing/sample
sample.go#L212: UnitMeta: *UnitMeta(m.ModulePath, m.ModulePath, m.Version, "", m.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#L248: minLen := len(m.ModulePath)
sample.go#L249: if m.ModulePath == stdlib.ModulePath {
sample.go#L261: AddUnit(m, UnitEmpty(pth, m.ModulePath, m.Version))
sample.go#L279: ModulePath: modulePath,
sample.go#L316: if strings.TrimPrefix(u.Path, m.ModulePath+"/") == dir {
sample.go#L357: ModulePath: modulePath,
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |