import org.gradle.internal.exceptions.Contextual;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

/**
 * Thrown when a model rule, or source of model rules, is declared in an invalid way.
 */
@Incubating
@Contextual
public class InvalidModelRuleDeclarationException extends GradleException {

    public InvalidModelRuleDeclarationException(String message) {
        super(message);
    }

 * this interface can do. For example, the {@link DynamicObject} may provide the ability to register new
 * properties or implement methods that this object does not provide in a concrete way.
 */
@NonNullApi
public interface DynamicObjectAware {

    /**
     * Returns a {@link DynamicObject} for this object. This should include all static and dynamic properties and methods for this object.
     *

                );
                formatter.endChildren();
            }
        }
    }

    /**
     * This is an adhoc reformatting tool which should go away as soon as we have
     * a better way to display multiline deprecation warnings
     */
    public static String convertToSingleLine(String message) {
        return message.replaceAll("(\\r?\\n *)+", ". ")
            .replaceAll("[.]+", ".")

    // The usage pattern of this exception providing the rule identity and the cause providing the detail is the
    // way it is due to how we render chained exceptions on build failures.
    // That is, because the information is usually dense, splitting things up this way provides better output.

    private final String descriptor;

    public InvalidModelRuleException(ModelRuleDescriptor descriptor, Throwable cause) {

/**
 * Generates DSL reference material using Docbook and some homegrown class parsing.
 *
 * TODO: It would be nice to replace the Docbook portion of this with Asciidoc so that it could be
 * generated in the same way as the user manual with cross-links between them.
 */
public class GradleDslReferencePlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();

    public abstract void finalizeOnNextGet();

    public abstract void disallowUnsafeRead();

    /**
     * Marks this value state as being explicitly assigned. Does not remember the given value in any way.
     *
     * @param value the new explicitly assigned value
     * @return the very <code>value</code> given
     */
    //TODO-RC rename this or the overload as they have significantly different semantics

@SuppressWarnings({"deprecation", "FieldNamingConvention"})
public class ConventionAwareHelper implements ConventionMapping, org.gradle.api.internal.HasConvention {
    //prefix internal fields with _ so that they don't get into the way of propertyMissing()
    private final org.gradle.api.plugins.Convention _convention;
    private final IConventionAware _source;
    // These are properties that could have convention mapping applied to them

     *
     * <p>When a file collection represents a container of file collections, the children of the file collection are visited in order. Visiting a child works in the
     * same way as visiting this collection, starting with a call to {@link #startVisit(FileCollectionInternal.Source, FileCollectionInternal)}.
     *

import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.external.javadoc.StandardJavadocDocletOptions;

import javax.inject.Inject;
import java.io.File;

/**
 * Generates Javadocs in a particular way.
 *
 * TODO: We should remove the workarounds here and migrate some of the changes here into the Javadoc task proper.
 */
public abstract class GradleJavadocsPlugin implements Plugin<Project> {

    @Inject

    /**
     * Creates a {@link FileCollection} with the given contents, and visiting its task dependencies (the tasks that it is built by) in the specified way.
     * <p>
     * The collection is live, so that the contents are queried as required on query of the collection.
     *
     * @param contents The file set contents for the constructed file collection