}

        Set<String> foundAdocFiles = new HashSet<>();
        try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {
            pathStream.filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".adoc"))
                .map(p -> p.getFileName().toString())
                .forEach(foundAdocFiles::add);
        }

                if (Files.isRegularFile(consumer)) {
                    return consumer.toFile();
                }
            }
        }
        Path target = getArtifactPath(artifact);
        return Files.isRegularFile(target) ? target.toFile() : null;
    }

    /**

        result.add(cliOptions);
        // atFile option
        if (cliOptions.atFile().isPresent()) {
            Path file = context.cwd.resolve(cliOptions.atFile().orElseThrow());
            if (Files.isRegularFile(file)) {
                result.add(parseMavenAtFileOptions(file));
            } else {
                throw new IllegalArgumentException("Specified file does not exists (" + file + ")");
            }
        }

                        installationToolchainsFile != null && Files.isRegularFile(installationToolchainsFile)
                                ? Sources.fromPath(installationToolchainsFile)
                                : null)
                .userToolchainsSource(
                        userToolchainsFile != null && Files.isRegularFile(userToolchainsFile)
                                ? Sources.fromPath(userToolchainsFile)

        if (Files.isDirectory(relatedPom)) {
            // TODO figure out how to reuse ModelLocator.locatePom(File) here
            relatedPom = relatedPom.resolve("pom.xml");
        }

        if (Files.isRegularFile(relatedPom) && Files.isReadable(relatedPom)) {
            return new FileModelSource(relatedPom.normalize());
        }

        return null;
    }

    @Override
    public URI getLocationURI() {

    for (classPathEntry in entries) {
      deployFile(classPathEntry.toPath())
    }
  }

  private fun RepositoryPlugin.deployFile(file: Path) {
    if (fileSystem.metadataOrNull(file)?.isRegularFile != true) return
    try {
      fileSystem.read(file) {
        put(inputStream(), RepositoryPlugin.PutOptions())
        println("Deployed ${file.name}")
      }
    } catch (e: IllegalArgumentException) {

                && "".equals(artifact.getClassifier())
                && artifact.getPath() != null) {
            Path artifactPath = artifact.getPath();
            if (Files.isRegularFile(artifactPath)) {
                try (JarFile artifactJar = new JarFile(artifactPath.toFile(), false)) {
                    ZipEntry pluginDescriptorEntry = artifactJar.getEntry(PLUGIN_DESCRIPTOR_LOCATION);

            }
        });
    }

    protected void failIfFileNotExists(LocalContext context, String fileName, String message) {
        Path path = context.cwd.resolve(fileName);
        if (!Files.isRegularFile(path)) {
            context.parsingFailed = true;
            context.parserRequest.logger().error(message + ": " + path);
        }
    }

    protected InvokerRequest getInvokerRequest(LocalContext context) {

        if (context.options().altUserSettings().isPresent()) {
            userSettingsFile =
                    context.cwd.resolve(context.options().altUserSettings().get());

            if (!Files.isRegularFile(userSettingsFile)) {
                throw new FileNotFoundException("The specified user settings file does not exist: " + userSettingsFile);
            }
        } else {
            String userSettingsFileStr =

            ArtifactRepository repository,
            LinkedHashMap<String, Set<String>> candidates) {
        if (metadata != null && metadata.getPath() != null && Files.isRegularFile(metadata.getPath())) {
            try {
                Map<String, ?> options = Collections.singletonMap(MetadataReader.IS_STRICT, Boolean.FALSE);

                Metadata pluginGroupMetadata =