Example #1
0
  @Override
  protected void run() throws Exception {
    if (localName != null && gitdir != null)
      throw die(CLIText.get().conflictingUsageOf_git_dir_andArguments);

    final URIish uri = new URIish(sourceUri);
    if (localName == null) {
      try {
        localName = uri.getHumanishName();
      } catch (IllegalArgumentException e) {
        throw die(MessageFormat.format(CLIText.get().cannotGuessLocalNameFrom, sourceUri));
      }
    }
    if (gitdir == null) gitdir = new File(localName, Constants.DOT_GIT).getAbsolutePath();

    dst = new FileRepositoryBuilder().setGitDir(new File(gitdir)).build();
    dst.create();
    final StoredConfig dstcfg = dst.getConfig();
    dstcfg.setBoolean("core", null, "bare", false); // $NON-NLS-1$ //$NON-NLS-2$
    dstcfg.save();
    db = dst;

    outw.print(MessageFormat.format(CLIText.get().initializedEmptyGitRepositoryIn, gitdir));
    outw.println();
    outw.flush();

    saveRemote(uri);
    final FetchResult r = runFetch();
    final Ref checkoutRef;
    if (branch == null) checkoutRef = guessHEAD(r);
    else {
      checkoutRef = r.getAdvertisedRef(Constants.R_HEADS + branch);
      if (checkoutRef == null)
        throw die(MessageFormat.format(CLIText.get().noSuchRemoteRef, branch));
    }
    doCheckout(checkoutRef);
  }
Example #2
0
  private void doCheckout(final Ref branch) throws IOException {
    if (branch == null) throw die(CLIText.get().cannotChekoutNoHeadsAdvertisedByRemote);
    if (!Constants.HEAD.equals(branch.getName())) {
      RefUpdate u = db.updateRef(Constants.HEAD);
      u.disableRefLog();
      u.link(branch.getName());
    }

    final RevCommit commit = parseCommit(branch);
    final RefUpdate u = db.updateRef(Constants.HEAD);
    u.setNewObjectId(commit);
    u.forceUpdate();

    DirCache dc = db.lockDirCache();
    DirCacheCheckout co = new DirCacheCheckout(db, dc, commit.getTree());
    co.checkout();
  }
Example #3
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);
    if (srcRef != null) mergeCmd.include(srcRef);
    else mergeCmd.include(src);
    MergeResult result = mergeCmd.call();

    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 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_SQUASHED:
      case FAST_FORWARD_SQUASHED:
        outw.println(CLIText.get().mergedSquashed);
        break;
      case ABORTED:
        throw die(CLIText.get().ffNotPossibleAborting);
      case NOT_SUPPORTED:
        outw.println(MessageFormat.format(CLIText.get().unsupportedOperation, result.toString()));
    }
  }