Example usage for org.eclipse.jgit.treewalk TreeWalk reset

List of usage examples for org.eclipse.jgit.treewalk TreeWalk reset

Introduction

In this page you can find the example usage for org.eclipse.jgit.treewalk TreeWalk reset.

Prototype

public void reset() 

Source Link

Document

Reset this walker so new tree iterators can be added to it.

Usage

From source file:MyDiffFormatter.java

License:Eclipse Distribution License

/**
* Determine the differences between two trees.
*
* No output is created, instead only the file paths that are different are
* returned. Callers may choose to format these paths themselves, or convert
* them into {@link FileHeader} instances with a complete edit list by
*
* @param a/*w w w.j  a  v  a2s  .  c om*/
*            the old (or previous) side.
* @param b
*            the new (or updated) side.
* @return the paths that are different.
* @throws IOException
*             trees cannot be read or file contents cannot be read.
*/
public List<DiffEntry> scan(AbstractTreeIterator a, AbstractTreeIterator b) throws IOException {
    assertHaveRepository();

    TreeWalk walk = new TreeWalk(reader);
    walk.addTree(a);
    walk.addTree(b);
    walk.setRecursive(true);

    TreeFilter filter = getDiffTreeFilterFor(a, b);
    if (pathFilter instanceof FollowFilter) {
        walk.setFilter(AndTreeFilter.create(PathFilter.create(((FollowFilter) pathFilter).getPath()), filter));
    } else {
        walk.setFilter(AndTreeFilter.create(pathFilter, filter));
    }

    source = new ContentSource.Pair(source(a), source(b));

    List<DiffEntry> files = DiffEntry.scan(walk);
    if (pathFilter instanceof FollowFilter && isAdd(files)) {
        // The file we are following was added here, find where it
        // came from so we can properly show the rename or copy,
        // then continue digging backwards.
        //
        a.reset();
        b.reset();
        walk.reset();
        walk.addTree(a);
        walk.addTree(b);
        walk.setFilter(filter);

        if (renameDetector == null)
            setDetectRenames(true);
        files = updateFollowFilter(detectRenames(DiffEntry.scan(walk)));

    } else if (renameDetector != null)
        files = detectRenames(files);

    return files;
}

From source file:com.gitblit.servlet.RawServlet.java

License:Apache License

protected boolean streamFromRepo(HttpServletRequest request, HttpServletResponse response,
        Repository repository, RevCommit commit, String requestedPath) throws IOException {

    boolean served = false;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    try {//  w ww.  j a v a  2  s.c om
        tw.reset();
        tw.addTree(commit.getTree());
        PathFilter f = PathFilter.create(requestedPath);
        tw.setFilter(f);
        tw.setRecursive(true);
        MutableObjectId id = new MutableObjectId();
        ObjectReader reader = tw.getObjectReader();
        while (tw.next()) {
            FileMode mode = tw.getFileMode(0);
            if (mode == FileMode.GITLINK || mode == FileMode.TREE) {
                continue;
            }
            tw.getObjectId(id, 0);

            String filename = StringUtils.getLastPathElement(requestedPath);
            try {
                String userAgent = request.getHeader("User-Agent");
                if (userAgent != null && userAgent.indexOf("MSIE 5.5") > -1) {
                    response.setHeader("Content-Disposition",
                            "filename=\"" + URLEncoder.encode(filename, Constants.ENCODING) + "\"");
                } else if (userAgent != null && userAgent.indexOf("MSIE") > -1) {
                    response.setHeader("Content-Disposition",
                            "attachment; filename=\"" + URLEncoder.encode(filename, Constants.ENCODING) + "\"");
                } else {
                    response.setHeader("Content-Disposition", "attachment; filename=\""
                            + new String(filename.getBytes(Constants.ENCODING), "latin1") + "\"");
                }
            } catch (UnsupportedEncodingException e) {
                response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + "\"");
            }

            long len = reader.getObjectSize(id, org.eclipse.jgit.lib.Constants.OBJ_BLOB);
            setContentType(response, "application/octet-stream");
            response.setIntHeader("Content-Length", (int) len);
            ObjectLoader ldr = repository.open(id);
            ldr.copyTo(response.getOutputStream());
            served = true;
        }
    } finally {
        tw.close();
        rw.dispose();
    }

    response.flushBuffer();
    return served;
}

From source file:com.gitblit.utils.CompressionUtils.java

License:Apache License

