}
        i++
      }
      if (path == null) {
        // TODO: send bad request error
        throw AssertionError()
      }
      val file = File(baseDirectory.toString() + path)
      if (file.isDirectory) {
        serveDirectory(stream, file.listFiles()!!)
      } else if (file.exists()) {
        serveFile(stream, file)
      } else {
        send404(stream, path)
      }
    } catch (e: IOException) {

        File targetFile = baseDir;
        for (int i = 0; i < paths.length - 1; i++) {
            File file = new File(targetFile, paths[i]);
            if (file.exists()) {
                if (!file.isDirectory()) {
                    for (int j = 0; j < maxDuplicatedPath; j++) {
                        file = new File(targetFile, paths[i] + "_" + j);
                        if (!file.exists()) {

        return path != null ? path.toFile() : null;
    }

    @Override
    public Path locateExistingPom(Path project) {
        if (project == null || Files.isDirectory(project)) {
            project = locatePom(project);
        }
        if (Files.isDirectory(project)) {
            Path pom = project.resolve("pom.xml");
            return Files.isRegularFile(pom) ? pom : null;
        } else if (Files.isRegularFile(project)) {

   * LinkOption...)} on input paths with the given link options.
   */
  public static Predicate<Path> isDirectory(LinkOption... options) {
    final LinkOption[] optionsCopy = options.clone();
    return new Predicate<Path>() {
      @Override
      public boolean apply(Path input) {
        return Files.isDirectory(input, optionsCopy);
      }

      @Override

   * LinkOption...)} on input paths with the given link options.
   */
  public static Predicate<Path> isDirectory(LinkOption... options) {
    final LinkOption[] optionsCopy = options.clone();
    return new Predicate<Path>() {
      @Override
      public boolean apply(Path input) {
        return Files.isDirectory(input, optionsCopy);
      }

      @Override

      Files.createSymbolicLink(symlinkToFile, file);

      assertTrue(MoreFiles.isDirectory().apply(symlinkToDir));
      assertFalse(MoreFiles.isRegularFile().apply(symlinkToDir));

      assertFalse(MoreFiles.isDirectory().apply(symlinkToFile));
      assertTrue(MoreFiles.isRegularFile().apply(symlinkToFile));

      assertFalse(MoreFiles.isDirectory(NOFOLLOW_LINKS).apply(symlinkToDir));

  val request = Request("https://publicsuffix.org/list/public_suffix_list.dat".toHttpUrl())

  suspend fun import() {
    check(fileSystem.metadata(resources).isDirectory)
    check(fileSystem.metadata(testResources).isDirectory)

    updateLocalFile()

    val importResults = readImportResults()

    writeOutputFile(importResults)
  }

  private suspend fun updateLocalFile() =

 */
@Named
@Deprecated(since = "4.0.0")
public class DefaultRootLocator implements RootLocator {

    public boolean isRootDirectory(Path dir) {
        if (Files.isDirectory(dir.resolve(".mvn"))) {
            return true;
        }
        // we're too early to use the modelProcessor ...
        Path pom = dir.resolve("pom.xml");
        try (InputStream is = Files.newInputStream(pom)) {

                if ("file".equals(resource.getProtocol())) {
                    final File directory = new File(resource.getFile());
                    if (directory.exists() && directory.isDirectory()) {
                        final File[] files = directory.listFiles(File::isDirectory);
                        if (files != null) {
                            for (final File file : files) {
                                final String name = file.getName();

    public void cleanUp() throws IOException {
        for (Iterator it = filesToDelete.iterator(); it.hasNext(); ) {
            File file = (File) it.next();

            if (file.exists()) {
                if (file.isDirectory()) {
                    FileUtils.deleteDirectory(file);
                } else {
                    file.delete();
                }
            }

            it.remove();
        }