}

    @Override
    public void setConf(@Nullable String conf) {
        throw new IllegalStateException();
    }

    @Override
    public String getExtension() {
        return extension;
    }

    @Override
    public void setExtension(String extension) {
        throw new IllegalStateException();
    }

    @Nullable
    @Override
    public String getClassifier() {
        return classifier;

class AbstractSignatureTypeProviderSpec extends Specification {

    static type1 = new AbstractSignatureType() { String getExtension() { "1" } }
    static type2 = new AbstractSignatureType() { String getExtension() { "2" } }
    static type3 = new AbstractSignatureType() { String getExtension() { "3" } }

    def provider = new AbstractSignatureTypeProvider() {{
        register(AbstractSignatureTypeProviderSpec.type1)

        String[] extensions = new String[scriptingLanguages.size()];
        for (int i = 0; i < scriptingLanguages.size(); i++) {
            extensions[i] = scriptingLanguages.get(i).getExtension();
        }
        return extensions;
    }

    private static String[] getFileNames(String basename) {
        List<ScriptingLanguage> scriptingLanguages = ScriptingLanguages.all();

            this.extension = artifact.getExtension();
            this.classifier = artifact.getClassifier();
            this.shouldBePublished = artifactInternal.shouldBePublished();
        }

        @Override
        public String getExtension() {
            return extension;
        }

        @Override
        public void setExtension(String extension) {

                .anyMatch(a -> "pom".equals(a.getExtension()) && CONSUMER_POM_CLASSIFIER.equals(a.getClassifier()));
    }

    private Collection<Artifact> replacePom(Collection<Artifact> artifacts) {
        List<Artifact> consumers = new ArrayList<>();
        List<Artifact> mains = new ArrayList<>();
        for (Artifact artifact : artifacts) {
            if ("pom".equals(artifact.getExtension()) || artifact.getExtension().startsWith("pom.")) {

            path.append(ARTIFACT_SEPARATOR).append(artifact.getClassifier());
        }

        if (artifactHandler.getExtension() != null
                && !artifactHandler.getExtension().isEmpty()) {
            path.append(GROUP_SEPARATOR).append(artifactHandler.getExtension());
        }

        return path.toString();
    }

            SnapshotVersion sv = new SnapshotVersion();
            sv.setClassifier(artifact.getClassifier());
            sv.setExtension(artifact.getExtension());
            sv.setVersion(getVersion());
            sv.setUpdated(lastUpdated);
            versions.put(getKey(sv.getClassifier(), sv.getExtension()), sv);
        }

        Versioning versioning = recessive.getVersioning();
        if (versioning != null) {

                differenceSet.add(ArtifactDifference.CLASSIFIER);
            }
            if (!source.getExtension().equals(mavenArtifact.getExtension())) {
                differenceSet.add(ArtifactDifference.EXTENSION);
            }
            // If it's all equal, we found a matching artifact that is being published

                    ? request.getClassifier()
                    : type != null ? type.getClassifier() : "";
            String str = request.getExtension();
            String extension =
                    str != null && !str.isEmpty() ? request.getExtension() : type != null ? type.getExtension() : "";
            return new DefaultArtifactCoordinate(
                    session,

            abstract class MakeGreen implements TransformAction<Parameters> {
                interface Parameters extends TransformParameters {
                    @Input
                    String getExtension()
                    void setExtension(String value)
                }

                @InputArtifact
                abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {