Java Code Examples for org.eclipse.jgit.revwalk.RevWalk#close()

private void addDiff(DiffImplementation returnable, RevCommit parent) throws IOException {
	RevWalk revWalk = new RevWalk(repository);
	parent = revWalk.parseCommit(parent.getId());
	revWalk.close();
	ByteArrayOutputStream put = new ByteArrayOutputStream(BUFFER_SIZE);
	DiffFormatter df = new DiffFormatter(put);
	df.setRepository(repository);
	df.setDiffComparator(RawTextComparator.DEFAULT);
	df.setDetectRenames(true);
	List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
	for(DiffEntry e : diffs){
		df.format(e);
		String diffText = put.toString(DEFAULT_ENCODING); //TODO make encoding insertable
		returnable.addOperation(e.getOldPath(), new GitOperation(diffText, e.getOldPath(), e.getNewPath(), e.getChangeType()));
		put.reset();
	}
	df.close();
}
 

@Override
public Collection<Tag> getTags() throws TagsNotAvailableException {
	List<Tag> result = new ArrayList<Tag>();
	try {
		Git del = new Git(delegateRepository);
		List<Ref> tags = del.tagList().call();
		del.close();
		RevWalk walk = new RevWalk(delegateRepository);
		for (Ref tag : tags){
			GitCommit commit = new GitCommit(delegateRepository, walk.parseCommit(tag.getObjectId()));
			GitTag wrapperTag = new GitTag(commit, createTagName(tag));
			result.add(wrapperTag);
			walk.close();
		}
		return result;
	} catch (Exception e) {
		throw new TagsNotAvailableException(e);
	}
}
 

@Override
public Churn churnAtCommit(Repository repository, String commitId, RefactoringHandler handler) {
	GitService gitService = new GitServiceImpl();
	RevWalk walk = new RevWalk(repository);
	try {
		RevCommit commit = walk.parseCommit(repository.resolve(commitId));
		if (commit.getParentCount() > 0) {
			walk.parseCommit(commit.getParent(0));
			return gitService.churn(repository, commit);
		}
		else {
			logger.warn(String.format("Ignored revision %s because it has no parent", commitId));
		}
	} catch (MissingObjectException moe) {
		logger.warn(String.format("Ignored revision %s due to missing commit", commitId), moe);
	} catch (Exception e) {
		logger.warn(String.format("Ignored revision %s due to error", commitId), e);
		handler.handleException(commitId, e);
	} finally {
		walk.close();
		walk.dispose();
	}
	return null;
}
 

public void countChangedFiles(List<String> commits, Map<String, Integer> counts) {
	RevWalk temprevwalk = new RevWalk(repository);
	try {
		revwalk.reset();
		Set<RevCommit> heads = getHeads();
		revwalk.markStart(heads);
		revwalk.sort(RevSort.TOPO, true);
		revwalk.sort(RevSort.COMMIT_TIME_DESC, true);
		revwalk.sort(RevSort.REVERSE, true);
		for (final RevCommit rc: revwalk) {
			final GitCommit gc = new GitCommit(this, repository, temprevwalk, projectName);
			System.out.println(rc.getName());
			commits.add(rc.getName());
			int count = gc.countChangedFiles(rc);
			counts.put(rc.getName(), count);
		}
	} catch (final IOException e) {
		if (debug)
			System.err.println("Git Error getting parsing HEAD commit for " + path + ". " + e.getMessage());
	} finally {
		temprevwalk.dispose();
		temprevwalk.close();
	}
}
 

public List<String> logCommitIds() {
	List<String> commits = new ArrayList<String>();
	RevWalk temprevwalk = new RevWalk(repository);
	try {
		revwalk.reset();
		Set<RevCommit> heads = getHeads();
		revwalk.markStart(heads);
		revwalk.sort(RevSort.TOPO, true);
		revwalk.sort(RevSort.COMMIT_TIME_DESC, true);
		revwalk.sort(RevSort.REVERSE, true);
		for (final RevCommit rc : revwalk)
			commits.add(rc.getName());
	} catch (final IOException e) {
		e.printStackTrace();
	} finally {
		temprevwalk.dispose();
		temprevwalk.close();
	}
	return commits;
}
 

private ObjectId getCommitObjectId(Repository db, ObjectId oid) throws MissingObjectException, IncorrectObjectTypeException, IOException {
	RevWalk walk = new RevWalk(db);
	try {
		return walk.parseCommit(oid);
	} finally {
		walk.close();
	}
}
 

