org.eclipse.jgit.dircache.DirCacheBuilder Java Examples

private DirCache createTreeDirCache(Map<SubtreeConfig, RevCommit> parentCommits,
		String commitMessage) throws IOException {

	try (TreeWalk treeWalk = new TreeWalk(repository)) {
		treeWalk.setRecursive(true);
		addTrees(parentCommits, treeWalk);

		DirCacheBuilder builder = DirCache.newInCore().builder();
		while (treeWalk.next()) {
			AbstractTreeIterator iterator = getSingleTreeIterator(treeWalk, commitMessage);
			if (iterator == null) {
				throw new IllegalStateException(
						"Tree walker did not return a single tree (should not happen): "
								+ treeWalk.getPathString());
			}
			byte[] path = Arrays.copyOf(iterator.getEntryPathBuffer(),
					iterator.getEntryPathLength());
			DirCacheEntry entry = new DirCacheEntry(path);
			entry.setFileMode(iterator.getEntryFileMode());
			entry.setObjectId(iterator.getEntryObjectId());
			builder.add(entry);
		}
		builder.finish();
		return builder.getDirCache();
	}
}
 

@Test
public void checkoutCacheWithIgnoringSomeFile_theIgnoredFileShouldNotBeCheckedOut() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file1.txt"));
  builder.add(someEntry("/test_file2.txt"));
  builder.add(someEntry("/test_file3.txt"));
  builder.finish();
  new GfsDefaultCheckout(gfs).ignoredFiles(singleton("/test_file2.txt")).checkout(cache);

  assertTrue(Files.exists(gfs.getPath("/test_file1.txt")));
  assertFalse(Files.exists(gfs.getPath("/test_file2.txt")));
  assertTrue(Files.exists(gfs.getPath("/test_file3.txt")));
}
 

@Test
public void writeLargeFile_shouldWork() throws IOException {
  repoDir = FileUtils.createTempDir(getClass().getSimpleName(), null, null);
  repo = RepositoryUtils.createRepository(repoDir, true);
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  byte[] largeData = new byte[50*1024*1024+1];
  Random random = new Random();
  random.nextBytes(largeData);
  AnyObjectId blobId = BlobUtils.insertBlob(largeData, repo);
  addFile("large.txt", REGULAR_FILE, blobId, builder);
  builder.finish();
  commitToMaster();
  initGitFileSystemForBranch(MASTER);
  byte[] data = someBytes();
  Path file = gfs.getPath("/large.txt");
  Files.write(file, data, APPEND);
}
 

@Test
public void writeLargeFile_shouldWork() throws IOException {
  repoDir = FileUtils.createTempDir(getClass().getSimpleName(), null, null);
  repo = RepositoryUtils.createRepository(repoDir, true);
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  byte[] largeData = new byte[50*1024*1024+1];
  Random random = new Random();
  random.nextBytes(largeData);
  AnyObjectId blobId = BlobUtils.insertBlob(largeData, repo);
  addFile("large.txt", REGULAR_FILE, blobId, builder);
  builder.finish();
  commitToMaster();
  initGitFileSystemForBranch(MASTER);
  byte[] data = someBytes();
  Path file = gfs.getPath("/large.txt");
  Files.write(file, data, APPEND);
}
 

@Override
protected void run() throws GitException {
    Repository repository = getRepository();
    DirCache cache = null;
    try {
        // cache must be locked because checkout index may modify its entries
        cache = repository.lockDirCache();
        DirCacheBuilder builder = cache.builder();
        if (cache.getEntryCount() > 0) {
            builder.keep(0, cache.getEntryCount());
        }
        builder.finish();
        new CheckoutIndex(repository, cache, roots, recursively, listener, monitor, true).checkout();
        // cache must be saved to disk because checkout index may modify its entries
        builder.commit();
    } catch (IOException ex) {
        throw new GitException(ex);
    } finally {
        if (cache != null) {
            cache.unlock();
        }
    }
}
 

