synapsecns/sanguine

package moduledetector

import (
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    "github.com/kendru/darwin/go/depgraph"
    "github.com/vishalkuo/bimap"
    "golang.org/x/mod/modfile"
    "os"
    "path"
    "path/filepath"
    "strings"
)

// getDependencyGraph returns a dependency graph of all the modules in the go.work file that refer to other modules in the go.work file
// returns a map of module (./my_module)->(./my_module_dependency1,./my_module_dependency2).
// nolint: cyclop
func getDependencyGraph(repoPath string) (moduleDeps map[string][]string, err error) {
    moduleDeps = make(map[string][]string)
    // parse the go.work file
    goWorkPath := path.Join(repoPath, "go.work")

    if !common.FileExist(goWorkPath) {
        return nil, fmt.Errorf("go.work file not found in %s", repoPath)
    }

    //nolint: gosec
    workFile, err := os.ReadFile(goWorkPath)
    if err != nil {
        return nil, fmt.Errorf("failed to read go.work file: %w", err)
    }

    parsedWorkFile, err := modfile.ParseWork(goWorkPath, workFile, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to parse go.work file: %w", err)
    }

    // map of module->dependencies + replaces
    var dependencies map[string]map[string]struct{}
    // bidirectional map of module->module
    // moduleRelativeName <-> modulePublicName
    var dependencyNames *bimap.BiMap[string, string]

    // iterate through each module in the go.work file
    // create a list of dependencies for each module
    // and module names
    dependencies, dependencyNames, err = makeDepMaps(repoPath, parsedWorkFile.Use)
    if err != nil {
        return nil, fmt.Errorf("failed to create dependency maps: %w", err)
    }

    depGraph := depgraph.New()
    // build the dependency graph
    for _, module := range parsedWorkFile.Use {
        for dep := range dependencies[module.Path] {
            // check if the full package name (e.g. github.com/myorg/myrepo/mymodule) is in the list of modules. If it is, add it as a dependency after renaming
            renamedDep, hasDep := dependencyNames.GetInverse(dep)
            if hasDep {
                err = depGraph.DependOn(module.Path, renamedDep)
                if err != nil {
                    return nil, fmt.Errorf("failed to add dependency %s -> %s: %w", module.Path, dep, err)
                }
            }

            if isRelativeDep(dep) {
                // if the dependency is relative, add it as a dependency
                err = depGraph.DependOn(module.Path, dep)
                if err != nil {
                    return nil, fmt.Errorf("failed to add dependency %s -> %s: %w", module.Path, dep, err)
                }
            }
        }
    }

    for _, module := range parsedWorkFile.Use {
        for dep := range depGraph.Dependencies(module.Path) {
            moduleDeps[module.Path] = append(moduleDeps[module.Path], dep)
        }
    }

    return moduleDeps, nil
}

// makeDepMaps builds a
// 1. module->dependency map
// 2. bidirectional map of module<->module (moduleRelativeName to modulePublicName).
func makeDepMaps(repoPath string, uses []*modfile.Use) (dependencies map[string]map[string]struct{}, dependencyNames *bimap.BiMap[string, string], err error) {
    // map of module->depndencies
    dependencies = make(map[string]map[string]struct{})

    // bidirectional map of module->module name
    // Maps relative to public names, used to filer out all external libraries/packages.
    dependencyNames = bimap.NewBiMap[string, string]()

    // iterate through each module in the go.work file
    // 1. Create a list of dependencies for each module
    // 2. Map public names to private names for each module
    //nolint: gosec
    for _, module := range uses {
        modContents, err := os.ReadFile(filepath.Join(repoPath, module.Path, "go.mod"))
        if err != nil {
            return dependencies, dependencyNames, fmt.Errorf("failed to read module file %s: %w", module.Path, err)
        }

        parsedModFile, err := modfile.Parse(module.Path, modContents, nil)
        if err != nil {
            return dependencies, dependencyNames, fmt.Errorf("failed to parse module file %s: %w", module.Path, err)
        }

        dependencyNames.Insert(module.Path, parsedModFile.Module.Mod.Path)
        dependencies[module.Path] = make(map[string]struct{})

        // include all requires and replaces, as they are dependencies
        for _, require := range parsedModFile.Require {
            dependencies[module.Path][convertRelPath(repoPath, module.Path, require.Mod.Path)] = struct{}{}
        }
        for _, require := range parsedModFile.Replace {
            dependencies[module.Path][convertRelPath(repoPath, module.Path, require.New.Path)] = struct{}{}
        }
    }

    return dependencies, dependencyNames, nil
}

// isRelativeDep returns true if the dependency is relative to the module (starts with ./ or ../).
func isRelativeDep(path string) bool {
    return strings.HasPrefix(path, "./") || strings.HasPrefix(path, "../")
}

// convertRelPath converts a path relative to a module to a path relative to the repository root.
// it does nothing if the path does not start with ./ or ../.
func convertRelPath(repoPath string, modulePath, dependency string) string {
    if !isRelativeDep(dependency) {
        return dependency
    }

    // repo/./module => repo/module
    fullModulePath := filepath.Join(repoPath, modulePath)
    // repo/module/../dependency => repo/dependency
    fullDependencyPath := filepath.Join(fullModulePath, dependency)
    // repo/dependency => dependency
    trimmedPath := strings.TrimPrefix(fullDependencyPath, repoPath)
    if len(trimmedPath) == 0 {
        return "."
    }

    return fmt.Sprintf(".%s", trimmedPath)
}