/**
 * Zips the contents of the tree at the (optionally) specified revision and
 * the (optionally) specified basepath to the supplied outputstream.
 *
 * @param repository/*  w w w.  j a  v  a  2s . c o m*/
 * @param basePath
 *            if unspecified, entire repository is assumed.
 * @param objectId
 *            if unspecified, HEAD is assumed.
 * @param os
 * @return true if repository was successfully zipped to supplied output
 *         stream
 */
public static boolean zip(Repository repository, IFilestoreManager filestoreManager, String basePath,
        String objectId, OutputStream os) {
    RevCommit commit = JGitUtils.getCommit(repository, objectId);
    if (commit == null) {
        return false;
    }
    boolean success = false;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    try {
        tw.reset();
        tw.addTree(commit.getTree());
        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(os);
        zos.setComment("Generated by Gitblit");
        if (!StringUtils.isEmpty(basePath)) {
            PathFilter f = PathFilter.create(basePath);
            tw.setFilter(f);
        }
        tw.setRecursive(true);
        MutableObjectId id = new MutableObjectId();
        ObjectReader reader = tw.getObjectReader();
        long modified = commit.getAuthorIdent().getWhen().getTime();
        while (tw.next()) {
            FileMode mode = tw.getFileMode(0);
            if (mode == FileMode.GITLINK || mode == FileMode.TREE) {
                continue;
            }
            tw.getObjectId(id, 0);

            ObjectLoader loader = repository.open(id);

            ZipArchiveEntry entry = new ZipArchiveEntry(tw.getPathString());

            FilestoreModel filestoreItem = null;

            if (JGitUtils.isPossibleFilestoreItem(loader.getSize())) {
                filestoreItem = JGitUtils.getFilestoreItem(tw.getObjectReader().open(id));
            }

            final long size = (filestoreItem == null) ? loader.getSize() : filestoreItem.getSize();

            entry.setSize(size);
            entry.setComment(commit.getName());
            entry.setUnixMode(mode.getBits());
            entry.setTime(modified);
            zos.putArchiveEntry(entry);

            if (filestoreItem == null) {
                //Copy repository stored file
                loader.copyTo(zos);
            } else {
                //Copy filestore file
                try (FileInputStream streamIn = new FileInputStream(
                        filestoreManager.getStoragePath(filestoreItem.oid))) {
                    IOUtils.copyLarge(streamIn, zos);
                } catch (Throwable e) {
                    LOGGER.error(
                            MessageFormat.format("Failed to archive filestore item {0}", filestoreItem.oid), e);

                    //Handle as per other errors 
                    throw e;
                }
            }

            zos.closeArchiveEntry();
        }
        zos.finish();
        success = true;
    } catch (IOException e) {
        error(e, repository, "{0} failed to zip files from commit {1}", commit.getName());
    } finally {
        tw.close();
        rw.dispose();
    }
    return success;
}

From source file:com.gitblit.utils.CompressionUtils.java

License:Apache License

/**
 * Compresses/archives the contents of the tree at the (optionally)
 * specified revision and the (optionally) specified basepath to the
 * supplied outputstream./* ww w .  ja  v  a2s. c  o m*/
 *
 * @param algorithm
 *            compression algorithm for tar (optional)
 * @param repository
 * @param basePath
 *            if unspecified, entire repository is assumed.
 * @param objectId
 *            if unspecified, HEAD is assumed.
 * @param os
 * @return true if repository was successfully zipped to supplied output
 *         stream
 */
