*/
    public String determineGeneratedParserPath() {
        if (isEmpty(getPackageName())) {
            return getClassName() + ".java";
        } else {
            return getPackageName().replace('.', File.separatorChar) + File.separatorChar + getClassName() + ".java";
        }
    }

    private boolean isEmpty(String packageName) {
        return packageName == null || packageName.trim().length() == 0;
    }

    }

    @Override
    public Server getServer() {
        return servers.isEmpty() ? null : servers.get(0);
    }

    @Override
    public List<Server> getServers() {
        return servers;
    }

    @Override
    public Proxy getProxy() {
        return proxies.isEmpty() ? null : proxies.get(0);
    }

    @Override
    public List<Proxy> getProxies() {

        LinkedList<String> fromPath = splitPath(from);
        LinkedList<String> toPath = splitPath(to);
        List<String> relativePath = new ArrayList<String>();

        while (!fromPath.isEmpty() && !toPath.isEmpty() && fromPath.get(0).equals(toPath.get(0))) {
            fromPath.removeFirst();
            toPath.removeFirst();
        }
        for (String ignored : fromPath) {
            relativePath.add("..");

    private final NavigableSet<Node> finalizingSuccessors = newSortedNodeSet();

    @Override
    protected void nodeSpecificHealthDiagnostics(StringBuilder builder) {
        if (!finalizingSuccessors.isEmpty()) {
            builder.append(", finalizes=").append(formatNodes(finalizingSuccessors));
        }
    }

    public Set<Node> getMustSuccessors() {
        return getDependencyNodes().getMustSuccessors();
    }

        return builder.toString();
    }

    private boolean requiredOnly() {
        return (getPreferredVersion().isEmpty() || getRequiredVersion().equals(getPreferredVersion()))
                && getStrictVersion().isEmpty()
                && getRejectedVersions().isEmpty()
                && getBranch() == null;
    }

    private String rejectedVersionsString() {

package org.gradle;

import org.apache.commons.lang.StringUtils;

/**
 * <p>Represents a person.</p>
 */
public class Person {
    private final String name;

    public Person(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException();
        }
        this.name = name;
    }

    /**
     * Get the person's name
     *
     * @return the name
     */

        if (jdk == null) {
            return false;
        }

        String version = context.getSystemProperties().get("java.version");

        if (version == null || version.isEmpty()) {
            problems.add(
                    BuilderProblem.Severity.ERROR,
                    ModelProblem.Version.BASE,
                    "Failed to determine Java version for profile " + profile.getId(),

        if (jdk == null) {
            return false;
        }

        String version = context.getSystemProperties().get("java.version");

        if (version == null || version.isEmpty()) {
            problems.add(new ModelProblemCollectorRequest(Severity.ERROR, Version.BASE)
                    .setMessage("Failed to determine Java version for profile " + profile.getId())

        if (variants.isEmpty()) {
            return ImmutableList.of();
        }
        List<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = Lists.newArrayListWithExpectedSize(variants.size());

    }

    @Override
    public Set<String> getClassNames(String sourceFileRelativePath) {
        Set<String> classNames = delegate.getClassNames(sourceFileRelativePath);
        if (!classNames.isEmpty()) {
            return classNames;
        }

        for (String fileExtension : fileExtensions) {
            if (sourceFileRelativePath.endsWith(fileExtension)) {