Beispiel #1
0
  @Test
  public void testHardResetAfterSquashMerge() throws Exception {
    Git g = new Git(db);

    writeTrashFile("file1", "file1");
    g.add().addFilepattern("file1").call();
    RevCommit first = g.commit().setMessage("initial commit").call();

    assertTrue(resolve(db.getWorkTree(), "file1").exists());
    createBranch(first, "refs/heads/branch1");
    checkoutBranch("refs/heads/branch1");

    writeTrashFile("file2", "file2");
    g.add().addFilepattern("file2").call();
    g.commit().setMessage("second commit").call();
    assertTrue(resolve(db.getWorkTree(), "file2").exists());

    checkoutBranch("refs/heads/master");

    MergeResult result = g.merge().include(db.getRef("branch1")).setSquash(true).call();

    assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED, result.getMergeStatus());
    assertNotNull(db.readSquashCommitMsg());

    g.reset().setMode(ResetType.HARD).setRef(first.getName()).call();

    assertNull(db.readSquashCommitMsg());
  }
Beispiel #2
0
 public static void pull(GitInput input) throws GitException {
   FetchResult fetchResult = fetch(input.directory, input.url);
   Ref ref = fetchResult.getAdvertisedRef("HEAD");
   MergeResult mergeResult = merge(input, ref);
   if (!mergeResult.getMergeStatus().isSuccessful()) {
     throw new GitException("Merge of " + ref + " in " + input.directory + " failed");
   }
 }
Beispiel #3
0
  @Test
  public void testStageState_mergeAndReset_bug() throws Exception {
    try (Git git = new Git(db)) {
      writeTrashFile("a", "content");
      git.add().addFilepattern("a").call();
      RevCommit initialCommit = git.commit().setMessage("initial commit").call();

      // create branch and add a new file
      final String branchName = Constants.R_HEADS + "branch";
      createBranch(initialCommit, branchName);
      checkoutBranch(branchName);
      writeTrashFile("b", "second file content - branch");
      git.add().addFilepattern("b").call();
      RevCommit branchCommit = git.commit().setMessage("branch commit").call();

      // checkout master and add the same new file
      checkoutBranch(Constants.R_HEADS + Constants.MASTER);
      writeTrashFile("b", "second file content - master");
      git.add().addFilepattern("b").call();
      git.commit().setMessage("master commit").call();

      // try and merge
      MergeResult result = git.merge().include(branchCommit).call();
      assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());

      FileTreeIterator iterator = new FileTreeIterator(db);
      IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(diff.getChanged().isEmpty());
      assertTrue(diff.getAdded().isEmpty());
      assertTrue(diff.getRemoved().isEmpty());
      assertTrue(diff.getMissing().isEmpty());
      assertTrue(diff.getModified().isEmpty());
      assertEquals(1, diff.getConflicting().size());
      assertTrue(diff.getConflicting().contains("b"));
      assertEquals(StageState.BOTH_ADDED, diff.getConflictingStageStates().get("b"));
      assertTrue(diff.getUntrackedFolders().isEmpty());

      // reset file b to its master state without altering the index
      writeTrashFile("b", "second file content - master");

      // we should have the same result
      iterator = new FileTreeIterator(db);
      diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(diff.getChanged().isEmpty());
      assertTrue(diff.getAdded().isEmpty());
      assertTrue(diff.getRemoved().isEmpty());
      assertTrue(diff.getMissing().isEmpty());
      assertTrue(diff.getModified().isEmpty());
      assertEquals(1, diff.getConflicting().size());
      assertTrue(diff.getConflicting().contains("b"));
      assertEquals(StageState.BOTH_ADDED, diff.getConflictingStageStates().get("b"));
      assertTrue(diff.getUntrackedFolders().isEmpty());
    }
  }
Beispiel #4
0
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   if (fetchResult != null) sb.append(fetchResult.toString());
   else sb.append("No fetch result");
   sb.append("\n");
   if (mergeResult != null) sb.append(mergeResult.toString());
   else if (rebaseResult != null) sb.append(rebaseResult.toString());
   else sb.append("No update result");
   return sb.toString();
 }
Beispiel #5
0
  @Test
  public void testConflicting() throws Exception {
    try (Git git = new Git(db)) {
      writeTrashFile("a", "1\na\n3\n");
      writeTrashFile("b", "1\nb\n3\n");
      git.add().addFilepattern("a").addFilepattern("b").call();
      RevCommit initialCommit = git.commit().setMessage("initial").call();

      // create side branch with two modifications
      createBranch(initialCommit, "refs/heads/side");
      checkoutBranch("refs/heads/side");
      writeTrashFile("a", "1\na(side)\n3\n");
      writeTrashFile("b", "1\nb\n3\n(side)");
      git.add().addFilepattern("a").addFilepattern("b").call();
      RevCommit secondCommit = git.commit().setMessage("side").call();

      // update a on master to generate conflict
      checkoutBranch("refs/heads/master");
      writeTrashFile("a", "1\na(main)\n3\n");
      git.add().addFilepattern("a").call();
      git.commit().setMessage("main").call();

      // merge side with master
      MergeResult result =
          git.merge().include(secondCommit.getId()).setStrategy(MergeStrategy.RESOLVE).call();
      assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
    }

    FileTreeIterator iterator = new FileTreeIterator(db);
    IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
    diff.diff();

    assertEquals("[b]", new TreeSet<String>(diff.getChanged()).toString());
    assertEquals("[]", diff.getAdded().toString());
    assertEquals("[]", diff.getRemoved().toString());
    assertEquals("[]", diff.getMissing().toString());
    assertEquals("[]", diff.getModified().toString());
    assertEquals("[a]", diff.getConflicting().toString());
    assertEquals(StageState.BOTH_MODIFIED, diff.getConflictingStageStates().get("a"));
    assertEquals(Collections.EMPTY_SET, diff.getUntrackedFolders());
  }
 private boolean merge(
     HttpServletRequest request,
     HttpServletResponse response,
     Repository db,
     String commitToMerge,
     boolean squash)
     throws ServletException, JSONException {
   try {
     ObjectId objectId = db.resolve(commitToMerge);
     Git git = new Git(db);
     MergeResult mergeResult = git.merge().setSquash(squash).include(objectId).call();
     JSONObject result = new JSONObject();
     result.put(GitConstants.KEY_RESULT, mergeResult.getMergeStatus().name());
     if (mergeResult.getFailingPaths() != null && !mergeResult.getFailingPaths().isEmpty())
       result.put(GitConstants.KEY_FAILING_PATHS, mergeResult.getFailingPaths());
     OrionServlet.writeJSONResponse(
         request, response, result, JsonURIUnqualificationStrategy.ALL_NO_GIT);
     return true;
   } catch (CheckoutConflictException e) {
     return workaroundBug356918(request, response, e);
   } catch (IOException e) {
     return statusHandler.handleRequest(
         request,
         response,
         new ServerStatus(
             IStatus.ERROR,
             HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
             "An error occured when merging.",
             e));
   } catch (GitAPIException e) {
     return statusHandler.handleRequest(
         request,
         response,
         new ServerStatus(
             IStatus.ERROR,
             HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
             "An error occured when merging.",
             e));
   }
 }
