internal: add Legacy prefix to GetPsuedoVersions and GetTaggedVersions functions

The GetPsuedoVersions* and GetTaggedVersions* functions read from the
packages table, and will be replaced by a single GetVersionsForPath
function.

These functions are now prefixed with "Legacy" to indicate that they
will be deprecated.

For golang/go#39629

Change-Id: I7f89f9890f135b5ddb363a51a9706e48d02594b5
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/241899
Reviewed-by: Jonathan Amsterdam <[email protected]>

Author: julieqiu

internal/datasource.go

@@ -26,19 +26,6 @@ type DataSource interface {
 	GetModuleInfo(ctx context.Context, modulePath, version string) (*ModuleInfo, error)
 	// GetPathInfo returns information about a path.
 	GetPathInfo(ctx context.Context, path, inModulePath, inVersion string) (outModulePath, outVersion string, isPackage bool, err error)
-	// GetPseudoVersionsForModule returns LegacyModuleInfo for all known
-	// pseudo-versions for the module corresponding to modulePath.
-	GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
-	// GetPseudoVersionsForModule returns LegacyModuleInfo for all known
-	// pseudo-versions for any module containing a package with the given import
-	// path.
-	GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
-	// GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
-	// versions for the module corresponding to modulePath.
-	GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
-	// GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
-	// versions for any module containing a package with the given import path.
-	GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 
 	// TODO(golang/go#39629): Deprecate these methods.
 	//
@@ -47,20 +34,33 @@ type DataSource interface {
 	// package paths satisfy this query, it should prefer the module with
 	// the longest path.
 	LegacyGetDirectory(ctx context.Context, dirPath, modulePath, version string, fields FieldSet) (_ *LegacyDirectory, err error)
+	// LegacyGetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
+	// version.
+	LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
 	// LegacyGetModuleLicenses returns all top-level Licenses for the given modulePath
 	// and version. (i.e., Licenses contained in the module root directory)
 	LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) ([]*licenses.License, error)
 	// LegacyGetPackage returns the LegacyVersionedPackage corresponding to the given package
 	// pkgPath, modulePath, and version. When multiple package paths satisfy this query, it
 	// should prefer the module with the longest path.
 	LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
+	// LegacyGetPackagesInModule returns LegacyPackages contained in the module version
+	// specified by modulePath and version.
+	LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) ([]*LegacyPackage, error)
 	// LegacyGetPackageLicenses returns all Licenses that apply to pkgPath, within the
 	// module version specified by modulePath and version.
 	LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) ([]*licenses.License, error)
-	// GetPackagesInModule returns LegacyPackages contained in the module version
-	// specified by modulePath and version.
-	LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) ([]*LegacyPackage, error)
-	// LegacyGetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
-	// version.
-	LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
+	// LegacyGetPsuedoVersionsForModule returns ModuleInfo for all known
+	// pseudo-versions for the module corresponding to modulePath.
+	LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
+	// LegacyGetPsuedoVersionsForModule returns ModuleInfo for all known
+	// pseudo-versions for any module containing a package with the given import
+	// path.
+	LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
+	// LegacyGetTaggedVersionsForModule returns ModuleInfo for all known tagged
+	// versions for the module corresponding to modulePath.
+	LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
+	// LegacyGetTaggedVersionsForModule returns ModuleInfo for all known tagged
+	// versions for any module containing a package with the given import path.
+	LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 }

internal/frontend/versions.go

@@ -64,14 +64,14 @@ type VersionSummary struct {
 // fetchModuleVersionsDetails builds a version hierarchy for module versions
 // with the same series path as the given version.
 func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi *internal.ModuleInfo) (*VersionsDetails, error) {
-	versions, err := ds.GetTaggedVersionsForModule(ctx, mi.ModulePath)
+	versions, err := ds.LegacyGetTaggedVersionsForModule(ctx, mi.ModulePath)
 	if err != nil {
 		return nil, err
 	}
 	// If no tagged versions of the module are found, fetch pseudo-versions
 	// instead.
 	if len(versions) == 0 {
-		versions, err = ds.GetPseudoVersionsForModule(ctx, mi.ModulePath)
+		versions, err = ds.LegacyGetPsuedoVersionsForModule(ctx, mi.ModulePath)
 		if err != nil {
 			return nil, err
 		}
@@ -85,14 +85,14 @@ func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi
 // fetchPackageVersionsDetails builds a version hierarchy for all module
 // versions containing a package path with v1 import path matching the given v1 path.
 func fetchPackageVersionsDetails(ctx context.Context, ds internal.DataSource, pkgPath, v1Path, modulePath string) (*VersionsDetails, error) {
-	versions, err := ds.GetTaggedVersionsForPackageSeries(ctx, pkgPath)
+	versions, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, pkgPath)
 	if err != nil {
 		return nil, err
 	}
 	// If no tagged versions for the package series are found, fetch the
 	// pseudo-versions instead.
 	if len(versions) == 0 {
-		versions, err = ds.GetPseudoVersionsForPackageSeries(ctx, pkgPath)
+		versions, err = ds.LegacyGetPsuedoVersionsForPackageSeries(ctx, pkgPath)
 		if err != nil {
 			return nil, err
 		}

internal/postgres/details.go

@@ -74,17 +74,17 @@ func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, version
 	return packages, nil
 }
 
-// GetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
+// LegacyGetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
 // descending semver order. This list includes tagged versions of packages that
 // have the same v1path.
-func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
-// GetPseudoVersionsForPackageSeries returns the 10 most recent from a list of
+// LegacyGetPsuedoVersionsForPackageSeries returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order. This list includes
 // pseudo-versions of packages that have the same v1path.
-func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypePseudo})
 }
 
