package org.apache.maven.scm.provider;
/*
* 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.maven.scm.CommandParameter;
import org.apache.maven.scm.CommandParameters;
import org.apache.maven.scm.NoSuchCommandScmException;
import org.apache.maven.scm.ScmBranch;
import org.apache.maven.scm.ScmBranchParameters;
import org.apache.maven.scm.ScmException;
import org.apache.maven.scm.ScmFileSet;
import org.apache.maven.scm.ScmRevision;
import org.apache.maven.scm.ScmTagParameters;
import org.apache.maven.scm.ScmVersion;
import org.apache.maven.scm.command.add.AddScmResult;
import org.apache.maven.scm.command.blame.BlameScmResult;
import org.apache.maven.scm.command.branch.BranchScmResult;
import org.apache.maven.scm.command.changelog.ChangeLogScmResult;
import org.apache.maven.scm.command.checkin.CheckInScmResult;
import org.apache.maven.scm.command.checkout.CheckOutScmResult;
import org.apache.maven.scm.command.diff.DiffScmResult;
import org.apache.maven.scm.command.edit.EditScmResult;
import org.apache.maven.scm.command.export.ExportScmResult;
import org.apache.maven.scm.command.info.InfoScmResult;
import org.apache.maven.scm.command.list.ListScmResult;
import org.apache.maven.scm.command.login.LoginScmResult;
import org.apache.maven.scm.command.mkdir.MkdirScmResult;
import org.apache.maven.scm.command.remoteinfo.RemoteInfoScmResult;
import org.apache.maven.scm.command.remove.RemoveScmResult;
import org.apache.maven.scm.command.status.StatusScmResult;
import org.apache.maven.scm.command.tag.TagScmResult;
import org.apache.maven.scm.command.unedit.UnEditScmResult;
import org.apache.maven.scm.command.update.UpdateScmResult;
import org.apache.maven.scm.log.ScmLogDispatcher;
import org.apache.maven.scm.log.ScmLogger;
import org.apache.maven.scm.repository.ScmRepository;
import org.apache.maven.scm.repository.ScmRepositoryException;
import org.apache.maven.scm.repository.UnknownRepositoryStructure;
import org.codehaus.plexus.util.StringUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* @author <a href="mailto:trygvis@inamo.no">Trygve Laugstøl</a>
* @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
* @author Olivier Lamy
* @version $Id: AbstractScmProvider.java 1306403 2012-03-28 15:13:37Z olamy $
*/
public abstract class AbstractScmProvider
implements ScmProvider
{
private ScmLogDispatcher logDispatcher = new ScmLogDispatcher();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
/**
* {@inheritDoc}
*/
public String getScmSpecificFilename()
{
return null;
}
/**
* {@inheritDoc}
*/
public String sanitizeTagName( String tag )
{
/* by default, we assume all tags are valid. */
return tag;
}
/**
* {@inheritDoc}
*/
public boolean validateTagName( String tag )
{
/* by default, we assume all tags are valid. */
return true;
}
/**
* {@inheritDoc}
*/
public List<String> validateScmUrl( String scmSpecificUrl, char delimiter )
{
List<String> messages = new ArrayList<String>();
try
{
makeProviderScmRepository( scmSpecificUrl, delimiter );
}
catch ( ScmRepositoryException e )
{
messages.add( e.getMessage() );
}
return messages;
}
/**
* {@inheritDoc}
*/
public boolean requiresEditMode()
{
return false;
}
// ----------------------------------------------------------------------
// Scm Implementation
// ----------------------------------------------------------------------
/**
* {@inheritDoc}
*/
public AddScmResult add( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
return add( repository, fileSet, (String) null );
}
/**
* {@inheritDoc}
*/
public AddScmResult add( ScmRepository repository, ScmFileSet fileSet, String message )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.MESSAGE, message == null ? "" : message );
// TODO: binary may be dependant on particular files though
// TODO: set boolean?
parameters.setString( CommandParameter.BINARY, "false" );
return add( repository.getProviderRepository(), fileSet, parameters );
}
public AddScmResult add( ScmRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
login( repository, fileSet );
// TODO: binary may be dependant on particular files though
// TODO: set boolean?
parameters.setString( CommandParameter.BINARY, "false" );
return add( repository.getProviderRepository(), fileSet, parameters );
}
public AddScmResult add( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "add" );
}
/**
* {@inheritDoc}
*/
public BranchScmResult branch( ScmRepository repository, ScmFileSet fileSet, String branchName )
throws ScmException
{
return branch( repository, fileSet, branchName, new ScmBranchParameters() );
}
/**
* {@inheritDoc}
*/
public BranchScmResult branch( ScmRepository repository, ScmFileSet fileSet, String branchName, String message )
throws ScmException
{
ScmBranchParameters scmBranchParameters = new ScmBranchParameters();
if ( StringUtils.isNotEmpty( message ) )
{
scmBranchParameters.setMessage( message );
}
return branch( repository, fileSet, branchName, scmBranchParameters );
}
public BranchScmResult branch( ScmRepository repository, ScmFileSet fileSet, String branchName,
ScmBranchParameters scmBranchParameters )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.BRANCH_NAME, branchName );
parameters.setScmBranchParameters( CommandParameter.SCM_BRANCH_PARAMETERS, scmBranchParameters );
return branch( repository.getProviderRepository(), fileSet, parameters );
}
protected BranchScmResult branch( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "branch" );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,
int numDays, String branch )
throws ScmException
{
return changeLog( repository, fileSet, startDate, endDate, numDays, branch, null );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,
int numDays, String branch, String datePattern )
throws ScmException
{
ScmBranch scmBranch = null;
if ( StringUtils.isNotEmpty( branch ) )
{
scmBranch = new ScmBranch( branch );
}
return changeLog( repository, fileSet, startDate, endDate, numDays, scmBranch, null );
}
/**
* {@inheritDoc}
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,
int numDays, ScmBranch branch )
throws ScmException
{
return changeLog( repository, fileSet, startDate, endDate, numDays, branch, null );
}
/**
* {@inheritDoc}
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,
int numDays, ScmBranch branch, String datePattern )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setDate( CommandParameter.START_DATE, startDate );
parameters.setDate( CommandParameter.END_DATE, endDate );
parameters.setInt( CommandParameter.NUM_DAYS, numDays );
parameters.setScmVersion( CommandParameter.BRANCH, branch );
parameters.setString( CommandParameter.CHANGELOG_DATE_PATTERN, datePattern );
return changelog( repository.getProviderRepository(), fileSet, parameters );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, String startTag, String endTag )
throws ScmException
{
return changeLog( repository, fileSet, startTag, endTag, null );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, String startTag, String endTag,
String datePattern )
throws ScmException
{
ScmVersion startRevision = null;
ScmVersion endRevision = null;
if ( StringUtils.isNotEmpty( startTag ) )
{
startRevision = new ScmRevision( startTag );
}
if ( StringUtils.isNotEmpty( endTag ) )
{
endRevision = new ScmRevision( endTag );
}
return changeLog( repository, fileSet, startRevision, endRevision, null );
}
/**
* {@inheritDoc}
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion,
ScmVersion endVersion )
throws ScmException
{
return changeLog( repository, fileSet, startVersion, endVersion, null );
}
/**
* {@inheritDoc}
*/
public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion,
ScmVersion endVersion, String datePattern )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.START_SCM_VERSION, startVersion );
parameters.setScmVersion( CommandParameter.END_SCM_VERSION, endVersion );
parameters.setString( CommandParameter.CHANGELOG_DATE_PATTERN, datePattern );
return changelog( repository.getProviderRepository(), fileSet, parameters );
}
protected ChangeLogScmResult changelog( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "changelog" );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public CheckInScmResult checkIn( ScmRepository repository, ScmFileSet fileSet, String tag, String message )
throws ScmException
{
ScmVersion scmVersion = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmVersion = new ScmBranch( tag );
}
return checkIn( repository, fileSet, scmVersion, message );
}
/**
* {@inheritDoc}
*/
public CheckInScmResult checkIn( ScmRepository repository, ScmFileSet fileSet, String message )
throws ScmException
{
return checkIn( repository, fileSet, (ScmVersion) null, message );
}
/**
* {@inheritDoc}
*/
public CheckInScmResult checkIn( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
String message )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
parameters.setString( CommandParameter.MESSAGE, message );
return checkin( repository.getProviderRepository(), fileSet, parameters );
}
protected CheckInScmResult checkin( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "checkin" );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, String tag )
throws ScmException
{
return checkOut( repository, fileSet, tag, true );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, String tag, boolean recursive )
throws ScmException
{
ScmVersion scmVersion = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmVersion = new ScmBranch( tag );
}
return checkOut( repository, fileSet, scmVersion, recursive );
}
/**
* {@inheritDoc}
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
return checkOut( repository, fileSet, (ScmVersion) null, true );
}
/**
* {@inheritDoc}
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion )
throws ScmException
{
return checkOut( repository, fileSet, scmVersion, true );
}
/**
* {@inheritDoc}
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, boolean recursive )
throws ScmException
{
return checkOut( repository, fileSet, (ScmVersion) null, recursive );
}
/**
* {@inheritDoc}
*/
public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
boolean recursive )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
parameters.setString( CommandParameter.RECURSIVE, recursive + "" );
return checkout( repository.getProviderRepository(), fileSet, parameters );
}
protected CheckOutScmResult checkout( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "checkout" );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public DiffScmResult diff( ScmRepository repository, ScmFileSet fileSet, String startRevision, String endRevision )
throws ScmException
{
ScmVersion startVersion = null;
ScmVersion endVersion = null;
if ( StringUtils.isNotEmpty( startRevision ) )
{
startVersion = new ScmRevision( startRevision );
}
if ( StringUtils.isNotEmpty( endRevision ) )
{
endVersion = new ScmRevision( endRevision );
}
return diff( repository, fileSet, startVersion, endVersion );
}
/**
* {@inheritDoc}
*/
public DiffScmResult diff( ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion,
ScmVersion endVersion )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.START_SCM_VERSION, startVersion );
parameters.setScmVersion( CommandParameter.END_SCM_VERSION, endVersion );
return diff( repository.getProviderRepository(), fileSet, parameters );
}
protected DiffScmResult diff( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "diff" );
}
/**
* {@inheritDoc}
*/
public EditScmResult edit( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
return edit( repository.getProviderRepository(), fileSet, parameters );
}
protected EditScmResult edit( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
if ( getLogger().isWarnEnabled() )
{
getLogger().warn( "Provider " + this.getScmType() + " does not support edit operation." );
}
return new EditScmResult( "", null, null, true );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, String tag )
throws ScmException
{
return export( repository, fileSet, tag, null );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, String tag, String outputDirectory )
throws ScmException
{
ScmVersion scmVersion = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmVersion = new ScmRevision( tag );
}
return export( repository, fileSet, scmVersion, outputDirectory );
}
/**
* {@inheritDoc}
*/
public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
return export( repository, fileSet, (ScmVersion) null, null );
}
/**
* {@inheritDoc}
*/
public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion )
throws ScmException
{
return export( repository, fileSet, scmVersion, null );
}
/**
* {@inheritDoc}
*/
public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
String outputDirectory )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
parameters.setString( CommandParameter.OUTPUT_DIRECTORY, outputDirectory );
return export( repository.getProviderRepository(), fileSet, parameters );
}
protected ExportScmResult export( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "export" );
}
/**
* {@inheritDoc}
*/
public ListScmResult list( ScmRepository repository, ScmFileSet fileSet, boolean recursive, String tag )
throws ScmException
{
ScmVersion scmVersion = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmVersion = new ScmRevision( tag );
}
return list( repository, fileSet, recursive, scmVersion );
}
/**
* {@inheritDoc}
*/
public ListScmResult list( ScmRepository repository, ScmFileSet fileSet, boolean recursive, ScmVersion scmVersion )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.RECURSIVE, Boolean.toString( recursive ) );
if ( scmVersion != null )
{
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
}
return list( repository.getProviderRepository(), fileSet, parameters );
}
/**
* List each element (files and directories) of <B>fileSet</B> as they exist in the repository.
*
* @param repository the source control system
* @param fileSet the files to list
* @param parameters
* @return The list of files in the repository
* @throws NoSuchCommandScmException unless overriden by subclass
* @throws ScmException if any
*/
protected ListScmResult list( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "list" );
}
/**
* {@inheritDoc}
*/
public MkdirScmResult mkdir( ScmRepository repository, ScmFileSet fileSet, String message, boolean createInLocal )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
if ( message == null )
{
message = "";
if ( !createInLocal )
{
getLogger().warn( "Commit message is empty!" );
}
}
parameters.setString( CommandParameter.MESSAGE, message );
parameters.setString( CommandParameter.SCM_MKDIR_CREATE_IN_LOCAL, Boolean.toString( createInLocal ) );
return mkdir( repository.getProviderRepository(), fileSet, parameters );
}
/**
* Create directory/directories in the repository.
*
* @param repository
* @param fileSet
* @param parameters
* @return
* @throws ScmException
*/
protected MkdirScmResult mkdir( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "mkdir" );
}
private void login( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
LoginScmResult result = login( repository.getProviderRepository(), fileSet, new CommandParameters() );
if ( !result.isSuccess() )
{
throw new ScmException( "Can't login.\n" + result.getCommandOutput() );
}
}
protected LoginScmResult login( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
return new LoginScmResult( null, null, null, true );
}
/**
* {@inheritDoc}
*/
public RemoveScmResult remove( ScmRepository repository, ScmFileSet fileSet, String message )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.MESSAGE, message == null ? "" : message );
return remove( repository.getProviderRepository(), fileSet, parameters );
}
protected RemoveScmResult remove( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "remove" );
}
/**
* {@inheritDoc}
*/
public StatusScmResult status( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
return status( repository.getProviderRepository(), fileSet, parameters );
}
protected StatusScmResult status( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "status" );
}
/**
* {@inheritDoc}
*/
public TagScmResult tag( ScmRepository repository, ScmFileSet fileSet, String tagName )
throws ScmException
{
return tag( repository, fileSet, tagName, new ScmTagParameters() );
}
/**
* {@inheritDoc}
*/
public TagScmResult tag( ScmRepository repository, ScmFileSet fileSet, String tagName, String message )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.TAG_NAME, tagName );
if ( StringUtils.isNotEmpty( message ) )
{
parameters.setString( CommandParameter.MESSAGE, message );
}
ScmTagParameters scmTagParameters = new ScmTagParameters( message );
parameters.setScmTagParameters( CommandParameter.SCM_TAG_PARAMETERS, scmTagParameters );
return tag( repository.getProviderRepository(), fileSet, parameters );
}
/**
* {@inheritDoc}
*/
public TagScmResult tag( ScmRepository repository, ScmFileSet fileSet, String tagName,
ScmTagParameters scmTagParameters )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.TAG_NAME, tagName );
parameters.setScmTagParameters( CommandParameter.SCM_TAG_PARAMETERS, scmTagParameters );
return tag( repository.getProviderRepository(), fileSet, parameters );
}
protected TagScmResult tag( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "tag" );
}
/**
* {@inheritDoc}
*/
public UnEditScmResult unedit( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
return unedit( repository.getProviderRepository(), fileSet, parameters );
}
protected UnEditScmResult unedit( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
if ( getLogger().isWarnEnabled() )
{
getLogger().warn( "Provider " + this.getScmType() + " does not support unedit operation." );
}
return new UnEditScmResult( "", null, null, true );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag )
throws ScmException
{
return update( repository, fileSet, tag, true );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag, boolean runChangelog )
throws ScmException
{
return update( repository, fileSet, tag, "", runChangelog );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet )
throws ScmException
{
return update( repository, fileSet, (ScmVersion) null, true );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion )
throws ScmException
{
return update( repository, fileSet, scmVersion, true );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, boolean runChangelog )
throws ScmException
{
return update( repository, fileSet, (ScmVersion) null, "", runChangelog );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
boolean runChangelog )
throws ScmException
{
return update( repository, fileSet, scmVersion, "", runChangelog );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag, String datePattern )
throws ScmException
{
return update( repository, fileSet, tag, datePattern, true );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
String datePattern )
throws ScmException
{
return update( repository, fileSet, scmVersion, datePattern, true );
}
/**
* @deprecated
*/
private UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag, String datePattern,
boolean runChangelog )
throws ScmException
{
ScmBranch scmBranch = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmBranch = new ScmBranch( tag );
}
return update( repository, fileSet, scmBranch, datePattern, runChangelog );
}
private UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
String datePattern, boolean runChangelog )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
parameters.setString( CommandParameter.CHANGELOG_DATE_PATTERN, datePattern );
parameters.setString( CommandParameter.RUN_CHANGELOG_WITH_UPDATE, String.valueOf( runChangelog ) );
return update( repository.getProviderRepository(), fileSet, parameters );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag, Date lastUpdate )
throws ScmException
{
return update( repository, fileSet, tag, lastUpdate, null );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion,
Date lastUpdate )
throws ScmException
{
return update( repository, fileSet, scmVersion, lastUpdate, null );
}
/**
* {@inheritDoc}
*
* @deprecated
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String tag, Date lastUpdate,
String datePattern )
throws ScmException
{
ScmBranch scmBranch = null;
if ( StringUtils.isNotEmpty( tag ) )
{
scmBranch = new ScmBranch( tag );
}
return update( repository, fileSet, scmBranch, lastUpdate, datePattern );
}
/**
* {@inheritDoc}
*/
public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion scmVersion, Date lastUpdate,
String datePattern )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setScmVersion( CommandParameter.SCM_VERSION, scmVersion );
if ( lastUpdate != null )
{
parameters.setDate( CommandParameter.START_DATE, lastUpdate );
}
parameters.setString( CommandParameter.CHANGELOG_DATE_PATTERN, datePattern );
parameters.setString( CommandParameter.RUN_CHANGELOG_WITH_UPDATE, "true" );
return update( repository.getProviderRepository(), fileSet, parameters );
}
protected UpdateScmResult update( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "update" );
}
/**
* {@inheritDoc}
*/
public BlameScmResult blame( ScmRepository repository, ScmFileSet fileSet, String filename )
throws ScmException
{
login( repository, fileSet );
CommandParameters parameters = new CommandParameters();
parameters.setString( CommandParameter.FILE, filename );
return blame( repository.getProviderRepository(), fileSet, parameters );
}
protected BlameScmResult blame( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
throw new NoSuchCommandScmException( "blame" );
}
public InfoScmResult info( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
throws ScmException
{
return null;
}
public RemoteInfoScmResult remoteInfo( ScmProviderRepository repository, ScmFileSet fileSet,
CommandParameters parameters )
throws ScmException
{
return null;
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
/**
* {@inheritDoc}
*/
public void addListener( ScmLogger logger )
{
logDispatcher.addListener( logger );
}
public ScmLogger getLogger()
{
return logDispatcher;
}
/**
* {@inheritDoc}
*/
public ScmProviderRepository makeProviderScmRepository( File path )
throws ScmRepositoryException, UnknownRepositoryStructure
{
throw new UnknownRepositoryStructure();
}
}