* At least one artifact pattern must be specified. If no Ivy patterns are specified, then the artifact patterns will be used.
 * Optionally supports a Maven style layout for the 'organisation' part, replacing any dots with forward slashes.
 */
public class DefaultIvyPatternRepositoryLayout extends AbstractRepositoryLayout implements IvyPatternRepositoryLayout {

                String rightOp = condition.substring(equalIndex + 1).trim();

                // allow organisation synonyms, like 'org' or 'organization'
                if (leftOp.equals("org") || leftOp.equals("organization")) {
                    leftOp = "organisation";
                }

                String attrValue = dd.getAttribute(leftOp);
                if (!rightOp.equals(attrValue)) {

    public static final String REVISION_KEY = "revision";

    public static final String MODULE_KEY = "module";

    public static final String ORGANISATION_KEY = "organisation";

    public static final String ORGANISATION_KEY2 = "organization";

    public static final String ORGANISATION_PATH_KEY = "orgPath";

    /**
     * Selective copy of {@link IvyPatternHelper#substituteTokens(String, Map)},

                    }
                }
                publications {
                    jar(IvyPublication) {
                        from components.java
                        organisation group
                        module '${lib}'
                        revision '${version}'
                    }
                }
            }
        """
    }

Stellen wir uns nun vor, dass Ihre Organisation Ihnen die Datei `app/internal/admin.py` gegeben hat.

Sie enthält einen `APIRouter` mit einigen administrativen *Pfadoperationen*, die Ihre Organisation zwischen mehreren Projekten teilt.

        given:
        setupRepositories([target, 'ivy'])
        repository('ivy') {
            "org:ivy:1.0" {
                withModule(IvyModule) {
                    dependsOn([organisation: 'org', module: target, revision: '1.0', conf: 'runtime->compile'])
                }
            }
        }

        when:
        buildFile << """
            dependencies {

                    }
                }
            }
        """
    }

    def group(String repoType) {
        if (repoType == "ivy") {
            return "organisation"
        } else if (repoType == "maven") {
            return "groupId"
        } else {
            throw new IllegalArgumentException()
        }
    }

    def version(String repoType) {

        """

        buildFile << """
            apply plugin: 'java'
            apply plugin: 'ivy-publish'

            version = '${module.revision}'
            group = '${module.organisation}'

            publishing {
                repositories {
                    ivy { url "${ivyRepo.uri}" }
                }
                publications {
                    ivy(IvyPublication) {

                    ivy {
                        url "${ivyRepo.uri}"
                        patternLayout {
                            artifact "[organisation]/[module]/[revision]/[artifact]-[revision](-[classifier])(.[ext])"
                            ivy "[organisation]/[module]/[revision]/[module]-[revision].ivy"
                        }
                    }
                }
                publications {

    public String getOrganisation() {
        return descriptor.getCoordinates().getOrganisation().get();
    }

    @Override
    public void setOrganisation(String organisation) {
        descriptor.getCoordinates().getOrganisation().set(organisation);
    }

    @Override
    public String getModule() {
        return descriptor.getCoordinates().getModule().get();
    }

    @Override