path: root/src/main/java/org/javacs/FileStore.java

package org.javacs;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import org.javacs.lsp.DidChangeTextDocumentParams;
import org.javacs.lsp.DidCloseTextDocumentParams;
import org.javacs.lsp.DidOpenTextDocumentParams;
import org.javacs.lsp.TextDocumentContentChangeEvent;

class FileStore {

    private static final Set<Path> workspaceRoots = new HashSet<>();

    private static final Map<URI, VersionedContent> activeDocuments = new HashMap<>();

    /** javaSources[file] is the javaSources time of a .java source file. */
    // TODO organize by package name for speed of list(...)
    private static final TreeMap<Path, Info> javaSources = new TreeMap<>();

    private static class Info {
        final Instant modified;
        final String packageName;

        Info(Instant modified, String packageName) {
            this.modified = modified;
            this.packageName = packageName;
        }
    }

    static void setWorkspaceRoots(Set<Path> newRoots) {
        newRoots = normalize(newRoots);
        for (var root : workspaceRoots) {
            if (!newRoots.contains(root)) {
                workspaceRoots.removeIf(f -> f.startsWith(root));
            }
        }
        for (var root : newRoots) {
            if (!workspaceRoots.contains(root)) {
                addFiles(root);
            }
        }
        workspaceRoots.clear();
        workspaceRoots.addAll(newRoots);
    }

    private static Set<Path> normalize(Set<Path> newRoots) {
        var normalize = new HashSet<Path>();
        for (var root : newRoots) {
            normalize.add(root.toAbsolutePath().normalize());
        }
        return normalize;
    }

