package org.apache.maven.shared.release.phase;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import java.io.File;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.ArtifactUtils;

 import org.apache.maven.model.Model;

 import org.apache.maven.model.Scm;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.scm.ScmException;

 import org.apache.maven.scm.ScmFileSet;

 import org.apache.maven.scm.command.edit.EditScmResult;

 import org.apache.maven.scm.manager.NoSuchScmProviderException;

 import org.apache.maven.scm.provider.ScmProvider;

 import org.apache.maven.scm.repository.ScmRepository;

 import org.apache.maven.scm.repository.ScmRepositoryException;

 import org.apache.maven.shared.release.ReleaseExecutionException;

 import org.apache.maven.shared.release.ReleaseFailureException;

 import org.apache.maven.shared.release.ReleaseResult;

 import org.apache.maven.shared.release.config.ReleaseDescriptor;

 import org.apache.maven.shared.release.env.ReleaseEnvironment;

 import org.apache.maven.shared.release.scm.IdentifiedScm;

 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;

 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;

 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;

 import org.apache.maven.shared.release.util.ReleaseUtil;

 import org.codehaus.plexus.interpolation.InterpolationException;

 import org.codehaus.plexus.interpolation.MapBasedValueSource;

 import org.codehaus.plexus.interpolation.ObjectBasedValueSource;

 import org.codehaus.plexus.interpolation.PrefixAwareRecursionInterceptor;

 import org.codehaus.plexus.interpolation.PrefixedObjectValueSource;

 import org.codehaus.plexus.interpolation.StringSearchInterpolator;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.WriterFactory;

 import org.jdom.CDATA;

 import org.jdom.Comment;

 import org.jdom.Document;

 import org.jdom.Element;

 import org.jdom.JDOMException;

 import org.jdom.Namespace;

 import org.jdom.Text;

 import org.jdom.filter.ContentFilter;

 import org.jdom.filter.ElementFilter;

 import org.jdom.input.SAXBuilder;

 import org.jdom.output.Format;

 import org.jdom.output.XMLOutputter;

 /**

  * Base class for rewriting phases.

  *

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  */

 public abstract class AbstractRewritePomsPhase

     extends AbstractReleasePhase

 {

     /**

      * Tool that gets a configured SCM repository from release configuration.

      */

     private ScmRepositoryConfigurator scmRepositoryConfigurator;

     /**

      * Configuration item for the suffix to add to rewritten POMs when simulating.

      */

     private String pomSuffix;

     private String ls = ReleaseUtil.LS;

     public void setLs( String ls )

     {

         this.ls = ls;

     }

     public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,

                                   List<MavenProject> reactorProjects )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         ReleaseResult result = new ReleaseResult();

         transform( releaseDescriptor, releaseEnvironment, reactorProjects, false, result );

         result.setResultCode( ReleaseResult.SUCCESS );

         return result;

     }

     private void transform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,

                             List<MavenProject> reactorProjects, boolean simulate, ReleaseResult result )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         for ( MavenProject project : reactorProjects )

         {

             logInfo( result, "Transforming '" + project.getName() + "'..." );

             transformProject( project, releaseDescriptor, releaseEnvironment, reactorProjects, simulate, result );

         }

     }

     private void transformProject( MavenProject project, ReleaseDescriptor releaseDescriptor,

                                    ReleaseEnvironment releaseEnvironment, List<MavenProject> reactorProjects,

                                    boolean simulate, ReleaseResult result )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         Document document;

         String intro = null;

         String outtro = null;

         try

         {

             String content = ReleaseUtil.readXmlFile( ReleaseUtil.getStandardPom( project ), ls );

             // we need to eliminate any extra whitespace inside elements, as JDOM will nuke it

             content = content.replaceAll( "<([^!][^>]*?)\\s{2,}([^>]*?)>", "<$1 $2>" );

             content = content.replaceAll( "(\\s{2,}|[^\\s])/>", "$1 />" );

             SAXBuilder builder = new SAXBuilder();

             document = builder.build( new StringReader( content ) );

             // Normalize line endings to platform's style (XML processors like JDOM normalize line endings to "\n" as

             // per section 2.11 of the XML spec)

             normaliseLineEndings( document );

             // rewrite DOM as a string to find differences, since text outside the root element is not tracked

             StringWriter w = new StringWriter();

             Format format = Format.getRawFormat();

             format.setLineSeparator( ls );

             XMLOutputter out = new XMLOutputter( format );

             out.output( document.getRootElement(), w );

             int index = content.indexOf( w.toString() );

             if ( index >= 0 )

             {

                 intro = content.substring( 0, index );

                 outtro = content.substring( index + w.toString().length() );

             }

             else

             {

                 /*

                  * NOTE: Due to whitespace, attribute reordering or entity expansion the above indexOf test can easily

                  * fail. So let's try harder. Maybe some day, when JDOM offers a StaxBuilder and this builder employes

                  * XMLInputFactory2.P_REPORT_PROLOG_WHITESPACE, this whole mess can be avoided.

                  */

                 final String SPACE = "\\s++";

                 final String XML = "<\\?(?:(?:[^\"'>]++)|(?:\"[^\"]*+\")|(?:'[^\']*+'))*+>";

                 final String INTSUB = "\\[(?:(?:[^\"'\\]]++)|(?:\"[^\"]*+\")|(?:'[^\']*+'))*+\\]";

                 final String DOCTYPE =

                     "<!DOCTYPE(?:(?:[^\"'\\[>]++)|(?:\"[^\"]*+\")|(?:'[^\']*+')|(?:" + INTSUB + "))*+>";

                 final String PI = XML;

                 final String COMMENT = "<!--(?:[^-]|(?:-[^-]))*+-->";

                 final String INTRO =

                     "(?:(?:" + SPACE + ")|(?:" + XML + ")|(?:" + DOCTYPE + ")|(?:" + COMMENT + ")|(?:" + PI + "))*";

                 final String OUTRO = "(?:(?:" + SPACE + ")|(?:" + COMMENT + ")|(?:" + PI + "))*";

                 final String POM = "(?s)(" + INTRO + ")(.*?)(" + OUTRO + ")";

                 Matcher matcher = Pattern.compile( POM ).matcher( content );

                 if ( matcher.matches() )

                 {

                     intro = matcher.group( 1 );

                     outtro = matcher.group( matcher.groupCount() );

                 }

             }

         }

         catch ( JDOMException e )

         {

             throw new ReleaseExecutionException( "Error reading POM: " + e.getMessage(), e );

         }

         catch ( IOException e )

         {

             throw new ReleaseExecutionException( "Error reading POM: " + e.getMessage(), e );

         }

         ScmRepository scmRepository;

         ScmProvider provider;

         try

         {

             scmRepository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor,

                                                                                releaseEnvironment.getSettings() );

             provider = scmRepositoryConfigurator.getRepositoryProvider( scmRepository );

         }

         catch ( ScmRepositoryException e )

         {

             throw new ReleaseScmRepositoryException( e.getMessage(), e.getValidationMessages() );

         }

         catch ( NoSuchScmProviderException e )

         {

             throw new ReleaseExecutionException( "Unable to configure SCM repository: " + e.getMessage(), e );

         }

         transformDocument( project, document.getRootElement(), releaseDescriptor, reactorProjects, scmRepository,

                            result, simulate );

         File pomFile = ReleaseUtil.getStandardPom( project );

         if ( simulate )

         {

             File outputFile = new File( pomFile.getParentFile(), pomFile.getName() + "." + pomSuffix );

             writePom( outputFile, document, releaseDescriptor, project.getModelVersion(), intro, outtro );

         }

         else

         {

             writePom( pomFile, document, releaseDescriptor, project.getModelVersion(), intro, outtro, scmRepository,

                       provider );

         }

     }

     private void normaliseLineEndings( Document document )

     {

         for ( Iterator<?> i = document.getDescendants( new ContentFilter( ContentFilter.COMMENT ) ); i.hasNext(); )

         {

             Comment c = (Comment) i.next();

             c.setText( ReleaseUtil.normalizeLineEndings( c.getText(), ls ) );

         }

         for ( Iterator<?> i = document.getDescendants( new ContentFilter( ContentFilter.CDATA ) ); i.hasNext(); )

         {

             CDATA c = (CDATA) i.next();

             c.setText( ReleaseUtil.normalizeLineEndings( c.getText(), ls ) );

         }

     }

     private void transformDocument( MavenProject project, Element rootElement, ReleaseDescriptor releaseDescriptor,

                                     List<MavenProject> reactorProjects, ScmRepository scmRepository, ReleaseResult result,

                                     boolean simulate )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         Namespace namespace = rootElement.getNamespace();

         Map<String, String> mappedVersions = getNextVersionMap( releaseDescriptor );

         Map<String, String> originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects, simulate );

         @SuppressWarnings("unchecked")

                 Map<String, Map<String, String>> resolvedSnapshotDependencies = releaseDescriptor.getResolvedSnapshotDependencies();

         Model model = project.getModel();

         Element properties = rootElement.getChild( "properties", namespace );

         String parentVersion = rewriteParent( project, rootElement, namespace, mappedVersions, 

                                               resolvedSnapshotDependencies, originalVersions );

         String projectId = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );

         rewriteVersion( rootElement, namespace, mappedVersions, projectId, project, parentVersion );

         List<Element> roots = new ArrayList<Element>();

         roots.add( rootElement );

         roots.addAll( getChildren( rootElement, "profiles", "profile" ) );

         for ( Element root : roots )

         {

             rewriteArtifactVersions( getChildren( root, "dependencies", "dependency" ), mappedVersions,

                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,

                                     releaseDescriptor );

             rewriteArtifactVersions( getChildren( root, "dependencyManagement", "dependencies", "dependency" ),

                                     mappedVersions, resolvedSnapshotDependencies, originalVersions, model, properties,

                                     result, releaseDescriptor );

             rewriteArtifactVersions( getChildren( root, "build", "extensions", "extension" ), mappedVersions,

                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,

                                     releaseDescriptor );

             List<Element> pluginElements = new ArrayList<Element>();

             pluginElements.addAll( getChildren( root, "build", "plugins", "plugin" ) );

             pluginElements.addAll( getChildren( root, "build", "pluginManagement", "plugins", "plugin" ) );

             rewriteArtifactVersions( pluginElements, mappedVersions, resolvedSnapshotDependencies, originalVersions,

                                     model, properties, result, releaseDescriptor );

             for ( Element pluginElement : pluginElements )

             {

                 rewriteArtifactVersions( getChildren( pluginElement, "dependencies", "dependency" ), mappedVersions,

                                         resolvedSnapshotDependencies, originalVersions, model, properties, result,

                                         releaseDescriptor );

             }

             rewriteArtifactVersions( getChildren( root, "reporting", "plugins", "plugin" ), mappedVersions,

                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,

                                     releaseDescriptor );

         }

         String commonBasedir;

         try

         {

             commonBasedir = ReleaseUtil.getCommonBasedir( reactorProjects );

         }

         catch ( IOException e )

         {

             throw new ReleaseExecutionException( "Exception occurred while calculating common basedir: "

                 + e.getMessage(), e );

         }

         transformScm( project, rootElement, namespace, releaseDescriptor, projectId, scmRepository, result,

                       commonBasedir );

     }

     @SuppressWarnings( "unchecked" )

     private List<Element> getChildren( Element root, String... names )

     {

         Element parent = root;

         for ( int i = 0; i < names.length - 1 && parent != null; i++ )

         {

             parent = parent.getChild( names[i], parent.getNamespace() );

         }

         if ( parent == null )

         {

             return Collections.emptyList();

         }

         return parent.getChildren( names[names.length - 1], parent.getNamespace() );

     }

     /**

      * Updates the text value of the given element. The primary purpose of this method is to preserve any whitespace and

      * comments around the original text value.

      *

      * @param element The element to update, must not be <code>null</code>.

      * @param value   The text string to set, must not be <code>null</code>.

      */

     private void rewriteValue( Element element, String value )

     {

         Text text = null;

         if ( element.getContent() != null )

         {

             for ( Iterator<?> it = element.getContent().iterator(); it.hasNext(); )

             {

                 Object content = it.next();

                 if ( ( content instanceof Text ) && ( (Text) content ).getTextTrim().length() > 0 )

                 {

                     text = (Text) content;

                     while ( it.hasNext() )

                     {

                         content = it.next();

                         if ( content instanceof Text )

                         {

                             text.append( (Text) content );

                             it.remove();

                         }

                         else

                         {

                             break;

                         }

                     }

                     break;

                 }

             }

         }

         if ( text == null )

         {

             element.addContent( value );

         }

         else

         {

             String chars = text.getText();

             String trimmed = text.getTextTrim();

             int idx = chars.indexOf( trimmed );

             String leadingWhitespace = chars.substring( 0, idx );

             String trailingWhitespace = chars.substring( idx + trimmed.length() );

             text.setText( leadingWhitespace + value + trailingWhitespace );

         }

     }

     private void rewriteVersion( Element rootElement, Namespace namespace, Map<String, String> mappedVersions, String projectId,

                                  MavenProject project, String parentVersion )

         throws ReleaseFailureException

     {

         Element versionElement = rootElement.getChild( "version", namespace );

         String version = mappedVersions.get( projectId );

         if ( version == null )

         {

             throw new ReleaseFailureException( "Version for '" + project.getName() + "' was not mapped" );

         }

         if ( versionElement == null )

         {

             if ( !version.equals( parentVersion ) )

             {

                 // we will add this after artifactId, since it was missing but different from the inherited version

                 Element artifactIdElement = rootElement.getChild( "artifactId", namespace );

                 int index = rootElement.indexOf( artifactIdElement );

                 versionElement = new Element( "version", namespace );

                 versionElement.setText( version );

                 rootElement.addContent( index + 1, new Text( "\n  " ) );

                 rootElement.addContent( index + 2, versionElement );

             }

         }

         else

         {

             rewriteValue( versionElement, version );

         }

     }

     private String rewriteParent( MavenProject project, Element rootElement, Namespace namespace, Map<String, String> mappedVersions,

                                   Map<String, Map<String, String>> resolvedSnapshotDependencies, Map<String, String> originalVersions )

         throws ReleaseFailureException

     {

         String parentVersion = null;

         if ( project.hasParent() )

         {

             Element parentElement = rootElement.getChild( "parent", namespace );

             Element versionElement = parentElement.getChild( "version", namespace );

             MavenProject parent = project.getParent();

             String key = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() );

             parentVersion = mappedVersions.get( key );

             if ( parentVersion == null )

             {

                 //MRELEASE-317

                 parentVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies );

             }

             if ( parentVersion == null )

             {

                 if ( parent.getVersion().equals( originalVersions.get( key ) ) )

                 {

                     throw new ReleaseFailureException( "Version for parent '" + parent.getName() + "' was not mapped" );

                 }

             }

             else

             {

                 rewriteValue( versionElement, parentVersion );

             }

         }

         return parentVersion;

     }

     private void rewriteArtifactVersions( Collection<Element> elements, Map<String, String> mappedVersions,

                                           Map<String, Map<String, String>> resolvedSnapshotDependencies, Map<String, String> originalVersions,

                                           Model projectModel, Element properties, ReleaseResult result,

                                           ReleaseDescriptor releaseDescriptor )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         if ( elements == null )

         {

             return;

         }

         String projectId = ArtifactUtils.versionlessKey( projectModel.getGroupId(), projectModel.getArtifactId() );

         for ( Element element : elements )

         {

             Element versionElement = element.getChild( "version", element.getNamespace() );

             if ( versionElement == null )

             {

                 // managed dependency or unversioned plugin

                 continue;

             }

             String rawVersion = versionElement.getTextTrim();

             Element groupIdElement = element.getChild( "groupId", element.getNamespace() );

             if ( groupIdElement == null )

             {

                 if ( "plugin".equals( element.getName() ) )

                 {

                     groupIdElement = new Element( "groupId", element.getNamespace() );

                     groupIdElement.setText( "org.apache.maven.plugins" );

                 }

                 else

                 {

                     // incomplete dependency

                     continue;

                 }

             }

             String groupId = interpolate( groupIdElement.getTextTrim(), projectModel );

             Element artifactIdElement = element.getChild( "artifactId", element.getNamespace() );

             if ( artifactIdElement == null )

             {

                 // incomplete element

                 continue;

             }

             String artifactId = interpolate( artifactIdElement.getTextTrim(), projectModel);

             String key = ArtifactUtils.versionlessKey( groupId, artifactId );

             String resolvedSnapshotVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies );

             String mappedVersion = mappedVersions.get( key );

             String originalVersion = originalVersions.get( key );

             if ( originalVersion == null )

             {

                 originalVersion = getOriginalResolvedSnapshotVersion( key, resolvedSnapshotDependencies );

             }

             // MRELEASE-220

             if ( mappedVersion != null && mappedVersion.endsWith( Artifact.SNAPSHOT_VERSION )

                 && !rawVersion.endsWith( Artifact.SNAPSHOT_VERSION ) && !releaseDescriptor.isUpdateDependencies() )

             {

                 continue;

             }

             if ( mappedVersion != null )

             {

                 if ( rawVersion.equals( originalVersion ) )

                 {

                     logInfo( result, "  Updating " + artifactId + " to " + mappedVersion );

                     rewriteValue( versionElement, mappedVersion );

                 }

                 else if ( rawVersion.matches( "\\$\\{.+\\}" ) )

                 {

                     String expression = rawVersion.substring( 2, rawVersion.length() - 1 );

                     if ( expression.startsWith( "project." ) || expression.startsWith( "pom." )

                         || "version".equals( expression ) )

                     {

                         if ( !mappedVersion.equals( mappedVersions.get( projectId ) ) )

                         {

                             logInfo( result, "  Updating " + artifactId + " to " + mappedVersion );

                             rewriteValue( versionElement, mappedVersion );

                         }

                         else

                         {

                             logInfo( result, "  Ignoring artifact version update for expression " + rawVersion );

                         }

                     }

                     else if ( properties != null )

                     {

                         // version is an expression, check for properties to update instead

                         Element property = properties.getChild( expression, properties.getNamespace() );

                         if ( property != null )

                         {

                             String propertyValue = property.getTextTrim();

                             if ( propertyValue.equals( originalVersion ) )

                             {

                                 logInfo( result, "  Updating " + rawVersion + " to " + mappedVersion );

                                 // change the property only if the property is the same as what's in the reactor

                                 rewriteValue( property, mappedVersion );

                             }

                             else if ( mappedVersion.equals( propertyValue ) )

                             {

                                 // this property may have been updated during processing a sibling.

                                 logInfo( result, "  Ignoring artifact version update for expression " + rawVersion

                                     + " because it is already updated" );

                             }

                             else if ( !mappedVersion.equals( rawVersion ) )

                             {

                                 if ( mappedVersion.matches( "\\$\\{project.+\\}" )

                                     || mappedVersion.matches( "\\$\\{pom.+\\}" ) || "${version}".equals( mappedVersion ) )

                                 {

                                     logInfo( result, "  Ignoring artifact version update for expression "

                                         + mappedVersion );

                                     // ignore... we cannot update this expression

                                 }

                                 else

                                 {

                                     // the value of the expression conflicts with what the user wanted to release

                                     throw new ReleaseFailureException( "The artifact (" + key + ") requires a "

                                         + "different version (" + mappedVersion + ") than what is found ("

                                         + propertyValue + ") for the expression (" + expression + ") in the "

                                         + "project (" + projectId + ")." );

                                 }

                             }

                         }

                         else

                         {

                             // the expression used to define the version of this artifact may be inherited

                             // TODO needs a better error message, what pom? what dependency?

                             throw new ReleaseFailureException( "The version could not be updated: " + rawVersion );

                         }

                     }

                 }

                 else

                 {

                     // different/previous version not related to current release

                 }

             }

             else if ( resolvedSnapshotVersion != null )

             {

                 logInfo( result, "  Updating " + artifactId + " to " + resolvedSnapshotVersion );

                 rewriteValue( versionElement, resolvedSnapshotVersion );

             }

             else

             {

                 // artifact not related to current release

             }

         }

     }

     private String interpolate( String value, Model model )

         throws ReleaseExecutionException

     {

         if ( value != null && value.contains( "${" ) )

         {

             StringSearchInterpolator interpolator = new StringSearchInterpolator();

             List<String> pomPrefixes = Arrays.asList( "pom.", "project." );

             interpolator.addValueSource( new PrefixedObjectValueSource( pomPrefixes, model, false ) );

             interpolator.addValueSource( new MapBasedValueSource( model.getProperties() ) );

             interpolator.addValueSource( new ObjectBasedValueSource( model ) );

             try

             {

                 value = interpolator.interpolate( value, new PrefixAwareRecursionInterceptor( pomPrefixes ) );

             }

             catch ( InterpolationException e )

             {

                 throw new ReleaseExecutionException(

                                                      "Failed to interpolate " + value + " for project " + model.getId(),

                                                      e );

             }

         }

         return value;

     }

     private void writePom( File pomFile, Document document, ReleaseDescriptor releaseDescriptor, String modelVersion,

                            String intro, String outtro, ScmRepository repository, ScmProvider provider )

         throws ReleaseExecutionException, ReleaseScmCommandException

     {

         try

         {

             if ( releaseDescriptor.isScmUseEditMode() || provider.requiresEditMode() )

             {

                 EditScmResult result = provider.edit( repository, new ScmFileSet(

                     new File( releaseDescriptor.getWorkingDirectory() ), pomFile ) );

                 if ( !result.isSuccess() )

                 {

                     throw new ReleaseScmCommandException( "Unable to enable editing on the POM", result );

                 }

             }

         }

         catch ( ScmException e )

         {

             throw new ReleaseExecutionException( "An error occurred enabling edit mode: " + e.getMessage(), e );

         }

         writePom( pomFile, document, releaseDescriptor, modelVersion, intro, outtro );

     }

     private void writePom( File pomFile, Document document, ReleaseDescriptor releaseDescriptor, String modelVersion,

                            String intro, String outtro )

         throws ReleaseExecutionException

     {

         Element rootElement = document.getRootElement();

         if ( releaseDescriptor.isAddSchema() )

         {

             Namespace pomNamespace = Namespace.getNamespace( "", "http://maven.apache.org/POM/" + modelVersion );

             rootElement.setNamespace( pomNamespace );

             Namespace xsiNamespace = Namespace.getNamespace( "xsi", "http://www.w3.org/2001/XMLSchema-instance" );

             rootElement.addNamespaceDeclaration( xsiNamespace );

             if ( rootElement.getAttribute( "schemaLocation", xsiNamespace ) == null )

             {

                 rootElement.setAttribute( "schemaLocation", "http://maven.apache.org/POM/" + modelVersion

                     + " http://maven.apache.org/maven-v" + modelVersion.replace( '.', '_' ) + ".xsd", xsiNamespace );

             }

             // the empty namespace is considered equal to the POM namespace, so match them up to avoid extra xmlns=""

             ElementFilter elementFilter = new ElementFilter( Namespace.getNamespace( "" ) );

             for ( Iterator<?> i = rootElement.getDescendants( elementFilter ); i.hasNext(); )

             {

                 Element e = (Element) i.next();

                 e.setNamespace( pomNamespace );

             }

         }

         Writer writer = null;

         try

         {

             writer = WriterFactory.newXmlWriter( pomFile );

             if ( intro != null )

             {

                 writer.write( intro );

             }

             Format format = Format.getRawFormat();

             format.setLineSeparator( ls );

             XMLOutputter out = new XMLOutputter( format );

             out.output( document.getRootElement(), writer );

             if ( outtro != null )

             {

                 writer.write( outtro );

             }

         }

         catch ( IOException e )

         {

             throw new ReleaseExecutionException( "Error writing POM: " + e.getMessage(), e );

         }

         finally

         {

             IOUtil.close( writer );

         }

     }

     public ReleaseResult simulate( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,

                                    List<MavenProject> reactorProjects )

         throws ReleaseExecutionException, ReleaseFailureException

     {

         ReleaseResult result = new ReleaseResult();

         transform( releaseDescriptor, releaseEnvironment, reactorProjects, true, result );

         result.setResultCode( ReleaseResult.SUCCESS );

         return result;

     }

     public ReleaseResult clean( List<MavenProject> reactorProjects )

     {

         ReleaseResult result = new ReleaseResult();

         super.clean( reactorProjects );

         if ( reactorProjects != null )

         {

             for ( MavenProject project : reactorProjects )

             {

                 File pomFile = ReleaseUtil.getStandardPom( project );

                 // MRELEASE-273 : if no pom

                 if ( pomFile != null )

                 {

                     File file = new File( pomFile.getParentFile(), pomFile.getName() + "." + pomSuffix );

                     if ( file.exists() )

                     {

                         file.delete();

                     }

                 }

             }

         }

         result.setResultCode( ReleaseResult.SUCCESS );

         return result;

     }

     protected abstract String getResolvedSnapshotVersion( String artifactVersionlessKey, Map<String, Map<String,String>> resolvedSnapshots );

     protected abstract Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, List<MavenProject> reactorProjects,

                                                   boolean simulate );

     protected abstract Map<String,String> getNextVersionMap( ReleaseDescriptor releaseDescriptor );

     protected abstract void transformScm( MavenProject project, Element rootElement, Namespace namespace,

                                           ReleaseDescriptor releaseDescriptor, String projectId,

                                           ScmRepository scmRepository, ReleaseResult result, String commonBasedir )

         throws ReleaseExecutionException;

     protected String getOriginalResolvedSnapshotVersion( String artifactVersionlessKey, Map<String, Map<String, String>> resolvedSnapshots )

     {

         Map<String, String> versionsMap = resolvedSnapshots.get( artifactVersionlessKey );

         if ( versionsMap != null )

         {

             return versionsMap.get( ReleaseDescriptor.ORIGINAL_VERSION );

         }

         else

         {

             return null;

         }

     }

     protected Element rewriteElement( String name, String value, Element root, Namespace namespace )

     {

         Element tagElement = root.getChild( name, namespace );

         if ( tagElement != null )

         {

             if ( value != null )

             {

                 rewriteValue( tagElement, value );

             }

             else

             {

                 int index = root.indexOf( tagElement );

                 root.removeContent( index );

                 for ( int i = index - 1; i >= 0; i-- )

                 {

                     if ( root.getContent( i ) instanceof Text )

                     {

                         root.removeContent( i );

                     }

                     else

                     {

                         break;

                     }

                 }

             }

         }

         else

         {

             if ( value != null )

             {

                 Element element = new Element( name, namespace );

                 element.setText( value );

                 root.addContent( "  " ).addContent( element ).addContent( "\n  " );

                 tagElement = element;

             }

         }

         return tagElement;

     }

     protected Scm buildScm( MavenProject project )

     {

         IdentifiedScm scm;

         if ( project.getOriginalModel().getScm() == null )

         {

             scm = null;

         }

         else

         {

             scm = new IdentifiedScm();

             scm.setConnection( project.getOriginalModel().getScm().getConnection() );

             scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() );

             scm.setTag( project.getOriginalModel().getScm().getTag() );

             scm.setUrl( project.getOriginalModel().getScm().getUrl() );

             scm.setId( project.getProperties().getProperty( "project.scm.id" ) );

         }

         return scm;

     }

 }