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

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

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

Introduction

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

Prototype

@SuppressWarnings({ "NonOverridingEquals", "AmbiguousMethodReference" })
public final boolean equals(AnyObjectId other)

Source Link

Document

Determine if this ObjectId has exactly the same value as another.

Usage

From source file:net.riezebos.thoth.content.impl.GitContentManager.java

License:Apache License

@Override
protected synchronized String cloneOrPull() throws ContentManagerException {
    StringBuilder log = new StringBuilder();
    try {//from   ww w . j  a v  a  2 s .com
        Configuration config = getConfiguration();
        RepositoryDefinition repositoryDefinition = getContextDefinition().getRepositoryDefinition();
        String repositoryUrl = repositoryDefinition.getLocation();
        String workspaceLocation = config.getWorkspaceLocation();
        if (StringUtils.isBlank(workspaceLocation))
            throw new IllegalArgumentException("No environment variable or system variable named "
                    + Configuration.WORKSPACELOCATION + " was set");
        File file = new File(workspaceLocation);
        if (!file.isDirectory()) {
            severe(log, "The library path " + workspaceLocation
                    + " does not exist. Cannot initialize content manager");
        } else {
            try {
                String contextFolder = getContextFolder();
                File target = new File(contextFolder);
                CredentialsProvider credentialsProvider = getCredentialsProvider();

                if (target.isDirectory()) {
                    try (Git repos = getRepository()) {

                        Repository repository = repos.getRepository();
                        ObjectId oldHead = repository.resolve(HEAD_TREE);

                        PullResult pullResult = repos.pull().setCredentialsProvider(credentialsProvider).call();
                        ObjectId newHead = repository.resolve(HEAD_TREE);
                        boolean changes = (oldHead == null && newHead != null)//
                                || (oldHead != null && !oldHead.equals(newHead));
                        if (changes)
                            notifyContextContentsChanged();

                        String message = pullResult.isSuccessful() ? ": Pull successful, "
                                : ": Pull of failed, ";
                        message += changes ? CHANGES_DETECTED_MSG : NO_CHANGES_DETECTED_MSG;
                        info(log, getContextName() + message);

                        setLatestRefresh(new Date());
                    } catch (Exception e) {
                        severe(log, e);
                    }
                } else {
                    info(log, getContextName() + ": Cloning from " + repositoryUrl + " to " + contextFolder);
                    target.mkdirs();
                    try (Git result = Git.cloneRepository()//
                            .setURI(repositoryUrl)//
                            .setBranch(getBranch())//
                            .setCredentialsProvider(credentialsProvider)//
                            .setDirectory(target).call()) {
                        info(log, getContextName() + ": Cloned repository: "
                                + result.getRepository().getDirectory());
                        setLatestRefresh(new Date());
                        notifyContextContentsChanged();
                    } catch (Exception e) {
                        severe(log, e);
                    }
                }
            } catch (Exception e) {
                severe(log, e);
            }
        }

    } catch (Exception e) {
        throw new ContentManagerException(e);
    }

    return log.toString().trim();
}

From source file:net.riezebos.thoth.content.impl.GitContentManager.java

License:Apache License

protected SourceDiff createSourceDiff(Repository repository, RevCommit revCommit, DiffEntry diff)
        throws MissingObjectException, IOException, UnsupportedEncodingException {
    SourceDiff result;/*  www .java 2  s .  co m*/
    ObjectId oldId = diff.getOldId().toObjectId();
    ObjectId newId = diff.getNewId().toObjectId();

    String oldSource = getContents(repository, oldId);
    String newSource = getContents(repository, newId);

    if (oldId.equals(newId))
        oldSource = "";

    PersonIdent authorIdent = revCommit.getAuthorIdent();
    String author = authorIdent == null ? "Unknown" : authorIdent.getName();
    Date timeModified = new Date(((long) revCommit.getCommitTime()) * 1000);

    result = new SourceDiff(author, oldSource, newSource, timeModified);
    result.setCommitMessage(revCommit.getFullMessage());
    return result;
}

From source file:org.cicomponents.git.impl.LatestRevisionGitBranchMonitor.java

