示例#1
0
  @Override
  public <S> List<S> filterUniqueRoots(
      final List<S> in, final Convertor<S, VirtualFile> convertor) {
    Collections.sort(
        in, new ComparatorDelegate<S, VirtualFile>(convertor, FilePathComparator.getInstance()));

    for (int i = 1; i < in.size(); i++) {
      final S sChild = in.get(i);
      final VirtualFile child = convertor.convert(sChild);
      final VirtualFile childRoot = HgUtil.getHgRootOrNull(myProject, child);
      if (childRoot == null) {
        continue;
      }
      for (int j = i - 1; j >= 0; --j) {
        final S sParent = in.get(j);
        final VirtualFile parent = convertor.convert(sParent);
        // if the parent is an ancestor of the child and that they share common root, the child is
        // removed
        if (VfsUtil.isAncestor(parent, child, false)
            && VfsUtil.isAncestor(childRoot, parent, false)) {
          in.remove(i);
          //noinspection AssignmentToForLoopParameter
          --i;
          break;
        }
      }
    }
    return in;
  }
  @Test
  public void updateKeepsWorkingAfterPull() throws Exception {

    changeFile_A_AndCommitInRemoteRepository();

    // do a simple pull without an update
    HgPullCommand pull = new HgPullCommand(myProject, projectRepoVirtualFile);
    pull.setSource(HgUtil.getRepositoryDefaultPath(myProject, projectRepoVirtualFile));
    pull.setUpdate(false);
    pull.execute();

    assertEquals(
        determineNumberOfIncomingChanges(projectRepo),
        0,
        "The update operation should have pulled the incoming changes from the default repository.");

    updateThroughPlugin();

    HgRevisionNumber parentRevision =
        new HgWorkingCopyRevisionsCommand(myProject).firstParent(projectRepoVirtualFile);
    assertEquals(
        parentRevision.getRevision(),
        "1",
        "The working directory should have been updated to the latest version");
  }
 @Override
 public void conflictResolvedForFile(VirtualFile file) {
   try {
     new HgResolveCommand(myProject).markResolved(HgUtil.getHgRootOrThrow(myProject, file), file);
   } catch (VcsException e) {
     LOG.error("Couldn't mark file resolved, because it is not under Mercurial root.");
   }
 }
 @Nullable
 @Override
 protected HgRepository guessCurrentRepository(@NotNull Project project) {
   return DvcsUtil.guessCurrentRepositoryQuick(
       project,
       HgUtil.getRepositoryManager(project),
       HgProjectSettings.getInstance(project).getRecentRootPath());
 }
 public static HgFile getOriginalHgFile(Project project, VirtualFile root) {
   HgFile hgFile = new HgFile(root, VcsUtil.getFilePath(root.getPath()));
   if (project.isDisposed()) {
     return hgFile;
   }
   FilePath originalFileName =
       HgUtil.getOriginalFileName(hgFile.toFilePath(), ChangeListManager.getInstance(project));
   return new HgFile(hgFile.getRepo(), originalFileName);
 }
