internal/proxydatasource: remove unused functions
For golang/go#39629
Change-Id: Ideabf77f8a65c6e04391fd05d09bb567ef59a4c2
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/258559
Trust: Julie Qiu <julie@golang.org>
Run-TryBot: Julie Qiu <julie@golang.org>
TryBot-Result: kokoro <noreply+kokoro@google.com>
Reviewed-by: Jonathan Amsterdam <jba@google.com>
diff --git a/internal/proxydatasource/datasource.go b/internal/proxydatasource/datasource.go
index ead449e..f105038 100644
--- a/internal/proxydatasource/datasource.go
+++ b/internal/proxydatasource/datasource.go
@@ -22,8 +22,6 @@
"golang.org/x/pkgsite/internal/fetch"
"golang.org/x/pkgsite/internal/proxy"
"golang.org/x/pkgsite/internal/source"
- "golang.org/x/pkgsite/internal/stdlib"
- "golang.org/x/pkgsite/internal/version"
)
var _ internal.DataSource = (*DataSource)(nil)
@@ -158,121 +156,6 @@
return "", nil, fmt.Errorf("unable to find module: %w", derrors.NotFound)
}
-// listPackageVersions finds the longest module corresponding to pkgPath, and
-// calls the proxy /list endpoint to list its versions. If pseudo is true, it
-// filters to pseudo versions. If pseudo is false, it filters to tagged
-// versions.
-func (ds *DataSource) listPackageVersions(ctx context.Context, pkgPath string, pseudo bool) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "listPackageVersions(%q, %t)", pkgPath, pseudo)
- ds.mu.RLock()
- mods := ds.packagePathToModules[pkgPath]
- ds.mu.RUnlock()
- var modulePath string
- if len(mods) > 0 {
- // Since mods is kept sorted, the first element is the longest module.
- modulePath = mods[0]
- } else {
- modulePath, _, err = ds.findModule(ctx, pkgPath, internal.LatestVersion)
- if err != nil {
- return nil, err
- }
- }
- return ds.listModuleVersions(ctx, modulePath, pseudo)
-}
-
-// listModuleVersions finds the longest module corresponding to pkgPath, and
-// calls the proxy /list endpoint to list its versions. If pseudo is true, it
-// filters to pseudo versions. If pseudo is false, it filters to tagged
-// versions.
-func (ds *DataSource) listModuleVersions(ctx context.Context, modulePath string, pseudo bool) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "listModuleVersions(%q, %t)", modulePath, pseudo)
- var versions []string
- if modulePath == stdlib.ModulePath {
- versions, err = stdlib.Versions()
- } else {
- versions, err = ds.proxyClient.ListVersions(ctx, modulePath)
- }
- if err != nil {
- return nil, err
- }
- var vis []*internal.ModuleInfo
- ds.mu.RLock()
- defer ds.mu.RUnlock()
- for _, vers := range versions {
- // In practice, the /list endpoint should only return either pseudo
- // versions or tagged versions, but we filter here for maximum
- // compatibility.
- if version.IsPseudo(vers) != pseudo {
- continue
- }
- if v, ok := ds.versionCache[versionKey{modulePath, vers}]; ok {
- vis = append(vis, &v.module.ModuleInfo)
- } else {
- // In this case we can't produce ModuleInfo without fully processing
- // the module zip, so we instead append a stub. We could further query
- // for this version's /info endpoint to get commit time, but that is
- // deferred as a potential future enhancement.
- vis = append(vis, &internal.ModuleInfo{
- ModulePath: modulePath,
- Version: vers,
- })
- }
- }
- sort.Slice(vis, func(i, j int) bool {
- return semver.Compare(vis[i].Version, vis[j].Version) > 0
- })
- return vis, nil
-}
-
-// getPackageVersion finds a module at version that contains a package with
-// import path pkgPath. To do this, it first checks the cache for any module
-// satisfying this requirement, querying the proxy if none is found.
-func (ds *DataSource) getPackageVersion(ctx context.Context, pkgPath, version string) (_ *internal.Module, err error) {
- defer derrors.Wrap(&err, "getPackageVersion(%q, %q)", pkgPath, version)
- // First, try to retrieve this version from the cache, using our reverse
- // indexes.
- if modulePath, ok := ds.findModulePathForPackage(pkgPath, version); ok {
- // This should hit the cache.
- return ds.getModule(ctx, modulePath, version)
- }
- modulePath, info, err := ds.findModule(ctx, pkgPath, version)
- if err != nil {
- return nil, err
- }
- return ds.getModule(ctx, modulePath, info.Version)
-}
-
-// findModulePathForPackage looks for an existing instance of a module at
-// version that contains a package with path pkgPath. The return bool reports
-// whether a valid module path was found.
-func (ds *DataSource) findModulePathForPackage(pkgPath, version string) (string, bool) {
- ds.mu.RLock()
- defer ds.mu.RUnlock()
- for _, mp := range ds.packagePathToModules[pkgPath] {
- for _, vers := range ds.modulePathToVersions[mp] {
- if vers == version {
- return mp, true
- }
- }
- }
- return "", false
-}
-
-// packageFromVersion extracts the LegacyVersionedPackage for pkgPath from the
-// Version payload.
-func packageFromVersion(pkgPath string, m *internal.Module) (_ *internal.LegacyVersionedPackage, err error) {
- defer derrors.Wrap(&err, "packageFromVersion(%q, ...)", pkgPath)
- for _, p := range m.LegacyPackages {
- if p.Path == pkgPath {
- return &internal.LegacyVersionedPackage{
- LegacyPackage: *p,
- LegacyModuleInfo: m.LegacyModuleInfo,
- }, nil
- }
- }
- return nil, fmt.Errorf("package missing from module %s: %w", m.ModulePath, derrors.NotFound)
-}
-
// getUnit returns information about a unit.
func (ds *DataSource) getUnit(ctx context.Context, fullPath, modulePath, version string) (_ *internal.Unit, err error) {
var m *internal.Module
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index e1d2c00..5fd740b 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -14,7 +14,6 @@
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
- "github.com/google/licensecheck"
"golang.org/x/pkgsite/internal"
"golang.org/x/pkgsite/internal/derrors"
"golang.org/x/pkgsite/internal/licenses"
@@ -63,31 +62,8 @@
}
var (
- wantLicenseMD = sample.LicenseMetadata[0]
- wantLicense = &licenses.License{Metadata: wantLicenseMD}
- wantLicenseMIT = &licenses.License{
- Metadata: &licenses.Metadata{
- Types: []string{"MIT"},
- FilePath: "LICENSE",
- Coverage: licensecheck.Coverage{
- Percent: 100,
- Match: []licensecheck.Match{{Name: "MIT", Type: licensecheck.MIT, Percent: 100, End: 1049}},
- },
- },
- Contents: []byte(testhelper.MITLicense),
- }
- wantLicenseBSD = &licenses.License{
- Metadata: &licenses.Metadata{
- Types: []string{"BSD-0-Clause"},
- FilePath: "qux/LICENSE",
- Coverage: licensecheck.Coverage{
- Percent: 100,
- Match: []licensecheck.Match{{Name: "BSD-0-Clause", Type: licensecheck.BSD, Percent: 100, End: 633}},
- },
- },
- Contents: []byte(testhelper.BSD0License),
- }
- wantPackage = internal.LegacyPackage{
+ wantLicenseMD = sample.LicenseMetadata[0]
+ wantPackage = internal.LegacyPackage{
Path: "foo.com/bar/baz",
Name: "baz",
Imports: []string{"net/http"},
@@ -105,12 +81,6 @@
IsRedistributable: true,
HasGoMod: true,
}
- wantVersionedPackage = &internal.LegacyVersionedPackage{
- LegacyModuleInfo: internal.LegacyModuleInfo{
- ModuleInfo: wantModuleInfo,
- },
- LegacyPackage: wantPackage,
- }
cmpOpts = append([]cmp.Option{
cmpopts.IgnoreFields(internal.LegacyPackage{}, "DocumentationHTML"),
cmpopts.IgnoreFields(licenses.License{}, "Contents"),