private RevCommit parseCommit() {
	ObjectId oid = ref.getObjectId();
	if (oid == null)
		return null;
	RevWalk walk = new RevWalk(db);
	try {
		return walk.parseCommit(oid);
	} catch (IOException e) {
		// ignore and return null
	} finally {
		walk.close();
	}
	return null;
}
 

private ObjectId getCommitObjectId(Repository db, ObjectId oid) throws MissingObjectException, IncorrectObjectTypeException, IOException {
	RevWalk walk = new RevWalk(db);
	try {
		return walk.parseCommit(oid);
	} finally {
		walk.close();
	}
}
 

private ObjectId getCommitObjectId(Repository db, ObjectId oid) throws MissingObjectException, IncorrectObjectTypeException, IOException {
	RevWalk walk = new RevWalk(db);
	try {
		return walk.parseCommit(oid);
	} finally {
		walk.close();
	}
}
 

private ObjectId getCommitObjectId(Repository db, ObjectId oid) throws MissingObjectException, IncorrectObjectTypeException, IOException {
	RevWalk walk = new RevWalk(db);
	try {
		return walk.parseCommit(oid);
	} finally {
		walk.close();
	}
}
 

private String getLastRevisionBeforeDate(VcsRepository repository, Date date) throws Exception
{
	Git git = getGit((GitRepository)repository);
	
	Repository repo = git.getRepository();
	RevWalk walk = new RevWalk(repo);
	
	Iterator<RevCommit> iterator = git.log().call().iterator();
	
	String revision="";
	// The commits are ordered latest first, so we want to find the fist that it is before the date
	int dateComparison;
	while(iterator.hasNext()) 
	{
		RevCommit commit = walk.parseCommit(iterator.next());
		dateComparison=new Date(Long.valueOf(commit.getCommitTime())*1000).compareTo(date);
		if (dateComparison < 0) {
			revision=commit.getId().getName();
			break;
		}
	}
	
	walk.close();
	repo.close();
	git.close();
	
	if(revision.isEmpty())
		return "";
	return revision;
}
 

private RevCommit getMergeBase(RevCommit baseCommit, RevCommit referenceHeadCommit) throws IOException {
    RevWalk walk = new RevWalk(git.getRepository());
    walk.setRevFilter(RevFilter.MERGE_BASE);
    walk.markStart(walk.lookupCommit(baseCommit));
    walk.markStart(walk.lookupCommit(referenceHeadCommit));
    RevCommit commit = walk.next();
    walk.close();
    logger.info("Using merge base of id: " + commit.getId());
    return commit;
}
 

private RevCommit getBranchCommit(String branchName) throws IOException {
    ObjectId objectId = git.getRepository().resolve(branchName);

    if (objectId == null) {
        throw new IllegalArgumentException("Git branch of name '" + branchName + "' not found.");
    }
    final RevWalk walk = new RevWalk(git.getRepository());
    RevCommit commit = walk.parseCommit(objectId);
    walk.close();
    logger.info("Reference commit of branch " + branchName + " is commit of id: " + commit.getId());
    return commit;
}
 

private List<Change> getChangesForCommitedFiles(String hash) throws IOException {
	RevWalk revWalk = new RevWalk(git.getRepository());
	RevCommit commit = revWalk.parseCommit(ObjectId.fromString(hash));

	if (commit.getParentCount() > 1) {
		revWalk.close();
		return new ArrayList<Change>();
	}

	RevCommit parentCommit = commit.getParentCount() > 0
			? revWalk.parseCommit(ObjectId.fromString(commit.getParent(0).getName()))
			: null;

	DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
	df.setBinaryFileThreshold(2048);
	df.setRepository(git.getRepository());
	df.setDiffComparator(RawTextComparator.DEFAULT);
	df.setDetectRenames(true);

	List<DiffEntry> diffEntries = df.scan(parentCommit, commit);
	df.close();
	revWalk.close();

	List<Change> changes = new ArrayList<Change>();
	for (DiffEntry entry : diffEntries) {
		Change change = new Change(entry.getNewPath(), entry.getOldPath(), 0, 0,
				ChangeType.valueOf(entry.getChangeType().name()));
		analyzeDiff(change, entry);
		changes.add(change);
	}

	return changes;
}