Example usage for org.eclipse.jgit.lib ObjectId getName

List of usage examples for org.eclipse.jgit.lib ObjectId getName

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. ObjectId
  6. getName

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib ObjectId getName.

Prototype

public final String getName()

Source Link

Document

Get string form of the SHA-1, in lower case hexadecimal.

Usage

From source file:org.craftercms.studio.impl.v1.repository.git.GitContentRepository.java

License:Open Source License

@Override
public String getRepoLastCommitId(final String site) {
    String toReturn = StringUtils.EMPTY;

    synchronized (helper.getRepository(site, StringUtils.isEmpty(site) ? GitRepositories.GLOBAL : SANDBOX)) {
        Repository repo = helper.getRepository(site, SANDBOX);
        try {//from   www . j a v a  2  s .c  om
            ObjectId commitId = repo.resolve(Constants.HEAD);
            toReturn = commitId.getName();
        } catch (IOException e) {
            logger.error("Error getting last commit ID for site " + site, e);
        }
    }

    return toReturn;
}

From source file:org.craftercms.studio.impl.v1.repository.git.GitContentRepository.java

License:Open Source License

@Override
public String getRepoFirstCommitId(final String site) {
    String toReturn = StringUtils.EMPTY;

    synchronized (helper.getRepository(site, StringUtils.isEmpty(site) ? GitRepositories.GLOBAL : SANDBOX)) {
        Repository repo = helper.getRepository(site, SANDBOX);
        try (RevWalk rw = new RevWalk(repo)) {
            ObjectId head = repo.resolve(Constants.HEAD);
            RevCommit root = rw.parseCommit(head);
            rw.sort(RevSort.REVERSE);/*w  w  w .  j  a  v a2  s  .  co  m*/
            rw.markStart(root);
            ObjectId first = rw.next();
            toReturn = first.getName();
            logger.error("FIRST COMMIT ID !!!: " + toReturn);
        } catch (IOException e) {
            logger.error("Error getting first commit ID for site " + site, e);
        }
    }

    return toReturn;
}

From source file:org.dstadler.jgit.api.JGitPrintContent.java

License:BSD License

public static void main(String[] args) throws Exception {
    File gitWorkDir = new File("C:\\Users\\kishore\\git\\JavaRepos\\.git");
    Git git = Git.open(gitWorkDir);/*from  w w w  .  j  ava 2s . c  o  m*/
    Repository repo = git.getRepository();

    ObjectId lastCommitId = repo.resolve(Constants.HEAD);

    RevWalk revWalk = new RevWalk(repo);
    RevCommit commit = revWalk.parseCommit(lastCommitId);

    RevTree tree = commit.getTree();

    TreeWalk treeWalk = new TreeWalk(repo);
    treeWalk.addTree(tree);
    treeWalk.setRecursive(true);
    treeWalk.setFilter(PathFilter.ALL);
    if (!treeWalk.next()) {
        System.out.println("Nothing found!");
        return;
    }

    ObjectId objectId = treeWalk.getObjectId(0);
    System.err.println(treeWalk.getPathString());
    System.err.println(objectId.getName());

    ObjectLoader loader = repo.open(objectId);

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    loader.copyTo(out);
    System.out.println("file1.txt:\n" + out.toString());
}

From source file:org.dstadler.jgit.api.ListFilesOfCommitAndTag.java

License:Apache License

public static void main(String[] args) throws IOException {
    try (Repository repository = CookbookHelper.openJGitCookbookRepository()) {
        List<String> paths = readElementsAt(repository, "6409ee1597a53c6fbee31edf9cde31dc3afbe20f",
                "src/main/java/org/dstadler/jgit/porcelain");

        System.out.println("Had paths for commit: " + paths);

        final ObjectId testbranch = repository.resolve("testbranch");
        paths = readElementsAt(repository, testbranch.getName(), "src/main/java/org/dstadler/jgit/porcelain");

        System.out.println("Had paths for tag: " + paths);
    }/*  w w  w . j  a  va  2  s  .co m*/
}

From source file:org.eclipse.che.git.impl.jgit.JGitConnection.java

License:Open Source License

