Source: latest.go in package golang.org/x/pkgsite/internal


package internal

import (
	"fmt"
	"strings"

	"golang.org/x/mod/modfile"
	"golang.org/x/mod/semver"
)

LatestModuleVersions describes the latest versions of a module. It also holds the go.mod file of the raw latest version, which establishes whether the module is deprecated, and what versions are retracted.

type LatestModuleVersions struct {
	ModulePath         string
	RawVersion         string        // ignoring retractions
	CookedVersion      string        // considering retractions
	GoodVersion        string        // successfully processed
	GoModFile          *modfile.File // of raw
	Deprecated         bool
	deprecationComment string
}

func NewLatestModuleVersions(modulePath, raw, cooked, good string, modBytes []byte) (*LatestModuleVersions, error) {
	modFile, err := modfile.ParseLax(fmt.Sprintf("%s@%s/go.mod", modulePath, raw), modBytes, nil)
	if err != nil {
		return nil, err
	}

	dep, comment := isDeprecated(modFile)
	return &LatestModuleVersions{
		ModulePath:         modulePath,
		RawVersion:         raw,
		CookedVersion:      cooked,
		GoodVersion:        good,
		GoModFile:          modFile,
		Deprecated:         dep,
		deprecationComment: comment,
	}, nil
}

isDeprecated reports whether the go.mod deprecates this module. It looks for "Deprecated" comments in the line comments before and next to the module declaration. If it finds one, it returns true along with the text after "Deprecated:". Otherwise it returns false, "".

func isDeprecated(mf *modfile.File) (bool, string) {
	const prefix = "Deprecated:"

	if mf.Module == nil {
		return false, ""
	}
	for _, comment := range append(mf.Module.Syntax.Before, mf.Module.Syntax.Suffix...) {
		text := strings.TrimSpace(strings.TrimPrefix(comment.Token, "//"))
		if strings.HasPrefix(text, prefix) {
			return true, strings.TrimSpace(text[len(prefix):])
		}
	}
	return false, ""
}

PopulateModuleInfo uses the LatestModuleVersions to populate fields of the given module.

func (li *LatestModuleVersions) PopulateModuleInfo(mi *ModuleInfo) {
	mi.Deprecated = li.Deprecated
	mi.DeprecationComment = li.deprecationComment
	mi.Retracted, mi.RetractionRationale = isRetracted(li.GoModFile, mi.Version)
}

IsRetracted reports whether the version is retracted according to the go.mod file in the receiver.

func (li *LatestModuleVersions) IsRetracted(version string) bool {
	r, _ := isRetracted(li.GoModFile, version)
	return r
}

isRetracted reports whether the go.mod file retracts the version. If so, it returns true along with the rationale for the retraction.

func isRetracted(mf *modfile.File, resolvedVersion string) (bool, string) {
	for _, r := range mf.Retract {
		if semver.Compare(resolvedVersion, r.Low) >= 0 && semver.Compare(resolvedVersion, r.High) <= 0 {
			return true, r.Rationale
		}
	}
	return false, ""