}

    @Override
    protected void transformScm(
            MavenProject project,
            Model modelTarget,
            ReleaseDescriptor releaseDescriptor,
            String projectId,
            ScmRepository scmRepository,
            ReleaseResult result)
            throws ReleaseExecutionException {
        // If SCM is null in original model, it is inherited, no mods needed
        if (project.getScm() != null) {
            Scm scmRoot = modelTarget.getScm();

            if (scmRoot != null) {
                try {
                    translateScm(project, releaseDescriptor, scmRoot, scmRepository, result);
                } catch (IOException e) {
                    throw new ReleaseExecutionException(e.getMessage(), e);
                }
            } else {
                MavenProject parent = project.getParent();
                if (parent != null) {
                    // If the SCM element is not present, only add it if the parent was not mapped (ie, it's external to
                    // the release process and so has not been modified, so the values will not be correct on the tag),
                    String parentId = ArtifactUtils.versionlessKey(parent.getGroupId(), parent.getArtifactId());
                    if (!releaseDescriptor.hasOriginalScmInfo(parentId)) {

logInfo(relResult, "Branching release with the label " + releaseDescriptor.getScmReleaseLabel() + "...");

        ReleaseDescriptor basedirAlignedReleaseDescriptor =
                ReleaseUtil.createBasedirAlignedReleaseDescriptor(releaseDescriptor, reactorProjects);

        ScmRepository repository;
        ScmProvider provider;
        try {
            repository = scmRepositoryConfigurator.getConfiguredRepository(
                    basedirAlignedReleaseDescriptor.getScmSourceUrl(),
                    releaseDescriptor,
                    releaseEnvironment.getSettings());

            repository.getProviderRepository().setPushChanges(releaseDescriptor.isPushChanges());

            repository.getProviderRepository().setWorkItem(releaseDescriptor.getWorkItem());

            provider = scmRepositoryConfigurator.getRepositoryProvider(repository);

        } catch (ScmRepositoryException e) {
            throw new ReleaseScmRepositoryException(e.getMessage(), e.getValidationMessages());
        } catch (NoSuchScmProviderException e) {
            throw new ReleaseExecutionException("Unable to configure SCM repository: " + e.getMessage(), e);
        }

String value = translator.resolveTag(branchName);
                if (value != null && !value.equals(scm.getTag())) {
                    scmTarget.setTag(value);
                    result = true;
                }
            }
        } else {
            String message = "No SCM translator found - skipping rewrite";

            relResult.appendDebug(message);

            getLogger().debug(message);
        }
        return result;
    }

    @Override
    protected String getOriginalVersion(ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate) {
        return releaseDescriptor.getProjectOriginalVersion(projectKey);
    }

    @Override
    protected String getNextVersion(ReleaseDescriptor releaseDescriptor, String key) {
        return releaseDescriptor.getProjectReleaseVersion(key);
    }

    @Override
    protected String getResolvedSnapshotVersion(String artifactVersionlessKey, ReleaseDescriptor releaseDescriptor) {
        return releaseDescriptor.getDependencyReleaseVersion(artifactVersionlessKey);
    }
}

List<Element> pluginElms = pluginsElm.getChildren("plugin", build.getNamespace());

            List<Plugin> plugins = new ArrayList<>(pluginElms.size());

            for (Element pluginElm : pluginElms) {
                plugins.add(new JDomPlugin(pluginElm));
            }

            return plugins;
        }
    }

    @Override
    public void removePlugin(Plugin plugin) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void setPlugins(List<Plugin> plugins) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void flushPluginMap() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map<String, Plugin> getPluginsAsMap() {
        throw new UnsupportedOperationException();
    }
}

modelTarget.setScm(scmRoot);
                            }
                        } catch (IOException e) {
                            throw new ReleaseExecutionException(e.getMessage(), e);
                        }
                    }
                }
            }
        }
    }

    private boolean translateScm(
            MavenProject project,
            ReleaseDescriptor releaseDescriptor,
            Scm scmTarget,
            ScmRepository scmRepository,
            ReleaseResult relResult)
            throws IOException {
        ScmTranslator translator = getScmTranslators().get(scmRepository.getProvider());
        boolean result = false;
        if (translator != null) {
            Scm scm = project.getOriginalModel().getScm();
            if (scm == null) {
                scm = project.getScm();
            }

            String branchName = releaseDescriptor.getScmReleaseLabel();