License:Mozilla Public License

@SneakyThrows
protected void emitRevisionIfNecessary(RefsChangedEvent event) {
    synchronized (git) {
        ObjectId newHead = event.getRepository().findRef("refs/heads/" + branch).getObjectId();
        if (!newHead.equals(head)) {
            log.info("Detected refs change for {}, branch {}, old: {}, new: {}", git, branch, head, newHead);
            WorkingDirectory workingDirectory = getWorkingDirectory();
            String directory = workingDirectory.getDirectory() + "/git";
            Git clone = Git.cloneRepository()
                    .setURI("file://" + git.getRepository().getDirectory().getAbsolutePath())
                    .setDirectory(new File(directory)).call();
            Ref checkedOutRef = clone.checkout().setName(newHead.getName()).call();
            assert checkedOutRef == newHead;
            GitRevision resource = new LocalGitRevision(clone, newHead, workingDirectory);
            ResourceHolder<GitRevision> holder = new SimpleResourceHolder<>(resource);
            emit(holder);//from  ww  w  .j  a  v a2  s .c  o m
            head = newHead;
            persistentMap.put(head.getName(), head.getName());
        }
    }
}

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

License:Open Source License

@Override
public List<RepoOperationTO> getOperations(String site, String commitIdFrom, String commitIdTo) {
    List<RepoOperationTO> operations = new ArrayList<>();

    synchronized (helper.getRepository(site, StringUtils.isEmpty(site) ? GitRepositories.GLOBAL : SANDBOX)) {
        try {//from  w w w  .  j  a v  a  2s  . c  om
            // Get the sandbox repo, and then get a reference to the commitId we received and another for head
            Repository repo = helper.getRepository(site, SANDBOX);
            ObjectId objCommitIdFrom = repo.resolve(commitIdFrom);
            ObjectId objCommitIdTo = repo.resolve(commitIdTo);

            // If the commitIdFrom is the same as commitIdTo, there is nothing to calculate, otherwise, let's do it
            if (!objCommitIdFrom.equals(objCommitIdTo)) {
                // Compare HEAD with commitId we're given
                // Get list of commits between commitId and HEAD in chronological order
                try (Git git = new Git(repo)) {
                    // Get the log of all the commits between commitId and head
                    Iterable<RevCommit> commits = git.log().addRange(objCommitIdFrom, objCommitIdTo).call();

                    // Loop through through the commits and diff one from the next util head
                    ObjectId prevCommitId = objCommitIdFrom;
                    ObjectId nextCommitId = objCommitIdFrom;

                    Iterator<RevCommit> iterator = commits.iterator();
                    while (iterator.hasNext()) {
                        RevCommit commit = iterator.next();
                        nextCommitId = commit.getId();

                        RevTree prevTree = helper.getTreeForCommit(repo, prevCommitId.getName());
                        RevTree nextTree = helper.getTreeForCommit(repo, nextCommitId.getName());

                        try (ObjectReader reader = repo.newObjectReader()) {
                            CanonicalTreeParser prevCommitTreeParser = new CanonicalTreeParser();
                            CanonicalTreeParser nextCommitTreeParser = new CanonicalTreeParser();
                            prevCommitTreeParser.reset(reader, prevTree.getId());
                            nextCommitTreeParser.reset(reader, nextTree.getId());

                            // Diff the two commit Ids
                            List<DiffEntry> diffEntries = git.diff().setOldTree(prevCommitTreeParser)
                                    .setNewTree(nextCommitTreeParser).call();

                            // Now that we have a diff, let's itemize the file changes, pack them into a TO
                            // and add them to the list of RepoOperations to return to the caller
                            // also include date/time of commit by taking number of seconds and multiply by 1000 and
                            // convert to java date before sending over
                            operations.addAll(
                                    processDiffEntry(diffEntries, new Date(commit.getCommitTime() * 1000)));
                            prevCommitId = nextCommitId;
                        }
                    }
                } catch (GitAPIException e) {
                    logger.error("Error getting operations for site " + site + " from commit ID: "
                            + commitIdFrom + " to commit ID: " + commitIdTo, e);
                }
            }
        } catch (IOException e) {
            logger.error("Error getting operations for site " + site + " from commit ID: " + commitIdFrom
                    + " to commit ID: " + commitIdTo, e);
        }
    }

    return operations;
}

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