private static boolean tar(String algorithm, Repository repository, IFilestoreManager filestoreManager,
        String basePath, String objectId, OutputStream os) {
    RevCommit commit = JGitUtils.getCommit(repository, objectId);
    if (commit == null) {
        return false;
    }

    OutputStream cos = os;
    if (!StringUtils.isEmpty(algorithm)) {
        try {
            cos = new CompressorStreamFactory().createCompressorOutputStream(algorithm, os);
        } catch (CompressorException e1) {
            error(e1, repository, "{0} failed to open {1} stream", algorithm);
        }
    }
    boolean success = false;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    try {
        tw.reset();
        tw.addTree(commit.getTree());
        TarArchiveOutputStream tos = new TarArchiveOutputStream(cos);
        tos.setAddPaxHeadersForNonAsciiNames(true);
        tos.setLongFileMode(TarArchiveOutputStream.LONGFILE_POSIX);
        if (!StringUtils.isEmpty(basePath)) {
            PathFilter f = PathFilter.create(basePath);
            tw.setFilter(f);
        }
        tw.setRecursive(true);
        MutableObjectId id = new MutableObjectId();
        long modified = commit.getAuthorIdent().getWhen().getTime();
        while (tw.next()) {
            FileMode mode = tw.getFileMode(0);
            if (mode == FileMode.GITLINK || mode == FileMode.TREE) {
                continue;
            }

            tw.getObjectId(id, 0);

            ObjectLoader loader = repository.open(id);
            if (FileMode.SYMLINK == mode) {
                TarArchiveEntry entry = new TarArchiveEntry(tw.getPathString(), TarArchiveEntry.LF_SYMLINK);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                loader.copyTo(bos);
                entry.setLinkName(bos.toString());
                entry.setModTime(modified);
                tos.putArchiveEntry(entry);
                tos.closeArchiveEntry();
            } else {
                TarArchiveEntry entry = new TarArchiveEntry(tw.getPathString());
                entry.setMode(mode.getBits());
                entry.setModTime(modified);

                FilestoreModel filestoreItem = null;

                if (JGitUtils.isPossibleFilestoreItem(loader.getSize())) {
                    filestoreItem = JGitUtils.getFilestoreItem(tw.getObjectReader().open(id));
                }

                final long size = (filestoreItem == null) ? loader.getSize() : filestoreItem.getSize();

                entry.setSize(size);
                tos.putArchiveEntry(entry);

                if (filestoreItem == null) {
                    //Copy repository stored file
                    loader.copyTo(tos);
                } else {
                    //Copy filestore file
                    try (FileInputStream streamIn = new FileInputStream(
                            filestoreManager.getStoragePath(filestoreItem.oid))) {

                        IOUtils.copyLarge(streamIn, tos);
                    } catch (Throwable e) {
                        LOGGER.error(
                                MessageFormat.format("Failed to archive filestore item {0}", filestoreItem.oid),
                                e);

                        //Handle as per other errors 
                        throw e;
                    }
                }

                tos.closeArchiveEntry();
            }
        }
        tos.finish();
        tos.close();
        cos.close();
        success = true;
    } catch (IOException e) {
        error(e, repository, "{0} failed to {1} stream files from commit {2}", algorithm, commit.getName());
    } finally {
        tw.close();
        rw.dispose();
    }
    return success;
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Returns the list of files changed in a specified commit. If the
 * repository does not exist or is empty, an empty list is returned.
 *
 * @param repository//  ww w  . j a v  a 2s  . c o  m
 * @param commit
 *            if null, HEAD is assumed.
 * @param calculateDiffStat
 *            if true, each PathChangeModel will have insertions/deletions
 * @return list of files changed in a commit
 */
public static List<PathChangeModel> getFilesInCommit(Repository repository, RevCommit commit,
        boolean calculateDiffStat) {
    List<PathChangeModel> list = new ArrayList<PathChangeModel>();
    if (!hasCommits(repository)) {
        return list;
    }
    RevWalk rw = new RevWalk(repository);
    try {
        if (commit == null) {
            ObjectId object = getDefaultBranch(repository);
            commit = rw.parseCommit(object);
        }

        if (commit.getParentCount() == 0) {
            TreeWalk tw = new TreeWalk(repository);
            tw.reset();
            tw.setRecursive(true);
            tw.addTree(commit.getTree());
            while (tw.next()) {
                long size = 0;
                FilestoreModel filestoreItem = null;
                ObjectId objectId = tw.getObjectId(0);

                try {
                    if (!tw.isSubtree() && (tw.getFileMode(0) != FileMode.GITLINK)) {

                        size = tw.getObjectReader().getObjectSize(objectId, Constants.OBJ_BLOB);

                        if (isPossibleFilestoreItem(size)) {
                            filestoreItem = getFilestoreItem(tw.getObjectReader().open(objectId));
                        }
                    }
                } catch (Throwable t) {
                    error(t, null, "failed to retrieve blob size for " + tw.getPathString());
                }

                list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), filestoreItem, size,
                        tw.getRawMode(0), objectId.getName(), commit.getId().getName(), ChangeType.ADD));
            }
            tw.close();
        } else {
            RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
            DiffStatFormatter df = new DiffStatFormatter(commit.getName(), repository);
            df.setRepository(repository);
            df.setDiffComparator(RawTextComparator.DEFAULT);
            df.setDetectRenames(true);
            List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
            for (DiffEntry diff : diffs) {
                // create the path change model
                PathChangeModel pcm = PathChangeModel.from(diff, commit.getName(), repository);

                if (calculateDiffStat) {
                    // update file diffstats
                    df.format(diff);
                    PathChangeModel pathStat = df.getDiffStat().getPath(pcm.path);
                    if (pathStat != null) {
                        pcm.insertions = pathStat.insertions;
                        pcm.deletions = pathStat.deletions;
                    }
                }
                list.add(pcm);
            }
        }
    } catch (Throwable t) {
        error(t, repository, "{0} failed to determine files in commit!");
    } finally {
        rw.dispose();
    }
    return list;
}

