import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected StatusScmResult executeStatusCommand( ScmProviderRepository repo, ScmFileSet fileSet )
    throws ScmException
{
    if ( getLogger().isInfoEnabled() )
    {
        getLogger().info( "SVN status directory: " + fileSet.getBasedir().getAbsolutePath() );
    }

    SvnJavaScmProviderRepository javaRepo = (SvnJavaScmProviderRepository) repo;

    SvnStatusHandler handler = new SvnStatusHandler( fileSet.getBasedir() );

    try
    {
        SvnJavaUtil.status( javaRepo.getClientManager(), fileSet.getBasedir(), true, // isRecursive
                            true, // isRemote
                            handler );

        return new StatusScmResult( SvnJavaScmProvider.COMMAND_LINE, handler.getFiles() );
    }
    catch ( SVNException e )
    {
        return new StatusScmResult( SvnJavaScmProvider.COMMAND_LINE, "SVN status failed.", e.getMessage(), false );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * @see org.apache.maven.scm.command.blame.AbstractBlameCommand#executeBlameCommand(org.apache.maven.scm.provider.ScmProviderRepository,
 *      org.apache.maven.scm.ScmFileSet, java.lang.String)
 */
@Override
public BlameScmResult executeBlameCommand( ScmProviderRepository repo, ScmFileSet workingDirectory,
                                           String filename )
    throws ScmException
{
    try
    {
        SvnJavaScmProviderRepository javaRepo = (SvnJavaScmProviderRepository) repo;
        javaRepo.getClientManager();
        AnnotationHandler handler = new AnnotationHandler();
        SvnJavaUtil.blame( javaRepo.getClientManager(), new File( workingDirectory.getBasedir(), filename ),
                           handler );
        return new BlameScmResult( "", handler.lines );
    }
    catch ( SVNException e )
    {
        throw new ScmException( e.getMessage(), e );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * Given the ScmManager for the current execution cycle, and the MavenProject structure, determine if we can
 * find a maven-provided manner of resolving the current git branch.
 *
 * @param scmManager The current maven ScmManager
 * @param project    The Current maven Project
 * @param log        A Log to write to
 * @return The current git branch name, or <code>${env.GIT_BRACH}</code> if the current git branch could not be resolved.
 * @throws ScmException
 */
public static String resolveBranchOrExpression(final ScmManager scmManager, final MavenProject project, final Log log) {
    String connectionUrl = resolveUrlOrExpression(project, log);

    // If a connectionURL other than the default expression was resolved, try to resolve the branch.
    if (!StringUtils.equals(connectionUrl, DEFAULT_URL_EXPRESSION)) {
        try {
            ScmRepository repository = scmManager.makeScmRepository(connectionUrl);
            ScmProvider provider = scmManager.getProviderByRepository(repository);

            if (GitScmProviderRepository.PROTOCOL_GIT.equals(provider.getScmType())) {
                ScmFileSet fileSet = new ScmFileSet(project.getBasedir());
                return GitBranchCommand.getCurrentBranch(new ScmLogDispatcher(), (GitScmProviderRepository) repository.getProviderRepository(), fileSet);
            } else {
                log.warn("Project SCM defines a non-git SCM provider. Falling back to  variable resolution.");
            }
        } catch (ScmException se) {
            log.warn("Unable to resolve Git Branch from Project SCM definition.", se);
        }
    }

    log.debug("Git branch unresolvable from Project SCM definition, defaulting to " + DEFAULT_BRANCH_EXPRESSION);
    return DEFAULT_BRANCH_EXPRESSION;
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
public String getRevision()
    throws MojoExecutionException
{
    try
    {
        return this.getScmRevision();
    }
    catch ( ScmException e )
    {
        if ( !StringUtils.isEmpty( revisionOnScmFailure ) )
        {
            getLog().warn( "Cannot get the revision information from the scm repository, proceeding with "
                + "revision of " + revisionOnScmFailure + " : \n" + e.getLocalizedMessage() );

            return revisionOnScmFailure;
        }

        throw new MojoExecutionException( "Cannot get the revision information from the scm repository : \n"
            + e.getLocalizedMessage(), e );

    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
protected ScmRepository getScmRepository()
    throws ScmException
{
    ScmRepository repository = scmManager.makeScmRepository( !StringUtils.isBlank( this.scmConnectionUrl )
                    ? scmConnectionUrl : scmDeveloperConnectionUrl );

    ScmProviderRepository scmRepo = repository.getProviderRepository();

    if ( scmRepo instanceof ScmProviderRepositoryWithHost )
    {
        loadInfosFromSettings( (ScmProviderRepositoryWithHost) scmRepo );
    }

    setPasswordIfNotEmpty( scmRepo, password );

    setUserIfNotEmpty( scmRepo, username );

    return repository;
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
protected void checkResult( ScmResult result )
    throws ScmException
{
    if ( !result.isSuccess() )
    {
        // TODO: improve error handling
        getLog().error( "Provider message:" );

        getLog().error( result.getProviderMessage() );

        getLog().error( "Command output:" );

        getLog().error( result.getCommandOutput() );

        throw new ScmException( "Error!" );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * Get info from scm.
 *
 * @param repository
 * @param fileSet
 * @return
 * @throws ScmException
 * @todo this should be rolled into org.apache.maven.scm.provider.ScmProvider and
 *       org.apache.maven.scm.provider.svn.SvnScmProvider
 */
protected InfoScmResult info( ScmRepository repository, ScmFileSet fileSet )
    throws ScmException
{
    CommandParameters commandParameters = new CommandParameters();

    // only for Git, we will make a test for shortRevisionLength parameter
    if ( GitScmProviderRepository.PROTOCOL_GIT.equals( scmManager.getProviderByRepository( repository ).getScmType() )
        && this.shortRevisionLength > 0 )
    {
        getLog().info( "ShortRevision tag detected. The value is '" + this.shortRevisionLength + "'." );
        if ( shortRevisionLength >= 0 && shortRevisionLength < 4 )
        {
            getLog().warn( "shortRevision parameter less then 4. ShortRevisionLength is relaying on 'git rev-parese --short=LENGTH' command, accordingly to Git rev-parse specification the LENGTH value is miminum 4. " );
        }
        commandParameters.setInt( CommandParameter.SCM_SHORT_REVISION_LENGTH, this.shortRevisionLength );
    }

    if ( !StringUtils.isBlank( scmTag ) && !"HEAD".equals( scmTag ) )
    {
        commandParameters.setScmVersion( CommandParameter.SCM_VERSION, new ScmTag( scmTag ) );
    }

    return scmManager.getProviderByRepository( repository ).info( repository.getProviderRepository(), fileSet,
                                                                  commandParameters );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
private Set<String> findModifiedPaths() throws MojoExecutionException {
  try {
    final ScmRepository repository = this.manager
        .makeScmRepository(getSCMConnection());
    final File scmRoot = scmRoot();
    this.getLog().info("Scm root dir is " + scmRoot);

    final Set<ScmFileStatus> statusToInclude = makeStatusSet();
    final Set<String> modifiedPaths;
    if (analyseLastCommit) {
      modifiedPaths = lastCommitChanges(statusToInclude, repository, scmRoot);
    } else if (originBranch != null && destinationBranch != null) {
      modifiedPaths = changesBetweenBranchs(originBranch, destinationBranch, statusToInclude, repository, scmRoot);
    } else {
      modifiedPaths = localChanges(statusToInclude, repository, scmRoot);
    }
    return modifiedPaths;
  } catch (final ScmException e) {
    throw new MojoExecutionException("Error while querying scm", e);
  }

}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
private Set<String> pathsAffectedByChange(ChangeLogScmRequest scmRequest, Set<ScmFileStatus> statusToInclude, int limit) throws ScmException {
  Set<String> affected = new LinkedHashSet<>();
  ChangeLogScmResult changeLogScmResult = this.manager.changeLog(scmRequest);
  if (changeLogScmResult.isSuccess()) {
    List<ChangeSet> changeSets = limit(changeLogScmResult.getChangeLog().getChangeSets(),limit);
    for (ChangeSet change : changeSets) {
      List<ChangeFile> files = change.getFiles();
      for (final ChangeFile changeFile : files) {
        if (statusToInclude.contains(changeFile.getAction())) {
          affected.add(changeFile.getName());
        }
      }
    }
  }
  return affected;
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
public CheckOutScmResult cloneRepository(String scmUrl, String revision, String cloneTo) throws ScmException {

        File buildDir = new File(cloneTo);
        if (!buildDir.exists())
            buildDir.mkdir();

        ScmRepository repo = getScmRepository(String.format("scm:%s:%s", repositoryType.name(), scmUrl), scmManager);
        return scmManager.checkOut(repo, new ScmFileSet(buildDir), new ScmTag(revision));
    }
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected String getRepositoryURL( File path )
    throws ScmException
{
    try
    {
        return SVNURL.fromFile( path ).getURIEncodedPath();
    }
    catch ( SVNException e )
    {
        throw new IllegalArgumentException( e.getMessage() );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
@Override
public RemoteInfoScmResult remoteInfo( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
    throws ScmException
{
    return new SvnJavaRemoteInfoCommand().executeRemoteInfoCommand( repository, fileSet, parameters );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
@Override
public ScmResult executeCommand( ScmProviderRepository repository, ScmFileSet fileSet,
                                 CommandParameters parameters )
    throws ScmException
{
    boolean recursive = parameters == null ? false : parameters.getBoolean( CommandParameter.RECURSIVE );
    ScmVersion scmVersion =
        parameters == null ? null : parameters.getScmVersion( CommandParameter.SCM_VERSION, null );
    return executeListCommand( repository, fileSet, recursive, scmVersion );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * @see org.apache.maven.scm.command.mkdir.AbstractMkdirCommand#executeMkdirCommand(org.apache.maven.scm.provider.ScmProviderRepository, org.apache.maven.scm.ScmFileSet, java.lang.String)
 */
@Override
protected MkdirScmResult executeMkdirCommand( ScmProviderRepository repository, ScmFileSet fileSet, String message,
                                              boolean createInLocal )
    throws ScmException
{
    SvnJavaScmProviderRepository javaRepo = (SvnJavaScmProviderRepository) repository;
    Iterator<File> it = fileSet.getFileList().iterator();
    String dirPath = it.next().getPath();
    // replacing \ with / for windauze
    if ( dirPath != null && Os.isFamily( Os.FAMILY_DOS ) )
    {
        dirPath = StringUtils.replace( dirPath, "\\", "/" );
    }
    String url = javaRepo.getUrl() + "/" + dirPath;
    if ( createInLocal )
    {
        url = dirPath;
    }
    List<SVNURL> svnurls = new ArrayList<SVNURL>( 1 );
    try
    {
        svnurls.add( SVNURL.parseURIEncoded( url ) );

        SVNCommitInfo commitInfo =
            SvnJavaUtil.mkdir( javaRepo.getClientManager(), svnurls.toArray( new SVNURL[svnurls.size()] ),
                               message );
        ScmResult scmResult = new ScmResult( null, null, null, true );

        return new MkdirScmResult( Long.toString( commitInfo.getNewRevision() ), scmResult );
    }
    catch ( SVNException e )
    {
        throw new ScmException( e.getMessage(), e );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected ScmResult executeAddCommand( ScmProviderRepository repository, ScmFileSet fileSet, String message,
                                       boolean binary )
    throws ScmException
{
    CommandParameters commandParameters = new CommandParameters();
    commandParameters.setString( CommandParameter.MESSAGE, message );
    return executeCommand( repository, fileSet, commandParameters );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected ChangeLogScmResult executeChangeLogCommand( ScmProviderRepository repository, ScmFileSet fileSet,
                                                      ScmVersion startVersion, ScmVersion endVersion,
                                                      String datePattern )
    throws ScmException
{
    throw new UnsupportedOperationException( "executeChangeLogCommand( ScmProviderRepository repository, "
                                                 + "ScmFileSet fileSet, ScmVersion startVersion, ScmVersion endVersion, String datePattern ) is not "
                                                 + "implemented" );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected ScmResult executeRemoveCommand( ScmProviderRepository repo, ScmFileSet fileSet, String message )
    throws ScmException
{
    if ( fileSet.getFileList().isEmpty() )
    {
        throw new ScmException( "You must provide at least one file/directory to remove" );
    }

    if ( getLogger().isInfoEnabled() )
    {
        getLogger().info( "SVN remove working directory: " + fileSet.getBasedir().getAbsolutePath() );
    }

    SvnJavaScmProviderRepository javaRepo = (SvnJavaScmProviderRepository) repo;

    ScmFileEventHandler handler = new ScmFileEventHandler( getLogger(), fileSet.getBasedir() );

    javaRepo.getClientManager().getWCClient().setEventHandler( handler );

    try
    {
        SvnJavaUtil.delete( javaRepo.getClientManager(), fileSet, true );

        return new RemoveScmResult( SvnJavaScmProvider.COMMAND_LINE, handler.getFiles() );
    }
    catch ( SVNException e )
    {
        return new RemoveScmResult( SvnJavaScmProvider.COMMAND_LINE, "SVN remove failed.", e.getMessage(), false );
    }
    finally
    {
        javaRepo.getClientManager().getWCClient().setEventHandler( null );
    }
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
public boolean remoteUrlExist( ScmProviderRepository repository, CommandParameters parameters )
    throws ScmException
{
    SvnJavaScmProviderRepository javaRepo = (SvnJavaScmProviderRepository) repository;

    String url = ( (SvnScmProviderRepository) repository ).getUrl();

    try
    {

        javaRepo.getClientManager().getWCClient().doInfo( SVNURL.parseURIEncoded( url ), SVNRevision.HEAD,
                                                          SVNRevision.HEAD, SVNDepth.EMPTY, new ISVNInfoHandler()
        {
            public void handleInfo( SVNInfo svnInfo )
                throws SVNException
            {
                svnInfo.getAuthor();
            }
        } );
    }
    catch ( SVNException e )
    {
        if ( e.getMessage().indexOf( "E170000" ) > -1 )
        {
            return false;
        }
        throw new ScmException( e.getMessage(), e );
    }
    return true;
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public ScmResult executeBranchCommand( ScmProviderRepository repo, ScmFileSet fileSet, String branch,
                                       String message )
    throws ScmException
{
    ScmBranchParameters scmBranchParameters = new ScmBranchParameters( message );
    return executeBranchCommand( repo, fileSet, branch, scmBranchParameters );
}
 

import org.apache.maven.scm.ScmException; //导入依赖的package包/类
private boolean doLocalModificationExist( StringBuilder message )
    throws MojoExecutionException
{
    boolean result = false;

    getLog().debug( "Verifying there are no local modifications ..." );

    List<ScmFile> changedFiles;

    try
    {
        changedFiles = getStatus();
    }
    catch ( ScmException e )
    {
        throw new MojoExecutionException( "An error has occurred while checking scm status.", e );
    }

    if ( !changedFiles.isEmpty() )
    {
        for ( ScmFile file : changedFiles )
        {
            message.append( file.toString() );

            message.append( System.lineSeparator() );
        }

        result = true;
    }

    return result;
}