Example usage for org.eclipse.jgit.revwalk RevCommit getParents

List of usage examples for org.eclipse.jgit.revwalk RevCommit getParents

Introduction

In this page you can find the example usage for org.eclipse.jgit.revwalk RevCommit getParents.

Prototype

public final RevCommit[] getParents() 

Source Link

Document

Obtain an array of all parents (NOTE - THIS IS NOT A COPY).

Usage

From source file:Node.java

License:Open Source License

public static Node createNode(RevWalk walk, ObjectId id, boolean recur) throws IOException {
    String key = id.getName();//from  w  w  w. ja v a2 s  .  c om
    RevCommit commit;
    Node node;

    if (nodeMap.containsKey(key)) {
        // commit node was already mapped
        node = nodeMap.get(key);
    } else {
        // create new commit node
        commit = walk.parseCommit(id);
        node = new Node(key, commit.getAuthorIdent().getEmailAddress(), commit.getCommitTime(),
                commit.getFullMessage(), commit.getShortMessage());
        node.setBackground(new Color(240, 240, 255));
        node.setForeground(new Color(0, 0, 127));

        if (recur) {
            // add parent nodes
            for (ObjectId parentCommit : commit.getParents())
                node.addParent(Node.createNode(walk, parentCommit, recur));
        }
    }

    return node;
}

From source file:br.edu.ifpb.scm.api.git.Git.java

/**
 * Recupera a referencia do RevCommit/* ww w  . j  a  va 2  s.  co m*/
 *
 * @param repoJGit {@link org.eclipse.jgit.lib.Repository} Repositorio JGit
 * @param commit String
 * @return List {@link List} de de {@link ChangedFiles}
 */
private List<ChangedFiles> getChangedFilesFromSpecifiedVersion(String commit) {
    RevCommit revCommit1 = convertStringToRevCommit(commit);
    //Fluxo alternativo quando chegar no primeiro commit do repositrio
    if (revCommit1.getParentCount() <= 0) {
        return searchDiff(revCommit1, revCommit1);
    }
    //trocado pela chamada de metodos
    RevCommit revCommit2 = convertStringToRevCommit(revCommit1.getParents()[0].getName());
    return searchDiff(revCommit1, revCommit2);
}

From source file:br.edu.ifpb.scm.api.loads.LoaderVersions.java

public static void funcionando(final String commit) throws IOException, GitAPIException {
    org.eclipse.jgit.api.Git git = org.eclipse.jgit.api.Git.open(PATH);
    try (org.eclipse.jgit.lib.Repository repository = git.getRepository()) {
        // The {tree} will return the underlying tree-id instead of the commit-id itself!
        // For a description of what the carets do see e.g. http://www.paulboxley.com/blog/2011/06/git-caret-and-tilde
        // This means we are selecting the parent of the parent of the parent of the parent of current HEAD and
        // take the tree-ish of it
        //id da tree
        // a RevWalk allows to walk over commits based on some filtering that is defined

        ObjectId obj = ObjectId.fromString(commit);
        RevWalk walk = new RevWalk(repository);
        RevCommit revCommit = walk.parseCommit(obj);

        RevCommit[] arra = revCommit.getParents();

        ObjectId obj2 = ObjectId.fromString(arra[0].getName());
        RevWalk walk2 = new RevWalk(repository);
        RevCommit revCommit2 = walk2.parseCommit(obj2);

        ObjectId oldHead = repository.resolve(revCommit2.getTree().getName());
        ObjectId head = repository.resolve(revCommit.getTree().getName());

        //Pegando o codigo de cada commit pra arvore
        System.out.println("Printing diff between tree: " + oldHead.getName() + " and " + head.getName());

        // prepare the two iterators to compute the diff between
        try (ObjectReader reader = repository.newObjectReader()) {
            CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
            oldTreeIter.reset(reader, oldHead);
            CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
            newTreeIter.reset(reader, head);

            // finally get the list of changed files
            try (org.eclipse.jgit.api.Git g = new org.eclipse.jgit.api.Git(repository)) {
                List<DiffEntry> diffs = g.diff().setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
                diffs.stream().forEach((entry) -> {
                    System.out.println("Entry: " + entry);
                });/* www . j a  v a 2  s. c o  m*/
            }
        }
    }

    System.out.println("Done");

}

From source file:com.amd.gerrit.plugins.manifestsubscription.Utilities.java

License:Open Source License

static ObjectId updateManifest(GitRepositoryManager gitRepoManager, MetaDataUpdate.Server metaDataUpdateFactory,
        ChangeHooks changeHooks, String projectName, String refName, Manifest manifest, String manifestSrc,
        String extraCommitMsg, String defaultBranchBase) throws JAXBException, IOException {
    Project.NameKey p = new Project.NameKey(projectName);
    Repository repo = gitRepoManager.openRepository(p);
    MetaDataUpdate update = metaDataUpdateFactory.create(p);
    ObjectId commitId = repo.resolve(refName);
    VersionedManifests vManifests = new VersionedManifests(refName);

    //TODO find a better way to detect no branch
    boolean refExists = true;
    try {/*from   www . jav  a  2 s .  c o m*/
        vManifests.load(update, commitId);
    } catch (Exception e) {
        refExists = false;
    }

    RevCommit commit = null;
    if (refExists) {
        Map<String, Manifest> entry = Maps.newHashMapWithExpectedSize(1);
        entry.put("default.xml", manifest);
        vManifests.setManifests(entry);
        vManifests.setSrcManifestRepo(manifestSrc);
        vManifests.setExtraCommitMsg(extraCommitMsg);
        commit = vManifests.commit(update);
    } else {
        if (defaultBranchBase == null)
            defaultBranchBase = "refs/heads/master";
        vManifests = new VersionedManifests(defaultBranchBase);
        ObjectId cid = repo.resolve(defaultBranchBase);
        try {
            vManifests.load(update, cid);
        } catch (ConfigInvalidException e) {
            e.printStackTrace();
        }
        Map<String, Manifest> entry = Maps.newHashMapWithExpectedSize(1);
        entry.put("default.xml", manifest);
        vManifests.setManifests(entry);
        commit = vManifests.commitToNewRef(update, refName);
    }

    // TODO this may be bug in the MetaDataUpdate or VersionedMetaData
    // May be related:
    // https://code.google.com/p/gerrit/issues/detail?id=2564
    // https://gerrit-review.googlesource.com/55540
    if (commit != null) {
        ObjectId parent = ObjectId.zeroId();

        if (commit.getParents().length > 0) {
            parent = commit.getParent(0).getId();
        }
        changeHooks.doRefUpdatedHook(new Branch.NameKey(p, refName), parent, commit.getId(), null);
        return commit.getId();
    } else {
        log.warn("Failing to commit manifest subscription update:" + "\n\tProject: " + projectName + "\n\tRef: "
                + refName);
    }

    return null;
}

From source file:com.gitblit.git.GitblitReceivePack.java

License:Apache License

/**
 * Instrumentation point where the incoming push event has been parsed,
 * validated, objects created BUT refs have not been updated. You might
 * use this to enforce a branch-write permissions model.
 *///  ww w  . ja  v a 2s .c om
@Override
public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {

    if (commands.size() == 0) {
        // no receive commands to process
        // this can happen if receive pack subclasses intercept and filter
        // the commands
        LOGGER.debug("skipping pre-receive processing, no refs created, updated, or removed");
        return;
    }

    if (repository.isMirror) {
        // repository is a mirror
        for (ReceiveCommand cmd : commands) {
            sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it is a mirror!",
                    repository.name);
        }
        return;
    }

    if (repository.isFrozen) {
        // repository is frozen/readonly
        for (ReceiveCommand cmd : commands) {
            sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it is frozen!",
                    repository.name);
        }
        return;
    }

    if (!repository.isBare) {
        // repository has a working copy
        for (ReceiveCommand cmd : commands) {
            sendRejection(cmd, "Gitblit does not allow pushes to \"{0}\" because it has a working copy!",
                    repository.name);
        }
        return;
    }

    if (!canPush(commands)) {
        // user does not have push permissions
        for (ReceiveCommand cmd : commands) {
            sendRejection(cmd, "User \"{0}\" does not have push permissions for \"{1}\"!", user.username,
                    repository.name);
        }
        return;
    }

    if (repository.accessRestriction.atLeast(AccessRestrictionType.PUSH) && repository.verifyCommitter) {
        // enforce committer verification
        if (StringUtils.isEmpty(user.emailAddress)) {
            // reject the push because the pushing account does not have an email address
            for (ReceiveCommand cmd : commands) {
                sendRejection(cmd,
                        "Sorry, the account \"{0}\" does not have an email address set for committer verification!",
                        user.username);
            }
            return;
        }

        // Optionally enforce that the committer of first parent chain
        // match the account being used to push the commits.
        //
        // This requires all merge commits are executed with the "--no-ff"
        // option to force a merge commit even if fast-forward is possible.
        // This ensures that the chain first parents has the commit
        // identity of the merging user.
        boolean allRejected = false;
        for (ReceiveCommand cmd : commands) {
            String firstParent = null;
            try {
                List<RevCommit> commits = JGitUtils.getRevLog(rp.getRepository(), cmd.getOldId().name(),
                        cmd.getNewId().name());
                for (RevCommit commit : commits) {

                    if (firstParent != null) {
                        if (!commit.getName().equals(firstParent)) {
                            // ignore: commit is right-descendant of a merge
                            continue;
                        }
                    }

                    // update expected next commit id
                    if (commit.getParentCount() == 0) {
                        firstParent = null;
                    } else {
                        firstParent = commit.getParents()[0].getId().getName();
                    }

                    PersonIdent committer = commit.getCommitterIdent();
                    if (!user.is(committer.getName(), committer.getEmailAddress())) {
                        // verification failed
                        String reason = MessageFormat.format(
                                "{0} by {1} <{2}> was not committed by {3} ({4}) <{5}>", commit.getId().name(),
                                committer.getName(),
                                StringUtils.isEmpty(committer.getEmailAddress()) ? "?"
                                        : committer.getEmailAddress(),
                                user.getDisplayName(), user.username, user.emailAddress);
                        LOGGER.warn(reason);
                        cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
                        allRejected &= true;
                        break;
                    } else {
                        allRejected = false;
                    }
                }
            } catch (Exception e) {
                LOGGER.error("Failed to verify commits were made by pushing user", e);
            }
        }

        if (allRejected) {
            // all ref updates rejected, abort
            return;
        }
    }

    for (ReceiveCommand cmd : commands) {
        String ref = cmd.getRefName();
        if (ref.startsWith(Constants.R_HEADS)) {
            switch (cmd.getType()) {
            case UPDATE_NONFASTFORWARD:
            case DELETE:
                // reset branch commit cache on REWIND and DELETE
                CommitCache.instance().clear(repository.name, ref);
                break;
            default:
                break;
            }
        } else if (ref.equals(BranchTicketService.BRANCH)) {
            // ensure pushing user is an administrator OR an owner
            // i.e. prevent ticket tampering
            boolean permitted = user.canAdmin() || repository.isOwner(user.username);
            if (!permitted) {
                sendRejection(cmd, "{0} is not permitted to push to {1}", user.username, ref);
            }
        } else if (ref.startsWith(Constants.R_FOR)) {
            // prevent accidental push to refs/for
            sendRejection(cmd, "{0} is not configured to receive patchsets", repository.name);
        }
    }

    // call pre-receive plugins
    for (ReceiveHook hook : gitblit.getExtensions(ReceiveHook.class)) {
        try {
            hook.onPreReceive(this, commands);
        } catch (Exception e) {
            LOGGER.error("Failed to execute extension", e);
        }
    }

    Set<String> scripts = new LinkedHashSet<String>();
    scripts.addAll(gitblit.getPreReceiveScriptsInherited(repository));
    if (!ArrayUtils.isEmpty(repository.preReceiveScripts)) {
        scripts.addAll(repository.preReceiveScripts);
    }
    runGroovy(commands, scripts);
    for (ReceiveCommand cmd : commands) {
        if (!Result.NOT_ATTEMPTED.equals(cmd.getResult())) {
            LOGGER.warn(MessageFormat.format("{0} {1} because \"{2}\"", cmd.getNewId().getName(),
                    cmd.getResult(), cmd.getMessage()));
        }
    }
}

