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,