示例#6
0
 /**
  * @return the prompthooks.py extension used for capturing prompts from Mercurial and requesting
  *     IDEA's user about authentication.
  */
 @NotNull
 public File getPromptHooksExtensionFile() {
   if (myPromptHooksExtensionFile == null) {
     // check that hooks are available
     myPromptHooksExtensionFile = HgUtil.getTemporaryPythonFile("prompthooks");
     if (myPromptHooksExtensionFile == null || !myPromptHooksExtensionFile.exists()) {
       LOG.error(
           "prompthooks.py Mercurial extension is not found. Please reinstall "
               + ApplicationNamesInfo.getInstance().getProductName());
     }
   }
   return myPromptHooksExtensionFile;
 }
 private HgCommandExitCode pull(VirtualFile repo, ProgressIndicator indicator, boolean isRebase)
     throws VcsException {
   indicator.setText2(HgVcsMessages.message("hg4idea.progress.pull.with.update"));
   HgPullCommand hgPullCommand = new HgPullCommand(project, repo);
   final String defaultPath = HgUtil.getRepositoryDefaultPath(project, repo);
   hgPullCommand.setSource(defaultPath);
   if (isRebase) {
     hgPullCommand.setRebase(true);
   } else {
     hgPullCommand.setUpdate(true);
   }
   return hgPullCommand.execute();
 }
 private void processRebase(final UpdatedFiles updatedFiles) throws VcsException {
   HgRepository repository = HgUtil.getRepositoryManager(project).getRepositoryForRoot(repoRoot);
   HgCommandResult result;
   do {
     resolvePossibleConflicts(updatedFiles);
     if (repository == null || !HgConflictResolver.findConflicts(project, repoRoot).isEmpty()) {
       return;
     }
     HgRebaseCommand rebaseCommand = new HgRebaseCommand(project, repository);
     result = rebaseCommand.continueRebase();
     if (HgErrorUtil.isAbort(result)) {
       new HgCommandResultNotifier(project)
           .notifyError(result, "Hg Error", "Couldn't continue rebasing");
       return;
     }
   } while (result.getExitValue() == 1);
 }
  public void showDialogAndPush(@Nullable final VirtualFile selectedRepo) {
    HgUtil.executeOnPooledThreadIfNeeded(
        new Runnable() {
          public void run() {
            final List<VirtualFile> repositories = HgUtil.getHgRepositories(myProject);
            if (repositories.isEmpty()) {
              VcsBalloonProblemNotifier.showOverChangesView(
                  myProject, "No Mercurial repositories in the project", MessageType.ERROR);
              return;
            }
            VirtualFile firstRepo = repositories.get(0);
            final List<HgTagBranch> branches = getBranches(myProject, firstRepo);
            if (branches.isEmpty()) {
              return;
            }
            final AtomicReference<HgPushCommand> pushCommand = new AtomicReference<HgPushCommand>();
            UIUtil.invokeAndWaitIfNeeded(
                new Runnable() {
                  @Override
                  public void run() {
                    final HgPushDialog dialog =
                        new HgPushDialog(myProject, repositories, branches, selectedRepo);
                    dialog.show();
                    if (dialog.isOK()) {
                      dialog.rememberSettings();
                      pushCommand.set(preparePushCommand(myProject, dialog));
                    }
                  }
                });

            if (pushCommand.get() != null) {
              push(myProject, pushCommand.get());
            }
          }
        });
  }
示例#10
0
  @Override
  public void activate() {
    super.activate();

    // validate hg executable on start
    if (!ApplicationManager.getApplication().isUnitTestMode()) {
      getExecutableValidator().checkExecutableAndNotifyIfNeeded();
    }

    // status bar
    myStatusWidget = new HgStatusWidget(this, getProject(), projectSettings);
    myStatusWidget.activate();

    myIncomingWidget = new HgIncomingOutgoingWidget(this, getProject(), projectSettings, true);
    myIncomingWidget.activate();

    myOutgoingWidget = new HgIncomingOutgoingWidget(this, getProject(), projectSettings, false);
    myOutgoingWidget.activate();

    // updaters and listeners
    myHgRemoteStatusUpdater =
        new HgRemoteStatusUpdater(
            this,
            myIncomingWidget.getChangesetStatus(),
            myOutgoingWidget.getChangesetStatus(),
            projectSettings);
    myHgRemoteStatusUpdater.activate();

    myHgCurrentBranchStatusUpdater =
        new HgCurrentBranchStatusUpdater(this, myStatusWidget.getCurrentBranchStatus());
    myHgCurrentBranchStatusUpdater.activate();

    messageBusConnection = myProject.getMessageBus().connect();
    messageBusConnection.subscribe(
        FileEditorManagerListener.FILE_EDITOR_MANAGER,
        new FileEditorManagerAdapter() {
          @Override
          public void selectionChanged(FileEditorManagerEvent event) {
            Project project = event.getManager().getProject();
            project.getMessageBus().syncPublisher(BRANCH_TOPIC).update(project, null);
          }
        });

    myVFSListener = new HgVFSListener(myProject, this);

    // ignore temporary files
    final String ignoredPattern = FileTypeManager.getInstance().getIgnoredFilesList();
    if (!ignoredPattern.contains(ORIG_FILE_PATTERN)) {
      final String newPattern =
          ignoredPattern + (ignoredPattern.endsWith(";") ? "" : ";") + ORIG_FILE_PATTERN;
      HgUtil.runWriteActionLater(
          new Runnable() {
            public void run() {
              FileTypeManager.getInstance().setIgnoredFilesList(newPattern);
            }
          });
    }

    // Force a branch topic update
    myProject.getMessageBus().syncPublisher(BRANCH_TOPIC).update(myProject, null);
  }