From source file:com.gitblit.git.ReceiveHook.java

License:Apache License

/**
 * Instrumentation point where the incoming push event has been parsed,
 * validated, objects created BUT refs have not been updated. You might
 * use this to enforce a branch-write permissions model.
 *///from   www.  j av  a 2  s . c o m
@Override
public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
    if (repository.isFrozen) {
        // repository is frozen/readonly
        String reason = MessageFormat.format("Gitblit does not allow pushes to \"{0}\" because it is frozen!",
                repository.name);
        logger.warn(reason);
        for (ReceiveCommand cmd : commands) {
            cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
        }
        return;
    }

    if (!repository.isBare) {
        // repository has a working copy
        String reason = MessageFormat.format(
                "Gitblit does not allow pushes to \"{0}\" because it has a working copy!", repository.name);
        logger.warn(reason);
        for (ReceiveCommand cmd : commands) {
            cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
        }
        return;
    }

    if (!user.canPush(repository)) {
        // user does not have push permissions
        String reason = MessageFormat.format("User \"{0}\" does not have push permissions for \"{1}\"!",
                user.username, repository.name);
        logger.warn(reason);
        for (ReceiveCommand cmd : commands) {
            cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
        }
        return;
    }

    if (repository.accessRestriction.atLeast(AccessRestrictionType.PUSH) && repository.verifyCommitter) {
        // enforce committer verification
        if (StringUtils.isEmpty(user.emailAddress)) {
            // emit warning if user does not have an email address 
            logger.warn(MessageFormat.format(
                    "Consider setting an email address for {0} ({1}) to improve committer verification.",
                    user.getDisplayName(), user.username));
        }

        // Optionally enforce that the committer of the left parent chain
        // match the account being used to push the commits.
        // 
        // This requires all merge commits are executed with the "--no-ff"
        // option to force a merge commit even if fast-forward is possible.
        // This ensures that the chain of left parents has the commit
        // identity of the merging user.
        boolean allRejected = false;
        for (ReceiveCommand cmd : commands) {
            String linearParent = null;
            try {
                List<RevCommit> commits = JGitUtils.getRevLog(rp.getRepository(), cmd.getOldId().name(),
                        cmd.getNewId().name());
                for (RevCommit commit : commits) {

                    if (linearParent != null) {
                        if (!commit.getName().equals(linearParent)) {
                            // ignore: commit is right-descendant of a merge
                            continue;
                        }
                    }

                    // update expected next commit id
                    if (commit.getParentCount() == 0) {
                        linearParent = null;
                    } else {
                        linearParent = commit.getParents()[0].getId().getName();
                    }

                    PersonIdent committer = commit.getCommitterIdent();
                    if (!user.is(committer.getName(), committer.getEmailAddress())) {
                        String reason;
                        if (StringUtils.isEmpty(user.emailAddress)) {
                            // account does not have an email address
                            reason = MessageFormat.format("{0} by {1} <{2}> was not committed by {3} ({4})",
                                    commit.getId().name(), committer.getName(),
                                    StringUtils.isEmpty(committer.getEmailAddress()) ? "?"
                                            : committer.getEmailAddress(),
                                    user.getDisplayName(), user.username);
                        } else {
                            // account has an email address
                            reason = MessageFormat.format(
                                    "{0} by {1} <{2}> was not committed by {3} ({4}) <{5}>",
                                    commit.getId().name(), committer.getName(),
                                    StringUtils.isEmpty(committer.getEmailAddress()) ? "?"
                                            : committer.getEmailAddress(),
                                    user.getDisplayName(), user.username, user.emailAddress);
                        }
                        logger.warn(reason);
                        cmd.setResult(Result.REJECTED_OTHER_REASON, reason);
                        allRejected &= true;
                        break;
                    } else {
                        allRejected = false;
                    }
                }
            } catch (Exception e) {
                logger.error("Failed to verify commits were made by pushing user", e);
            }
        }

        if (allRejected) {
            // all ref updates rejected, abort
            return;
        }
    }

    // reset branch commit cache on REWIND and DELETE
    for (ReceiveCommand cmd : commands) {
        String ref = cmd.getRefName();
        if (ref.startsWith(Constants.R_HEADS)) {
            switch (cmd.getType()) {
            case UPDATE_NONFASTFORWARD:
            case DELETE:
                CommitCache.instance().clear(repository.name, ref);
                break;
            default:
                break;
            }
        }
    }

    Set<String> scripts = new LinkedHashSet<String>();
    scripts.addAll(GitBlit.self().getPreReceiveScriptsInherited(repository));
    if (!ArrayUtils.isEmpty(repository.preReceiveScripts)) {
        scripts.addAll(repository.preReceiveScripts);
    }
    runGroovy(repository, user, commands, rp, scripts);
    for (ReceiveCommand cmd : commands) {
        if (!Result.NOT_ATTEMPTED.equals(cmd.getResult())) {
            logger.warn(MessageFormat.format("{0} {1} because \"{2}\"", cmd.getNewId().getName(),
                    cmd.getResult(), cmd.getMessage()));
        }
    }
}

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

