Example usage for org.eclipse.jgit.lib ObjectReader resolve

List of usage examples for org.eclipse.jgit.lib ObjectReader resolve

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. ObjectReader
  6. resolve

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib ObjectReader resolve.

Prototype

public abstract Collection<ObjectId> resolve(AbbreviatedObjectId id) throws IOException;

Source Link

Document

Resolve an abbreviated ObjectId to its full form.

Usage

From source file:com.google.gitiles.LogServlet.java

License:Open Source License

private static Optional<ObjectId> getStart(ListMultimap<String, String> params, ObjectReader reader)
        throws IOException {
    List<String> values = params.get(START_PARAM);
    switch (values.size()) {
    case 0://from w  w w .j a  va  2s.c  o  m
        return Optional.absent();
    case 1:
        Collection<ObjectId> ids = reader.resolve(AbbreviatedObjectId.fromString(values.get(0)));
        if (ids.size() != 1) {
            return null;
        }
        return Optional.of(Iterables.getOnlyElement(ids));
    default:
        return null;
    }
}

From source file:com.madgag.agit.diff.LineContextDiffer.java

License:Open Source License

private byte[] open(ObjectReader reader, FileMode mode, AbbreviatedObjectId id) throws IOException {
    if (mode == FileMode.MISSING)
        return new byte[] {};

    if (mode.getObjectType() != Constants.OBJ_BLOB)
        return new byte[] {};

    if (!id.isComplete()) {
        Collection<ObjectId> ids = reader.resolve(id);
        if (ids.size() == 1)
            id = AbbreviatedObjectId.fromObjectId(ids.iterator().next());
        else if (ids.size() == 0)
            throw new MissingObjectException(id, Constants.OBJ_BLOB);
        else/*from w ww.  j  a v a2 s .com*/
            throw new AmbiguousObjectException(id, ids);
    }

    ObjectLoader ldr = reader.open(id.toObjectId());
    return ldr.getCachedBytes(bigFileThreshold);
}

From source file:com.microsoft.gittf.client.clc.commands.CheckinCommand.java

License:Open Source License

private AbbreviatedObjectId[] getSquashCommitIDs() throws Exception {
    Repository repository = getRepository();

    ObjectReader objReader = null;
    RevWalk revWalk = null;//from w  w w  .jav  a2s . co m
    try {
        objReader = repository.newObjectReader();
        revWalk = new RevWalk(repository);

        Argument[] squashPrefixArgs = getArguments().getArguments("squash"); //$NON-NLS-1$

        if (squashPrefixArgs == null || squashPrefixArgs.length == 0) {
            return null;
        }

        AbbreviatedObjectId[] squashCommitIDs = new AbbreviatedObjectId[squashPrefixArgs.length];

        for (int i = 0; i < squashPrefixArgs.length; i++) {
            squashCommitIDs[i] = AbbreviatedObjectId
                    .fromString(((ValueArgument) squashPrefixArgs[i]).getValue());

            Collection<ObjectId> candidateObjects = null;

            try {
                candidateObjects = objReader.resolve(squashCommitIDs[i]);
            } catch (Exception e) {
                /*
                 * commit id could not be resolved by git
                 */
            }

            if (candidateObjects == null || candidateObjects.size() == 0) {
                throw new Exception(Messages.formatString("CheckinCommand.CommitIdAmbiguousFormat", //$NON-NLS-1$
                        squashCommitIDs[i].name()));
            } else if (candidateObjects.size() > 1) {
                throw new Exception(Messages.formatString("CheckinCommand.CommitIdAmbiguousFormat", //$NON-NLS-1$
                        squashCommitIDs[i].name()));
            } else {
                RevCommit revCommit = revWalk.parseCommit(candidateObjects.toArray(new ObjectId[1])[0]);

                if (revCommit == null) {
                    throw new Exception(Messages.formatString("CheckinCommand.CommitIdDoesNotExistFormat", //$NON-NLS-1$
                            squashCommitIDs[i].name()));
                }
            }
        }

        return squashCommitIDs;
    } finally {
        if (objReader != null) {
            objReader.release();
        }

        if (revWalk != null) {
            revWalk.release();
        }
    }
}

From source file:com.microsoft.gittf.core.util.CommitUtil.java

License:Open Source License

/**
 * Resolves the abbreviated id specified
 * /*from w  ww.  j  a  v  a2s.c o m*/
 * @param repository
 *        the git repository
 * @param objectID
 *        objectid to expand
 * @return
 */