Beispiel #7
0
  @Override
  protected void run() throws Exception {
    if (squash && ff == FastForwardMode.NO_FF) throw die(CLIText.get().cannotCombineSquashWithNoff);
    // determine the merge strategy
    if (strategyName != null) {
      mergeStrategy = MergeStrategy.get(strategyName);
      if (mergeStrategy == null)
        throw die(MessageFormat.format(CLIText.get().unknownMergeStrategy, strategyName));
    }

    // determine the other revision we want to merge with HEAD
    final Ref srcRef = db.getRef(ref);
    final ObjectId src = db.resolve(ref + "^{commit}"); // $NON-NLS-1$
    if (src == null) throw die(MessageFormat.format(CLIText.get().refDoesNotExistOrNoCommit, ref));

    Ref oldHead = db.getRef(Constants.HEAD);
    Git git = new Git(db);
    MergeCommand mergeCmd =
        git.merge()
            .setStrategy(mergeStrategy)
            .setSquash(squash)
            .setFastForward(ff)
            .setCommit(!noCommit);
    if (srcRef != null) mergeCmd.include(srcRef);
    else mergeCmd.include(src);
    MergeResult result;
    try {
      result = mergeCmd.call();
    } catch (CheckoutConflictException e) {
      result = new MergeResult(e.getConflictingPaths()); // CHECKOUT_CONFLICT
    }

    switch (result.getMergeStatus()) {
      case ALREADY_UP_TO_DATE:
        if (squash) outw.print(CLIText.get().nothingToSquash);
        outw.println(CLIText.get().alreadyUpToDate);
        break;
      case FAST_FORWARD:
        ObjectId oldHeadId = oldHead.getObjectId();
        outw.println(
            MessageFormat.format(
                CLIText.get().updating,
                oldHeadId.abbreviate(7).name(),
                result.getNewHead().abbreviate(7).name()));
        outw.println(result.getMergeStatus().toString());
        break;
      case CHECKOUT_CONFLICT:
        outw.println(CLIText.get().mergeCheckoutConflict);
        for (String collidingPath : result.getCheckoutConflicts())
          outw.println("\t" + collidingPath); // $NON-NLS-1$
        outw.println(CLIText.get().mergeCheckoutFailed);
        break;
      case CONFLICTING:
        for (String collidingPath : result.getConflicts().keySet())
          outw.println(MessageFormat.format(CLIText.get().mergeConflict, collidingPath));
        outw.println(CLIText.get().mergeFailed);
        break;
      case FAILED:
        for (Map.Entry<String, MergeFailureReason> entry : result.getFailingPaths().entrySet())
          switch (entry.getValue()) {
            case DIRTY_WORKTREE:
            case DIRTY_INDEX:
              outw.println(CLIText.get().dontOverwriteLocalChanges);
              outw.println("        " + entry.getKey()); // $NON-NLS-1$
              break;
            case COULD_NOT_DELETE:
              outw.println(CLIText.get().cannotDeleteFile);
              outw.println("        " + entry.getKey()); // $NON-NLS-1$
              break;
          }
        break;
      case MERGED:
        String name;
        if (!isMergedInto(oldHead, src)) name = mergeStrategy.getName();
        else name = "recursive"; // $NON-NLS-1$
        outw.println(MessageFormat.format(CLIText.get().mergeMadeBy, name));
        break;
      case MERGED_NOT_COMMITTED:
        outw.println(CLIText.get().mergeWentWellStoppedBeforeCommitting);
        break;
      case MERGED_SQUASHED:
      case FAST_FORWARD_SQUASHED:
      case MERGED_SQUASHED_NOT_COMMITTED:
        outw.println(CLIText.get().mergedSquashed);
        outw.println(CLIText.get().mergeWentWellStoppedBeforeCommitting);
        break;
      case ABORTED:
        throw die(CLIText.get().ffNotPossibleAborting);
      case NOT_SUPPORTED:
        outw.println(MessageFormat.format(CLIText.get().unsupportedOperation, result.toString()));
    }
  }
Beispiel #8
0
 private boolean hasMergeResults() {
   final MergeResult mergeResult = result.getMergeResult();
   return mergeResult != null && mergeResult.getMergeStatus() != MergeStatus.ALREADY_UP_TO_DATE;
 }