License:Apache License

/**
 * Generates the feed content.//w  ww.  j a  v a2s.co m
 *
 * @param request
 * @param response
 * @throws javax.servlet.ServletException
 * @throws java.io.IOException
 */
private void processRequest(javax.servlet.http.HttpServletRequest request,
        javax.servlet.http.HttpServletResponse response)
        throws javax.servlet.ServletException, java.io.IOException {

    String servletUrl = request.getContextPath() + request.getServletPath();
    String url = request.getRequestURI().substring(servletUrl.length());
    if (url.length() > 1 && url.charAt(0) == '/') {
        url = url.substring(1);
    }
    String repositoryName = url;
    String objectId = request.getParameter("h");
    String l = request.getParameter("l");
    String page = request.getParameter("pg");
    String searchString = request.getParameter("s");
    Constants.SearchType searchType = Constants.SearchType.COMMIT;
    if (!StringUtils.isEmpty(request.getParameter("st"))) {
        Constants.SearchType type = Constants.SearchType.forName(request.getParameter("st"));
        if (type != null) {
            searchType = type;
        }
    }

    Constants.FeedObjectType objectType = Constants.FeedObjectType.COMMIT;
    if (!StringUtils.isEmpty(request.getParameter("ot"))) {
        Constants.FeedObjectType type = Constants.FeedObjectType.forName(request.getParameter("ot"));
        if (type != null) {
            objectType = type;
        }
    }

    int length = settings.getInteger(Keys.web.syndicationEntries, 25);
    if (StringUtils.isEmpty(objectId)) {
        objectId = org.eclipse.jgit.lib.Constants.HEAD;
    }
    if (!StringUtils.isEmpty(l)) {
        try {
            length = Integer.parseInt(l);
        } catch (NumberFormatException x) {
        }
    }
    int offset = 0;
    if (!StringUtils.isEmpty(page)) {
        try {
            offset = length * Integer.parseInt(page);
        } catch (NumberFormatException x) {
        }
    }

    response.setContentType("application/rss+xml; charset=UTF-8");

    boolean isProjectFeed = false;
    String feedName = "Gitblit";
    String feedTitle = null;
    String feedDescription = null;

    List<String> repositories = null;
    if (repositoryName.indexOf('/') == -1 && !repositoryName.toLowerCase().endsWith(".git")) {
        // try to find a project
        UserModel user = null;
        if (request instanceof AuthenticatedRequest) {
            user = ((AuthenticatedRequest) request).getUser();
        }
        ProjectModel project = projectManager.getProjectModel(repositoryName, user);
        if (project != null) {
            isProjectFeed = true;
            repositories = new ArrayList<String>(project.repositories);

            // project feed
            feedName = project.name;
            feedTitle = project.title;
            feedDescription = project.description;
        }
    }

    if (repositories == null) {
        // could not find project, assume this is a repository
        repositories = Arrays.asList(repositoryName);
    }

    boolean mountParameters = settings.getBoolean(Keys.web.mountParameters, true);

    String gitblitUrl = settings.getString(Keys.web.canonicalUrl, null);
    if (StringUtils.isEmpty(gitblitUrl)) {
        gitblitUrl = HttpUtils.getGitblitURL(request);
    }
    char fsc = settings.getChar(Keys.web.forwardSlashCharacter, '/');

    List<FeedEntryModel> entries = new ArrayList<FeedEntryModel>();

    for (String name : repositories) {
        Repository repository = repositoryManager.getRepository(name);
        RepositoryModel model = repositoryManager.getRepositoryModel(name);

        if (repository == null) {
            if (model != null && model.isCollectingGarbage) {
                logger.warn(MessageFormat.format("Temporarily excluding {0} from feed, busy collecting garbage",
                        name));
            }
            continue;
        }
        if (!isProjectFeed) {
            // single-repository feed
            feedName = model.name;
            feedTitle = model.name;
            feedDescription = model.description;
        }

        if (objectType == Constants.FeedObjectType.TAG) {

            String urlPattern;
            if (mountParameters) {
                // mounted parameters
                urlPattern = "{0}/tag/{1}/{2}";
            } else {
                // parameterized parameters
                urlPattern = "{0}/tag/?r={1}&h={2}";
            }

            List<RefModel> tags = JGitUtils.getTags(repository, false, length, offset);

            for (RefModel tag : tags) {
                FeedEntryModel entry = new FeedEntryModel();
                entry.title = tag.getName();
                entry.author = tag.getAuthorIdent().getName();
                entry.link = MessageFormat.format(urlPattern, gitblitUrl,
                        StringUtils.encodeURL(model.name.replace('/', fsc)), tag.getObjectId().getName());
                entry.published = tag.getDate();
                entry.contentType = "text/html";
                entry.content = tag.getFullMessage();
                entry.repository = model.name;
                entry.branch = objectId;

                entry.tags = new ArrayList<String>();

                // add tag id and referenced commit id
                entry.tags.add("tag:" + tag.getObjectId().getName());
                entry.tags.add("commit:" + tag.getReferencedObjectId().getName());

                entries.add(entry);
            }
        } else {

            String urlPattern;
            if (mountParameters) {
                // mounted parameters
                urlPattern = "{0}/commit/{1}/{2}";
            } else {
                // parameterized parameters
                urlPattern = "{0}/commit/?r={1}&h={2}";
            }

            List<RevCommit> commits;
            if (StringUtils.isEmpty(searchString)) {
                // standard log/history lookup
                commits = JGitUtils.getRevLog(repository, objectId, offset, length);
            } else {
                // repository search
                commits = JGitUtils.searchRevlogs(repository, objectId, searchString, searchType, offset,
                        length);
            }
            Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository, model.showRemoteBranches);
            BugtraqProcessor processor = new BugtraqProcessor(settings);

            // convert RevCommit to SyndicatedEntryModel
            for (RevCommit commit : commits) {
                FeedEntryModel entry = new FeedEntryModel();
                entry.title = commit.getShortMessage();
                entry.author = commit.getAuthorIdent().getName();
                entry.link = MessageFormat.format(urlPattern, gitblitUrl,
                        StringUtils.encodeURL(model.name.replace('/', fsc)), commit.getName());
                entry.published = commit.getCommitterIdent().getWhen();
                entry.contentType = "text/html";
                String message = processor.processCommitMessage(repository, model, commit.getFullMessage());
                entry.content = message;
                entry.repository = model.name;
                entry.branch = objectId;
                entry.tags = new ArrayList<String>();

                // add commit id and parent commit ids
                entry.tags.add("commit:" + commit.getName());
                for (RevCommit parent : commit.getParents()) {
                    entry.tags.add("parent:" + parent.getName());
                }

                // add refs to tabs list
                List<RefModel> refs = allRefs.get(commit.getId());
                if (refs != null && refs.size() > 0) {
                    for (RefModel ref : refs) {
                        entry.tags.add("ref:" + ref.getName());
                    }
                }
                entries.add(entry);
            }
        }
    }

    // sort & truncate the feed
    Collections.sort(entries);
    if (entries.size() > length) {
        // clip the list
        entries = entries.subList(0, length);
    }

    String feedLink;
    if (isProjectFeed) {
        // project feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/project/{1}", gitblitUrl, StringUtils.encodeURL(feedName));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/project/?p={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    } else {
        // repository feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/summary/{1}", gitblitUrl,
                    StringUtils.encodeURL(feedName.replace('/', fsc)));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/summary/?r={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    }

    try {
        SyndicationUtils.toRSS(gitblitUrl, feedLink, getTitle(feedTitle, objectId), feedDescription, entries,
                response.getOutputStream());
    } catch (Exception e) {
        logger.error("An error occurred during feed generation", e);
    }
}

