FileLookup.java

package appland.files;

import appland.index.AppMapSearchScopes;
import com.google.common.collect.Lists;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.DumbService;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.search.FilenameIndex;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.concurrency.annotations.RequiresReadLock;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * This class locates files by relative paths.
 * <p>
 * AppMaps contain relative paths. Although these paths are usually based on the "project root path" the root path isn't
 * clearly defined.
 * <p>
 * This class tries to locate the best matching file in the project.
 */
public class FileLookup {
    private static final Logger LOG = Logger.getInstance(FileLookup.class);

    /**
     * @param project      Current project
     * @param base         The base file or directory. This usually is the currently opened appmap file. {@code null} indicates that no context is available.
     * @param relativePath A relative path, it has to use / as delimiter.
     * @return The target file, if it was found
     */
    @RequiresReadLock
    public static @Nullable VirtualFile findRelativeFile(@NotNull Project project,
                                                         @Nullable VirtualFile base,
                                                         @NotNull String relativePath) {
        return findRelativeFile(project, null, base, relativePath);
    }

    /**
     * @param project      Current project
     * @param searchScope  Search scope to restrict the search if it's a relative path
     * @param base         The base file or directory. This usually is the currently opened appmap file. {@code null} indicates that no context is available.
     * @param relativePath A relative path, it has to use / as delimiter.
     * @return The target file, if it was found
     */
    @RequiresReadLock
    public static @Nullable VirtualFile findRelativeFile(@NotNull Project project,
                                                         @Nullable GlobalSearchScope searchScope,
                                                         @Nullable VirtualFile base,
                                                         @NotNull String relativePath) {
        var appliedSearchScope = AppMapSearchScopes.projectFilesWithExcluded(project);
        if (searchScope != null) {
            appliedSearchScope = appliedSearchScope.intersectWith(searchScope);
        }

        // support the rare case of absolute paths
        if (isAbsolutePath(relativePath)) {
            return LocalFileSystem.getInstance().findFileByPath(relativePath);
        }

        // 1st, try to locate relative to the base path
        if (base != null) {
            var baseDir = base.isDirectory() ? base : base.getParent();
            var file = baseDir.findFileByRelativePath(relativePath);
            if (file != null) {
                return file;
            }
        }

        if (DumbService.isDumb(project)) {
            // no further lookup possible without an index
            return null;
        }

        // Candidates need to be sorted by length to make sure "a/searched/file" is returned and not "a/a/searched/file".
        var candidates = FilenameIndex.getVirtualFilesByName(filename(relativePath), true, appliedSearchScope)
                .stream()
                .sorted(Comparator.comparingInt(o -> o.getPath().length()));
        for (var candidate : candidates.collect(Collectors.toList())) {
            var parent = candidate.getParent();
            for (String expectedParentName : parentsReversed(relativePath)) {
                if (parent == null || !FileUtil.namesEqual(expectedParentName, parent.getName())) {
                    parent = null;
                    break;
                }
                parent = parent.getParent();
            }

            if (parent != null) {
                // the candidate is matching all parent directories in the hierarchy
                return candidate;
            }
        }

        // Fallback: try extension points for finding files in external libraries
        // Language-specific extensions (e.g., Java) run first, followed by generic lookup
        LOG.debug("File not found in project content, trying extension lookups: " + relativePath);
        var data = new AppMapFileLookup.Data(relativePath, null);
        for (var lookup : AppMapFileLookup.EP_NAME.getExtensionList()) {
            var file = lookup.findFile(project, data);
            if (file != null) {
                LOG.debug("File found by extension " + lookup + ": " + file.getPath());
                return file;
            }
        }

        // no match :(
        return null;
    }

    public static boolean isAbsolutePath(@NotNull String relativePath) {
        return isAbsolutePath(relativePath, SystemInfo.isWindows);
    }

    public static boolean isAbsolutePath(@NotNull String relativePath, boolean checkWindowsPath) {
        // handle C:/dir/file.txt or C:\dir\file.txt
        // /-based paths are generated by Ruby on Windows, for example
        if (checkWindowsPath && relativePath.length() >= 3 && relativePath.charAt(1) == ':') {
            var thirdChar = relativePath.charAt(2);
            return thirdChar == '/' || thirdChar == '\\';
        }

        return relativePath.startsWith("/");
    }

    static String filename(@NotNull String path) {
        int index = path.lastIndexOf('/');
        if (index == -1) {
            return path;
        }
        return path.substring(index + 1);
    }

    static List<String> parentsReversed(@NotNull String path) {
        int index = path.lastIndexOf('/');
        if (index == -1) {
            return Collections.emptyList();
        }

        return Lists.reverse(StringUtil.split(path.substring(0, index), "/"));
    }
}