Set<File> runtimeClasspath = findDependencyJars(moduleName, runtimeJarNames);

        String[] projects = split(properties.getProperty("projects"));
        String[] optionalProjects = split(properties.getProperty("optional"));
        return new DefaultModule(moduleName, implementationClasspath, runtimeClasspath, projects, optionalProjects);
    }

    private Set<File> findDependencyJars(String moduleName, String[] jarNames) {

        task.asciidoctorj.docExtensions(
            project.getDependencies().create(project(":docs-asciidoctor-extensions-base")),
        )
    } else {
        task.asciidoctorj.docExtensions(
            project.getDependencies().create(project(":docs-asciidoctor-extensions")),
            project.getDependencies().create(project.files("src/main/resources"))
        )
    }
}

gradleDocumentation {

}

const (
	projectsHeader = `# This is a /etc/projects header
1048578:/quota/d
`
	projects1 = `1048577:/quota1/a
`
	projects2 = `1048577:/quota1/a
1048580:/quota1/b
`
	projects3 = `1048577:/quota1/a
1048580:/quota1/b
1048581:/quota2/b
`
	projects4 = `1048577:/quota1/a
1048581:/quota2/b
`
	projects5 = `1048581:/quota2/b
`

            allprojects { task someTask }
            project(':a') { task someTaskA }
            project(':b') { task someTaskB }
        """

        when:
        fails "someTest"

        then:
        verifyAll(receivedProblem) {
            fqid == 'task-selection:no-matches'

Resolving a configuration can have side effects on Gradle's project model.
As a result, Gradle must manage access to each project's configurations.
There are a number of ways a configuration might be resolved unsafely.
For example:

* A task from one project directly resolves a configuration in another project in the task's action.
* A task specifies a configuration from another project as an input file collection.

[[sec:binary_plugin_example]]
[source, build.gradle.kts]
----
class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        println("Plugin ${this.javaClass.simpleName} applied on ${project.name}")
    }
}

apply<MyPlugin>()
----

/**
 * A model resolver to assist building of projects. This resolver gives priority to those repositories that have been
 * declared in the POM.
 *
 */
public class ProjectModelResolver implements ModelResolver {

    private static final int MAX_CAP = 0x7fff;

    private final RepositorySystemSession session;

    private final RequestTrace trace;

    private final String context = "project";

The default behavior is equivalent to calling this method:

.Preferring rules declared in projects
====
include::sample[dir="snippets/dependencyManagement/customizingResolution-metadataRule/kotlin",files="settings.gradle.kts[tags=prefer-projects]"]
include::sample[dir="snippets/dependencyManagement/customizingResolution-metadataRule/groovy",files="settings.gradle[tags=prefer-projects]"]
====


[[sec:component_metadata_rules_details]]

            return delegate.project(referrer, path, configureAction)
        }

        override fun project(referrer: ProjectInternal, path: String, configureAction: Action<in Project>): ProjectInternal {
            return delegate.project(referrer, path, configureAction)
        }

        override fun getSubprojects(): Set<Project> {

import "io"

// There's no RFC for bzip2. I used the Wikipedia page for reference and a lot
// of guessing: https://en.wikipedia.org/wiki/Bzip2
// The source code to pyflate was useful for debugging:
// http://www.paul.sladen.org/projects/pyflate

// A StructuralError is returned when the bzip2 data is found to be
// syntactically invalid.
type StructuralError string

func (s StructuralError) Error() string {
	return "bzip2 data invalid: " + string(s)