import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void copy(@NotNull SvnTarget source,
                 @NotNull File destination,
                 @Nullable SVNRevision revision,
                 boolean makeParents,
                 @Nullable ProgressTracker handler) throws VcsException {
  SVNCopyClient client = myVcs.getSvnKitManager().createCopyClient();
  client.setEventHandler(toEventHandler(handler));

  try {
    client.doCopy(new SVNCopySource[]{createCopySource(source, revision)}, destination, false, makeParents, true);
  }
  catch (SVNException e) {
    throw new SvnBindException(e);
  }
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void upgrade(@NotNull File path, @NotNull WorkingCopyFormat format, @Nullable ProgressTracker handler) throws VcsException {
  validateFormat(format, getSupportedFormats());

  // fake event indicating upgrade start
  callHandler(handler, createEvent(path, EventAction.UPDATE_COMPLETED));

  List<String> parameters = new ArrayList<String>();

  CommandUtil.put(parameters, path);

  // TODO: Add general possibility to invoke "handler.checkCancelled" (process should be killed). But currently upgrade process is not
  // TODO: cancellable from UI - and this makes sense.
  // for 1.8 - no output
  // for 1.7 - output in format "Upgraded '<path>'"
  FileStatusResultParser parser = new FileStatusResultParser(CHANGED_PATH, handler, new UpgradeStatusConvertor());
  UpgradeLineCommandListener listener = new UpgradeLineCommandListener(parser);

  execute(myVcs, SvnTarget.fromFile(path), SvnCommandName.upgrade, parameters, listener);
  listener.throwIfException();
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@NotNull
private CommitInfo[] runCommit(@NotNull List<File> paths, @NotNull String message) throws VcsException {
  if (ContainerUtil.isEmpty(paths)) return new CommitInfo[]{CommitInfo.EMPTY};

  Command command = newCommand(SvnCommandName.ci);

  command.put(Depth.EMPTY);
  command.put("-m", message);
  // TODO: seems that sort is not necessary here
  ContainerUtil.sort(paths);
  command.setTargets(paths);

  IdeaCommitHandler handler = new IdeaCommitHandler(ProgressManager.getInstance().getProgressIndicator());
  CmdCheckinClient.CommandListener listener = new CommandListener(handler);
  listener.setBaseDirectory(CommandUtil.requireExistingParent(paths.get(0)));
  execute(myVcs, SvnTarget.fromFile(paths.get(0)), null, command, listener);
  listener.throwExceptionIfOccurred();

  long revision = validateRevisionNumber(listener.getCommittedRevision());

  return new CommitInfo[]{new CommitInfo.Builder().setRevision(revision).build()};
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public long doStatus(@NotNull final File path,
                     @Nullable final SVNRevision revision,
                     @NotNull final Depth depth,
                     boolean remote,
                     boolean reportAll,
                     boolean includeIgnored,
                     boolean collectParentExternals,
                     @NotNull final StatusConsumer handler,
                     @Nullable final Collection changeLists) throws SvnBindException {
  File base = CommandUtil.requireExistingParent(path);
  final Info infoBase = myFactory.createInfoClient().doInfo(base, revision);
  List<String> parameters = new ArrayList<String>();

  putParameters(parameters, path, depth, remote, reportAll, includeIgnored, changeLists);

  CommandExecutor command = execute(myVcs, SvnTarget.fromFile(path), SvnCommandName.st, parameters, null);
  parseResult(path, revision, handler, base, infoBase, command);
  return 0;
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void annotate(@NotNull SvnTarget target,
                     @NotNull SVNRevision startRevision,
                     @NotNull SVNRevision endRevision,
                     boolean includeMergedRevisions,
                     @Nullable DiffOptions diffOptions,
                     @Nullable AnnotationConsumer handler) throws VcsException {
  try {
    SVNLogClient client = myVcs.getSvnKitManager().createLogClient();

    client.setDiffOptions(toDiffOptions(diffOptions));
    if (target.isFile()) {
      client
        .doAnnotate(target.getFile(), target.getPegRevision(), startRevision, endRevision, true, includeMergedRevisions,
                    toAnnotateHandler(handler), null);
    }
    else {
      client
        .doAnnotate(target.getURL(), target.getPegRevision(), startRevision, endRevision, true, includeMergedRevisions,
                    toAnnotateHandler(handler), null);
    }
  }
  catch (SVNException e) {
    throw new VcsException(e);
  }
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void annotate(@NotNull SvnTarget target,
                     @NotNull SVNRevision startRevision,
                     @NotNull SVNRevision endRevision,
                     boolean includeMergedRevisions,
                     @Nullable DiffOptions diffOptions,
                     @Nullable final AnnotationConsumer handler) throws VcsException {
  List<String> parameters = new ArrayList<String>();
  CommandUtil.put(parameters, target);
  CommandUtil.put(parameters, startRevision, endRevision);
  CommandUtil.put(parameters, includeMergedRevisions, "--use-merge-history");
  CommandUtil.put(parameters, diffOptions);
  parameters.add("--xml");

  CommandExecutor command = execute(myVcs, target, SvnCommandName.blame, parameters, null);

  parseOutput(command.getOutput(), handler);
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
private void doLog(final boolean includeMerged, final SVNRevision truncateTo, final int max) throws VcsException {
  myClient.doLog(SvnTarget.fromFile(myIoFile), myEndRevision, truncateTo == null ? SVNRevision.create(1L) : truncateTo,
                 false, false, includeMerged, max, null,
                 new LogEntryConsumer() {
                   @Override
                   public void consume(LogEntry logEntry) {
                     if (SVNRevision.UNDEFINED.getNumber() == logEntry.getRevision()) {
                       return;
                     }

                     if (myProgress != null) {
                       myProgress.checkCanceled();
                       myProgress.setText2(SvnBundle.message("progress.text2.revision.processed", logEntry.getRevision()));
                     }
                     myResult.setRevision(logEntry.getRevision(), new SvnFileRevision(myVcs, SVNRevision.UNDEFINED, logEntry, myUrl, ""));
                   }
                 });
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
public void editFiles(VirtualFile[] files) throws VcsException {
  File[] ioFiles = new File[files.length];

  for (int i = 0; i < files.length; i++) {
    ioFiles[i] = new File(files[i].getPath());

    PropertyClient client = myVCS.getFactory(ioFiles[i]).createPropertyClient();
    PropertyValue property = client.getProperty(SvnTarget.fromFile(ioFiles[i], SVNRevision.WORKING), SvnPropertyKeys.SVN_NEEDS_LOCK,
                                                  false, SVNRevision.WORKING);

    if (property == null) {
      throw new VcsException(SvnBundle.message("exception.text.file.miss.svn", ioFiles[i].getName()));
    }
  }
  SvnUtil.doLockFiles(myVCS.getProject(), myVCS, ioFiles);
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void revert(@NotNull Collection<File> paths, @Nullable Depth depth, @Nullable ProgressTracker handler) throws VcsException {
  if (!ContainerUtil.isEmpty(paths)) {
    Command command = newCommand(SvnCommandName.revert);

    command.put(depth);
    command.setTargets(paths);

    // TODO: handler should be called in parallel with command execution, but this will be in other thread
    // TODO: check if that is ok for current handler implementation
    // TODO: add possibility to invoke "handler.checkCancelled" - process should be killed
    SvnTarget target = SvnTarget.fromFile(ObjectUtils.assertNotNull(ContainerUtil.getFirstItem(paths)));
    CommandExecutor executor = execute(myVcs, target, CommandUtil.getHomeDirectory(), command, null);
    FileStatusResultParser parser = new FileStatusResultParser(CHANGED_PATH, handler, new RevertStatusConvertor());
    parser.parse(executor.getOutput());
  }
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void copy(@NotNull SvnTarget source,
                 @NotNull File destination,
                 @Nullable SVNRevision revision,
                 boolean makeParents,
                 @Nullable ProgressTracker handler) throws VcsException {
  List<String> parameters = new ArrayList<String>();

  CommandUtil.put(parameters, source);
  CommandUtil.put(parameters, destination);
  CommandUtil.put(parameters, revision);
  CommandUtil.put(parameters, makeParents, "--parents");

  File workingDirectory = CommandUtil.getHomeDirectory();
  BaseUpdateCommandListener listener = new BaseUpdateCommandListener(workingDirectory, handler);

  execute(myVcs, source, workingDirectory, SvnCommandName.copy, parameters, listener);

  listener.throwWrappedIfException();
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void export(@NotNull SvnTarget from,
                   @NotNull File to,
                   @Nullable SVNRevision revision,
                   @Nullable Depth depth,
                   @Nullable String nativeLineEnd,
                   boolean force,
                   boolean ignoreExternals,
                   @Nullable ProgressTracker handler) throws VcsException {
  SVNUpdateClient client = myVcs.getSvnKitManager().createUpdateClient();

  client.setEventHandler(toEventHandler(handler));
  client.setIgnoreExternals(ignoreExternals);

  try {
    if (from.isFile()) {
      client.doExport(from.getFile(), to, from.getPegRevision(), revision, nativeLineEnd, force, toDepth(depth));
    }
    else {
      client.doExport(from.getURL(), to, from.getPegRevision(), revision, nativeLineEnd, force, toDepth(depth));
    }
  }
  catch (SVNException e) {
    throw new SvnBindException(e);
  }
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void list(@NotNull SvnTarget target,
                 @Nullable SVNRevision revision,
                 @Nullable Depth depth,
                 @Nullable DirectoryEntryConsumer handler) throws VcsException {
  assertUrl(target);

  SVNLogClient client = getLogClient();
  ISVNDirEntryHandler wrappedHandler = wrapHandler(handler);

  client.setIgnoreExternals(true);
  try {
    if (target.isFile()) {
      client.doList(target.getFile(), target.getPegRevision(), notNullize(revision), true, toDepth(depth), SVNDirEntry.DIRENT_ALL, wrappedHandler);
    }
    else {
      client.doList(target.getURL(), target.getPegRevision(), notNullize(revision), true, toDepth(depth), SVNDirEntry.DIRENT_ALL, wrappedHandler);
    }
  }
  catch (SVNException e) {
    throw new SvnBindException(e);
  }
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void merge(@NotNull SvnTarget source1,
                  @NotNull SvnTarget source2,
                  @NotNull File destination,
                  @Nullable Depth depth,
                  boolean useAncestry,
                  boolean dryRun,
                  boolean recordOnly,
                  boolean force,
                  @Nullable DiffOptions diffOptions,
                  @Nullable ProgressTracker handler) throws VcsException {
  assertUrl(source1);
  assertUrl(source2);

  List<String> parameters = new ArrayList<String>();

  CommandUtil.put(parameters, source1);
  CommandUtil.put(parameters, source2);
  fillParameters(parameters, destination, depth, dryRun, recordOnly, force, false, diffOptions);
  CommandUtil.put(parameters, !useAncestry, "--ignore-ancestry");

  run(destination, handler, parameters);
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Nullable
private String getCommitMessage(@NotNull File path, @NotNull Info info) {
  String result;

  try {
    PropertyValue property =
      myVcs.getFactory(path).createPropertyClient()
        .getProperty(SvnTarget.fromFile(path), COMMIT_MESSAGE, true, info.getCommittedRevision());

    result = PropertyValue.toString(property);
  }
  catch (VcsException e) {
    LOG.info("Failed to get commit message for file " + path + ", " + info.getCommittedRevision() + ", " + info.getRevision(), e);
    result = "";
  }

  return result;
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
public static boolean remoteFolderIsEmpty(final SvnVcs vcs, final String url) throws VcsException {
  SvnTarget target = SvnTarget.fromURL(createUrl(url));
  final Ref<Boolean> result = new Ref<Boolean>(true);
  DirectoryEntryConsumer handler = new DirectoryEntryConsumer() {

    @Override
    public void consume(final DirectoryEntry entry) throws SVNException {
      if (entry != null) {
        result.set(false);
      }
    }
  };

  vcs.getFactory(target).createBrowseClient().list(target, null, Depth.IMMEDIATES, handler);
  return result.get();
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@NotNull
public static SvnTarget append(@NotNull SvnTarget target, @NotNull String path, boolean checkAbsolute) throws SvnBindException {
  SvnTarget result;

  if (target.isFile()) {
    result = SvnTarget.fromFile(resolvePath(target.getFile(), path));
  }
  else {
    try {
      result = SvnTarget
        .fromURL(checkAbsolute && URI.create(path).isAbsolute() ? SVNURL.parseURIEncoded(path) : target.getURL().appendPath(path, false));
    }
    catch (SVNException e) {
      throw new SvnBindException(e);
    }
  }

  return result;
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public void add(@NotNull File file,
                @Nullable Depth depth,
                boolean makeParents,
                boolean includeIgnored,
                boolean force,
                @Nullable ProgressTracker handler) throws VcsException {
  List<String> parameters = prepareParameters(file, depth, makeParents, includeIgnored, force);

  // TODO: handler should be called in parallel with command execution, but this will be in other thread
  // TODO: check if that is ok for current handler implementation
  // TODO: add possibility to invoke "handler.checkCancelled" - process should be killed
  CommandExecutor command = execute(myVcs, SvnTarget.fromFile(file), SvnCommandName.add, parameters, null);
  FileStatusResultParser parser = new FileStatusResultParser(CHANGED_PATH, handler, new AddStatusConvertor());
  parser.parse(command.getOutput());
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
@Override
public long doSwitch(File path,
                     SVNURL url,
                     SVNRevision pegRevision,
                     SVNRevision revision,
                     Depth depth,
                     boolean allowUnversionedObstructions,
                     boolean depthIsSticky) throws SvnBindException {
  checkWorkingCopy(path);

  List<String> parameters = new ArrayList<String>();

  CommandUtil.put(parameters, SvnTarget.fromURL(url, pegRevision));
  CommandUtil.put(parameters, path, false);
  fillParameters(parameters, revision, depth, depthIsSticky, allowUnversionedObstructions);
  if (!myVcs.is16SupportedByCommandLine() ||
      WorkingCopyFormat.from(myFactory.createVersionClient().getVersion()).isOrGreater(WorkingCopyFormat.ONE_DOT_SEVEN)) {
    parameters.add("--ignore-ancestry");
  }

  long[] revisions = run(path, parameters, SvnCommandName.switchCopy);

  return revisions != null && revisions.length > 0 ? revisions[0] : -1;
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
private void loadBackwards(SVNURL svnurl) throws SVNException, VcsException {
  // this method is called when svnurl does not exist in latest repository revision - thus concrete old revision is used for "info"
  // command to get repository url
  Info info = myVcs.getInfo(svnurl, myPeg, myPeg);
  final SVNURL rootURL = info != null ? info.getRepositoryRootURL() : null;
  final String root = rootURL != null ? rootURL.toString() : "";
  String relativeUrl = myUrl;
  if (myUrl.startsWith(root)) {
    relativeUrl = myUrl.substring(root.length());
  }

  final RepositoryLogEntryHandler repositoryLogEntryHandler =
      new RepositoryLogEntryHandler(myVcs, myUrl, SVNRevision.UNDEFINED, relativeUrl,
                                    new ThrowableConsumer<VcsFileRevision, SVNException>() {
                                      @Override
                                      public void consume(VcsFileRevision revision) throws SVNException {
                                        myConsumer.consume(revision);
                                      }
                                    }, rootURL);
  repositoryLogEntryHandler.setThrowCancelOnMeetPathCreation(true);

  SvnTarget target = SvnTarget.fromURL(rootURL, myFrom);
  myVcs.getFactory(target).createHistoryClient()
    .doLog(target, myFrom, myTo == null ? SVNRevision.create(1) : myTo, false, true, myShowMergeSources && mySupport15, 1, null,
           repositoryLogEntryHandler);
}
 

import org.tmatesoft.svn.core.wc2.SvnTarget; //导入依赖的package包/类
private static List<String> prepareCommand(@NotNull SvnTarget target,
                                           @NotNull SVNRevision startRevision,
                                           @NotNull SVNRevision endRevision,
                                           boolean stopOnCopy, boolean discoverChangedPaths, boolean includeMergedRevisions, long limit) {
  List<String> parameters = new ArrayList<String>();

  CommandUtil.put(parameters, target);
  CommandUtil.put(parameters, startRevision, endRevision);
  CommandUtil.put(parameters, stopOnCopy, "--stop-on-copy");
  CommandUtil.put(parameters, discoverChangedPaths, "--verbose");
  CommandUtil.put(parameters, includeMergedRevisions, "--use-merge-history");
  if (limit > 0) {
    parameters.add("--limit");
    parameters.add(String.valueOf(limit));
  }
  parameters.add("--xml");

  return parameters;
}