@Test
public void checkoutCacheWithIgnoringSomeFile_theIgnoredFileShouldNotBeCheckedOut() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file1.txt"));
  builder.add(someEntry("/test_file2.txt"));
  builder.add(someEntry("/test_file3.txt"));
  builder.finish();
  new GfsDefaultCheckout(gfs).ignoredFiles(singleton("/test_file2.txt")).checkout(cache);

  assertTrue(Files.exists(gfs.getPath("/test_file1.txt")));
  assertFalse(Files.exists(gfs.getPath("/test_file2.txt")));
  assertTrue(Files.exists(gfs.getPath("/test_file3.txt")));
}
 

@Test
public void addFilesWithDirCacheBuilderTest() {
  DirCache cache = DirCache.newInCore();

  DirCacheBuilder builder = cache.builder();
  String[] files = new String[] {"a/b/c1.txt",
                                  "a/c2.txt",
                                  "a/c3.txt",
                                  "a/b/c4.txt"};
  for(String file : files)
    CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);builder.finish();

  int entryCount = cache.getEntryCount();
  assertEquals(4, entryCount);
}
 

@Test
public void addFilesWithDirCacheBuilderTest() {
  DirCache cache = DirCache.newInCore();

  DirCacheBuilder builder = cache.builder();
  String[] files = new String[] {"a/b/c1.txt",
                                  "a/c2.txt",
                                  "a/c3.txt",
                                  "a/b/c4.txt"};
  for(String file : files)
    CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);builder.finish();

  int entryCount = cache.getEntryCount();
  assertEquals(4, entryCount);
}
 

@Test
public void keepEverything_ExistingEntriesShouldBeKept() throws IOException {
  writeMultipleToCache("/file1.txt", "/file2.txt");
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  builder.finish();
  assertNotNull(CacheUtils.getEntry("/file1.txt", cache));
  assertNotNull(CacheUtils.getEntry("/file2.txt", cache));
}
 

@Nonnull
private static DirCache setupCache(String... files) {
  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  for(String file : files)
    CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);
  builder.finish();
  return cache;
}
 

protected void writeMultipleToCache(String... paths) throws IOException {
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  for(String path : paths) {
    AnyObjectId blobId = repo != null ? BlobUtils.insertBlob(someBytes(), repo) : someObjectId();
    addFile(path, REGULAR_FILE, blobId, builder);
  }
  builder.finish();
}
 

@Test
public void checkoutCacheWithIgnoringMultiStagesFile_theIgnoredFileShouldNotBeCheckedOut() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file.txt", STAGE_1));
  builder.add(someEntry("/test_file.txt", STAGE_2));
  builder.add(someEntry("/test_file.txt", STAGE_3));
  builder.finish();
  new GfsDefaultCheckout(gfs).ignoredFiles(singleton("/test_file.txt")).checkout(cache);

  assertFalse(Files.exists(gfs.getPath("/test_file.txt")));
}
 

@Test(expected = IllegalStateException.class)
public void checkoutCacheWithMultiStagesFile_shouldThrowIllegalStateException() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file.txt", STAGE_1));
  builder.add(someEntry("/test_file.txt", STAGE_2));
  builder.add(someEntry("/test_file.txt", STAGE_3));
  builder.finish();

  new GfsDefaultCheckout(gfs).checkout(cache);
}
 

@Test
public void keepEverything_ExistingEntriesShouldBeKept() throws IOException {
  writeMultipleToCache("/file1.txt", "/file2.txt");
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  builder.finish();
  assertNotNull(CacheUtils.getEntry("/file1.txt", cache));
  assertNotNull(CacheUtils.getEntry("/file2.txt", cache));
}
 

@Nonnull
private static DirCache setupCache(String... files) {
  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  for(String file : files)
    CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);
  builder.finish();
  return cache;
}
 

protected void writeMultipleToCache(String... paths) throws IOException {
  DirCacheBuilder builder = CacheUtils.keepEverything(cache);
  for(String path : paths) {
    AnyObjectId blobId = repo != null ? BlobUtils.insertBlob(someBytes(), repo) : someObjectId();
    addFile(path, REGULAR_FILE, blobId, builder);
  }
  builder.finish();
}
 