From source file:com.gitblit.wicket.panels.HistoryPanel.java

License:Apache License

public HistoryPanel(String wicketId, final String repositoryName, final String objectId, final String path,
        Repository r, int limit, int pageOffset, boolean showRemoteRefs) {
    super(wicketId);
    boolean pageResults = limit <= 0;
    int itemsPerPage = app().settings().getInteger(Keys.web.itemsPerPage, 50);
    if (itemsPerPage <= 1) {
        itemsPerPage = 50;/*from   ww  w . java  2 s  .  c o  m*/
    }

    RevCommit commit = JGitUtils.getCommit(r, objectId);
    PathModel matchingPath = null;
    Map<String, SubmoduleModel> submodules = new HashMap<String, SubmoduleModel>();

    if (commit == null) {
        // commit missing
        String msg = MessageFormat.format("Failed to find history of **{0}** *{1}*", path, objectId);
        logger().error(msg + " " + repositoryName);
        add(new Label("commitHeader", MarkdownUtils.transformMarkdown(msg)).setEscapeModelStrings(false));
        add(new Label("breadcrumbs"));
    } else {
        // commit found
        List<PathChangeModel> paths = JGitUtils.getFilesInCommit(r, commit);
        add(new CommitHeaderPanel("commitHeader", repositoryName, commit));
        add(new PathBreadcrumbsPanel("breadcrumbs", repositoryName, path, objectId));
        for (SubmoduleModel model : JGitUtils.getSubmodules(r, commit.getTree())) {
            submodules.put(model.path, model);
        }

        for (PathModel p : paths) {
            if (p.path.equals(path)) {
                matchingPath = p;
                break;
            }
        }
        if (matchingPath == null) {
            // path not in commit
            // manually locate path in tree
            TreeWalk tw = new TreeWalk(r);
            tw.reset();
            tw.setRecursive(true);
            try {
                tw.addTree(commit.getTree());
                tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
                while (tw.next()) {
                    if (tw.getPathString().equals(path)) {
                        matchingPath = new PathChangeModel(tw.getPathString(), tw.getPathString(), null, 0,
                                tw.getRawMode(0), tw.getObjectId(0).getName(), commit.getId().getName(),
                                ChangeType.MODIFY);
                    }
                }
            } catch (Exception e) {
            } finally {
                tw.close();
            }
        }
    }

    final boolean isTree = matchingPath == null ? true : matchingPath.isTree();
    final boolean isSubmodule = matchingPath == null ? false : matchingPath.isSubmodule();

    // submodule
    final String submodulePath;
    final boolean hasSubmodule;
    if (isSubmodule) {
        SubmoduleModel submodule = getSubmodule(submodules, repositoryName,
                matchingPath == null ? null : matchingPath.path);
        submodulePath = submodule.gitblitPath;
        hasSubmodule = submodule.hasSubmodule;
    } else {
        submodulePath = "";
        hasSubmodule = false;
    }

    final Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(r, showRemoteRefs);
    List<RevCommit> commits;
    if (pageResults) {
        // Paging result set
        commits = JGitUtils.getRevLog(r, objectId, path, pageOffset * itemsPerPage, itemsPerPage);
    } else {
        // Fixed size result set
        commits = JGitUtils.getRevLog(r, objectId, path, 0, limit);
    }

    // inaccurate way to determine if there are more commits.
    // works unless commits.size() represents the exact end.
    hasMore = commits.size() >= itemsPerPage;

    final int hashLen = app().settings().getInteger(Keys.web.shortCommitIdLength, 6);
    ListDataProvider<RevCommit> dp = new ListDataProvider<RevCommit>(commits);
    DataView<RevCommit> logView = new DataView<RevCommit>("commit", dp) {
        private static final long serialVersionUID = 1L;
        int counter;

        @Override
        public void populateItem(final Item<RevCommit> item) {
            final RevCommit entry = item.getModelObject();
            final Date date = JGitUtils.getAuthorDate(entry);

            item.add(WicketUtils.createDateLabel("commitDate", date, getTimeZone(), getTimeUtils()));

            // author search link
            String author = entry.getAuthorIdent().getName();
            LinkPanel authorLink = new LinkPanel("commitAuthor", "list", author, GitSearchPage.class,
                    WicketUtils.newSearchParameter(repositoryName, null, author, Constants.SearchType.AUTHOR));
            setPersonSearchTooltip(authorLink, author, Constants.SearchType.AUTHOR);
            item.add(authorLink);

            // merge icon
            if (entry.getParentCount() > 1) {
                item.add(WicketUtils.newImage("commitIcon", "commit_merge_16x16.png"));
            } else {
                item.add(WicketUtils.newBlankImage("commitIcon"));
            }

            String shortMessage = entry.getShortMessage();
            String trimmedMessage = shortMessage;
            if (allRefs.containsKey(entry.getId())) {
                trimmedMessage = StringUtils.trimString(shortMessage, Constants.LEN_SHORTLOG_REFS);
            } else {
                trimmedMessage = StringUtils.trimString(shortMessage, Constants.LEN_SHORTLOG);
            }
            LinkPanel shortlog = new LinkPanel("commitShortMessage", "list subject", trimmedMessage,
                    CommitPage.class, WicketUtils.newObjectParameter(repositoryName, entry.getName()));
            if (!shortMessage.equals(trimmedMessage)) {
                WicketUtils.setHtmlTooltip(shortlog, shortMessage);
            }
            item.add(shortlog);

            item.add(new RefsPanel("commitRefs", repositoryName, entry, allRefs));

            if (isTree) {
                // tree
                item.add(new Label("hashLabel", getString("gb.tree") + "@"));
                LinkPanel commitHash = new LinkPanel("hashLink", null, entry.getName().substring(0, hashLen),
                        TreePage.class, WicketUtils.newObjectParameter(repositoryName, entry.getName()));
                WicketUtils.setCssClass(commitHash, "shortsha1");
                WicketUtils.setHtmlTooltip(commitHash, entry.getName());
                item.add(commitHash);

                Fragment links = new Fragment("historyLinks", "treeLinks", HistoryPanel.this);
                links.add(new BookmarkablePageLink<Void>("commitdiff", CommitDiffPage.class,
                        WicketUtils.newObjectParameter(repositoryName, entry.getName())));
                item.add(links);
            } else if (isSubmodule) {
                // submodule
                Repository repository = app().repositories().getRepository(repositoryName);
                String submoduleId = JGitUtils.getSubmoduleCommitId(repository, path, entry);
                repository.close();
                if (StringUtils.isEmpty(submoduleId)) {
                    // not a submodule at this commit, just a matching path
                    item.add(new Label("hashLabel").setVisible(false));
                    item.add(new Label("hashLink").setVisible(false));
                } else {
                    // really a submodule
                    item.add(new Label("hashLabel", submodulePath + "@"));
                    LinkPanel commitHash = new LinkPanel("hashLink", null, submoduleId.substring(0, hashLen),
                            TreePage.class, WicketUtils.newObjectParameter(submodulePath, submoduleId));
                    WicketUtils.setCssClass(commitHash, "shortsha1");
                    WicketUtils.setHtmlTooltip(commitHash, submoduleId);
                    item.add(commitHash.setEnabled(hasSubmodule));
                }
                Fragment links = new Fragment("historyLinks", "treeLinks", HistoryPanel.this);
                links.add(new BookmarkablePageLink<Void>("commitdiff", CommitDiffPage.class,
                        WicketUtils.newObjectParameter(repositoryName, entry.getName())));
                item.add(links);
            } else {
                // commit
                item.add(new Label("hashLabel", getString("gb.blob") + "@"));
                LinkPanel commitHash = new LinkPanel("hashLink", null, entry.getName().substring(0, hashLen),
                        BlobPage.class, WicketUtils.newPathParameter(repositoryName, entry.getName(), path));
                WicketUtils.setCssClass(commitHash, "sha1");
                WicketUtils.setHtmlTooltip(commitHash, entry.getName());
                item.add(commitHash);

                Fragment links = new Fragment("historyLinks", "blobLinks", HistoryPanel.this);
                links.add(new BookmarkablePageLink<Void>("commitdiff", CommitDiffPage.class,
                        WicketUtils.newObjectParameter(repositoryName, entry.getName())));
                links.add(new BookmarkablePageLink<Void>("difftocurrent", BlobDiffPage.class,
                        WicketUtils.newBlobDiffParameter(repositoryName, entry.getName(), objectId, path))
                                .setEnabled(counter > 0));
                item.add(links);
            }

            WicketUtils.setAlternatingBackground(item, counter);
            counter++;
        }
    };
    add(logView);

    // determine to show pager, more, or neither
    if (limit <= 0) {
        // no display limit
        add(new Label("moreHistory", "").setVisible(false));
    } else {
        if (pageResults) {
            // paging
            add(new Label("moreHistory", "").setVisible(false));
        } else {
            // more
            if (commits.size() == limit) {
                // show more
                add(new LinkPanel("moreHistory", "link", new StringResourceModel("gb.moreHistory", this, null),
                        HistoryPage.class, WicketUtils.newPathParameter(repositoryName, objectId, path)));
            } else {
                // no more
                add(new Label("moreHistory", "").setVisible(false));
            }
        }
    }
}