public static final ObjectId resolveAbbreviatedId(final Repository repository,
        final AbbreviatedObjectId objectID) {
    Check.notNull(repository, "repository"); //$NON-NLS-1$
    Check.notNull(objectID, "objectID"); //$NON-NLS-1$

    if (repository != null) {
        ObjectReader objReader = repository.getObjectDatabase().newReader();

        try {
            Collection<ObjectId> objects = objReader.resolve(objectID);

            if (objects.size() == 0) {
                return null;
            } else if (objects.size() == 1) {
                return objects.iterator().next();
            } else {
                throw new RuntimeException(
                        Messages.formatString("RepositoryUtil.AmbiguousObjectFormat", objectID)); //$NON-NLS-1$
            }
        } catch (IOException exception) {
            throw new RuntimeException(exception);
        } finally {
            if (objReader != null) {
                objReader.release();
            }
        }
    }

    return null;
}

From source file:com.tasktop.c2c.server.scm.service.GitBrowseUtil.java

License:Open Source License

public static Commit resolveCommit(Repository r, String commitId) throws IOException {

    ObjectId oid = null;//from  ww w .  ja v  a  2 s  .  com
    Commit commit = new Commit();

    if (commitId.length() < 40) {
        ObjectReader or = r.newObjectReader();
        try {
            AbbreviatedObjectId aid = AbbreviatedObjectId.fromString(commitId);

            Collection<ObjectId> oids = or.resolve(aid);

            if (oids == null || oids.size() == 0) {
                commit.setSha("nex");
                return commit;
            } else if (oids.size() > 1) {
                commit.setSha("ambigous");
                return commit;
            } else {
                oid = oids.iterator().next();
            }
        } finally {
            or.release();
        }
    } else {
        oid = ObjectId.fromString(commitId);
    }

    RevWalk rw = new RevWalk(r);
    try {
        RevCommit rc = rw.parseCommit(oid);
        return GitDomain.createCommit(rc);
    } catch (MissingObjectException ex) {
        commit.setSha("nex");
        return commit;
    } catch (IncorrectObjectTypeException ex) {
        commit.setSha("nex");
        return commit;
    }

}

From source file:playRepository.GitRepository.java

License:Apache License