@Test
public void checkoutCacheWithIgnoringMultiStagesFile_theIgnoredFileShouldNotBeCheckedOut() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file.txt", STAGE_1));
  builder.add(someEntry("/test_file.txt", STAGE_2));
  builder.add(someEntry("/test_file.txt", STAGE_3));
  builder.finish();
  new GfsDefaultCheckout(gfs).ignoredFiles(singleton("/test_file.txt")).checkout(cache);

  assertFalse(Files.exists(gfs.getPath("/test_file.txt")));
}
 

@Test(expected = IllegalStateException.class)
public void checkoutCacheWithMultiStagesFile_shouldThrowIllegalStateException() throws IOException {
  initGitFileSystem("/some_existing_file.txt");

  DirCache cache = DirCache.newInCore();
  DirCacheBuilder builder = cache.builder();
  builder.add(someEntry("/test_file.txt", STAGE_1));
  builder.add(someEntry("/test_file.txt", STAGE_2));
  builder.add(someEntry("/test_file.txt", STAGE_3));
  builder.finish();

  new GfsDefaultCheckout(gfs).checkout(cache);
}
 

public void testResetConflict () throws Exception {
    File file = new File(workDir, "file");
    write(file, "init");
    File[] files = new File[] { file };
    add(files);
    commit(files);

    DirCache index = repository.lockDirCache();
    DirCacheBuilder builder = index.builder();
    DirCacheEntry e = index.getEntry(file.getName());
    DirCacheEntry e1 = new DirCacheEntry(file.getName(), 1);
    e1.setCreationTime(e.getCreationTime());
    e1.setFileMode(e.getFileMode());
    e1.setLastModified(e.getLastModified());
    e1.setLength(e.getLength());
    e1.setObjectId(e.getObjectId());
    builder.add(e1);
    builder.finish();
    builder.commit();
    
    GitClient client = getClient(workDir);
    Map<File, GitStatus> status = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertTrue(status.get(file).isConflict());
    assertEquals(GitConflictDescriptor.Type.BOTH_DELETED, status.get(file).getConflictDescriptor().getType());
    
    client.reset(files, "HEAD", true, NULL_PROGRESS_MONITOR);
    status = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertFalse(status.get(file).isConflict());
}
 

private void mergeConflicts (List<String> conflicts, DirCache cache) throws GitException {
    DirCacheBuilder builder = cache.builder();
    DirCacheBuildIterator dci = new DirCacheBuildIterator(builder);
    ObjectDatabase od = null;
    DiffAlgorithm.SupportedAlgorithm diffAlg = getRepository().getConfig().getEnum(
                    ConfigConstants.CONFIG_DIFF_SECTION, null,
                    ConfigConstants.CONFIG_KEY_ALGORITHM,
                    DiffAlgorithm.SupportedAlgorithm.HISTOGRAM);
    MergeAlgorithm merger = new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
    try (TreeWalk walk = new TreeWalk(getRepository());) {
        od = getRepository().getObjectDatabase();
        walk.addTree(dci);
        walk.setFilter(PathFilterGroup.create(Utils.getPathFilters(conflicts)));
        String lastPath = null;
        DirCacheEntry[] entries = new DirCacheEntry[3];
        walk.setRecursive(true);
        while (walk.next()) {
            DirCacheEntry e = walk.getTree(0, DirCacheIterator.class).getDirCacheEntry();
            String path = e.getPathString();
            if (lastPath != null && !lastPath.equals(path)) {
                resolveEntries(merger, lastPath, entries, od, builder);
            }
            if (e.getStage() == 0) {
                DirCacheIterator c = walk.getTree(0, DirCacheIterator.class);
                builder.add(c.getDirCacheEntry());
            } else {
                entries[e.getStage() - 1] = e;
                lastPath = path;
            }
        }
        resolveEntries(merger, lastPath, entries, od, builder);
        builder.commit();
    } catch (IOException ex) {
        throw new GitException(ex);
    } finally {
        if (od != null) {
            od.close();
        }
    }
}