From source file:com.gitblit.SyndicationServlet.java

License:Apache License

/**
 * Generates the feed content./*from  ww w .  j a v a2s . c  om*/
 * 
 * @param request
 * @param response
 * @throws javax.servlet.ServletException
 * @throws java.io.IOException
 */
private void processRequest(javax.servlet.http.HttpServletRequest request,
        javax.servlet.http.HttpServletResponse response)
        throws javax.servlet.ServletException, java.io.IOException {

    String servletUrl = request.getContextPath() + request.getServletPath();
    String url = request.getRequestURI().substring(servletUrl.length());
    if (url.charAt(0) == '/' && url.length() > 1) {
        url = url.substring(1);
    }
    String repositoryName = url;
    String objectId = request.getParameter("h");
    String l = request.getParameter("l");
    String page = request.getParameter("pg");
    String searchString = request.getParameter("s");
    Constants.SearchType searchType = Constants.SearchType.COMMIT;
    if (!StringUtils.isEmpty(request.getParameter("st"))) {
        Constants.SearchType type = Constants.SearchType.forName(request.getParameter("st"));
        if (type != null) {
            searchType = type;
        }
    }
    int length = GitBlit.getInteger(Keys.web.syndicationEntries, 25);
    if (StringUtils.isEmpty(objectId)) {
        objectId = org.eclipse.jgit.lib.Constants.HEAD;
    }
    if (!StringUtils.isEmpty(l)) {
        try {
            length = Integer.parseInt(l);
        } catch (NumberFormatException x) {
        }
    }
    int offset = 0;
    if (!StringUtils.isEmpty(page)) {
        try {
            offset = length * Integer.parseInt(page);
        } catch (NumberFormatException x) {
        }
    }

    response.setContentType("application/rss+xml; charset=UTF-8");

    boolean isProjectFeed = false;
    String feedName = null;
    String feedTitle = null;
    String feedDescription = null;

    List<String> repositories = null;
    if (repositoryName.indexOf('/') == -1 && !repositoryName.toLowerCase().endsWith(".git")) {
        // try to find a project
        UserModel user = null;
        if (request instanceof AuthenticatedRequest) {
            user = ((AuthenticatedRequest) request).getUser();
        }
        ProjectModel project = GitBlit.self().getProjectModel(repositoryName, user);
        if (project != null) {
            isProjectFeed = true;
            repositories = new ArrayList<String>(project.repositories);

            // project feed
            feedName = project.name;
            feedTitle = project.title;
            feedDescription = project.description;
        }
    }

    if (repositories == null) {
        // could not find project, assume this is a repository
        repositories = Arrays.asList(repositoryName);
    }

    boolean mountParameters = GitBlit.getBoolean(Keys.web.mountParameters, true);
    String urlPattern;
    if (mountParameters) {
        // mounted parameters
        urlPattern = "{0}/commit/{1}/{2}";
    } else {
        // parameterized parameters
        urlPattern = "{0}/commit/?r={1}&h={2}";
    }
    String gitblitUrl = HttpUtils.getGitblitURL(request);
    char fsc = GitBlit.getChar(Keys.web.forwardSlashCharacter, '/');

    List<FeedEntryModel> entries = new ArrayList<FeedEntryModel>();

    for (String name : repositories) {
        Repository repository = GitBlit.self().getRepository(name);
        RepositoryModel model = GitBlit.self().getRepositoryModel(name);

        if (!isProjectFeed) {
            // single-repository feed
            feedName = model.name;
            feedTitle = model.name;
            feedDescription = model.description;
        }

        List<RevCommit> commits;
        if (StringUtils.isEmpty(searchString)) {
            // standard log/history lookup
            commits = JGitUtils.getRevLog(repository, objectId, offset, length);
        } else {
            // repository search
            commits = JGitUtils.searchRevlogs(repository, objectId, searchString, searchType, offset, length);
        }
        Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository, model.showRemoteBranches);

        // convert RevCommit to SyndicatedEntryModel
        for (RevCommit commit : commits) {
            FeedEntryModel entry = new FeedEntryModel();
            entry.title = commit.getShortMessage();
            entry.author = commit.getAuthorIdent().getName();
            entry.link = MessageFormat.format(urlPattern, gitblitUrl,
                    StringUtils.encodeURL(model.name.replace('/', fsc)), commit.getName());
            entry.published = commit.getCommitterIdent().getWhen();
            entry.contentType = "text/html";
            String message = GitBlit.self().processCommitMessage(model.name, commit.getFullMessage());
            entry.content = message;
            entry.repository = model.name;
            entry.branch = objectId;
            entry.tags = new ArrayList<String>();

            // add commit id and parent commit ids
            entry.tags.add("commit:" + commit.getName());
            for (RevCommit parent : commit.getParents()) {
                entry.tags.add("parent:" + parent.getName());
            }

            // add refs to tabs list
            List<RefModel> refs = allRefs.get(commit.getId());
            if (refs != null && refs.size() > 0) {
                for (RefModel ref : refs) {
                    entry.tags.add("ref:" + ref.getName());
                }
            }
            entries.add(entry);
        }
    }

    // sort & truncate the feed
    Collections.sort(entries);
    if (entries.size() > length) {
        // clip the list
        entries = entries.subList(0, length);
    }

    String feedLink;
    if (isProjectFeed) {
        // project feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/project/{1}", gitblitUrl, StringUtils.encodeURL(feedName));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/project/?p={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    } else {
        // repository feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/summary/{1}", gitblitUrl, StringUtils.encodeURL(feedName));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/summary/?r={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    }

    try {
        SyndicationUtils.toRSS(gitblitUrl, feedLink, getTitle(feedTitle, objectId), feedDescription, entries,
                response.getOutputStream());
    } catch (Exception e) {
        logger.error("An error occurred during feed generation", e);
    }
}