From source file:com.microsoft.gittf.core.tasks.FetchTaskTest.java

License:Open Source License

@Test
public void testFetchDeep() throws Exception {
    URI projectCollectionURI = new URI("http://fakeCollection:8080/tfs/DefaultCollection"); //$NON-NLS-1$
    String tfsPath = "$/project"; //$NON-NLS-1$
    String gitRepositoryPath = Util.getRepositoryFile(getName()).getAbsolutePath();

    final MockVersionControlService mockVersionControlService = new MockVersionControlService();

    mockVersionControlService.AddFile("$/project/folder/file0.txt", 1); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder2/file0.txt", 1); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder/nestedFolder/file0.txt", 1); //$NON-NLS-1$

    mockVersionControlService.AddFile("$/project/folder/file1.txt", 2); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder2/file1.txt", 2); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder/nestedFolder/file1.txt", 2); //$NON-NLS-1$

    mockVersionControlService.AddFile("$/project/folder/file2.txt", 3); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder2/file2.txt", 3); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder/nestedFolder/file2.txt", 3); //$NON-NLS-1$

    Calendar date = Calendar.getInstance();
    date.set(2012, 11, 12, 18, 15);//ww w . ja  va 2s.c  o m

    MockChangesetProperties changesetProperties = new MockChangesetProperties("ownerDisplayName", //$NON-NLS-1$
            "ownerName", //$NON-NLS-1$
            "committerDisplayName", //$NON-NLS-1$
            "committerName", //$NON-NLS-1$
            "comment", //$NON-NLS-1$
            date);
    mockVersionControlService.updateChangesetInformation(changesetProperties, 3);

    final Repository repository = RepositoryUtil.createNewRepository(gitRepositoryPath, false);

    CloneTask cloneTask = new CloneTask(projectCollectionURI, mockVersionControlService, tfsPath, repository);
    TaskStatus cloneTaskStatus = cloneTask.run(new NullTaskProgressMonitor());

    // Verify task completed without errors
    assertTrue(cloneTaskStatus.isOK());

    // Update some files
    mockVersionControlService.AddFile("$/project/folder/file1.txt", 4); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder2/file1.txt", 4); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder/nestedFolder/file1.txt", 4); //$NON-NLS-1$

    MockChangesetProperties changesetProperties2 = new MockChangesetProperties("ownerDisplayName4", //$NON-NLS-1$
            "ownerName4", //$NON-NLS-1$
            "committerDisplayName4", //$NON-NLS-1$
            "committerName4", //$NON-NLS-1$
            "comment4", //$NON-NLS-1$
            date);
    mockVersionControlService.updateChangesetInformation(changesetProperties2, 4);

    mockVersionControlService.AddFile("$/project/folder/file1.txt", 5); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder2/file1.txt", 5); //$NON-NLS-1$
    mockVersionControlService.AddFile("$/project/folder/nestedFolder/file1.txt", 5); //$NON-NLS-1$

    MockChangesetProperties changesetProperties3 = new MockChangesetProperties("ownerDisplayName5", //$NON-NLS-1$
            "ownerName5", //$NON-NLS-1$
            "committerDisplayName5", //$NON-NLS-1$
            "committerName5", //$NON-NLS-1$
            "comment5", //$NON-NLS-1$
            date);
    mockVersionControlService.updateChangesetInformation(changesetProperties3, 5);

    FetchTask fetchTask = new FetchTask(repository, mockVersionControlService);
    fetchTask.setDeep(true);
    TaskStatus fetchTaskStatus = fetchTask.run(new NullTaskProgressMonitor());

    // Verify task completed without errors
    assertTrue(fetchTaskStatus.isOK());

    // Retrieve commits
    Ref fetchHeadRef = repository.getRef(Constants.FETCH_HEAD);
    Ref headRef = repository.getRef(Constants.HEAD);

    assertNotNull(fetchHeadRef);
    assertNotNull(headRef);

    ObjectId fetchHeadCommitID = fetchHeadRef.getObjectId();
    ObjectId headCommitID = headRef.getObjectId();

    RevWalk revWalk = new RevWalk(repository);
    RevCommit fetchedCommit = revWalk.parseCommit(fetchHeadCommitID);
    RevCommit headCommit = revWalk.parseCommit(headCommitID);

    assertEquals(fetchedCommit.getParentCount(), 1);

    RevCommit intermediateCommit = revWalk.parseCommit(fetchedCommit.getParent(0).getId());

    // Verify intermediateCommit
    assertEquals(intermediateCommit.getFullMessage(), "comment4"); //$NON-NLS-1$

    PersonIdent ownwer = intermediateCommit.getAuthorIdent();
    assertEquals(ownwer.getEmailAddress(), "ownerName4"); //$NON-NLS-1$
    assertEquals(ownwer.getName(), "ownerDisplayName4"); //$NON-NLS-1$

    PersonIdent committer = intermediateCommit.getCommitterIdent();
    assertEquals(committer.getEmailAddress(), "committerName4"); //$NON-NLS-1$
    assertEquals(committer.getName(), "committerDisplayName4"); //$NON-NLS-1$

    // Verify fetch_head commit
    assertEquals(fetchedCommit.getFullMessage(), "comment5"); //$NON-NLS-1$

    ownwer = fetchedCommit.getAuthorIdent();
    assertEquals(ownwer.getEmailAddress(), "ownerName5"); //$NON-NLS-1$
    assertEquals(ownwer.getName(), "ownerDisplayName5"); //$NON-NLS-1$

    committer = fetchedCommit.getCommitterIdent();
    assertEquals(committer.getEmailAddress(), "committerName5"); //$NON-NLS-1$
    assertEquals(committer.getName(), "committerDisplayName5"); //$NON-NLS-1$

    // Verify the file content
    TreeWalk treeWalk = new TreeWalk(repository);
    treeWalk.setRecursive(true);

    treeWalk.addTree(headCommit.getTree());
    treeWalk.addTree(intermediateCommit.getTree());

    treeWalk.setFilter(TreeFilter.ANY_DIFF);

    int count = 0;
    while (treeWalk.next()) {
        ObjectId fileObjectId = treeWalk.getObjectId(1);
        byte[] fileContent = repository.getObjectDatabase().open(fileObjectId, OBJ_BLOB).getBytes();

        switch (count) {
        case 0:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent, "$/project/folder/file1.txt", //$NON-NLS-1$
                    4));
            break;
        case 2:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent, "$/project/folder2/file1.txt", //$NON-NLS-1$
                    4));
            break;
        case 1:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent,
                    "$/project/folder/nestedFolder/file1.txt", //$NON-NLS-1$
                    4));
            break;
        }

        count++;
    }

    treeWalk.reset();
    treeWalk.setRecursive(true);

    treeWalk.addTree(headCommit.getTree());
    treeWalk.addTree(fetchedCommit.getTree());

    treeWalk.setFilter(TreeFilter.ANY_DIFF);

    count = 0;
    while (treeWalk.next()) {
        ObjectId fileObjectId = treeWalk.getObjectId(1);
        byte[] fileContent = repository.getObjectDatabase().open(fileObjectId, OBJ_BLOB).getBytes();

        switch (count) {
        case 0:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent, "$/project/folder/file1.txt", //$NON-NLS-1$
                    5));
            break;
        case 2:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent, "$/project/folder2/file1.txt", //$NON-NLS-1$
                    5));
            break;
        case 1:
            assertTrue(mockVersionControlService.verifyFileContent(fileContent,
                    "$/project/folder/nestedFolder/file1.txt", //$NON-NLS-1$
                    5));
            break;
        }

        count++;
    }

    Git git = new Git(repository);

    // Verify the tags
    List<Ref> tags = git.tagList().call();
    assertEquals(3, tags.size());
}

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