License:Open Source License

/**
 * Scans given {@code repo} and build list of commits between two given
 * RevCommit objectId's. Each commit contains list of changed resources
 *
 * @param repo//w  w w  .j a v a  2 s.  com
 *            repository that should be scanned
 * @param srcId
 *            RevCommit id that git history traverse will start from
 * @param dstId
 *            RevCommit id that git history traverse will end
 * @param pathFilter
 *            path filter definition or {@code null} when all paths should
 *            be included
 * @return list of {@link Commit} object's between {@code srcId} and
 *         {@code dstId}
 * @throws IOException
 */
public static List<Commit> build(Repository repo, ObjectId srcId, ObjectId dstId, TreeFilter pathFilter)
        throws IOException {
    if (dstId.equals(srcId))
        return new ArrayList<Commit>(0);

    final RevWalk rw = new RevWalk(repo);

    final RevFlag localFlag = rw.newFlag("local"); //$NON-NLS-1$
    final RevFlag remoteFlag = rw.newFlag("remote"); //$NON-NLS-1$
    final RevFlagSet allFlags = new RevFlagSet();
    allFlags.add(localFlag);
    allFlags.add(remoteFlag);
    rw.carry(allFlags);

    RevCommit srcCommit = rw.parseCommit(srcId);
    srcCommit.add(localFlag);
    rw.markStart(srcCommit);
    srcCommit = null; // free not needed resources

    RevCommit dstCommit = rw.parseCommit(dstId);
    dstCommit.add(remoteFlag);
    rw.markStart(dstCommit);
    dstCommit = null; // free not needed resources

    if (pathFilter != null)
        rw.setTreeFilter(pathFilter);

    List<Commit> result = new ArrayList<Commit>();
    for (RevCommit revCommit : rw) {
        if (revCommit.hasAll(allFlags))
            break;

        Commit commit = new Commit();
        commit.shortMessage = revCommit.getShortMessage();
        commit.commitId = AbbreviatedObjectId.fromObjectId(revCommit);
        commit.authorName = revCommit.getAuthorIdent().getName();
        commit.committerName = revCommit.getCommitterIdent().getName();
        commit.commitDate = revCommit.getAuthorIdent().getWhen();

        RevCommit actualCommit, parentCommit;
        if (revCommit.has(localFlag)) {
            actualCommit = revCommit;
            parentCommit = getParentCommit(revCommit);
            commit.direction = RIGHT;
        } else if (revCommit.has(remoteFlag)) {
            actualCommit = getParentCommit(revCommit);
            parentCommit = revCommit;
            commit.direction = LEFT;
        } else
            throw new GitCommitsModelDirectionException();

        commit.children = getChangedObjects(repo, actualCommit, parentCommit, pathFilter, commit.direction);

        if (commit.children != null)
            result.add(commit);
    }
    rw.dispose();

    return result;
}

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

License:Open Source License

/**
 * @param progress/* w w  w  .j  ava 2 s  .co m*/
 * @return members
 * @throws IOException
 */
public IResourceVariant[] getMembers(IProgressMonitor progress) throws IOException {
    if (members != null)
        try {
            return members;
        } finally {
            progress.done();
        }

    Repository repo = getRepository();
    TreeWalk tw = new TreeWalk(repo);
    tw.reset();

    int nth = tw.addTree(getObjectId());
    int iteratorNth = tw.addTree(new FileTreeIterator(repo));

    tw.setFilter(new NotIgnoredFilter(iteratorNth));

    IProgressMonitor monitor = SubMonitor.convert(progress);
    monitor.beginTask(NLS.bind(CoreText.GitFolderResourceVariant_fetchingMembers, this), tw.getTreeCount());

    List<IResourceVariant> result = new ArrayList<IResourceVariant>();
    try {
        while (tw.next()) {
            if (monitor.isCanceled())
                throw new OperationCanceledException();

            ObjectId newObjectId = tw.getObjectId(nth);
            String path = getPath() + "/" + new String(tw.getRawPath()); //$NON-NLS-1$
            if (!newObjectId.equals(zeroId()))
                if (tw.isSubtree())
                    result.add(new GitFolderResourceVariant(repo, getRevCommit(), newObjectId, path));
                else
                    result.add(new GitBlobResourceVariant(repo, getRevCommit(), newObjectId, path));
            monitor.worked(1);
        }

        members = result.toArray(new IResourceVariant[result.size()]);
        return members;
    } finally {
        monitor.done();
    }
}

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