From source file:com.gitblit.wicket.pages.CommitDiffPage.java

License:Apache License

public CommitDiffPage(PageParameters params) {
    super(params);

    final Repository r = getRepository();
    final RevCommit commit = getCommit();
    final DiffComparator diffComparator = WicketUtils.getDiffComparator(params);

    List<String> parents = new ArrayList<String>();
    if (commit.getParentCount() > 0) {
        for (RevCommit parent : commit.getParents()) {
            parents.add(parent.name());/*  www .  j  av a 2  s.  co  m*/
        }
    }

    // commit page links
    if (parents.size() == 0) {
        add(new Label("parentLink", getString("gb.none")));
    } else {
        add(new LinkPanel("parentLink", null, parents.get(0).substring(0, 8), CommitDiffPage.class,
                newCommitParameter(parents.get(0))));
    }
    add(new BookmarkablePageLink<Void>("patchLink", PatchPage.class,
            WicketUtils.newObjectParameter(repositoryName, objectId)));
    add(new BookmarkablePageLink<Void>("commitLink", CommitPage.class,
            WicketUtils.newObjectParameter(repositoryName, objectId)));
    add(new LinkPanel("whitespaceLink", null, getString(diffComparator.getOpposite().getTranslationKey()),
            CommitDiffPage.class,
            WicketUtils.newDiffParameter(repositoryName, objectId, diffComparator.getOpposite())));

    add(new CommitHeaderPanel("commitHeader", repositoryName, commit));

    final List<String> imageExtensions = app().settings().getStrings(Keys.web.imageExtensions);
    final ImageDiffHandler handler = new ImageDiffHandler(this, repositoryName,
            parents.isEmpty() ? null : parents.get(0), commit.getName(), imageExtensions);
    final int tabLength = app().settings().getInteger(Keys.web.tabLength, 4);
    final DiffOutput diff = DiffUtils.getCommitDiff(r, commit, diffComparator, DiffOutputType.HTML, handler,
            tabLength);
    if (handler.getImgDiffCount() > 0) {
        addBottomScript("scripts/imgdiff.js"); // Tiny support script for image diffs
    }

    // add commit diffstat
    int insertions = 0;
    int deletions = 0;
    for (PathChangeModel pcm : diff.stat.paths) {
        insertions += pcm.insertions;
        deletions += pcm.deletions;
    }
    add(new DiffStatPanel("diffStat", insertions, deletions));

    addFullText("fullMessage", commit.getFullMessage());

    // git notes
    List<GitNote> notes = JGitUtils.getNotesOnCommit(r, commit);
    ListDataProvider<GitNote> notesDp = new ListDataProvider<GitNote>(notes);
    DataView<GitNote> notesView = new DataView<GitNote>("notes", notesDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<GitNote> item) {
            GitNote entry = item.getModelObject();
            item.add(new RefsPanel("refName", repositoryName, Arrays.asList(entry.notesRef)));
            item.add(createPersonPanel("authorName", entry.notesRef.getAuthorIdent(),
                    Constants.SearchType.AUTHOR));
            item.add(new AvatarImage("noteAuthorAvatar", entry.notesRef.getAuthorIdent()));
            item.add(WicketUtils.createTimestampLabel("authorDate", entry.notesRef.getAuthorIdent().getWhen(),
                    getTimeZone(), getTimeUtils()));
            item.add(new Label("noteContent", bugtraqProcessor().processPlainCommitMessage(getRepository(),
                    repositoryName, entry.content)).setEscapeModelStrings(false));
        }
    };
    add(notesView.setVisible(notes.size() > 0));

    // changed paths list
    add(new CommitLegendPanel("commitLegend", diff.stat.paths));
    ListDataProvider<PathChangeModel> pathsDp = new ListDataProvider<PathChangeModel>(diff.stat.paths);
    DataView<PathChangeModel> pathsView = new DataView<PathChangeModel>("changedPath", pathsDp) {
        private static final long serialVersionUID = 1L;
        int counter;

        @Override
        public void populateItem(final Item<PathChangeModel> item) {
            final PathChangeModel entry = item.getModelObject();

            Label changeType = new Label("changeType", "");
            WicketUtils.setChangeTypeCssClass(changeType, entry.changeType);
            setChangeTypeTooltip(changeType, entry.changeType);
            item.add(changeType);
            item.add(new DiffStatPanel("diffStat", entry.insertions, entry.deletions, true));
            item.add(WicketUtils.setHtmlTooltip(new Label("filestore", ""), getString("gb.filestore"))
                    .setVisible(entry.isFilestoreItem()));

            boolean hasSubmodule = false;
            String submodulePath = null;

            if (entry.isTree()) {
                // tree
                item.add(new LinkPanel("pathName", null, entry.path, TreePage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path)));
            } else if (entry.isSubmodule()) {
                // submodule
                String submoduleId = entry.objectId;
                SubmoduleModel submodule = getSubmodule(entry.path);
                submodulePath = submodule.gitblitPath;
                hasSubmodule = submodule.hasSubmodule;

                // add relative link
                item.add(new LinkPanel("pathName", "list", entry.path + " @ " + getShortObjectId(submoduleId),
                        "#n" + entry.objectId));
            } else {
                // add relative link
                if (entry.isFilestoreItem()) {

                    item.add(new LinkPanel("pathName", "list", entry.path, new Link<Object>("link", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {
                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    }));
                } else {
                    item.add(new LinkPanel("pathName", "list", entry.path, "#n" + entry.objectId));
                }
            }

            // quick links
            if (entry.isSubmodule()) {
                item.add(new ExternalLink("raw", "").setEnabled(false));
                // submodule
                item.add(new ExternalLink("patch", "").setEnabled(false));
                item.add(new BookmarkablePageLink<Void>("view", CommitPage.class,
                        WicketUtils.newObjectParameter(submodulePath, entry.objectId))
                                .setEnabled(hasSubmodule));
                item.add(new ExternalLink("blame", "").setEnabled(false));
                item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
            } else {
                // tree or blob
                item.add(new BookmarkablePageLink<Void>("patch", PatchPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)
                                        && !entry.changeType.equals(ChangeType.DELETE)));

                if (entry.isFilestoreItem()) {
                    item.add(new Link<Object>("view", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {

                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    });

                    item.add(new Link<Object>("raw", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {

                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    });
                } else {
                    item.add(new BookmarkablePageLink<Void>("view", BlobPage.class,
                            WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                    .setEnabled(!entry.changeType.equals(ChangeType.DELETE)));

                    item.add(new ExternalLink("raw",
                            RawServlet.asLink(getContextUrl(), repositoryName, entry.commitId, entry.path))
                                    .setEnabled(!entry.changeType.equals(ChangeType.DELETE)));
                }

                item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)
                                        && !entry.changeType.equals(ChangeType.DELETE)));
                item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
            }

            WicketUtils.setAlternatingBackground(item, counter);
            counter++;
        }
    };
    add(pathsView);
    add(new Label("diffText", diff.content).setEscapeModelStrings(false));
}

