synapsecns/sanguine

package internal

import (
    "fmt"
    "github.com/markbates/pkger"
    "github.com/pkg/errors"
    "golang.org/x/mod/modfile"
    "os"
    "path"
    "path/filepath"
)

const modFileName = "go.mod"

// GetModulePath gets the module path for a dependency
// for example, for ethereum, dependencyName would be github.com/ethereum/go-ethereum
// note: we keep this in place w/ packager so tests can determine valid resolution
// pkger is safe to use directly with the tests in place.
func GetModulePath(dependencyName string) (modPath string, err error) {
    modFile, err := getModfile()
    if err != nil {
        return "", err
    }

    // make sure the module is not a replace which we don't have functionality for yet
    if _, err := hasUnsupportedDirective(modFile, dependencyName); err != nil {
        return "", fmt.Errorf("module has unupoorted directive: %w", err)
    }

    var resolvedModule *modfile.Require
    for _, mod := range modFile.Require {
        // this is our module
        if mod.Mod.Path == dependencyName {
            resolvedModule = mod
        }
    }

    if resolvedModule == nil {
        return "", fmt.Errorf("could not find module at %s in go.mod", dependencyName)
    }

    // now we use pkger to resolve the module name. If we could've done this the whole time, why didn't we?
    // a) we need the module included in the go.mod so we don't have to run go mod tidy after generation.
    //   pkger is go module aware, but it's user friendliness comes at a cost. It'll try to import
    //   things that aren't in the modules file
    // b) pkger will not handle replaces: see the above check
    depModFile, err := pkger.Open(fmt.Sprintf("%s/:go.mod", dependencyName))
    if err != nil {
        return "", fmt.Errorf("pkger could not resolve go.mod file: %w", err)
    }
    resolvedModFile := path.Join(depModFile.Info().Dir, modFileName)

    //nolint: gosec
    depModFileContents, err := os.ReadFile(resolvedModFile)
    if err != nil {
        return "", fmt.Errorf("could not read resolved module file at %s: %w", depModFile.Path().String(), err)
    }

    // parse the resolved module file
    parsedFile, err := modfile.Parse(depModFile.Path().String(), depModFileContents, nil)
    if err != nil {
        return "", fmt.Errorf("could not read mod file: %w", err)
    }

    if parsedFile.Module.Mod.Path != depModFile.Info().Module.Path {
        return "", fmt.Errorf("incorrect module resolved at path %s, expected: %s got %s", depModFile.Path().String(),
            parsedFile.Module.Mod.String(),
            resolvedModule.Mod.String())
    }

    return depModFile.Info().Dir, nil
}

// hasUnsupportedDirective checks if the module is either a replace or exclude which are not currently supported
// note: there's no reason they can't be. We just don't use them at all yet.
func hasUnsupportedDirective(modFile *modfile.File, dependencyName string) (ok bool, err error) {
    for _, mod := range modFile.Replace {
        if mod.Old.Path == dependencyName {
            return true, errors.New("replaced modules are not currently supported")
        }
    }

    for _, mod := range modFile.Exclude {
        if mod.Mod.Path == dependencyName {
            return true, errors.New("excluded modules are not currently supported")
        }
    }
    return false, nil
}

// findModPath recursively searches parent directories for the module path.
// Throws an error if it hits a breakpoint (either due to permissions or getting to repo root).
func findModPath() (string, error) {
    currentPath, err := os.Getwd()
    if err != nil {
        return "", fmt.Errorf("could not get current path: %w", err)
    }

    for {
        exists := true

        prospectiveFile := filepath.Join(currentPath, modFileName)

        if _, err := os.Stat(prospectiveFile); os.IsNotExist(err) {
            exists = false
        }

        if !exists {
            lastPath := currentPath
            currentPath = filepath.Dir(currentPath)

            if lastPath == currentPath {
                return "", errors.New("could not find go.mod file")
            }

            continue
        }

        return prospectiveFile, nil
    }
}

// getModFile gets the module file from the root of the repo. It returns an error if the module cannot be found.
func getModfile() (*modfile.File, error) {
    modFile, err := findModPath()
    if err != nil {
        return nil, fmt.Errorf("could not get modfile: %w", err)
    }

    // read the file
    //nolint: gosec
    modContents, err := os.ReadFile(modFile)
    if err != nil {
        return nil, fmt.Errorf("could not read modfile: %w", err)
    }

    parsedFile, err := modfile.Parse(modFile, modContents, nil)
    if err != nil {
        return nil, fmt.Errorf("could not parse mod file")
    }

    return parsedFile, nil
}