License:Open Source License

private IResourceVariant fetchVariant(IResource resource, IProgressMonitor monitor) throws TeamException {
    GitSynchronizeData gsd = gsds.getData(resource.getProject());
    if (gsd == null)
        return null;

    Repository repo = gsd.getRepository();
    String path = getPath(resource, repo);
    RevCommit revCommit = getRevCommit(gsd);
    if (revCommit == null)
        return null;

    if (path.length() == 0)
        return handleRepositoryRoot(resource, repo, revCommit);

    try {//from ww  w  . j a  v a  2 s .c om
        if (monitor.isCanceled())
            throw new OperationCanceledException();

        TreeWalk tw = initializeTreeWalk(repo, path);

        int nth = tw.addTree(revCommit.getTree());
        if (resource.getType() == IResource.FILE) {
            tw.setRecursive(true);
            if (tw.next() && !tw.getObjectId(nth).equals(zeroId()))
                return new GitBlobResourceVariant(repo, revCommit, tw.getObjectId(nth), path);
        } else {
            while (tw.next() && !path.equals(tw.getPathString())) {
                if (monitor.isCanceled())
                    throw new OperationCanceledException();

                if (tw.isSubtree())
                    tw.enterSubtree();
            }

            ObjectId objectId = tw.getObjectId(nth);
            if (!objectId.equals(zeroId()))
                return new GitFolderResourceVariant(repo, revCommit, objectId, path);
        }
    } catch (IOException e) {
        throw new TeamException(NLS.bind(CoreText.GitResourceVariantTree_couldNotFindResourceVariant, resource),
                e);
    }

    return null;
}

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

License:Open Source License

private int calculateKindImpl(Repository repo, TreeWalk tw, int srcNth, int dstNth) throws IOException {
    ObjectId srcId = tw.getObjectId(srcNth);
    ObjectId dstId = tw.getObjectId(dstNth);

    if (srcId.equals(zeroId()))
        return INCOMING | ADDITION;
    if (dstId.equals(zeroId()))
        return OUTGOING | ADDITION;
    if (!srcId.equals(dstId)) {
        RevWalk rw = new RevWalk(repo);
        RevFlag srcFlag = rw.newFlag("source"); //$NON-NLS-1$
        RevFlag dstFlag = rw.newFlag("destination"); //$NON-NLS-1$
        initializeRevWalk(rw, srcFlag, dstFlag);

        RevCommit commit = rw.next();//from w w w  . j ava 2s.c  o  m
        if (commit.has(srcFlag))
            return OUTGOING | CHANGE;
        else if (commit.has(dstFlag))
            return INCOMING | CHANGE;
        else
            return CONFLICTING | CHANGE;
    }

    return IN_SYNC;
}

From source file:org.eclipse.egit.ui.internal.decorators.GitDocument.java

License:Open Source License