@Override
public MergeResult merge(MergeRequest request) throws GitException {
    org.eclipse.jgit.api.MergeResult jGitMergeResult;
    MergeResult.MergeStatus status;//ww w  . j  av  a  2 s  .  c o m
    try {
        Ref ref = repository.findRef(request.getCommit());
        if (ref == null) {
            throw new IllegalArgumentException("Invalid reference to commit for merge " + request.getCommit());
        }
        // Shorten local branch names by removing '/refs/heads/' from the beginning
        String name = ref.getName();
        if (name.startsWith(Constants.R_HEADS)) {
            name = name.substring(Constants.R_HEADS.length());
        }
        jGitMergeResult = getGit().merge().include(name, ref.getObjectId()).call();
    } catch (CheckoutConflictException exception) {
        jGitMergeResult = new org.eclipse.jgit.api.MergeResult(exception.getConflictingPaths());
    } catch (IOException | GitAPIException exception) {
        throw new GitException(exception.getMessage(), exception);
    }

    switch (jGitMergeResult.getMergeStatus()) {
    case ALREADY_UP_TO_DATE:
        status = MergeResult.MergeStatus.ALREADY_UP_TO_DATE;
        break;
    case CONFLICTING:
        status = MergeResult.MergeStatus.CONFLICTING;
        break;
    case FAILED:
        status = MergeResult.MergeStatus.FAILED;
        break;
    case FAST_FORWARD:
        status = MergeResult.MergeStatus.FAST_FORWARD;
        break;
    case MERGED:
        status = MergeResult.MergeStatus.MERGED;
        break;
    case NOT_SUPPORTED:
        status = MergeResult.MergeStatus.NOT_SUPPORTED;
        break;
    case CHECKOUT_CONFLICT:
        status = MergeResult.MergeStatus.CONFLICTING;
        break;
    default:
        throw new IllegalStateException("Unknown merge status " + jGitMergeResult.getMergeStatus());
    }

    ObjectId[] jGitMergedCommits = jGitMergeResult.getMergedCommits();
    List<String> mergedCommits = new ArrayList<>();
    if (jGitMergedCommits != null) {
        for (ObjectId commit : jGitMergedCommits) {
            mergedCommits.add(commit.getName());
        }
    }

    List<String> conflicts;
    if (org.eclipse.jgit.api.MergeResult.MergeStatus.CHECKOUT_CONFLICT
            .equals(jGitMergeResult.getMergeStatus())) {
        conflicts = jGitMergeResult.getCheckoutConflicts();
    } else {
        Map<String, int[][]> jGitConflicts = jGitMergeResult.getConflicts();
        conflicts = jGitConflicts != null ? new ArrayList<>(jGitConflicts.keySet()) : Collections.emptyList();
    }

    Map<String, ResolveMerger.MergeFailureReason> jGitFailing = jGitMergeResult.getFailingPaths();
    ObjectId newHead = jGitMergeResult.getNewHead();

    return newDto(MergeResult.class)
            .withFailed(jGitFailing != null ? new ArrayList<>(jGitFailing.keySet()) : Collections.emptyList())
            .withNewHead(newHead != null ? newHead.getName() : null).withMergeStatus(status)
            .withConflicts(conflicts).withMergedCommits(mergedCommits);
}

From source file:org.eclipse.egit.core.op.CommitOperation.java

License:Open Source License

private void doCommits(String actMessage, HashMap<Repository, Tree> treeMap) throws IOException, TeamException {

    String commitMessage = actMessage;
    final Date commitDate = new Date();
    final TimeZone timeZone = TimeZone.getDefault();

    final PersonIdent authorIdent = RawParseUtils.parsePersonIdent(author);
    final PersonIdent committerIdent = RawParseUtils.parsePersonIdent(committer);

    for (java.util.Map.Entry<Repository, Tree> entry : treeMap.entrySet()) {
        Tree tree = entry.getValue();//ww  w.j  a va  2  s  .  com
        Repository repo = tree.getRepository();
        repo.getIndex().write();
        writeTreeWithSubTrees(tree);

        ObjectId currentHeadId = repo.resolve(Constants.HEAD);
        ObjectId[] parentIds;
        if (amending) {
            RevCommit[] parents = previousCommit.getParents();
            parentIds = new ObjectId[parents.length];
            for (int i = 0; i < parents.length; i++)
                parentIds[i] = parents[i].getId();
        } else {
            if (currentHeadId != null)
                parentIds = new ObjectId[] { currentHeadId };
            else
                parentIds = new ObjectId[0];
        }
        if (createChangeId) {
            ObjectId parentId;
            if (parentIds.length > 0)
                parentId = parentIds[0];
            else
                parentId = null;
            ObjectId changeId = ChangeIdUtil.computeChangeId(tree.getId(), parentId, authorIdent,
                    committerIdent, commitMessage);
            commitMessage = ChangeIdUtil.insertId(commitMessage, changeId);
            if (changeId != null)
                commitMessage = commitMessage.replaceAll(
                        "\nChange-Id: I0000000000000000000000000000000000000000\n", //$NON-NLS-1$
                        "\nChange-Id: I" + changeId.getName() + "\n"); //$NON-NLS-1$ //$NON-NLS-2$
        }
        CommitBuilder commit = new CommitBuilder();
        commit.setTreeId(tree.getTreeId());
        commit.setParentIds(parentIds);
        commit.setMessage(commitMessage);
        commit.setAuthor(new PersonIdent(authorIdent, commitDate, timeZone));
        commit.setCommitter(new PersonIdent(committerIdent, commitDate, timeZone));

        ObjectInserter inserter = repo.newObjectInserter();
        ObjectId commitId;
        try {
            commitId = inserter.insert(commit);
            inserter.flush();
        } finally {
            inserter.release();
        }

        final RefUpdate ru = repo.updateRef(Constants.HEAD);
        ru.setNewObjectId(commitId);
        ru.setRefLogMessage(buildReflogMessage(commitMessage), false);
        if (ru.forceUpdate() == RefUpdate.Result.LOCK_FAILURE) {
            throw new TeamException(NLS.bind(CoreText.CommitOperation_failedToUpdate, ru.getName(), commitId));
        }
    }
}

