import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Render the access from behind a firewall section
 *
 * @param devRepository the dev repository
 */
private void renderAccessBehindFirewallSection(ScmRepository devRepository) {
    startSection(getI18nString("accessbehindfirewall.title"));

    if (devRepository != null && isScmSystem(devRepository, "svn")) {
        SvnScmProviderRepository svnRepo = (SvnScmProviderRepository) devRepository.getProviderRepository();

        paragraph(getI18nString("accessbehindfirewall.svn.intro"));

        verbatimText("$ svn checkout " + svnRepo.getUrl() + " " + checkoutDirectoryName);
    } else if (devRepository != null && isScmSystem(devRepository, "cvs")) {
        linkPatternedText(getI18nString("accessbehindfirewall.cvs.intro"));
    } else {
        paragraph(getI18nString("accessbehindfirewall.general.intro"));
    }

    endSection();
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的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.repository.ScmRepository; //导入依赖的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.repository.ScmRepository; //导入依赖的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.repository.ScmRepository; //导入依赖的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.repository.ScmRepository; //导入依赖的package包/类
private ScmResultWrapper execute(final ScmFileSet fileSet,
    final ScmRepository repository, final ScmProvider provider)
  throws org.apache.maven.scm.ScmException
{
  final ScmVersion remoteVersion = scmConnectionInfo.getRemoteVersion();
  final ScmResultWrapper result;
  if (remoteVersion != null)
  {
    final ScmVersion localVersion = null;
    result =
        createScmDiffResultWrapper(provider.diff(repository, fileSet,
            remoteVersion, localVersion));
  }
  else
  {
    result =
        createScmStatusResultWrapper(provider.status(repository, fileSet));
  }
  return result;
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Render the overview section
 *
 * @param anonymousRepository the anonymous repository
 * @param devRepository the developer repository
 */
private void renderOverviewSection(ScmRepository anonymousRepository, ScmRepository devRepository) {
    startSection(getI18nString("overview.title"));

    if (isScmSystem(anonymousRepository, "clearcase") || isScmSystem(devRepository, "clearcase")) {
        sink.paragraph();
        linkPatternedText(getI18nString("clearcase.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "cvs") || isScmSystem(devRepository, "cvs")) {
        sink.paragraph();
        linkPatternedText(getI18nString("cvs.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "git") || isScmSystem(devRepository, "git")) {
        sink.paragraph();
        linkPatternedText(getI18nString("git.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "hg") || isScmSystem(devRepository, "hg")) {
        sink.paragraph();
        linkPatternedText(getI18nString("hg.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "perforce") || isScmSystem(devRepository, "perforce")) {
        sink.paragraph();
        linkPatternedText(getI18nString("perforce.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "starteam") || isScmSystem(devRepository, "starteam")) {
        sink.paragraph();
        linkPatternedText(getI18nString("starteam.intro"));
        sink.paragraph_();
    } else if (isScmSystem(anonymousRepository, "svn") || isScmSystem(devRepository, "svn")) {
        sink.paragraph();
        linkPatternedText(getI18nString("svn.intro"));
        sink.paragraph_();
    } else {
        paragraph(getI18nString("general.intro"));
    }

    endSection();
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Render the anonymous access section depending the repository.
 * <p>
 * Note: ClearCase, Starteam et Perforce seems to have no anonymous access.
 * </p>
 *
 * @param anonymousRepository the anonymous repository
 */
private void renderAnonymousAccessSection(ScmRepository anonymousRepository) {
    if (isScmSystem(anonymousRepository, "clearcase") || isScmSystem(anonymousRepository, "perforce")
            || isScmSystem(anonymousRepository, "starteam") || StringUtils.isEmpty(anonymousConnection)) {
        return;
    }

    startSection(getI18nString("anonymousaccess.title"));

    if (anonymousRepository != null && isScmSystem(anonymousRepository, "cvs")) {
        CvsScmProviderRepository cvsRepo
                = (CvsScmProviderRepository) anonymousRepository.getProviderRepository();

        anonymousAccessCVS(cvsRepo);
    } else if (anonymousRepository != null && isScmSystem(anonymousRepository, "git")) {
        GitScmProviderRepository gitRepo
                = (GitScmProviderRepository) anonymousRepository.getProviderRepository();

        anonymousAccessGit(gitRepo);
    } else if (anonymousRepository != null && isScmSystem(anonymousRepository, "hg")) {
        HgScmProviderRepository hgRepo = (HgScmProviderRepository) anonymousRepository.getProviderRepository();

        anonymousAccessMercurial(hgRepo);
    } else if (anonymousRepository != null && isScmSystem(anonymousRepository, "svn")) {
        SvnScmProviderRepository svnRepo
                = (SvnScmProviderRepository) anonymousRepository.getProviderRepository();

        anonymousAccessSubversion(svnRepo);
    } else {
        paragraph(getI18nString("anonymousaccess.general.intro"));

        verbatimText(anonymousConnection.substring(4));
    }

    endSection();
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Render the access from behind a firewall section
 *
 * @param anonymousRepository the anonymous repository
 * @param devRepository the dev repository
 */
private void renderAccessThroughProxySection(ScmRepository anonymousRepository, ScmRepository devRepository) {
    if (isScmSystem(anonymousRepository, "svn") || isScmSystem(devRepository, "svn")) {
        startSection(getI18nString("accessthroughtproxy.title"));

        paragraph(getI18nString("accessthroughtproxy.svn.intro1"));
        paragraph(getI18nString("accessthroughtproxy.svn.intro2"));
        paragraph(getI18nString("accessthroughtproxy.svn.intro3"));

        verbatimText("[global]" + SystemUtils.LINE_SEPARATOR + "http-proxy-host = your.proxy.name"
                + SystemUtils.LINE_SEPARATOR + "http-proxy-port = 3128" + SystemUtils.LINE_SEPARATOR);

        endSection();
    }
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的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.repository.ScmRepository; //导入依赖的package包/类
/**
 * FIXME remove when upgrading to scm 1.8 as the method commit has been to protected
 */
protected void doCommit( File workingDirectory, ScmRepository repository )
    throws Exception
{
    CheckInScmResult result = getScmManager().checkIn( repository, new ScmFileSet( workingDirectory ), "No msg" );

    assertTrue( "Check result was successful, output: " + result.getCommandOutput(), result.isSuccess() );

    List<ScmFile> committedFiles = result.getCheckedInFiles();

    assertEquals( "Expected 2 files in the committed files list " + committedFiles, 2, committedFiles.size() );
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
public List<ScmFile> update()
    throws MojoExecutionException
{
    try
    {
        ScmRepository repository = getScmRepository();

        ScmProvider scmProvider = scmManager.getProviderByRepository( repository );

        UpdateScmResult result = scmProvider.update( repository, new ScmFileSet( scmDirectory ) );

        if ( result == null )
        {
            return Collections.emptyList();
        }

        checkResult( result );

        if ( result instanceof UpdateScmResultWithRevision )
        {
            String revision = ( (UpdateScmResultWithRevision) result ).getRevision();
            getLog().info( "Got a revision during update: " + revision );
            this.revision = revision;
        }

        return result.getUpdatedFiles();
    }
    catch ( ScmException e )
    {
        throw new MojoExecutionException( "Couldn't update project. " + e.getMessage(), e );
    }

}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Get the branch info for this revision from the repository. For svn, it is in svn info.
 *
 * @return
 * @throws MojoExecutionException
 * @throws MojoExecutionException
 */
public String getScmBranch()
    throws MojoExecutionException
{
    try
    {
        ScmRepository repository = getScmRepository();
        ScmProvider provider = scmManager.getProviderByRepository( repository );
        /* git branch can be obtained directly by a command */
        if ( GitScmProviderRepository.PROTOCOL_GIT.equals( provider.getScmType() ) )
        {
            ScmFileSet fileSet = new ScmFileSet( scmDirectory );
            return GitBranchCommand.getCurrentBranch( getLogger(),
                                                      (GitScmProviderRepository) repository.getProviderRepository(),
                                                      fileSet );
        }
        else if ( provider instanceof HgScmProvider )
        {
            /* hg branch can be obtained directly by a command */
            HgOutputConsumer consumer = new HgOutputConsumer( getLogger() );
            ScmResult result = HgUtils.execute( consumer, logger, scmDirectory, new String[] { "id", "-b" } );
            checkResult( result );
            if ( StringUtils.isNotEmpty( consumer.getOutput() ) )
            {
                return consumer.getOutput();
            }
        }
    }
    catch ( ScmException e )
    {
        getLog().warn( "Cannot get the branch information from the git repository: \n" + e.getLocalizedMessage() );
    }

    return getScmBranchFromUrl();
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
private void makeChanges(ScmManager scmManager, ScmRepository scmRepository,
                         List<File> toCheckIn, List<File> toDelete, List<File> toAdd)
        throws ScmException {
    if (toAdd.size() > 0) {
        scmManager.add(scmRepository, new ScmFileSet(workingDir, toAdd), "");
    }
    if (toDelete.size() > 0) {
        scmManager.remove(scmRepository, new ScmFileSet(workingDir, toDelete), "");
    }
    if (toCheckIn.size() > 0) {
        scmManager.checkIn(scmRepository, new ScmFileSet(workingDir, toCheckIn), "");
    }
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
private Set<String> localChanges(Set<ScmFileStatus> statusToInclude, ScmRepository repository, File scmRoot) throws ScmException {
  final StatusScmResult status = this.manager.status(repository,
          new ScmFileSet(scmRoot));
  Set<String> affected = new LinkedHashSet<>();
  for (final ScmFile file : status.getChangedFiles()) {
    if (statusToInclude.contains(file.getStatus())) {
      affected.add(file.getPath());
    }
  }
  return affected;
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
private void setFileWithStatus(final ScmFileStatus status)
    throws ScmException {
  when(this.manager.status(any(ScmRepository.class), any(ScmFileSet.class)))
      .thenReturn(
          new StatusScmResult("", Arrays.asList(new ScmFile(
              "foo/bar/Bar.java", status))));
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
public void testUnknownAndDeletedClassesAreNotMutationTested()
    throws Exception {
  setupConnection();
  when(this.manager.status(any(ScmRepository.class), any(ScmFileSet.class)))
      .thenReturn(
          new StatusScmResult("", Arrays.asList(new ScmFile(
              "foo/bar/Bar.java", ScmFileStatus.DELETED), new ScmFile(
              "foo/bar/Bar.java", ScmFileStatus.UNKNOWN))));
  this.testee.execute();
  verify(this.executionStrategy, never()).execute(any(File.class),
      any(ReportOptions.class), any(PluginServices.class), anyMap());
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
 * Load user name password from settings if user has not set them via JVM
 * properties.
 *
 * @return the connection information to connect to the SCM system.
 * @throws IllegalStateException if the connection string to the SCM cannot be
 *           fetched.
 * @throws ScmRepositoryException if the repository information is not
 *           sufficient to build the repository instance.
 * @throws NoSuchScmProviderException if there is no provider for the SCM
 *           connection URL.
 */
private ScmConnectionInfo loadConnectionInfo() throws IllegalStateException,
  ScmRepositoryException, NoSuchScmProviderException
{
  final String scmConnection = getConnection();
  final ScmCredentials credentials = scmInfo.getScmCrendentials();
  if (credentials.getUserName() == null || credentials.getPassword() == null)
  {
    final ScmRepository repository =
        scmInfo.getScmManager().makeScmRepository(scmConnection);
    if (repository.getProviderRepository() instanceof ScmProviderRepositoryWithHost)
    {
      final ScmProviderRepositoryWithHost repositoryWithHost =
          (ScmProviderRepositoryWithHost) repository.getProviderRepository();
      final String host = createHostName(repositoryWithHost);
      credentials.configureByServer(host);
    }
  }

  final ScmConnectionInfo info = new ScmConnectionInfo();
  info.setUserName(credentials.getUserName());
  info.setPassword(credentials.getPassword());
  info.setPrivateKey(credentials.getPrivateKey());
  info.setScmConnectionUrl(scmConnection);
  info.setTagBase(scmInfo.getTagBase());
  info.setRemoteVersion(scmInfo.getRemoteVersion());
  return info;
}
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
   * {@inheritDoc}
   */
  @Override
public Revision fetchLatestRevisionNumber() throws ScmException
  {
      if (getLog().isDebugEnabled())
      {
          getLog().debug("  Fetching latest revision number.\n    "
                  + this.scmConnectionInfo + "\n    " + this.scmAccessInfo);
      }

      final ScmRepository repository =
              scmConnectionInfo.createRepository(scmManager);
      final ScmProvider provider = createScmProvider(repository);
      final ChangeLogScmResult result =
              scmAccessInfo.fetchChangeLog(repository, provider);

      Revision revision = null;

      if (result != null && result.isSuccess())
      {
          final List<ChangeSet> changeLogSets = result.getChangeLog().getChangeSets();

          if (changeLogSets.size() > 0)
          {
              revision = new StringRevision (changeLogSets.get(0).getRevision(),
                      changeLogSets.get(0).getDate());
              if (getLog().isDebugEnabled())
              {
                  getLog().debug("Found revision '" + revision + "'.");
              }
          }
      }
      else if (getLog().isDebugEnabled())
      {
          getLog().debug("No revision information found.");
      }
      return revision;
  }
 

import org.apache.maven.scm.repository.ScmRepository; //导入依赖的package包/类
/**
   * {@inheritDoc}
   */
  @Override
public LocallyModifiedInfo containsModifications(final ScmFileSet fileSet)
    throws ScmException
  {
    if (getLog().isDebugEnabled())
    {
      getLog().debug("  Fetching modification information.\n    "
                + this.scmConnectionInfo + "\n    " + this.scmAccessInfo);
    }

    try
    {
      final ScmRepository repository =
          scmConnectionInfo.createRepository(scmManager);
      final ScmProvider provider = createScmProvider(repository);

      final ScmResultWrapper result = execute(fileSet, repository, provider);
      if (result.isSuccess())
      {
        return createLocallyModifiedInfo(result);
      }
      else
      {
        final String message = result.toString();
        if (getLog().isDebugEnabled())
        {
          getLog().debug(message);
        }

        throw new ScmException(message);
      }
    }
    catch (final org.apache.maven.scm.ScmException e)
    {
      throw new ScmException(e);
    }
  }