Examples with IResourceVariant org.eclipse.team.core.variants.IResourceVariant used on opensource projects

Example 16 with IResourceVariant

use of org.eclipse.team.core.variants.IResourceVariant in project egit by eclipse.

the class GitResourceVariantTreeSubscriberTest method getBaseVariant.

private IResourceVariant getBaseVariant(GitResourceVariantTreeSubscriber subscriber, IResource resource) throws TeamException {
    IResourceVariantTree tree = subscriber.getBaseTree();
    assertNotNull(tree);
    assertTrue(tree instanceof GitBaseResourceVariantTree);
    IResourceVariant resourceVariant = tree.getResourceVariant(resource);
    assertNotNull(resourceVariant);
    assertTrue(resourceVariant instanceof GitRemoteResource);
    return resourceVariant;
}

Example 17 with IResourceVariant

use of org.eclipse.team.core.variants.IResourceVariant in project egit by eclipse.

the class GitResourceVariantTreeTest method shouldNotReturnNullOnSameResouceVariant.

@Test
public void shouldNotReturnNullOnSameResouceVariant() throws Exception {
    String modifiedFileName = "changingFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    String unchangedFileName = "notChangingFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    String removedFileName = "toBeRemovedFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    File modifiedFile = testRepo.createFile(iProject, modifiedFileName);
    File unchangedFile = testRepo.createFile(iProject, unchangedFileName);
    File removedFile = testRepo.createFile(iProject, removedFileName);
    testRepo.appendFileContent(modifiedFile, "My content is changing");
    testRepo.appendFileContent(unchangedFile, "My content is constant");
    testRepo.appendFileContent(removedFile, "I will be removed");
    IFile iModifiedFile = testRepo.getIFile(iProject, modifiedFile);
    IFile iUnchangedFile = testRepo.getIFile(iProject, unchangedFile);
    IFile iRemovedFile = testRepo.getIFile(iProject, removedFile);
    testRepo.trackAllFiles(iProject);
    RevCommit firstCommit = testRepo.commit("C1");
    testRepo.appendFileContent(modifiedFile, " My content has changed");
    testRepo.track(modifiedFile);
    testRepo.removeFromIndex(removedFile);
    RevCommit secondCommit = testRepo.commit("C2");
    // @formatter:off
    // History (X means has changed)
    // ------------------------------------------------------------
    // files					   C1 [HEAD]		  	C2
    // changingFile.sample   	|-----X----------|-------X-------|->
    // notChangingFile.sample	|-----X----------|---------------|->
    // toBeRemovedFile.sample	|-----X----------|-------X-------|->
    // -------------------------------------------------------------
    // @formatter:on
    testRepo.checkoutBranch(firstCommit.getName());
    iProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
    // Now synchronize the two commits using our logical model provider
    SampleModelProvider provider = new SampleModelProvider();
    // Get the affected resources
    ResourceMapping[] mappings = provider.getMappings(iModifiedFile, ResourceMappingContext.LOCAL_CONTEXT, new NullProgressMonitor());
    Set<IResource> includedResource = collectResources(mappings);
    Set<IResource> expectedIncludedResources = new HashSet<IResource>();
    expectedIncludedResources.add(iModifiedFile);
    expectedIncludedResources.add(iUnchangedFile);
    expectedIncludedResources.add(iRemovedFile);
    assertEquals(expectedIncludedResources, includedResource);
    // Synchronize the data
    final GitSynchronizeData data = new GitSynchronizeData(testRepo.getRepository(), firstCommit.getName(), secondCommit.getName(), true, includedResource);
    GitSynchronizeDataSet gitSynchDataSet = new GitSynchronizeDataSet(data);
    final GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(gitSynchDataSet);
    subscriber.init(new NullProgressMonitor());
    IResourceVariantTree sourceVariantTree = subscriber.getSourceTree();
    assertNotNull(sourceVariantTree);
    IResourceVariantTree remoteVariantTree = subscriber.getRemoteTree();
    assertNotNull(remoteVariantTree);
    // In the use case in which the file has been deleted the source variant is
    // not null whereas the remote variant is null.It seems quite logic.
    // However in the second use case we have the same result, the source variant is
    // not null whereas the remote is null. In both cases the null value does
    // not mean the same thing. In the first case, the null value means that
    // the resource is no longer in the repository and in the second the
    // null value means there is no change between the two versions.
    // Using these values I am not able to distinguish both case.
    // It is in contradiction with test #shouldReturnNullResourceVariant2()
    // and test #shoulReturnSameResourceVariant(). However I haven't found
    // another way to handle this case. Maybe something can be
    // done with ThreeWayDiffEntry.scan(tw) to force including in the cache
    // some entry even if they have not changed. For example,
    // ThreeWayDiffEntry.scan(tw,includedSource) or maybe try preventing the variant
    // tree to return null by walking throught the repository and looking for the file...
    IResourceVariant unchangedSourceVariant = sourceVariantTree.getResourceVariant(iUnchangedFile);
    IResourceVariant unchangedRemoteVariant = remoteVariantTree.getResourceVariant(iUnchangedFile);
    assertNotNull(unchangedSourceVariant);
    assertNotNull(unchangedRemoteVariant);
    IResourceVariant removedSourceVariant = sourceVariantTree.getResourceVariant(iRemovedFile);
    IResourceVariant removedRemoteVariant = remoteVariantTree.getResourceVariant(iRemovedFile);
    assertNotNull(removedSourceVariant);
    assertNull(removedRemoteVariant);
    GitSubscriberResourceMappingContext context = new GitSubscriberResourceMappingContext(subscriber, gitSynchDataSet);
    assertFalse(context.hasLocalChange(iUnchangedFile, new NullProgressMonitor()));
    assertFalse(context.hasRemoteChange(iUnchangedFile, new NullProgressMonitor()));
    assertFalse(context.hasLocalChange(iModifiedFile, new NullProgressMonitor()));
    assertTrue(context.hasRemoteChange(iModifiedFile, new NullProgressMonitor()));
    assertFalse(context.hasLocalChange(iRemovedFile, new NullProgressMonitor()));
    assertTrue(context.hasRemoteChange(iRemovedFile, new NullProgressMonitor()));
}

