internal/testing/sample: move legacy functions to legacy.go

Any function that references a legacy struct is moved to legacy.go.

Pure code in motion.

These functions will either be deprecated or rewritten to not use a
legacy struct in a future CL.

For golang/go#39629

Change-Id: I8574fe3f90c1f17eec6b5f181feb42ee137bca5d
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/258597
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>

1 files changed, 0 insertions, 114 deletions

diff --git a/internal/testing/sample/sample.go b/internal/testing/sample/sample.go
index 4f6cad03..de80a691 100644
--- a/internal/testing/sample/sample.go
+++ b/internal/testing/sample/sample.go
@@ -93,29 +93,6 @@ func NowTruncated() time.Time {
 	return time.Now().Truncate(time.Microsecond)
 }
 
-// LegacyPackage constructs a package with the given module path and suffix.
-//
-// If modulePath is the standard library, the package path is the
-// suffix, which must not be empty. Otherwise, the package path
-// is the concatenation of modulePath and suffix.
-//
-// The package name is last component of the package path.
-func LegacyPackage(modulePath, suffix string) *internal.LegacyPackage {
-	p := constructFullPath(modulePath, suffix)
-	return &internal.LegacyPackage{
-		Name:              path.Base(p),
-		Path:              p,
-		V1Path:            internal.V1Path(p, modulePath),
-		Synopsis:          Synopsis,
-		IsRedistributable: true,
-		Licenses:          LicenseMetadata,
-		DocumentationHTML: DocumentationHTML,
-		Imports:           Imports,
-		GOOS:              GOOS,
-		GOARCH:            GOARCH,
-	}
-}
-
 func PackageMeta(fullPath string) *internal.PackageMeta {
 	return &internal.PackageMeta{
 		Path:              fullPath,
@@ -126,15 +103,6 @@ func PackageMeta(fullPath string) *internal.PackageMeta {
 	}
 }
 
-func LegacyModuleInfo(modulePath, versionString string) *internal.LegacyModuleInfo {
-	mi := ModuleInfoReleaseType(modulePath, versionString)
-	return &internal.LegacyModuleInfo{
-		ModuleInfo:           *mi,
-		LegacyReadmeFilePath: ReadmeFilePath,
-		LegacyReadmeContents: ReadmeContents,
-	}
-}
-
 func ModuleInfo(modulePath, versionString string) *internal.ModuleInfo {
 	mi := ModuleInfoReleaseType(modulePath, versionString)
 	return mi
@@ -154,12 +122,6 @@ func ModuleInfoReleaseType(modulePath, versionString string) *internal.ModuleInf
 	}
 }
 
-func DefaultModule() *internal.Module {
-	return AddPackage(
-		Module(ModulePath, VersionString),
-		LegacyPackage(ModulePath, Suffix))
-}
-
 func DefaultVersionMap() *internal.VersionMap {
 	return &internal.VersionMap{
 		ModulePath:       ModulePath,
@@ -171,56 +133,6 @@ func DefaultVersionMap() *internal.VersionMap {
 	}
 }
 
-// Module creates a Module with the given path and version.
-// The list of suffixes is used to create LegacyPackages within the module.
-func Module(modulePath, version string, suffixes ...string) *internal.Module {
-	mi := LegacyModuleInfo(modulePath, version)
-	m := &internal.Module{
-		LegacyModuleInfo: *mi,
-		LegacyPackages:   nil,
-		Licenses:         Licenses,
-	}
-	m.Units = []*internal.Unit{UnitForModuleRoot(mi, LicenseMetadata)}
-	for _, s := range suffixes {
-		lp := LegacyPackage(modulePath, s)
-		if s != "" {
-			AddPackage(m, lp)
-		} else {
-			m.LegacyPackages = append(m.LegacyPackages, lp)
-			u := UnitForPackage(lp, modulePath, version)
-			m.Units[0].Documentation = u.Documentation
-			m.Units[0].Name = u.Name
-		}
-	}
-	return m
-}
-
-func AddPackage(m *internal.Module, p *internal.LegacyPackage) *internal.Module {
-	if m.ModulePath != stdlib.ModulePath && !strings.HasPrefix(p.Path, m.ModulePath) {
-		panic(fmt.Sprintf("package path %q not a prefix of module path %q",
-			p.Path, m.ModulePath))
-	}
-	m.LegacyPackages = append(m.LegacyPackages, p)
-	AddUnit(m, UnitForPackage(p, m.ModulePath, m.Version))
-	minLen := len(m.ModulePath)
-	if m.ModulePath == stdlib.ModulePath {
-		minLen = 1
-	}
-	for pth := p.Path; len(pth) > minLen; pth = path.Dir(pth) {
-		found := false
-		for _, u := range m.Units {
-			if u.Path == pth {
-				found = true
-				break
-			}
-		}
-		if !found {
-			AddUnit(m, UnitEmpty(pth, m.ModulePath, m.Version))
-		}
-	}
-	return m
-}
-
 func AddUnit(m *internal.Module, u *internal.Unit) {
 	for _, e := range m.Units {
 		if e.Path == u.Path {
@@ -249,32 +161,6 @@ func UnitEmpty(path, modulePath, version string) *internal.Unit {
 	}
 }
 
-func UnitForModuleRoot(m *internal.LegacyModuleInfo, licenses []*licenses.Metadata) *internal.Unit {
-	u := &internal.Unit{
-		UnitMeta:        *UnitMeta(m.ModulePath, m.ModulePath, m.Version, "", m.IsRedistributable),
-		LicenseContents: Licenses,
-	}
-	u.Readme = &internal.Readme{
-		Filepath: ReadmeFilePath,
-		Contents: ReadmeContents,
-	}
-	return u
-}
-
-func UnitForPackage(pkg *internal.LegacyPackage, modulePath, version string) *internal.Unit {
-	return &internal.Unit{
-		UnitMeta:        *UnitMeta(pkg.Path, modulePath, version, pkg.Name, pkg.IsRedistributable),
-		Imports:         pkg.Imports,
-		LicenseContents: Licenses,
-		Documentation: &internal.Documentation{
-			Synopsis: pkg.Synopsis,
-			HTML:     pkg.DocumentationHTML,
-			GOOS:     pkg.GOOS,
-			GOARCH:   pkg.GOARCH,
-		},
-	}
-}
-
 func UnitMeta(path, modulePath, version, name string, isRedistributable bool) *internal.UnitMeta {
 	return &internal.UnitMeta{
 		ModulePath:        modulePath,