return choice(question, options).defaultOption(defaultOption).ask();
        }

        @Override
        public <T> Choice<T> choice(String question, Collection<T> options) {
            if (options.isEmpty()) {
                throw new IllegalArgumentException("No options provided.");
            }
            return new InteractiveChoiceBuilder<>(this, options, question);
        }

        @Override

            EvictingQueue<String> tailLines = lines.collect(Collectors.toCollection(() -> EvictingQueue.create(tailSize)));
            return tailLines.isEmpty() ? "<<empty>>" : String.join("\n", tailLines);
        }
    }

        builder.append(defaultValue);
        builder.append("): ");
        return builder.toString();
    }

    @Override
    public PromptResult<String> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultValue);
        }
        return PromptResult.response(text);
    }

    public List<String> asDefaultTask() {
        return Collections.singletonList(ProjectInternal.HELP_TASK);
    }

    @Override
    public boolean commandLineMatches(List<String> taskNames) {
        return taskNames.isEmpty() || taskNames.get(0).equals(ProjectInternal.HELP_TASK) || taskNames.get(0).equals(":" + ProjectInternal.HELP_TASK);
    }

                }
            }
        }

        metadata.getVersioning().setSnapshotVersions(new ArrayList<>(versions.values()));

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {
            metadata.setPlugins(new ArrayList<>(recessive.getPlugins()));
        }

        artifacts.clear();
    }

    private String getKey(String classifier, String extension) {

                        groupId,
                        artifactId,
                        version);
            }
            List<Version> versions = session.resolveVersionRange(coord);
            if (versions.isEmpty()) {
                throw new ModelResolverException(
                        String.format("No versions matched the requested version range '%s'", version),
                        groupId,
                        artifactId,

        List<TaskDependency> buildDependencies = populate(project.getRootProject());
        if (!buildDependencies.isEmpty()) {
            Gradle rootGradle = getRootGradle(project.getGradle());
            Project rootProject = rootGradle.getRootProject();
            StartParameter startParameter = rootGradle.getStartParameter();

        @Override
        public <T> T getAttribute(Attribute<T> key) {
            return getDesugared().getAttribute(key);
        }

        @Override
        public boolean isEmpty() {
            return getDesugared().isEmpty();
        }

        @Override
        public boolean contains(Attribute<?> key) {
            return getDesugared().contains(key);
        }

        @Override

            lock.unlock();
        }
    }

    @Override
    public Optional<ServiceRegistry> getCurrentServices() {
        lock.lock();
        try {
            return servicesForHomeDir.isEmpty()
                ? Optional.empty()
                : Optional.of(servicesForHomeDir.values().iterator().next().registry);
        } finally {
            lock.unlock();
        }
    }

    @Override

        metadata = metadata.withVersioning(metadata.getVersioning().withSnapshotVersions(versions.values()));

        // just carry-on as-is
        if (recessive.getPlugins() != null && !recessive.getPlugins().isEmpty()) {
            metadata = metadata.withPlugins(new ArrayList<>(recessive.getPlugins()));
        }

        artifacts.clear();
    }

    private String getKey(String classifier, String extension) {