From source file:org.eclipse.egit.core.synchronize.GitResourceVariantTreeSubscriberTest.java

License:Open Source License

/**
 * Both source and destination branches has some different commits but they
 * has also common ancestor. This situation is described more detailed in
 * bug #317934/*from  ww  w. jav  a 2  s .co m*/
 *
 * This test passes when it is run as a stand alone test case, but it fails
 * when it is run as part of test suite. It throws NPE when it try's to
 * checkout master branch.
 *
 * @throws Exception
 */
@Test
@Ignore
public void shouldReturnCommonAncestorAsBase() throws Exception {
    // when
    String fileName = "Main.java";
    File file = testRepo.createFile(iProject, fileName);
    RevCommit commit = testRepo.appendContentAndCommit(iProject, file, "class Main {}", "initial commit");
    IFile mainJava = testRepo.getIFile(iProject, file);
    // this should be our common ancestor
    ObjectId fileId = findFileId(commit, mainJava);

    testRepo.createAndCheckoutBranch(Constants.HEAD, Constants.R_HEADS + "test");
    testRepo.appendContentAndCommit(iProject, file, "// test 1", "second commit");

    testRepo.checkoutBranch(Constants.R_HEADS + Constants.MASTER);
    testRepo.appendContentAndCommit(iProject, file, "// test 2", "third commit");

    // given
    GitResourceVariantTreeSubscriber grvts = createGitResourceVariantTreeSubscriber(Constants.HEAD,
            Constants.R_HEADS + "test");
    grvts.getBaseTree();
    IResourceVariantTree baseTree = grvts.getBaseTree();

    // then
    IResourceVariant actual = commonAssertionsForBaseTree(baseTree, mainJava);
    assertEquals(fileId.getName(), actual.getContentIdentifier());
}

From source file:org.eclipse.egit.core.synchronize.GitResourceVariantTreeSubscriberTest.java

License:Open Source License

/**
 * This test passes when it is run as a stand alone test case, but it fails
 * when it is run as part of test suite. It throws NPE when it try's to
 * checkout master branch./*from   ww w .j a v a  2 s  . c o  m*/
 *
 * @throws Exception
 */
@Test
@Ignore
public void shouldReturnRemoteTree() throws Exception {
    // when
    String fileName = "Main.java";
    File file = testRepo.createFile(iProject, fileName);
    testRepo.appendContentAndCommit(iProject, file, "class Main {}", "initial commit");
    IFile mainJava = testRepo.getIFile(iProject, file);

    testRepo.createAndCheckoutBranch(Constants.HEAD, Constants.R_HEADS + "test");
    RevCommit commit = testRepo.appendContentAndCommit(iProject, file, "// test 1", "second commit");
    ObjectId fileId = findFileId(commit, mainJava);

    // given
    GitResourceVariantTreeSubscriber grvts = createGitResourceVariantTreeSubscriber(Constants.HEAD, "test");
    grvts.getBaseTree();
    IResourceVariantTree remoteTree = grvts.getRemoteTree();

    // then
    assertNotNull(remoteTree);
    assertTrue(remoteTree instanceof GitRemoteResourceVariantTree);
    IResourceVariant resourceVariant = remoteTree.getResourceVariant(mainJava);
    assertNotNull(resourceVariant);
    assertTrue(resourceVariant instanceof GitResourceVariant);
    assertEquals(fileId.getName(), resourceVariant.getContentIdentifier());
}