Example 18 with IResourceVariant

use of org.eclipse.team.core.variants.IResourceVariant in project egit by eclipse.

the class GitResourceVariantTreeTest method shouldReturnDifferentResourceVariant.

/**
 * Create and commit Main.java file in master branch, then create branch
 * "test" checkout nearly created branch and modify Main.java file.
 * getResourceVariant() should obtain Main.java file content from "master"
 * branch. Passes only when it is run as a single test, not as a part of
 * largest test suite
 *
 * @throws Exception
 */
@Test
public void shouldReturnDifferentResourceVariant() 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.R_HEADS + Constants.MASTER, Constants.R_HEADS + "test");
    testRepo.appendContentAndCommit(iProject, file, "// test", "first commit");
    GitSynchronizeData data = new GitSynchronizeData(repo, HEAD, MASTER, true);
    GitSynchronizeDataSet dataSet = new GitSynchronizeDataSet(data);
    GitSyncCache cache = GitSyncCache.getAllData(dataSet, new NullProgressMonitor());
    // given
    GitResourceVariantTree grvt = new GitBaseResourceVariantTree(cache, dataSet);
    // then
    IResourceVariant actual = grvt.getResourceVariant(mainJava);
    assertNotNull(actual);
    assertEquals(fileName, actual.getName());
    InputStream actualIn = actual.getStorage(new NullProgressMonitor()).getContents();
    byte[] actualByte = getBytesAndCloseStream(actualIn);
    InputStream expectedIn = mainJava.getContents();
    byte[] expectedByte = getBytesAndCloseStream(expectedIn);
    // assert arrays not equals
    assertFalse(Arrays.equals(expectedByte, actualByte));
}

Example 19 with IResourceVariant

use of org.eclipse.team.core.variants.IResourceVariant in project egit by eclipse.

the class GitResourceVariantTree method fetchVariant.

private IResourceVariant fetchVariant(IResource resource) {
    if (gitCache == null)
        return null;
    IResourceVariant cachedVariant = cache.get(resource);
    if (cachedVariant != null)
        return cachedVariant;
    GitSynchronizeData gsd = gsds.getData(resource.getProject());
    if (gsd == null)
        return null;
    Repository repo = gsd.getRepository();
    String path = getPath(resource, repo);
    GitSyncObjectCache syncCache = gitCache.get(repo);
    GitSyncObjectCache cachedData = syncCache.get(path);
    if (cachedData == null)
        return null;
    IResourceVariant variant = null;
    ObjectId objectId = getObjectId(cachedData.getDiffEntry());
    if (!objectId.equals(zeroId())) {
        if (resource.getType() == IResource.FILE)
            variant = new GitRemoteFile(repo, getCommitId(gsd), objectId, path);
        else
            variant = new GitRemoteFolder(repo, cachedData, getCommitId(gsd), objectId, path);
        cache.put(resource, variant);
    }
    return variant;
}

Example 20 with IResourceVariant

use of org.eclipse.team.core.variants.IResourceVariant in project egit by eclipse.

the class GitSourceResourceVariantTree method fetchMembers.

@Override
protected IResourceVariant[] fetchMembers(IResourceVariant variant, IProgressMonitor progress) throws TeamException {
    if (variant instanceof GitLocalResourceVariant && ((GitLocalResourceVariant) variant).getResource() instanceof IContainer) {
        IContainer resource = (IContainer) ((GitLocalResourceVariant) variant).getResource();
        try {
            IResource[] children = resource.members();
            IResourceVariant[] result = new IResourceVariant[children.length];
            for (int i = 0; i < children.length; i++) result[i] = new GitLocalResourceVariant(children[i]);
            return result;
        } catch (CoreException e) {
        // fall back to using remote data
        }
    }
    return super.fetchMembers(variant, progress);
}