src/main/java/org/apache/maven/plugins/scmpublish/AbstractScmPublishMojo.java - maven-scm-publish-plugin - Git at Google

 package org.apache.maven.plugins.scmpublish;

 /*
  * 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 org.apache.commons.io.FileUtils;
 import org.apache.commons.io.FilenameUtils;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.Component;
 import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.scm.CommandParameter;
 import org.apache.maven.scm.CommandParameters;
 import org.apache.maven.scm.ScmBranch;
 import org.apache.maven.scm.ScmException;
 import org.apache.maven.scm.ScmFileSet;
 import org.apache.maven.scm.ScmResult;
 import org.apache.maven.scm.command.add.AddScmResult;
 import org.apache.maven.scm.command.checkin.CheckInScmResult;
 import org.apache.maven.scm.manager.NoSuchScmProviderException;
 import org.apache.maven.scm.manager.ScmManager;
 import org.apache.maven.scm.provider.ScmProvider;
 import org.apache.maven.scm.provider.svn.AbstractSvnScmProvider;
 import org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository;
 import org.apache.maven.scm.repository.ScmRepository;
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.settings.Settings;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
 import org.codehaus.plexus.util.Os;

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;

 /**
  * Base class for the scm-publish mojos.
  */
 public abstract class AbstractScmPublishMojo
     extends AbstractMojo
 {
     /**
      * Location of the scm publication tree.
      */
     @Parameter ( property = "scmpublish.pubScmUrl", defaultValue = "${project.distributionManagement.site.url}",
                  required = true )
     protected String pubScmUrl;

     /**
      * Location where the scm check-out is done.
      */
     @Parameter ( property = "scmpublish.checkoutDirectory",
                  defaultValue = "${project.build.directory}/scmpublish-checkout" )
     protected File checkoutDirectory;

     /**
      * Display list of added, deleted, and changed files, but do not do any actual SCM operations.
      */
     @Parameter ( property = "scmpublish.dryRun" )
     private boolean dryRun;

     /**
      * Run add and delete commands, but leave the actually checkin for the user to run manually.
      */
     @Parameter ( property = "scmpublish.skipCheckin" )
     private boolean skipCheckin;

     /**
      * SCM log/checkin comment for this publication.
      */
     @Parameter ( property = "scmpublish.checkinComment", defaultValue = "Site checkin for project ${project.name}" )
     private String checkinComment;

     /**
      * Patterns to exclude from the scm tree.
      */
     @Parameter
     protected String excludes;

     /**
      * Patterns to include in the scm tree.
      */
     @Parameter
     protected String includes;

     /**
      * List of SCM provider implementations.
      * Key is the provider type, eg. <code>cvs</code>.
      * Value is the provider implementation (the role-hint of the provider), eg. <code>cvs</code> or <code>cvs_native</code>.
      * @see ScmManager.setScmProviderImplementation
      */
     @Parameter
     private Map<String, String> providerImplementations;

     /**
      * The SCM manager.
      */
     @Component
     private ScmManager scmManager;

     /**
      * Tool that gets a configured SCM repository from release configuration.
      */
     @Component
     protected ScmRepositoryConfigurator scmRepositoryConfigurator;

     /**
      * The SCM username to use.
      */
     @Parameter ( property = "username" )
     protected String username;

     /**
      * The SCM password to use.
      */
     @Parameter ( property = "password" )
     protected String password;

     /**
      * Use a local checkout instead of doing a checkout from the upstream repository. <b>WARNING</b>: This will only work
      * with distributed SCMs which support the file:// protocol
      * TODO: we should think about having the defaults for the various SCM providers provided via Modello!
      */
     @Parameter ( property = "localCheckout", defaultValue = "false" )
     protected boolean localCheckout;

     /**
      * The outputEncoding parameter of the site plugin. This plugin will corrupt your site
      * if this does not match the value used by the site plugin.
      */
     @Parameter ( property = "outputEncoding", defaultValue = "${project.reporting.outputEncoding}" )
     protected String siteOutputEncoding;

     /**
      * If the checkout directory exists and this flag is activated, the plugin will try an SCM-update rather
      * than delete then checkout.
      */
     @Parameter ( property = "scmpublish.tryUpdate", defaultValue = "false" )
     protected boolean tryUpdate;

     /**
      * Do not delete files to the scm
      */
     @Parameter ( property = "scmpublish.skipDeletedFiles", defaultValue = "false" )
     protected boolean skipDeletedFiles;

     /**
      */
     @Parameter ( defaultValue = "${basedir}", readonly = true )
     protected File basedir;

     /**
      */
     @Component
     protected Settings settings;

     /**
      * Collections of paths not to delete when checking content to delete.
      * If your site has subdirectories published by an other mechanism/build
      */
     @Parameter
     protected String[] ignorePathsToDelete;

     /**
      * SCM branch to use. For github, you must configure with <code>gh-pages</code>.
      */
     @Parameter ( property = "scmpublish.scm.branch" )
     protected String scmBranch;

     /**
      * Configure svn automatic remote url creation.
      */
     @Parameter ( property = "scmpublish.automaticRemotePathCreation", defaultValue = "true" )
     protected boolean automaticRemotePathCreation;

     /**
      * Filename extensions of files which need new line normalization.
      */
     private final static String[] NORMALIZE_EXTENSIONS = { "html", "css", "js" };

     /**
      * Extra file extensions to normalize line ending (will be added to default
      * <code>html</code>,<code>css</code>,<code>js</code> list)
      */
     @Parameter
     protected String[] extraNormalizeExtensions;

     protected ScmProvider scmProvider;

     protected ScmRepository scmRepository;

     protected void logInfo( String format, Object... params )
     {
         getLog().info( String.format( format, params ) );
     }

     protected void logWarn( String format, Object... params )
     {
         getLog().warn( String.format( format, params ) );
     }

     protected void logError( String format, Object... params )
     {
         getLog().error( String.format( format, params ) );
     }

     private File relativize( File base, File file )
     {
         return new File( base.toURI().relativize( file.toURI() ).getPath() );
     }

     protected boolean requireNormalizeNewlines( File f )
         throws IOException
     {
         List<String> extensions = Arrays.asList( NORMALIZE_EXTENSIONS );
         if ( extraNormalizeExtensions != null )
         {
             extensions.addAll( Arrays.asList( extraNormalizeExtensions ) );
         }

         return FilenameUtils.isExtension( f.getName(), extensions );
     }

     private ReleaseDescriptor setupScm()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
         String scmUrl;
         if ( localCheckout )
         {
             // in the release phase we have to change the checkout URL
             // to do a local checkout instead of going over the network.

             // the first step is a bit tricky, we need to know which provider! like e.g. "scm:jgit:http://"
             // the offset of 4 is because 'scm:' has 4 characters...
             String providerPart = pubScmUrl.substring( 0, pubScmUrl.indexOf( ':', 4 ) );

             // X TODO: also check the information from releaseDescriptor.getScmRelativePathProjectDirectory()
             // X TODO: in case our toplevel git directory has no pom.
             // X TODO: fix pathname once I understand this.
             scmUrl = providerPart + ":file://" + "target/localCheckout";
             logInfo( "Performing a LOCAL checkout from " + scmUrl );
         }

         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         releaseDescriptor.setInteractive( settings.isInteractiveMode() );

         //TODO use from settings with decrypt stuff

         releaseDescriptor.setScmPassword( password );
         releaseDescriptor.setScmUsername( username );

         releaseDescriptor.setWorkingDirectory( basedir.getAbsolutePath() );
         releaseDescriptor.setLocalCheckout( localCheckout );
         releaseDescriptor.setScmSourceUrl( pubScmUrl );

         if ( providerImplementations != null )
         {
             for ( Map.Entry<String, String> providerEntry : providerImplementations.entrySet() )
             {
                 logInfo( "Changing the default '%s' provider implementation to '%s'.", providerEntry.getKey(),
                          providerEntry.getValue() );
                 scmManager.setScmProviderImplementation( providerEntry.getKey(), providerEntry.getValue() );
             }
         }

         scmRepository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );

         scmProvider = scmRepositoryConfigurator.getRepositoryProvider( scmRepository );

         return releaseDescriptor;
     }

     protected void checkoutExisting()
         throws MojoExecutionException
     {

         if ( scmProvider instanceof AbstractSvnScmProvider )
         {
             checkCreateRemoteSvnPath();
         }

         logInfo( "%s the pub tree from  %s ...", ( tryUpdate ? "Updating" : "Checking out" ), pubScmUrl );

         if ( checkoutDirectory.exists() && !tryUpdate )

         {
             try
             {
                 FileUtils.deleteDirectory( checkoutDirectory );
             }
             catch ( IOException e )
             {
                 logError( e.getMessage() );

                 throw new MojoExecutionException( "Unable to remove old checkout directory: " + e.getMessage(), e );
             }
         }

         boolean forceCheckout = false;

         if ( !checkoutDirectory.exists() )

         {
             if ( tryUpdate )
             {
                 logInfo( "TryUpdate is configured but no local copy currently available: forcing checkout." );
             }
             checkoutDirectory.mkdirs();
             forceCheckout = true;
         }

         try
         {
             ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, includes, excludes );

             ScmResult scmResult;
             if ( tryUpdate && !forceCheckout )
             {
                 scmResult = scmProvider.update( scmRepository, fileSet );
             }
             else if ( scmBranch == null )
             {
                 scmResult = scmProvider.checkOut( scmRepository, fileSet );
             }
             else
             {
                 ScmBranch scmBranch = new ScmBranch( this.scmBranch );
                 scmResult = scmProvider.checkOut( scmRepository, fileSet, scmBranch );
             }

             checkScmResult( scmResult, "check out from SCM" );
         }
         catch ( ScmException e )
         {
             logError( e.getMessage() );

             throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
         }
         catch ( IOException e )
         {
             logError( e.getMessage() );

             throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
         }
     }

     private void checkCreateRemoteSvnPath()
         throws MojoExecutionException
     {
         getLog().debug( "AbstractSvnScmProvider used, so we can check if remote url exists and eventually create it." );
         AbstractSvnScmProvider svnScmProvider = (AbstractSvnScmProvider) scmProvider;

         try
         {
             boolean remoteExists = svnScmProvider.remoteUrlExist( scmRepository.getProviderRepository(), null );

             if ( remoteExists )
             {
                 return;
             }
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }

         String remoteUrl = ( (SvnScmProviderRepository) scmRepository.getProviderRepository() ).getUrl();

         if ( !automaticRemotePathCreation )
         {
             // olamy: return ?? that will fail during checkout IMHO :-)
             logWarn( "Remote svn url %s does not exist and automatic remote path creation disabled.",
                      remoteUrl );
             return;
         }

         logInfo( "Remote svn url %s does not exist: creating.", remoteUrl );

         File baseDir = null;
         try
         {

             // create a temporary directory for svnexec
             baseDir = File.createTempFile( "scm", "tmp" );
             baseDir.delete();
             baseDir.mkdirs();
             // to prevent fileSet cannot be empty
             ScmFileSet scmFileSet = new ScmFileSet( baseDir, new File( "" ) );

             CommandParameters commandParameters = new CommandParameters();
             commandParameters.setString( CommandParameter.SCM_MKDIR_CREATE_IN_LOCAL, Boolean.FALSE.toString() );
             commandParameters.setString( CommandParameter.MESSAGE, "Automatic svn path creation: " + remoteUrl );
             svnScmProvider.mkdir( scmRepository.getProviderRepository(), scmFileSet, commandParameters );

             // new remote url so force checkout!
             if ( checkoutDirectory.exists() )
             {
                 FileUtils.deleteDirectory( checkoutDirectory );
             }
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         finally
         {
             if ( baseDir != null )
             {
                 try
                 {
                     FileUtils.forceDeleteOnExit( baseDir );
                 }
                 catch ( IOException e )
                 {
                     throw new MojoExecutionException( e.getMessage(), e );
                 }
             }
         }
     }

     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
         // setup the scm plugin with help from release plugin utilities
         try
         {
             setupScm();
         }
         catch ( ScmRepositoryException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         catch ( NoSuchScmProviderException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }

         boolean tmpCheckout = false;

         if ( checkoutDirectory.getPath().contains( "${project." ) )
         {
             try
             {
                 tmpCheckout = true;
                 checkoutDirectory = File.createTempFile( "maven-scm-publish", ".checkout" );
                 checkoutDirectory.delete();
                 checkoutDirectory.mkdir();
             }
             catch ( IOException ioe )
             {
                 throw new MojoExecutionException( ioe.getMessage(), ioe );
             }
         }

         try
         {
             scmPublishExecute();
         }
         finally
         {
             if ( tmpCheckout )
             {
                 FileUtils.deleteQuietly( checkoutDirectory );
             }
         }
     }

     /**
      * Check-in content from scm checkout.
      *
      * @throws MojoExecutionException
      */
     protected void checkinFiles()
         throws MojoExecutionException
     {
         if ( skipCheckin )
         {
             return;
         }

         ScmFileSet updatedFileSet = new ScmFileSet( checkoutDirectory );
         try
         {
             logInfo( "Checking in to the scm" );

             CheckInScmResult checkinResult =
                 checkScmResult( scmProvider.checkIn( scmRepository, updatedFileSet, new ScmBranch( scmBranch ),
                                                      checkinComment ), "check-in files to SCM" );

             logInfo( "Checked in %d file(s) to revision: %s", checkinResult.getCheckedInFiles().size(),
                      checkinResult.getScmRevision() );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to perform SCM checkin", e );
         }
     }

     protected void deleteFiles( Collection<File> deleted )
         throws MojoExecutionException
     {
         if ( skipDeletedFiles )
         {
             logInfo( "Deleting files is skipped." );
             return;
         }
         List<File> deletedList = new ArrayList<File>();
         for ( File f : deleted )
         {
             deletedList.add( relativize( checkoutDirectory, f ) );
         }
         ScmFileSet deletedFileSet = new ScmFileSet( checkoutDirectory, deletedList );
         try
         {
             getLog().debug( "Deleting files: " + deletedList );

             checkScmResult( scmProvider.remove( scmRepository, deletedFileSet, "Deleting obsolete site files." ),
                             "delete files from SCM" );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to delete removed files to SCM", e );
         }
     }

     /**
      * Add files to scm.
      *
      * @param added files to be added
      * @throws MojoFailureException
      * @throws MojoExecutionException
      */
     protected void addFiles( Collection<File> added )
         throws MojoFailureException, MojoExecutionException
     {
         List<File> addedList = new ArrayList<File>();
         Set<File> createdDirs = new HashSet<File>();
         Set<File> dirsToAdd = new TreeSet<File>();

         createdDirs.add( relativize( checkoutDirectory, checkoutDirectory ) );

         for ( File f : added )
         {
             for ( File dir = f.getParentFile(); !dir.equals( checkoutDirectory ); dir = dir.getParentFile() )
             {
                 File relativized = relativize( checkoutDirectory, dir );
                 //  we do the best we can with the directories
                 if ( createdDirs.add( relativized ) )
                 {
                     dirsToAdd.add( relativized );
                 }
                 else
                 {
                     break;
                 }
             }
             addedList.add( relativize( checkoutDirectory, f ) );
         }

         for ( File relativized : dirsToAdd )
         {
             try
             {
                 ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, relativized );
                 getLog().debug( "scm add directory: " + relativized );
                 AddScmResult addDirResult = scmProvider.add( scmRepository, fileSet, "Adding directory" );
                 if ( !addDirResult.isSuccess() )
                 {
                     getLog().debug( " Error adding directory " + relativized + ": " + addDirResult.getCommandOutput() );
                 }
             }
             catch ( ScmException e )
             {
                 //
             }
         }

         // remove directories already added !
         addedList.removeAll( dirsToAdd );

         ScmFileSet addedFileSet = new ScmFileSet( checkoutDirectory, addedList );
         getLog().debug( "scm add files: " + addedList );
         try
         {

                 CommandParameters commandParameters = new CommandParameters();
                 commandParameters.setString( CommandParameter.MESSAGE, "Adding new site files." );
                 commandParameters.setString( CommandParameter.FORCE_ADD, Boolean.TRUE.toString() );
                 checkScmResult( scmProvider.add( scmRepository, addedFileSet, commandParameters ),
                                 "add new files to SCM" );

         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to add new files to SCM", e );
         }
     }

     private<T extends ScmResult> T checkScmResult( T result, String failure )
         throws MojoExecutionException
     {
         if ( !result.isSuccess() )
         {
             String msg = "Failed to " + failure + ": " + result.getProviderMessage() + " " + result.getCommandOutput();
             logError( msg );
             throw new MojoExecutionException( msg );
         }
         return result;
     }

     public boolean isDryRun()
     {
         return dryRun;
     }

     public abstract void scmPublishExecute()
         throws MojoExecutionException, MojoFailureException;
 }
	package org.apache.maven.plugins.scmpublish;

	/*
	* 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 org.apache.commons.io.FileUtils;
	import org.apache.commons.io.FilenameUtils;
	import org.apache.maven.plugin.AbstractMojo;
	import org.apache.maven.plugin.MojoExecutionException;
	import org.apache.maven.plugin.MojoFailureException;
	import org.apache.maven.plugins.annotations.Component;
	import org.apache.maven.plugins.annotations.Parameter;
	import org.apache.maven.scm.CommandParameter;
	import org.apache.maven.scm.CommandParameters;
	import org.apache.maven.scm.ScmBranch;
	import org.apache.maven.scm.ScmException;
	import org.apache.maven.scm.ScmFileSet;
	import org.apache.maven.scm.ScmResult;
	import org.apache.maven.scm.command.add.AddScmResult;
	import org.apache.maven.scm.command.checkin.CheckInScmResult;
	import org.apache.maven.scm.manager.NoSuchScmProviderException;
	import org.apache.maven.scm.manager.ScmManager;
	import org.apache.maven.scm.provider.ScmProvider;
	import org.apache.maven.scm.provider.svn.AbstractSvnScmProvider;
	import org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository;
	import org.apache.maven.scm.repository.ScmRepository;
	import org.apache.maven.scm.repository.ScmRepositoryException;
	import org.apache.maven.settings.Settings;
	import org.apache.maven.shared.release.config.ReleaseDescriptor;
	import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
	import org.codehaus.plexus.util.Os;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeSet;

	/**
	* Base class for the scm-publish mojos.
	*/
	public abstract class AbstractScmPublishMojo
	extends AbstractMojo
	{
	/**
	* Location of the scm publication tree.
	*/
	@Parameter ( property = "scmpublish.pubScmUrl", defaultValue = "${project.distributionManagement.site.url}",
	required = true )
	protected String pubScmUrl;

	/**
	* Location where the scm check-out is done.
	*/
	@Parameter ( property = "scmpublish.checkoutDirectory",
	defaultValue = "${project.build.directory}/scmpublish-checkout" )
	protected File checkoutDirectory;

	/**
	* Display list of added, deleted, and changed files, but do not do any actual SCM operations.
	*/
	@Parameter ( property = "scmpublish.dryRun" )
	private boolean dryRun;

	/**
	* Run add and delete commands, but leave the actually checkin for the user to run manually.
	*/
	@Parameter ( property = "scmpublish.skipCheckin" )
	private boolean skipCheckin;

	/**
	* SCM log/checkin comment for this publication.
	*/
	@Parameter ( property = "scmpublish.checkinComment", defaultValue = "Site checkin for project ${project.name}" )
	private String checkinComment;

	/**
	* Patterns to exclude from the scm tree.
	*/
	@Parameter
	protected String excludes;

	/**
	* Patterns to include in the scm tree.
	*/
	@Parameter
	protected String includes;

	/**
	* List of SCM provider implementations.
	* Key is the provider type, eg. <code>cvs</code>.
	* Value is the provider implementation (the role-hint of the provider), eg. <code>cvs</code> or <code>cvs_native</code>.
	* @see ScmManager.setScmProviderImplementation
	*/
	@Parameter
	private Map<String, String> providerImplementations;

	/**
	* The SCM manager.
	*/
	@Component
	private ScmManager scmManager;

	/**
	* Tool that gets a configured SCM repository from release configuration.
	*/
	@Component
	protected ScmRepositoryConfigurator scmRepositoryConfigurator;

	/**
	* The SCM username to use.
	*/
	@Parameter ( property = "username" )
	protected String username;

	/**
	* The SCM password to use.
	*/
	@Parameter ( property = "password" )
	protected String password;

	/**
	* Use a local checkout instead of doing a checkout from the upstream repository. <b>WARNING</b>: This will only work
	* with distributed SCMs which support the file:// protocol
	* TODO: we should think about having the defaults for the various SCM providers provided via Modello!
	*/
	@Parameter ( property = "localCheckout", defaultValue = "false" )
	protected boolean localCheckout;

	/**
	* The outputEncoding parameter of the site plugin. This plugin will corrupt your site
	* if this does not match the value used by the site plugin.
	*/
	@Parameter ( property = "outputEncoding", defaultValue = "${project.reporting.outputEncoding}" )
	protected String siteOutputEncoding;

	/**
	* If the checkout directory exists and this flag is activated, the plugin will try an SCM-update rather
	* than delete then checkout.
	*/
	@Parameter ( property = "scmpublish.tryUpdate", defaultValue = "false" )
	protected boolean tryUpdate;

	/**
	* Do not delete files to the scm
	*/
	@Parameter ( property = "scmpublish.skipDeletedFiles", defaultValue = "false" )
	protected boolean skipDeletedFiles;

	/**
	*/
	@Parameter ( defaultValue = "${basedir}", readonly = true )
	protected File basedir;

	/**
	*/
	@Component
	protected Settings settings;

	/**
	* Collections of paths not to delete when checking content to delete.
	* If your site has subdirectories published by an other mechanism/build
	*/
	@Parameter
	protected String[] ignorePathsToDelete;

	/**
	* SCM branch to use. For github, you must configure with <code>gh-pages</code>.
	*/
	@Parameter ( property = "scmpublish.scm.branch" )
	protected String scmBranch;

	/**
	* Configure svn automatic remote url creation.
	*/
	@Parameter ( property = "scmpublish.automaticRemotePathCreation", defaultValue = "true" )
	protected boolean automaticRemotePathCreation;

	/**
	* Filename extensions of files which need new line normalization.
	*/
	private final static String[] NORMALIZE_EXTENSIONS = { "html", "css", "js" };

	/**
	* Extra file extensions to normalize line ending (will be added to default
	* <code>html</code>,<code>css</code>,<code>js</code> list)
	*/
	@Parameter
	protected String[] extraNormalizeExtensions;

	protected ScmProvider scmProvider;

	protected ScmRepository scmRepository;

	protected void logInfo( String format, Object... params )
	{
	getLog().info( String.format( format, params ) );
	}

	protected void logWarn( String format, Object... params )
	{
	getLog().warn( String.format( format, params ) );
	}

	protected void logError( String format, Object... params )
	{
	getLog().error( String.format( format, params ) );
	}

	private File relativize( File base, File file )
	{
	return new File( base.toURI().relativize( file.toURI() ).getPath() );
	}

	protected boolean requireNormalizeNewlines( File f )
	throws IOException
	{
	List<String> extensions = Arrays.asList( NORMALIZE_EXTENSIONS );
	if ( extraNormalizeExtensions != null )
	{
	extensions.addAll( Arrays.asList( extraNormalizeExtensions ) );
	}

	return FilenameUtils.isExtension( f.getName(), extensions );
	}

	private ReleaseDescriptor setupScm()
	throws ScmRepositoryException, NoSuchScmProviderException
	{
	String scmUrl;
	if ( localCheckout )
	{
	// in the release phase we have to change the checkout URL
	// to do a local checkout instead of going over the network.

	// the first step is a bit tricky, we need to know which provider! like e.g. "scm:jgit:http://"
	// the offset of 4 is because 'scm:' has 4 characters...
	String providerPart = pubScmUrl.substring( 0, pubScmUrl.indexOf( ':', 4 ) );

	// X TODO: also check the information from releaseDescriptor.getScmRelativePathProjectDirectory()
	// X TODO: in case our toplevel git directory has no pom.
	// X TODO: fix pathname once I understand this.
	scmUrl = providerPart + ":file://" + "target/localCheckout";
	logInfo( "Performing a LOCAL checkout from " + scmUrl );
	}

	ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
	releaseDescriptor.setInteractive( settings.isInteractiveMode() );

	//TODO use from settings with decrypt stuff

	releaseDescriptor.setScmPassword( password );
	releaseDescriptor.setScmUsername( username );

	releaseDescriptor.setWorkingDirectory( basedir.getAbsolutePath() );
	releaseDescriptor.setLocalCheckout( localCheckout );
	releaseDescriptor.setScmSourceUrl( pubScmUrl );

	if ( providerImplementations != null )
	{
	for ( Map.Entry<String, String> providerEntry : providerImplementations.entrySet() )
	{
	logInfo( "Changing the default '%s' provider implementation to '%s'.", providerEntry.getKey(),
	providerEntry.getValue() );
	scmManager.setScmProviderImplementation( providerEntry.getKey(), providerEntry.getValue() );
	}
	}

	scmRepository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );

	scmProvider = scmRepositoryConfigurator.getRepositoryProvider( scmRepository );

	return releaseDescriptor;
	}

	protected void checkoutExisting()
	throws MojoExecutionException
	{

	if ( scmProvider instanceof AbstractSvnScmProvider )
	{
	checkCreateRemoteSvnPath();
	}

	logInfo( "%s the pub tree from %s ...", ( tryUpdate ? "Updating" : "Checking out" ), pubScmUrl );

	if ( checkoutDirectory.exists() && !tryUpdate )

	{
	try
	{
	FileUtils.deleteDirectory( checkoutDirectory );
	}
	catch ( IOException e )
	{
	logError( e.getMessage() );

	throw new MojoExecutionException( "Unable to remove old checkout directory: " + e.getMessage(), e );
	}
	}

	boolean forceCheckout = false;

	if ( !checkoutDirectory.exists() )

	{
	if ( tryUpdate )
	{
	logInfo( "TryUpdate is configured but no local copy currently available: forcing checkout." );
	}
	checkoutDirectory.mkdirs();
	forceCheckout = true;
	}

	try
	{
	ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, includes, excludes );

	ScmResult scmResult;
	if ( tryUpdate && !forceCheckout )
	{
	scmResult = scmProvider.update( scmRepository, fileSet );
	}
	else if ( scmBranch == null )
	{
	scmResult = scmProvider.checkOut( scmRepository, fileSet );
	}
	else
	{
	ScmBranch scmBranch = new ScmBranch( this.scmBranch );
	scmResult = scmProvider.checkOut( scmRepository, fileSet, scmBranch );
	}

	checkScmResult( scmResult, "check out from SCM" );
	}
	catch ( ScmException e )
	{
	logError( e.getMessage() );

	throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
	}
	catch ( IOException e )
	{
	logError( e.getMessage() );

	throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
	}
	}

	private void checkCreateRemoteSvnPath()
	throws MojoExecutionException
	{
	getLog().debug( "AbstractSvnScmProvider used, so we can check if remote url exists and eventually create it." );
	AbstractSvnScmProvider svnScmProvider = (AbstractSvnScmProvider) scmProvider;

	try
	{
	boolean remoteExists = svnScmProvider.remoteUrlExist( scmRepository.getProviderRepository(), null );

	if ( remoteExists )
	{
	return;
	}
	}
	catch ( ScmException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}

	String remoteUrl = ( (SvnScmProviderRepository) scmRepository.getProviderRepository() ).getUrl();

	if ( !automaticRemotePathCreation )
	{
	// olamy: return ?? that will fail during checkout IMHO :-)
	logWarn( "Remote svn url %s does not exist and automatic remote path creation disabled.",
	remoteUrl );
	return;
	}

	logInfo( "Remote svn url %s does not exist: creating.", remoteUrl );

	File baseDir = null;
	try
	{

	// create a temporary directory for svnexec
	baseDir = File.createTempFile( "scm", "tmp" );
	baseDir.delete();
	baseDir.mkdirs();
	// to prevent fileSet cannot be empty
	ScmFileSet scmFileSet = new ScmFileSet( baseDir, new File( "" ) );

	CommandParameters commandParameters = new CommandParameters();
	commandParameters.setString( CommandParameter.SCM_MKDIR_CREATE_IN_LOCAL, Boolean.FALSE.toString() );
	commandParameters.setString( CommandParameter.MESSAGE, "Automatic svn path creation: " + remoteUrl );
	svnScmProvider.mkdir( scmRepository.getProviderRepository(), scmFileSet, commandParameters );

	// new remote url so force checkout!
	if ( checkoutDirectory.exists() )
	{
	FileUtils.deleteDirectory( checkoutDirectory );
	}
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}
	catch ( ScmException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}
	finally
	{
	if ( baseDir != null )
	{
	try
	{
	FileUtils.forceDeleteOnExit( baseDir );
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}
	}
	}
	}

	public void execute()
	throws MojoExecutionException, MojoFailureException
	{
	// setup the scm plugin with help from release plugin utilities
	try
	{
	setupScm();
	}
	catch ( ScmRepositoryException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}
	catch ( NoSuchScmProviderException e )
	{
	throw new MojoExecutionException( e.getMessage(), e );
	}

	boolean tmpCheckout = false;

	if ( checkoutDirectory.getPath().contains( "${project." ) )
	{
	try
	{
	tmpCheckout = true;
	checkoutDirectory = File.createTempFile( "maven-scm-publish", ".checkout" );
	checkoutDirectory.delete();
	checkoutDirectory.mkdir();
	}
	catch ( IOException ioe )
	{
	throw new MojoExecutionException( ioe.getMessage(), ioe );
	}
	}

	try
	{
	scmPublishExecute();
	}
	finally
	{
	if ( tmpCheckout )
	{
	FileUtils.deleteQuietly( checkoutDirectory );
	}
	}
	}

	/**
	* Check-in content from scm checkout.
	*
	* @throws MojoExecutionException
	*/
	protected void checkinFiles()
	throws MojoExecutionException
	{
	if ( skipCheckin )
	{
	return;
	}

	ScmFileSet updatedFileSet = new ScmFileSet( checkoutDirectory );
	try
	{
	logInfo( "Checking in to the scm" );

	CheckInScmResult checkinResult =
	checkScmResult( scmProvider.checkIn( scmRepository, updatedFileSet, new ScmBranch( scmBranch ),
	checkinComment ), "check-in files to SCM" );

	logInfo( "Checked in %d file(s) to revision: %s", checkinResult.getCheckedInFiles().size(),
	checkinResult.getScmRevision() );
	}
	catch ( ScmException e )
	{
	throw new MojoExecutionException( "Failed to perform SCM checkin", e );
	}
	}

	protected void deleteFiles( Collection<File> deleted )
	throws MojoExecutionException
	{
	if ( skipDeletedFiles )
	{
	logInfo( "Deleting files is skipped." );
	return;
	}
	List<File> deletedList = new ArrayList<File>();
	for ( File f : deleted )
	{
	deletedList.add( relativize( checkoutDirectory, f ) );
	}
	ScmFileSet deletedFileSet = new ScmFileSet( checkoutDirectory, deletedList );
	try
	{
	getLog().debug( "Deleting files: " + deletedList );

	checkScmResult( scmProvider.remove( scmRepository, deletedFileSet, "Deleting obsolete site files." ),
	"delete files from SCM" );
	}
	catch ( ScmException e )
	{
	throw new MojoExecutionException( "Failed to delete removed files to SCM", e );
	}
	}

	/**
	* Add files to scm.
	*
	* @param added files to be added
	* @throws MojoFailureException
	* @throws MojoExecutionException
	*/
	protected void addFiles( Collection<File> added )
	throws MojoFailureException, MojoExecutionException
	{
	List<File> addedList = new ArrayList<File>();
	Set<File> createdDirs = new HashSet<File>();
	Set<File> dirsToAdd = new TreeSet<File>();

	createdDirs.add( relativize( checkoutDirectory, checkoutDirectory ) );

	for ( File f : added )
	{
	for ( File dir = f.getParentFile(); !dir.equals( checkoutDirectory ); dir = dir.getParentFile() )
	{
	File relativized = relativize( checkoutDirectory, dir );
	// we do the best we can with the directories
	if ( createdDirs.add( relativized ) )
	{
	dirsToAdd.add( relativized );
	}
	else
	{
	break;
	}
	}
	addedList.add( relativize( checkoutDirectory, f ) );
	}

	for ( File relativized : dirsToAdd )
	{
	try
	{
	ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, relativized );
	getLog().debug( "scm add directory: " + relativized );
	AddScmResult addDirResult = scmProvider.add( scmRepository, fileSet, "Adding directory" );
	if ( !addDirResult.isSuccess() )
	{
	getLog().debug( " Error adding directory " + relativized + ": " + addDirResult.getCommandOutput() );
	}
	}
	catch ( ScmException e )
	{
	//
	}
	}

	// remove directories already added !
	addedList.removeAll( dirsToAdd );

	ScmFileSet addedFileSet = new ScmFileSet( checkoutDirectory, addedList );
	getLog().debug( "scm add files: " + addedList );
	try
	{

	CommandParameters commandParameters = new CommandParameters();
	commandParameters.setString( CommandParameter.MESSAGE, "Adding new site files." );
	commandParameters.setString( CommandParameter.FORCE_ADD, Boolean.TRUE.toString() );
	checkScmResult( scmProvider.add( scmRepository, addedFileSet, commandParameters ),
	"add new files to SCM" );

	}
	catch ( ScmException e )
	{
	throw new MojoExecutionException( "Failed to add new files to SCM", e );
	}
	}

	private<T extends ScmResult> T checkScmResult( T result, String failure )
	throws MojoExecutionException
	{
	if ( !result.isSuccess() )
	{
	String msg = "Failed to " + failure + ": " + result.getProviderMessage() + " " + result.getCommandOutput();
	logError( msg );
	throw new MojoExecutionException( msg );
	}
	return result;
	}

	public boolean isDryRun()
	{
	return dryRun;
	}

	public abstract void scmPublishExecute()
	throws MojoExecutionException, MojoFailureException;
	}