From source file:org.eclipse.egit.ui.internal.actions.ResetMenu.java

License:Open Source License

/**
 * @param shell//from  www  .ja v a 2  s. c  o m
 * @param repo
 * @param commitId
 * @param resetType
 */
public static void performReset(Shell shell, final Repository repo, final ObjectId commitId,
        ResetType resetType) {

    final String jobName;
    switch (resetType) {
    case HARD:
        if (!CommandConfirmation.confirmHardReset(shell, repo)) {
            return;
        }
        jobName = UIText.HardResetToRevisionAction_hardReset;
        break;
    case SOFT:
        jobName = UIText.SoftResetToRevisionAction_softReset;
        break;
    case MIXED:
        jobName = UIText.MixedResetToRevisionAction_mixedReset;
        break;
    default:
        return; // other types are currently not used
    }

    ResetOperation operation = new ResetOperation(repo, commitId.getName(), resetType);
    JobUtil.scheduleUserWorkspaceJob(operation, jobName, JobFamilies.RESET);
}

From source file:org.eclipse.egit.ui.internal.history.command.OpenInTextEditorHandler.java

License:Open Source License

public Object execute(ExecutionEvent event) throws ExecutionException {
    IStructuredSelection selection = getSelection(getPage());
    if (selection.size() < 1)
        return null;
    Object input = getPage().getInputInternal().getSingleFile();
    if (input == null)
        return null;
    boolean errorOccured = false;
    List<ObjectId> ids = new ArrayList<ObjectId>();
    String gitPath = null;//  w  w w.  j  av a  2  s  . com
    if (input instanceof IFile) {
        IFile resource = (IFile) input;
        final RepositoryMapping map = RepositoryMapping.getMapping(resource);
        gitPath = map.getRepoRelativePath(resource);
        Iterator<?> it = selection.iterator();
        while (it.hasNext()) {
            RevCommit commit = (RevCommit) it.next();
            IFileRevision rev = null;
            try {
                rev = CompareUtils.getFileRevision(gitPath, commit, map.getRepository(), null);
            } catch (IOException e) {
                Activator.logError(NLS.bind(UIText.GitHistoryPage_errorLookingUpPath, gitPath, commit.getId()),
                        e);
                errorOccured = true;
            }
            if (rev != null) {
                try {
                    EgitUiEditorUtils.openTextEditor(getPart(event).getSite().getPage(), rev, null);
                } catch (CoreException e) {
                    Activator.logError(e.getMessage(), e);
                    errorOccured = true;
                }
            } else {
                ids.add(commit.getId());
            }
        }
    }
    if (input instanceof File) {
        Repository repo = getRepository(event);
        File fileInput = (File) input;
        gitPath = getRepoRelativePath(repo, fileInput);
        Iterator<?> it = selection.iterator();
        while (it.hasNext()) {
            RevCommit commit = (RevCommit) it.next();
            IFileRevision rev = null;
            try {
                rev = CompareUtils.getFileRevision(gitPath, commit, repo, null);
            } catch (IOException e) {
                Activator.logError(NLS.bind(UIText.GitHistoryPage_errorLookingUpPath, gitPath, commit.getId()),
                        e);
                errorOccured = true;
            }
            if (rev != null) {
                try {
                    EgitUiEditorUtils.openTextEditor(getPart(event).getSite().getPage(), rev, null);
                } catch (CoreException e) {
                    Activator.logError(e.getMessage(), e);
                    errorOccured = true;
                }
            } else {
                ids.add(commit.getId());
            }
        }
    }
    if (errorOccured)
        Activator.showError(UIText.GitHistoryPage_openFailed, null);
    if (ids.size() > 0) {
        StringBuilder idList = new StringBuilder(""); //$NON-NLS-1$
        for (ObjectId objectId : ids)
            idList.append(objectId.getName()).append(' ');
        MessageDialog.openError(getPart(event).getSite().getShell(), UIText.GitHistoryPage_fileNotFound,
                NLS.bind(UIText.GitHistoryPage_notContainedInCommits, gitPath, idList.toString()));
    }
    return null;
}