License:Open Source License

public static void fixFileAttributes(final Repository repository) throws IOException {
    if (Platform.isCurrentPlatform(Platform.GENERIC_UNIX)) {
        final TreeWalk treeWalk = new NameConflictTreeWalk(repository);
        final Ref headReference = repository.getRef(Constants.HEAD);
        final RevCommit headCommit = new RevWalk(repository).parseCommit(headReference.getObjectId());

        treeWalk.setRecursive(true);//from w w  w .  j  a v a 2  s .  com
        treeWalk.addTree(headCommit.getTree().getId());
        treeWalk.setFilter(TreeFilter.ANY_DIFF);

        final File workingDirectory = repository.getWorkTree();

        while (treeWalk.next()) {
            final FileMode fileMode = treeWalk.getFileMode(0);

            if (FileMode.EXECUTABLE_FILE == fileMode) {
                final File file = new File(workingDirectory, treeWalk.getPathString());
                log.debug("Executable: " + file.getAbsolutePath());

                final FileSystemAttributes attr = FileSystemUtils.getInstance().getAttributes(file);

                attr.setExecutable(true);
                FileSystemUtils.getInstance().setAttributes(file, attr);
            }
        }

        treeWalk.reset();
    }
}

From source file:de.codesourcery.gittimelapse.GitHelper.java