@@ -156,15 +156,15 @@ func versionTypeExpr(vts []version.Type) string {
 	return strings.Join(vs, ", ")
 }
 
-// GetTaggedVersionsForModule returns a list of tagged versions sorted in
+// LegacyGetTaggedVersionsForModule returns a list of tagged versions sorted in
 // descending semver order.
-func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
-// GetPseudoVersionsForModule returns the 10 most recent from a list of
+// LegacyGetPsuedoVersionsForModule returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order.
-func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypePseudo})
 }
 

internal/postgres/details_test.go

@@ -340,7 +340,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 					t.Fatal(err)
 				}
 
-				// GetPseudoVersions should only return the 10 most recent pseudo versions,
+				// LegacyGetPsuedoVersions should only return the 10 most recent pseudo versions,
 				// if there are more than 10 in the database
 				if i < 10 {
 					wantPseudoVersions = append(wantPseudoVersions, &internal.ModuleInfo{
@@ -357,36 +357,36 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 				}
 			}
 
-			got, err := testDB.GetPseudoVersionsForPackageSeries(ctx, tc.path)
+			got, err := testDB.LegacyGetPsuedoVersionsForPackageSeries(ctx, tc.path)
 			if err != nil {
 				t.Fatal(err)
 			}
 			if diff := cmp.Diff(wantPseudoVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Errorf("testDB.GetPseudoVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
+				t.Errorf("testDB.LegacyGetPsuedoVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
 			}
 
-			got, err = testDB.GetTaggedVersionsForPackageSeries(ctx, tc.path)
+			got, err = testDB.LegacyGetTaggedVersionsForPackageSeries(ctx, tc.path)
 			if err != nil {
 				t.Fatal(err)
 			}
 			if diff := cmp.Diff(tc.wantTaggedVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Errorf("testDB.GetTaggedVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
+				t.Errorf("testDB.LegacyGetTaggedVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
 			}
 
-			got, err = testDB.GetPseudoVersionsForModule(ctx, tc.modulePath)
+			got, err = testDB.LegacyGetPsuedoVersionsForModule(ctx, tc.modulePath)
 			if err != nil {
 				t.Fatal(err)
 			}
 			if diff := cmp.Diff(wantPseudoVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Errorf("testDB.GetPseudoVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
+				t.Errorf("testDB.LegacyGetPsuedoVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
 			}
 
-			got, err = testDB.GetTaggedVersionsForModule(ctx, tc.modulePath)
+			got, err = testDB.LegacyGetTaggedVersionsForModule(ctx, tc.modulePath)
 			if err != nil {
 				t.Fatal(err)
 			}
 			if diff := cmp.Diff(tc.wantTaggedVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Errorf("testDB.GetTaggedVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
+				t.Errorf("testDB.LegacyGetTaggedVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
 			}
 		})
 	}

internal/proxydatasource/datasource.go

@@ -189,33 +189,33 @@ func (ds *DataSource) LegacyGetPackagesInModule(ctx context.Context, modulePath,
 	return v.LegacyPackages, nil
 }
 
-// GetPseudoVersionsForModule returns versions from the the proxy /list
+// LegacyGetPsuedoVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetPseudoVersionsForModule(%q)", modulePath)
+func (ds *DataSource) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForModule(%q)", modulePath)
 	return ds.listModuleVersions(ctx, modulePath, true)
 }
 
-// GetPseudoVersionsForPackageSeries finds the longest module path containing
+// LegacyGetPsuedoVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetPseudoVersionsForPackageSeries(%q)", pkgPath)
+func (ds *DataSource) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForPackageSeries(%q)", pkgPath)
 	return ds.listPackageVersions(ctx, pkgPath, true)
 }
 
-// GetTaggedVersionsForModule returns versions from the the proxy /list
+// LegacyGetTaggedVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetTaggedVersionsForModule(%q)", modulePath)
+func (ds *DataSource) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForModule(%q)", modulePath)
 	return ds.listModuleVersions(ctx, modulePath, false)
 }
 
-// GetTaggedVersionsForPackageSeries finds the longest module path containing
+// LegacyGetTaggedVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetTaggedVersionsForPackageSeries(%q)", pkgPath)
+func (ds *DataSource) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForPackageSeries(%q)", pkgPath)
 	return ds.listPackageVersions(ctx, pkgPath, false)
 }
 

internal/proxydatasource/datasource_test.go

@@ -195,10 +195,10 @@ func TestDataSource_GetPackagesInVersion(t *testing.T) {
 	}
 }
 
-func TestDataSource_GetTaggedVersionsForModule(t *testing.T) {
+func TestDataSource_LegacyGetTaggedVersionsForModule(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
-	got, err := ds.GetTaggedVersionsForModule(ctx, "foo.com/bar")
+	got, err := ds.LegacyGetTaggedVersionsForModule(ctx, "foo.com/bar")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -210,19 +210,19 @@ func TestDataSource_GetTaggedVersionsForModule(t *testing.T) {
 	}
 	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
 	if diff := cmp.Diff(want, got, ignore); diff != "" {
-		t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
+		t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
 	}
 }
 
-func TestDataSource_GetTaggedVersionsForPackageSeries(t *testing.T) {
+func TestDataSource_LegacyGetTaggedVersionsForPackageSeries(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
 	// // TODO (rFindley): this shouldn't be necessary.
 	// _, err := ds.GetLatestPackage(ctx, "foo.com/bar/baz")
 	// if err != nil {
 	// 	t.Fatal(err)
 	// }
-	got, err := ds.GetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
+	got, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -234,7 +234,7 @@ func TestDataSource_GetTaggedVersionsForPackageSeries(t *testing.T) {
 	}
 	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
 	if diff := cmp.Diff(want, got, ignore); diff != "" {
-		t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
+		t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
 	}
 }