    private static void addFiles(Path root) {
        try {
            Files.walk(root).filter(FileStore::isJavaFile).forEach(FileStore::readInfoFromDisk);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static Collection<Path> all() {
        return javaSources.keySet();
    }

    static List<Path> list(String packageName) {
        var list = new ArrayList<Path>();
        for (var kv : javaSources.entrySet()) {
            var file = kv.getKey();
            var info = kv.getValue();
            if (info.packageName.equals(packageName)) list.add(file);
        }
        return list;
    }

    static boolean contains(Path file) {
        return isJavaFile(file) && javaSources.containsKey(file);
    }

    static Instant modified(Path file) {
        // If we've never checked before, look up modified time on disk
        if (!javaSources.containsKey(file)) {
            readInfoFromDisk(file);
        }

        // Look up modified time from cache
        return javaSources.get(file).modified;
    }

    static String packageName(Path file) {
        // If we've never checked before, look up modified time on disk
        if (!javaSources.containsKey(file)) {
            readInfoFromDisk(file);
        }

        // Look up modified time from cache
        return javaSources.get(file).packageName;
    }

    static String suggestedPackageName(Path file) {
        var sourceRoot = sourceRoot(file);
        var relativePath = sourceRoot.relativize(file).getParent();
        if (relativePath == null) return "";
        return relativePath.toString().replace(File.separatorChar, '.');
    }

    private static Path sourceRoot(Path file) {
        for (var dir = file.getParent(); dir != null; dir = dir.getParent()) {
            for (var related : javaSourcesIn(dir)) {
                if (related.equals(file)) continue;
                var packageName = packageName(related);
                var relativePath = Paths.get(packageName.replace('.', File.separatorChar));
                var sourceRoot = dir;
                for (var i = 0; i < relativePath.getNameCount(); i++) {
                    sourceRoot = sourceRoot.getParent();
                }
                return sourceRoot;
            }
        }
        return file.getParent();
    }

    private static List<Path> javaSourcesIn(Path dir) {
        var tail = javaSources.tailMap(dir, false);
        var list = new ArrayList<Path>();
        for (var file : tail.keySet()) {
            if (!file.startsWith(dir)) break;
            list.add(file);
        }
        return list;
    }

    static void externalCreate(Path file) {
        readInfoFromDisk(file);
    }

    static void externalChange(Path file) {
        readInfoFromDisk(file);
    }

    static void externalDelete(Path file) {
        javaSources.remove(file);
    }

    private static void readInfoFromDisk(Path file) {
        try {
            var time = Files.getLastModifiedTime(file).toInstant();
            var packageName = Parser.packageName(file);
            javaSources.put(file, new Info(time, packageName));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static void open(DidOpenTextDocumentParams params) {
        var document = params.textDocument;
        var uri = document.uri;
        if (!isJavaFile(uri)) return;
        activeDocuments.put(uri, new VersionedContent(document.text, document.version));
    }

    static void change(DidChangeTextDocumentParams params) {
        var document = params.textDocument;
        var uri = document.uri;
        if (isJavaFile(uri)) {
            var existing = activeDocuments.get(uri);
            var newText = existing.content;

            if (document.version > existing.version) {
                for (var change : params.contentChanges) {
                    if (change.range == null) newText = change.text;
                    else newText = patch(newText, change);
                }

                activeDocuments.put(uri, new VersionedContent(newText, document.version));
            } else LOG.warning("Ignored change with version " + document.version + " <= " + existing.version);
        }
    }

    static void close(DidCloseTextDocumentParams params) {
        var document = params.textDocument;
        var uri = document.uri;
        if (isJavaFile(uri)) {
            // Remove from source cache
            activeDocuments.remove(uri);
        }
    }

    static Set<URI> activeDocuments() {
        return activeDocuments.keySet();
    }

    static int version(URI file) {
        if (!activeDocuments.containsKey(file)) return -1;
        return activeDocuments.get(file).version;
    }

    static String contents(URI file) {
        if (!isJavaFile(file)) {
            throw new RuntimeException(file + " is not a java file");
        }
        if (activeDocuments.containsKey(file)) {
            return activeDocuments.get(file).content;
        }
        try {
            // TODO I think there is a faster path here
            return Files.readAllLines(Paths.get(file)).stream().collect(Collectors.joining("\n"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static String contents(Path file) {
        return contents(file.toUri());
    }

    static InputStream inputStream(Path file) {
        var uri = file.toUri();
        if (activeDocuments.containsKey(uri)) {
            var string = activeDocuments.get(uri).content;
            var bytes = string.getBytes();
            return new ByteArrayInputStream(bytes);
        }
        try {
            return Files.newInputStream(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static BufferedReader bufferedReader(Path file) {
        var uri = file.toUri();
        if (activeDocuments.containsKey(uri)) {
            var string = activeDocuments.get(uri).content;
            return new BufferedReader(new StringReader(string));
        }
        try {
            return Files.newBufferedReader(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static BufferedReader lines(Path file) {
        try {
            return Files.newBufferedReader(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static String patch(String sourceText, TextDocumentContentChangeEvent change) {
        try {
            var range = change.range;
            var reader = new BufferedReader(new StringReader(sourceText));
            var writer = new StringWriter();

            // Skip unchanged lines
            int line = 0;

            while (line < range.start.line) {
                writer.write(reader.readLine() + '\n');
                line++;
            }

            // Skip unchanged chars
            for (int character = 0; character < range.start.character; character++) writer.write(reader.read());

            // Write replacement text
            writer.write(change.text);

            // Skip replaced text
            reader.skip(change.rangeLength);

            // Write remaining text
            while (true) {
                int next = reader.read();

                if (next == -1) return writer.toString();
                else writer.write(next);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static boolean isJavaFile(Path file) {
        var name = file.getFileName().toString();
        // We hide module-info.java from javac, because when javac sees module-info.java
        // it goes into "module mode" and starts looking for classes on the module class path.
        // This becomes evident when javac starts recompiling *way too much* on each task,
        // because it doesn't realize there are already up-to-date .class files.
        // The better solution would be for java-language server to detect the presence of module-info.java,
        // and go into its own "module mode" where it infers a module source path and a module class path.
        return name.endsWith(".java") && !name.equals("module-info.java");
    }

    static boolean isJavaFile(URI uri) {
        return uri.getScheme().equals("file") && isJavaFile(Paths.get(uri));
    }

    private static Set<Path> allJavaFilesInDirs(Set<Path> dirs) {
        var all = new HashSet<Path>();
        for (var dir : dirs) {
            try {
                Files.walk(dir).filter(FileStore::isJavaFile).forEach(all::add);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return all;
    }

    private static Set<Path> sourcePath(Set<Path> workspaceRoots) {
        LOG.info("Searching for source roots in " + workspaceRoots);

        var certaintyThreshold = 10;
        var sourceRoots = new HashMap<Path, Integer>();
        fileLoop:
        for (var file : allJavaFilesInDirs(workspaceRoots)) {
            // First, check if we already have a high-confidence source root containing file
            for (var root : sourceRoots.keySet()) {
                var confidence = sourceRoots.get(root);
                if (file.startsWith(root) && confidence > certaintyThreshold) {
                    continue fileLoop;
                }
            }
            // Otherwise, parse the file and look at its package declaration
            var parse = Parser.parse(file);
            var packageName = Objects.toString(parse.getPackageName(), "");
            var packagePath = packageName.replace('.', File.separatorChar);
            // If file has no package declaration, don't try to guess a source root
            // This is probably a new file that the user will add a package declaration to later
            if (packagePath.isEmpty()) {
                LOG.warning("Ignoring file with missing package declaration " + file);
                continue fileLoop;
            }
            // If path to file contradicts package declaration, give up
            var dir = file.getParent();
            if (!dir.endsWith(packagePath)) {
                LOG.warning("Java source file " + file + " is not in " + packagePath);
                continue fileLoop;
            }
            // Otherwise, use the package declaration to guess the source root
            var up = Paths.get(packagePath).getNameCount();
            var sourceRoot = dir;
            for (int i = 0; i < up; i++) {
                sourceRoot = sourceRoot.getParent();
            }
            // Increment our confidence in sourceRoot as a source root
            var count = sourceRoots.getOrDefault(sourceRoot, 0);
            sourceRoots.put(sourceRoot, count + 1);
        }
        return sourceRoots.keySet();
    }

    private static final Logger LOG = Logger.getLogger("main");
}