}

    @Override
    public boolean matchesStrictly(ModuleVersionIdentifier identifier) {
        return identifier.getModule().equals(getModule()) && identifier.getVersion().equals(projectDependency.getVersion());
    }

    @Override
    public ModuleIdentifier getModule() {
        String group = projectDependency.getGroup();

        return ImmutableList.of(new Artifact(new DefaultIvyArtifactName(from.getModule(), "jar", "jar"), SINGLE_DEFAULT_CONFIGURATION_NAME));
    }

    private ModuleVersionIdentifier asVersionIdentifier(ModuleComponentIdentifier from) {
        return moduleIdentifierFactory.moduleWithVersion(from.getGroup(), from.getModule(), from.getVersion());
    }

    @Override

        HashMap<String, String> attributes = new HashMap<>();
        attributes.put(PatternHelper.ORGANISATION_KEY, componentIdentifier.getGroup());
        attributes.put(PatternHelper.MODULE_KEY, componentIdentifier.getModule());
        attributes.put(PatternHelper.REVISION_KEY, componentIdentifier.getVersion());
        return attributes;
    }

    @Override
    public boolean isComplete(ModuleIdentifier moduleIdentifier) {

                caretTag = "restoreAt"
            ).single().first

        val project = declaration.project
        val declarationModule = ProjectStructureProvider.getModule(project, declaration, contextualModule = null)
        val restoreAtModule = ProjectStructureProvider.getModule(project, restoreAt, contextualModule = null)

        val (debugRendered, prettyRendered, pointer) = analyseForTest(declaration) {

        ModuleVersionSelector moduleSelector = autoAppliedPlugin.getModule();
        if (moduleSelector != null) {
            predicate = predicate.or(dependency -> hasMatchingCoordinates(dependency, moduleSelector.getModule()));
        }

        Configuration classpathConfiguration = scriptHandler.getConfigurations().getByName(ScriptHandler.CLASSPATH_CONFIGURATION);

        analyseForTest(mainFile) {
            val fileSymbol = mainFile.getFileSymbol()
            val module = fileSymbol.getContainingModule()

            val providerModule = ProjectStructureProvider.getModule(mainFile.project, mainFile, contextualModule = null)
            assert(module == providerModule)
            assert(module == mainModule.ktModule)

            val actualString = buildString {

    Module publishWithChangedContent()
    Module withModuleMetadata()
    Module withSignature(@DelegatesTo(value = File, strategy = Closure.DELEGATE_FIRST) Closure<?> signer)

    String getGroup()
    String getModule()
    String getVersion()

    /**
     * Returns the Gradle module metadata file of this module
     */
    ModuleArtifact getModuleMetadata()
    GradleModuleMetadata getParsedModuleMetadata()

        // or removed only in the dangling file.
        val baseKtModule = when (val ktModule = ProjectStructureProvider.getModule(project, ktClass, contextualModule = null)) {
            is KtDanglingFileModule -> ktModule.contextModule
            else -> ktModule
        }

    }

    @Override
    public String getOrganisation() {
        return backingModule.getOrganisation();
    }

    @Override
    public String getModule() {
        return backingModule.getModule();
    }

    @Override
    public String getVersion() {
        return backingModule.getVersion();
    }

    @Override
    public String getRevision() {

 *
 * @since 6.8
 */
@HasInternalProtocol
public interface MinimalExternalModuleDependency extends ExternalModuleDependency {
    @Override
    ModuleIdentifier getModule();
    @Override
    VersionConstraint getVersionConstraint();

    /**
     * {@inheritDoc}
     */
    @Override
    MinimalExternalModuleDependency copy();