From source file:com.gitblit.wicket.pages.CommitPage.java

License:Apache License

public CommitPage(PageParameters params) {
    super(params);

    Repository r = getRepository();//from  w ww . j a  v a2  s  . c  o  m
    RevCommit c = getCommit();

    List<String> parents = new ArrayList<String>();
    if (c.getParentCount() > 0) {
        for (RevCommit parent : c.getParents()) {
            parents.add(parent.name());
        }
    }

    // commit page links
    if (parents.size() == 0) {
        add(new Label("parentLink", "none"));
        add(new Label("commitdiffLink", getString("gb.commitdiff")));
    } else {
        add(new LinkPanel("parentLink", null, getShortObjectId(parents.get(0)), CommitPage.class,
                newCommitParameter(parents.get(0))));
        add(new LinkPanel("commitdiffLink", null, new StringResourceModel("gb.commitdiff", this, null),
                CommitDiffPage.class, WicketUtils.newObjectParameter(repositoryName, objectId)));
    }
    add(new BookmarkablePageLink<Void>("patchLink", PatchPage.class,
            WicketUtils.newObjectParameter(repositoryName, objectId)));

    add(new CommitHeaderPanel("commitHeader", repositoryName, c));

    addRefs(r, c);

    // author
    add(createPersonPanel("commitAuthor", c.getAuthorIdent(), Constants.SearchType.AUTHOR));
    add(WicketUtils.createTimestampLabel("commitAuthorDate", c.getAuthorIdent().getWhen(), getTimeZone(),
            getTimeUtils()));

    // committer
    add(createPersonPanel("commitCommitter", c.getCommitterIdent(), Constants.SearchType.COMMITTER));
    add(WicketUtils.createTimestampLabel("commitCommitterDate", c.getCommitterIdent().getWhen(), getTimeZone(),
            getTimeUtils()));

    add(new Label("commitId", c.getName()));

    add(new LinkPanel("commitTree", "list", c.getTree().getName(), TreePage.class, newCommitParameter()));
    add(new BookmarkablePageLink<Void>("treeLink", TreePage.class, newCommitParameter()));
    final String baseUrl = WicketUtils.getGitblitURL(getRequest());

    add(new CompressedDownloadsPanel("compressedLinks", baseUrl, repositoryName, objectId, null));

    // Parent Commits
    ListDataProvider<String> parentsDp = new ListDataProvider<String>(parents);
    DataView<String> parentsView = new DataView<String>("commitParents", parentsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<String> item) {
            String entry = item.getModelObject();
            item.add(new LinkPanel("commitParent", "list", entry, CommitPage.class, newCommitParameter(entry)));
            item.add(new BookmarkablePageLink<Void>("view", CommitPage.class, newCommitParameter(entry)));
            item.add(new BookmarkablePageLink<Void>("diff", CommitDiffPage.class, newCommitParameter(entry)));
        }
    };
    add(parentsView);

    addFullText("fullMessage", c.getFullMessage());

    // git notes
    List<GitNote> notes = JGitUtils.getNotesOnCommit(r, c);
    ListDataProvider<GitNote> notesDp = new ListDataProvider<GitNote>(notes);
    DataView<GitNote> notesView = new DataView<GitNote>("notes", notesDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<GitNote> item) {
            GitNote entry = item.getModelObject();
            item.add(new RefsPanel("refName", repositoryName, Arrays.asList(entry.notesRef)));
            item.add(createPersonPanel("authorName", entry.notesRef.getAuthorIdent(),
                    Constants.SearchType.AUTHOR));
            item.add(new AvatarImage("noteAuthorAvatar", entry.notesRef.getAuthorIdent()));
            item.add(WicketUtils.createTimestampLabel("authorDate", entry.notesRef.getAuthorIdent().getWhen(),
                    getTimeZone(), getTimeUtils()));
            item.add(new Label("noteContent", bugtraqProcessor().processPlainCommitMessage(getRepository(),
                    repositoryName, entry.content)).setEscapeModelStrings(false));
        }
    };
    add(notesView.setVisible(notes.size() > 0));

    // changed paths list
    List<PathChangeModel> paths = JGitUtils.getFilesInCommit(r, c);

    // add commit diffstat
    int insertions = 0;
    int deletions = 0;
    for (PathChangeModel pcm : paths) {
        insertions += pcm.insertions;
        deletions += pcm.deletions;
    }
    add(new DiffStatPanel("diffStat", insertions, deletions));

    add(new CommitLegendPanel("commitLegend", paths));
    ListDataProvider<PathChangeModel> pathsDp = new ListDataProvider<PathChangeModel>(paths);
    DataView<PathChangeModel> pathsView = new DataView<PathChangeModel>("changedPath", pathsDp) {
        private static final long serialVersionUID = 1L;
        int counter;

        @Override
        public void populateItem(final Item<PathChangeModel> item) {
            final PathChangeModel entry = item.getModelObject();

            Label changeType = new Label("changeType", "");
            WicketUtils.setChangeTypeCssClass(changeType, entry.changeType);
            setChangeTypeTooltip(changeType, entry.changeType);
            item.add(changeType);
            item.add(new DiffStatPanel("diffStat", entry.insertions, entry.deletions, true));
            item.add(WicketUtils.setHtmlTooltip(new Label("filestore", ""), getString("gb.filestore"))
                    .setVisible(entry.isFilestoreItem()));

            boolean hasSubmodule = false;
            String submodulePath = null;
            if (entry.isTree()) {
                // tree
                item.add(new LinkPanel("pathName", null, entry.path, TreePage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path)));
            } else if (entry.isSubmodule()) {
                // submodule
                String submoduleId = entry.objectId;
                SubmoduleModel submodule = getSubmodule(entry.path);
                submodulePath = submodule.gitblitPath;
                hasSubmodule = submodule.hasSubmodule;

                item.add(new LinkPanel("pathName", "list", entry.path + " @ " + getShortObjectId(submoduleId),
                        TreePage.class, WicketUtils.newPathParameter(submodulePath, submoduleId, ""))
                                .setEnabled(hasSubmodule));
            } else {
                // blob
                String displayPath = entry.path;
                String path = entry.path;
                if (entry.isSymlink()) {
                    path = JGitUtils.getStringContent(getRepository(), getCommit().getTree(), path);
                    displayPath = entry.path + " -> " + path;
                }

                if (entry.isFilestoreItem()) {
                    item.add(new LinkPanel("pathName", "list", entry.path, new Link<Object>("link", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {

                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    }));

                } else {
                    item.add(new LinkPanel("pathName", "list", displayPath, BlobPage.class,
                            WicketUtils.newPathParameter(repositoryName, entry.commitId, path)));
                }
            }

            // quick links
            if (entry.isSubmodule()) {
                item.add(new ExternalLink("raw", "").setEnabled(false));

                // submodule
                item.add(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
                item.add(new BookmarkablePageLink<Void>("view", CommitPage.class,
                        WicketUtils.newObjectParameter(submodulePath, entry.objectId))
                                .setEnabled(hasSubmodule));
                item.add(new ExternalLink("blame", "").setEnabled(false));
                item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
            } else {
                // tree or blob
                item.add(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)
                                        && !entry.changeType.equals(ChangeType.DELETE)));

                if (entry.isFilestoreItem()) {
                    item.add(new Link<Object>("view", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {

                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    });

                    item.add(new Link<Object>("raw", null) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick() {

                            IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                private static final long serialVersionUID = 1L;

                                @Override
                                public void write(OutputStream output) {
                                    UserModel user = GitBlitWebSession.get().getUser();
                                    user = user == null ? UserModel.ANONYMOUS : user;

                                    app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                            getRepositoryModel(), output);
                                }
                            };

                            ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                    resourceStream, entry.path);
                            getRequestCycle().scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                        }
                    });

                } else {
                    item.add(new BookmarkablePageLink<Void>("view", BlobPage.class,
                            WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                    .setEnabled(!entry.changeType.equals(ChangeType.DELETE)));
                    String rawUrl = RawServlet.asLink(getContextUrl(), repositoryName, entry.commitId,
                            entry.path);
                    item.add(new ExternalLink("raw", rawUrl)
                            .setEnabled(!entry.changeType.equals(ChangeType.DELETE)));
                }
                item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)
                                        && !entry.changeType.equals(ChangeType.DELETE)));
                item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
            }

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