License:Apache License

private Set<String> getFilesInCommit(RevCommit commit) throws IOException {
    if (commit == null) {
        throw new IllegalArgumentException("commit must not be NULL");
    }//from   w  w w.j a  v  a  2s.co  m

    List<PathChangeModel> list = new ArrayList<>();

    final RevWalk rw = new RevWalk(repository);
    try {
        if (commit.getParentCount() == 0) {
            TreeWalk tw = new TreeWalk(repository);
            tw.reset();
            tw.setRecursive(true);
            tw.addTree(commit.getTree());
            while (tw.next()) {
                list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), 0, tw.getRawMode(0),
                        tw.getObjectId(0).getName(), commit.getId().getName(), ChangeType.ADD));
            }
            tw.release();
        } else {
            RevCommit parent = rw.parseCommit(commit.getParent(0).getId());

            final ByteArrayOutputStream out = new ByteArrayOutputStream();
            final DiffFormatter df = new DiffFormatter(out);
            df.setRepository(repository);
            df.setDiffComparator(RawTextComparator.DEFAULT);
            df.setDetectRenames(false);

            final List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
            for (DiffEntry diff : diffs) {
                // create the path change model
                PathChangeModel pcm = PathChangeModel.from(diff, commit.getName());
                list.add(pcm);
            }
        }
    } finally {
        rw.dispose();
    }
    Set<String> result = new HashSet<>();
    for (PathChangeModel model : list) {
        if (model.isFile()) {
            result.add(model.path);
        }
    }
    return result;
}