示例#11
0
 @Override
 public boolean isVersionedDirectory(VirtualFile dir) {
   return HgUtil.getNearestHgRoot(dir) != null;
 }
 @Override
 protected boolean isMultiRoot(@NotNull Project project) {
   return HgUtil.getRepositoryManager(project).moreThanOneRoot();
 }
 @NotNull
 @Override
 protected String getFullBranchName(@NotNull HgRepository repository) {
   return HgUtil.getDisplayableBranchOrBookmarkText(repository);
 }
  public boolean update(
      final UpdatedFiles updatedFiles, ProgressIndicator indicator, List<VcsException> warnings)
      throws VcsException {
    indicator.setText(HgVcsMessages.message("hg4idea.progress.updating", repoRoot.getPath()));

    String defaultPath = HgUtil.getRepositoryDefaultPath(project, repoRoot);

    if (StringUtil.isEmptyOrSpaces(defaultPath)) {
      throw new VcsException(
          HgVcsMessages.message("hg4idea.warning.no-default-update-path", repoRoot.getPath()));
    }

    List<HgRevisionNumber> branchHeadsBeforePull = new HgHeadsCommand(project, repoRoot).execute();

    if (branchHeadsBeforePull.size() > 1) {
      reportWarning(
          warnings,
          HgVcsMessages.message(
              "hg4idea.update.warning.multipleHeadsBeforeUpdate", repoRoot.getPath()));
    }

    // TODO perhaps report a warning in this case ?
    //    //if the parent of the working dir is not the tip of the current branch, the user has
    //    //manually brought his working copy to some specific revision. In that case we won't touch
    //    //his setup
    //    if (!parentRevision.equals(currentBranchHead)) {
    //      throw new VcsException("working dir not at branch tip (use \"Update to...\" to check out
    // branch tip)");
    //    }

    HgRevisionNumber parentBeforeUpdate =
        new HgWorkingCopyRevisionsCommand(project).firstParent(repoRoot);
    HgCommandExitCode pullResult = pull(repoRoot, indicator, shouldRebase());
    if (pullResult == HgCommandExitCode.ERROR) {
      return false;
    }

    if (pullResult == HgCommandExitCode.SUCCESS) {
      HgRevisionNumber parentAfterUpdate =
          new HgWorkingCopyRevisionsCommand(project).firstParent(repoRoot);
      addUpdatedFiles(repoRoot, updatedFiles, parentBeforeUpdate, parentAfterUpdate);
      return true;
    }

    if (shouldMerge()) {

      indicator.setText2(HgVcsMessages.message("hg4idea.progress.countingHeads"));

      List<HgRevisionNumber> branchHeadsAfterPull = new HgHeadsCommand(project, repoRoot).execute();
      List<HgRevisionNumber> pulledBranchHeads =
          determinePulledBranchHeads(branchHeadsBeforePull, branchHeadsAfterPull);
      List<HgRevisionNumber> remainingOriginalBranchHeads =
          determingRemainingOriginalBranchHeads(branchHeadsBeforePull, branchHeadsAfterPull);

      if (branchHeadsAfterPull.size() > 1) {
        abortOnLocalChanges();
        abortOnMultiplePulledHeads(pulledBranchHeads);
        abortOnMultipleLocalHeads(remainingOriginalBranchHeads);

        HgCommandResult mergeResult = doMerge(indicator);

        if (shouldCommitAfterMerge()) {
          commitOrWarnAboutConflicts(warnings, mergeResult);
        }
      }
      // any kind of update could have resulted in merges and merge conflicts, so run the resolver
      resolvePossibleConflicts(updatedFiles);
    } else {
      processRebase(updatedFiles);
    }

    return true;
  }