void populate() throws IOException {
    if (GitTraceLocation.QUICKDIFF.isActive())
        GitTraceLocation.getTrace().traceEntry(GitTraceLocation.QUICKDIFF.getLocation(), resource);
    TreeWalk tw = null;// ww  w .  jav a2 s.co  m
    RevWalk rw = null;
    try {
        RepositoryMapping mapping = RepositoryMapping.getMapping(resource);
        if (mapping == null) {
            setResolved(null, null, null, ""); //$NON-NLS-1$
            return;
        }
        final String gitPath = mapping.getRepoRelativePath(resource);
        final Repository repository = mapping.getRepository();
        String baseline = GitQuickDiffProvider.baseline.get(repository);
        if (baseline == null)
            baseline = Constants.HEAD;
        ObjectId commitId = repository.resolve(baseline);
        if (commitId != null) {
            if (commitId.equals(lastCommit)) {
                if (GitTraceLocation.QUICKDIFF.isActive())
                    GitTraceLocation.getTrace().trace(GitTraceLocation.QUICKDIFF.getLocation(),
                            "(GitDocument) already resolved"); //$NON-NLS-1$
                return;
            }
        } else {
            String msg = NLS.bind(UIText.GitDocument_errorResolveQuickdiff,
                    new Object[] { baseline, resource, repository });
            Activator.logError(msg, new Throwable());
            setResolved(null, null, null, ""); //$NON-NLS-1$
            return;
        }
        rw = new RevWalk(repository);
        RevCommit baselineCommit;
        try {
            baselineCommit = rw.parseCommit(commitId);
        } catch (IOException err) {
            String msg = NLS.bind(UIText.GitDocument_errorLoadCommit,
                    new Object[] { commitId, baseline, resource, repository });
            Activator.logError(msg, err);
            setResolved(null, null, null, ""); //$NON-NLS-1$
            return;
        }
        RevTree treeId = baselineCommit.getTree();
        if (treeId.equals(lastTree)) {
            if (GitTraceLocation.QUICKDIFF.isActive())
                GitTraceLocation.getTrace().trace(GitTraceLocation.QUICKDIFF.getLocation(),
                        "(GitDocument) already resolved"); //$NON-NLS-1$
            return;
        }

        tw = TreeWalk.forPath(repository, gitPath, treeId);
        ObjectId id = tw.getObjectId(0);
        if (id.equals(ObjectId.zeroId())) {
            setResolved(null, null, null, ""); //$NON-NLS-1$
            String msg = NLS.bind(UIText.GitDocument_errorLoadTree,
                    new Object[] { treeId, baseline, resource, repository });
            Activator.logError(msg, new Throwable());
            setResolved(null, null, null, ""); //$NON-NLS-1$
            return;
        }
        if (!id.equals(lastBlob)) {
            if (GitTraceLocation.QUICKDIFF.isActive())
                GitTraceLocation.getTrace().trace(GitTraceLocation.QUICKDIFF.getLocation(),
                        "(GitDocument) compareTo: " + baseline); //$NON-NLS-1$
            ObjectLoader loader = repository.open(id, Constants.OBJ_BLOB);
            byte[] bytes = loader.getBytes();
            String charset;
            charset = CompareUtils.getResourceEncoding(resource);
            // Finally we could consider validating the content with respect
            // to the content. We don't do that here.
            String s = new String(bytes, charset);
            setResolved(commitId, treeId, id, s);
            if (GitTraceLocation.QUICKDIFF.isActive())
                GitTraceLocation.getTrace().trace(GitTraceLocation.QUICKDIFF.getLocation(),
                        "(GitDocument) has reference doc, size=" + s.length() + " bytes"); //$NON-NLS-1$ //$NON-NLS-2$
        } else {
            if (GitTraceLocation.QUICKDIFF.isActive())
                GitTraceLocation.getTrace().trace(GitTraceLocation.QUICKDIFF.getLocation(),
                        "(GitDocument) already resolved"); //$NON-NLS-1$
        }
    } finally {
        if (tw != null)
            tw.release();
        if (rw != null)
            rw.release();
        if (GitTraceLocation.QUICKDIFF.isActive())
            GitTraceLocation.getTrace().traceExit(GitTraceLocation.QUICKDIFF.getLocation());
    }

}

From source file:org.eclipse.egit.ui.internal.dialogs.CommitCombo.java

License:Open Source License

/**
 * Selects the item with is associated with given <code>objectId</code>
 *
 * @param objectId/*from   ww  w .  j a  v  a  2s. c om*/
 */
public void setSelectedElement(ObjectId objectId) {
    if (objectId == null) {
        return;
    }

    for (int i = 0; i < commits.size(); i++)
        if (objectId.equals(commits.get(i).objectId)) {
            combo.select(i);
            break;
        }
}