private static List<FileDiff> getFileDiffs(final Repository repositoryA, Repository repositoryB,
        ObjectId commitA, ObjectId commitB) throws IOException {
    class MultipleRepositoryObjectReader extends ObjectReader {
        Collection<ObjectReader> readers = new HashSet<>();

        @Override/*from   w  w w.ja  v a 2s.  c  om*/
        public ObjectReader newReader() {
            return new MultipleRepositoryObjectReader(readers);
        }

        public MultipleRepositoryObjectReader(Collection<ObjectReader> readers) {
            this.readers = readers;
        }

        public MultipleRepositoryObjectReader() {
            this.readers = new HashSet<>();
        }

        public void addObjectReader(ObjectReader reader) {
            this.readers.add(reader);
        }

        @Override
        public Collection<ObjectId> resolve(AbbreviatedObjectId id) throws IOException {
            Set<ObjectId> result = new HashSet<>();
            for (ObjectReader reader : readers) {
                result.addAll(reader.resolve(id));
            }
            return result;
        }

        @Override
        public ObjectLoader open(AnyObjectId objectId, int typeHint) throws IOException {
            for (ObjectReader reader : readers) {
                if (reader.has(objectId, typeHint)) {
                    return reader.open(objectId, typeHint);
                }
            }
            return null;
        }

        @Override
        public Set<ObjectId> getShallowCommits() throws IOException {
            Set<ObjectId> union = new HashSet<>();
            for (ObjectReader reader : readers) {
                union.addAll(reader.getShallowCommits());
            }
            return union;
        }
    }

    final MultipleRepositoryObjectReader reader = new MultipleRepositoryObjectReader();
    reader.addObjectReader(repositoryA.newObjectReader());
    reader.addObjectReader(repositoryB.newObjectReader());

    @SuppressWarnings("rawtypes")
    Repository fakeRepo = new Repository(new BaseRepositoryBuilder()) {

        @Override
        public void create(boolean bare) throws IOException {
            throw new UnsupportedOperationException();
        }

        @Override
        public ObjectDatabase getObjectDatabase() {
            throw new UnsupportedOperationException();
        }

        @Override
        public RefDatabase getRefDatabase() {
            throw new UnsupportedOperationException();
        }

        @Override
        public StoredConfig getConfig() {
            return repositoryA.getConfig();
        }

        @Override
        public void scanForRepoChanges() throws IOException {
            throw new UnsupportedOperationException();
        }

        @Override
        public void notifyIndexChanged() {
            throw new UnsupportedOperationException();
        }

        @Override
        public ReflogReader getReflogReader(String refName) throws IOException {
            throw new UnsupportedOperationException();
        }

        public ObjectReader newObjectReader() {
            return reader;
        }
    };

    DiffFormatter formatter = new DiffFormatter(NullOutputStream.INSTANCE);
    formatter.setRepository(fakeRepo);
    formatter.setDetectRenames(true);

    AbstractTreeIterator treeParserA, treeParserB;
    RevTree treeA = null, treeB = null;

    if (commitA != null) {
        treeA = new RevWalk(repositoryA).parseTree(commitA);
        treeParserA = new CanonicalTreeParser();
        ((CanonicalTreeParser) treeParserA).reset(reader, treeA);
    } else {
        treeParserA = new EmptyTreeIterator();
    }

    if (commitB != null) {
        treeB = new RevWalk(repositoryB).parseTree(commitB);
        treeParserB = new CanonicalTreeParser();
        ((CanonicalTreeParser) treeParserB).reset(reader, treeB);
    } else {
        treeParserB = new EmptyTreeIterator();
    }

    List<FileDiff> result = new ArrayList<>();
    int size = 0;
    int lines = 0;

    for (DiffEntry diff : formatter.scan(treeParserA, treeParserB)) {
        FileDiff fileDiff = new FileDiff();
        fileDiff.commitA = commitA != null ? commitA.getName() : null;
        fileDiff.commitB = commitB != null ? commitB.getName() : null;

        fileDiff.changeType = diff.getChangeType();

        fileDiff.oldMode = diff.getOldMode();
        fileDiff.newMode = diff.getNewMode();

        String pathA = diff.getPath(DiffEntry.Side.OLD);
        String pathB = diff.getPath(DiffEntry.Side.NEW);

        byte[] rawA = null;
        if (treeA != null && Arrays.asList(DELETE, MODIFY, RENAME, COPY).contains(diff.getChangeType())) {
            TreeWalk t1 = TreeWalk.forPath(repositoryA, pathA, treeA);
            ObjectId blobA = t1.getObjectId(0);
            fileDiff.pathA = pathA;

            try {
                rawA = repositoryA.open(blobA).getBytes();
                fileDiff.isBinaryA = RawText.isBinary(rawA);
                fileDiff.a = fileDiff.isBinaryA ? null : new RawText(rawA);
            } catch (org.eclipse.jgit.errors.LargeObjectException e) {
                fileDiff.addError(FileDiff.Error.A_SIZE_EXCEEDED);
            }
        }

        byte[] rawB = null;
        if (treeB != null && Arrays.asList(ADD, MODIFY, RENAME, COPY).contains(diff.getChangeType())) {
            TreeWalk t2 = TreeWalk.forPath(repositoryB, pathB, treeB);
            ObjectId blobB = t2.getObjectId(0);
            fileDiff.pathB = pathB;

            try {
                rawB = repositoryB.open(blobB).getBytes();
                fileDiff.isBinaryB = RawText.isBinary(rawB);
                fileDiff.b = fileDiff.isBinaryB ? null : new RawText(rawB);
            } catch (org.eclipse.jgit.errors.LargeObjectException e) {
                fileDiff.addError(FileDiff.Error.B_SIZE_EXCEEDED);
            }
        }

        if (size > DIFF_SIZE_LIMIT || lines > DIFF_LINE_LIMIT) {
            fileDiff.addError(FileDiff.Error.OTHERS_SIZE_EXCEEDED);
            result.add(fileDiff);
            continue;
        }

        // Get diff if necessary
        if (fileDiff.a != null && fileDiff.b != null && !(fileDiff.isBinaryA || fileDiff.isBinaryB)
                && Arrays.asList(MODIFY, RENAME).contains(diff.getChangeType())) {
            DiffAlgorithm diffAlgorithm = DiffAlgorithm
                    .getAlgorithm(repositoryB.getConfig().getEnum(ConfigConstants.CONFIG_DIFF_SECTION, null,
                            ConfigConstants.CONFIG_KEY_ALGORITHM, DiffAlgorithm.SupportedAlgorithm.HISTOGRAM));
            fileDiff.editList = diffAlgorithm.diff(RawTextComparator.DEFAULT, fileDiff.a, fileDiff.b);
            size += fileDiff.getHunks().size;
            lines += fileDiff.getHunks().lines;
        }

        // update lines and sizes
        if (fileDiff.b != null && !fileDiff.isBinaryB && diff.getChangeType().equals(ADD)) {
            lines += fileDiff.b.size();
            size += rawB.length;
        }

        // update lines and sizes
        if (fileDiff.a != null && !fileDiff.isBinaryA && diff.getChangeType().equals(DELETE)) {
            lines += fileDiff.a.size();
            size += rawA.length;
        }

        // Stop if exceeds the limit for total number of files
        if (result.size() > DIFF_FILE_LIMIT) {
            break;
        }

        result.add(fileDiff);
    }

    return result;
}