From source file:io.fabric8.forge.rest.git.RepositoryResource.java

License:Apache License

protected List<CommitTreeInfo> doGetCommitTree(Git git, String commitId) {
    Repository repository = git.getRepository();
    List<CommitTreeInfo> list = new ArrayList<CommitTreeInfo>();
    RevCommit commit = CommitUtils.getCommit(repository, commitId);
    if (commit != null) {
        RevWalk rw = new RevWalk(repository);
        try {/*from w ww  .  ja va2  s  . c  o  m*/
            if (commit.getParentCount() == 0) {
                TreeWalk treeWalk = new TreeWalk(repository);
                treeWalk.reset();
                treeWalk.setRecursive(true);
                treeWalk.addTree(commit.getTree());
                while (treeWalk.next()) {
                    String pathString = treeWalk.getPathString();
                    ObjectId objectId = treeWalk.getObjectId(0);
                    int rawMode = treeWalk.getRawMode(0);
                    list.add(new CommitTreeInfo(pathString, pathString, 0, rawMode, objectId.getName(),
                            commit.getId().getName(), DiffEntry.ChangeType.ADD));
                }
                treeWalk.close();
            } else {
                RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
                DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
                df.setRepository(repository);
                df.setDiffComparator(RawTextComparator.DEFAULT);
                df.setDetectRenames(true);
                List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
                for (DiffEntry diff : diffs) {
                    String objectId = diff.getNewId().name();
                    if (diff.getChangeType().equals(DiffEntry.ChangeType.DELETE)) {
                        list.add(new CommitTreeInfo(diff.getOldPath(), diff.getOldPath(), 0,
                                diff.getNewMode().getBits(), objectId, commit.getId().getName(),
                                diff.getChangeType()));
                    } else if (diff.getChangeType().equals(DiffEntry.ChangeType.RENAME)) {
                        list.add(new CommitTreeInfo(diff.getOldPath(), diff.getNewPath(), 0,
                                diff.getNewMode().getBits(), objectId, commit.getId().getName(),
                                diff.getChangeType()));
                    } else {
                        list.add(new CommitTreeInfo(diff.getNewPath(), diff.getNewPath(), 0,
                                diff.getNewMode().getBits(), objectId, commit.getId().getName(),
                                diff.getChangeType()));
                    }
                }
            }
        } catch (Throwable e) {
            LOG.warn("Failed to walk tree for commit " + commitId + ". " + e, e);
        } finally {
            rw.dispose();
        }
    }
    return list;
}