// tag::plugin-extension[]
plugins {
    id 'org.myorg.binary-repository-version'
}

binaryRepo {
    coordinates = 'commons-lang:commons-lang'
    serverUrl = 'http://repo2.myorg.org/maven2'
}
// end::plugin-extension[]

// tag::direct-task-register[]
tasks.register('latestVersionMavenCentral', LatestArtifactVersion) {
    coordinates = 'commons-lang:commons-lang'
    serverUrl = 'http://repo1.maven.org/maven2'
}

import org.gradle.api.internal.attributes.ImmutableAttributes;

class ComponentData {
    final ModuleVersionIdentifier coordinates;
    final ImmutableAttributes attributes;

    ComponentData(ModuleVersionIdentifier coordinates, ImmutableAttributes attributes) {
        this.coordinates = coordinates;
        this.attributes = attributes;
    }

            properties["hibernate.version"] == "5.4.1.Final"
        }
    }

    def "encodes coordinates for XML and unicode"() {
        given:
        pom.coordinates.groupId.set('group-ぴ₦ガき∆ç√∫')
        pom.coordinates.artifactId.set('artifact-<tag attrib="value"/>-markup')
        pom.coordinates.version.set('version-&"')

        expect:
        with (xml) {
            groupId == 'group-ぴ₦ガき∆ç√∫'

Found the following publications in <project>:
  - Publication 'mock' with coordinates pub-group:pub-name:pub-version
  - Publication 'pub2' with coordinates other-group:other-name:other-version""")
    }

    def "resolve fails when target project has multiple component publications with different coordinates"() {
        given:

/**
 * Given a declared dependency to be published, determines the coordinates
 * that should be used to reference the dependency in published metadata. Dependencies
 * are resolved to component-level precision, meaning the coordinates of the resolved
 * variant's owning component are returned.
 */
public interface ComponentDependencyResolver {

    /**
     * Determines the published coordinates for an external dependency to component-level precision.

/**
 * Given a declared dependency to be published, determines the coordinates
 * that should be used to reference the dependency in published metadata. Dependencies
 * are resolved to variant-level precision, meaning that if resolved variant
 * is published to different coordinates than the declared component, the
 * variant coordinates are returned.
 *

/**
 * Resolves a POM from its coordinates.
 */
public interface ModelResolver extends Service {

    /**
     * Tries to resolve the POM for the specified parent coordinates possibly updating {@code parent}.
     *
     * @param session The session to use to resolve the model, must not be {@code null}.
     * @param parent The parent coordinates to resolve, must not be {@code null}.

        /**
         * If true, the resolved coordinates of the dependencies will be published instead of
         * the declared coordinates. For example, if a given dependency resolves to a variant
         * of the target component that is published as an external variant, then the external
         * coordinates will be published instead of the declared coordinates.
         */
        Property<Boolean> getPublishResolvedCoordinates();

import org.apache.maven.api.model.Dependency;
import org.apache.maven.api.model.Parent;
import org.apache.maven.api.model.Repository;
import org.apache.maven.model.building.ModelSource;

/**
 * Resolves a POM from its coordinates. During the build process, the
 * {@link org.apache.maven.model.building.ModelBuilder} will add any relevant repositories to the model resolver. In

import org.gradle.api.artifacts.ModuleVersionIdentifier;

/**
 * Represents a component that determines its publication coordinates.
 *
 * @since 4.7
 */
public interface ComponentWithCoordinates extends SoftwareComponent {
    /**
     * The publication coordinates for this component.
     */
    ModuleVersionIdentifier getCoordinates();