Fixed symlink absolute path/canonical path mixup with JGit (issue 78)

James Moger

2012-03-28 1aa6e081ffe319ff3ddfa246783cb65dc1c71b3b

 src/com/gitblit/utils/JGitUtils.java

@@ -21,9 +21,9 @@
import java.io.InputStream;

import java.io.OutputStream;

import java.nio.charset.Charset;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

@@ -44,23 +44,30 @@
import org.eclipse.jgit.errors.IncorrectObjectTypeException;

import org.eclipse.jgit.errors.MissingObjectException;

import org.eclipse.jgit.errors.StopWalkException;

import org.eclipse.jgit.lib.CommitBuilder;

import org.eclipse.jgit.lib.Constants;

import org.eclipse.jgit.lib.FileMode;

import org.eclipse.jgit.lib.ObjectId;

import org.eclipse.jgit.lib.ObjectInserter;

import org.eclipse.jgit.lib.ObjectLoader;

import org.eclipse.jgit.lib.PersonIdent;

import org.eclipse.jgit.lib.Ref;

import org.eclipse.jgit.lib.RefUpdate;

import org.eclipse.jgit.lib.RefUpdate.Result;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.lib.RepositoryCache.FileKey;

import org.eclipse.jgit.lib.StoredConfig;

import org.eclipse.jgit.lib.TreeFormatter;

import org.eclipse.jgit.revwalk.RevBlob;

import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.jgit.revwalk.RevObject;

import org.eclipse.jgit.revwalk.RevSort;

import org.eclipse.jgit.revwalk.RevTree;

import org.eclipse.jgit.revwalk.RevWalk;

import org.eclipse.jgit.revwalk.filter.CommitTimeRevFilter;

import org.eclipse.jgit.revwalk.filter.RevFilter;

import org.eclipse.jgit.storage.file.FileRepository;

import org.eclipse.jgit.transport.CredentialsProvider;

import org.eclipse.jgit.transport.FetchResult;

import org.eclipse.jgit.transport.RefSpec;

import org.eclipse.jgit.treewalk.TreeWalk;

@@ -80,9 +87,38 @@
import com.gitblit.models.PathModel.PathChangeModel;

import com.gitblit.models.RefModel;



/**

 * Collection of static methods for retrieving information from a repository.

 * 
 * @author James Moger

 * 
 */

public class JGitUtils {



   static final Logger LOGGER = LoggerFactory.getLogger(JGitUtils.class);



   /**

    * Log an error message and exception.

    * 
    * @param t

    * @param repository

    *            if repository is not null it MUST be the {0} parameter in the

    *            pattern.

    * @param pattern

    * @param objects

    */

   private static void error(Throwable t, Repository repository, String pattern, Object... objects) {

      List<Object> parameters = new ArrayList<Object>();

      if (objects != null && objects.length > 0) {

         for (Object o : objects) {

            parameters.add(o);

         }

      }

      if (repository != null) {

         parameters.add(0, repository.getDirectory().getAbsolutePath());

      }

      LOGGER.error(MessageFormat.format(pattern, parameters.toArray()), t);

   }



   /**

    * Returns the displayable name of the person in the form "Real Name <email

@@ -104,6 +140,15 @@
   }



   /**

    * Encapsulates the result of cloning or pulling from a repository.

    */

   public static class CloneResult {

      public String name;

      public FetchResult fetchResult;

      public boolean createdRepository;

   }



   /**

    * Clone or Fetch a repository. If the local repository does not exist,

    * clone is called. If the repository does exist, fetch is called. By

    * default the clone/fetch retrieves the remote heads, tags, and notes.

@@ -111,33 +156,65 @@
    * @param repositoriesFolder

    * @param name

    * @param fromUrl

    * @return FetchResult

    * @return CloneResult

    * @throws Exception

    */

   public static FetchResult cloneRepository(File repositoriesFolder, String name, String fromUrl)

   public static CloneResult cloneRepository(File repositoriesFolder, String name, String fromUrl)

         throws Exception {

      FetchResult result = null;

      if (!name.toLowerCase().endsWith(Constants.DOT_GIT_EXT)) {

         name += Constants.DOT_GIT_EXT;

      return cloneRepository(repositoriesFolder, name, fromUrl, true, null);

   }



   /**

    * Clone or Fetch a repository. If the local repository does not exist,

    * clone is called. If the repository does exist, fetch is called. By

    * default the clone/fetch retrieves the remote heads, tags, and notes.

    * 
    * @param repositoriesFolder

    * @param name

    * @param fromUrl

    * @param bare

    * @param credentialsProvider

    * @return CloneResult

    * @throws Exception

    */

   public static CloneResult cloneRepository(File repositoriesFolder, String name, String fromUrl,

         boolean bare, CredentialsProvider credentialsProvider) throws Exception {

      CloneResult result = new CloneResult();

      if (bare) {

         // bare repository, ensure .git suffix

         if (!name.toLowerCase().endsWith(Constants.DOT_GIT_EXT)) {

            name += Constants.DOT_GIT_EXT;

         }

      } else {

         // normal repository, strip .git suffix

         if (name.toLowerCase().endsWith(Constants.DOT_GIT_EXT)) {

            name = name.substring(0, name.indexOf(Constants.DOT_GIT_EXT));

         }

      }

      result.name = name;



      File folder = new File(repositoriesFolder, name);

      if (folder.exists()) {

         File gitDir = FileKey.resolve(new File(repositoriesFolder, name), FS.DETECTED);

         FileRepository repository = new FileRepository(gitDir);

         result = fetchRepository(repository);

         result.fetchResult = fetchRepository(credentialsProvider, repository);

         repository.close();

      } else {

         CloneCommand clone = new CloneCommand();

         clone.setBare(true);

         clone.setBare(bare);

         clone.setCloneAllBranches(true);

         clone.setURI(fromUrl);

         clone.setDirectory(folder);

         if (credentialsProvider != null) {

            clone.setCredentialsProvider(credentialsProvider);

         }

         clone.call();

         // Now we have to fetch because CloneCommand doesn't fetch

         // refs/notes nor does it allow manual RefSpec.

         File gitDir = FileKey.resolve(new File(repositoriesFolder, name), FS.DETECTED);

         FileRepository repository = new FileRepository(gitDir);

         result = fetchRepository(repository);

         result.createdRepository = true;

         result.fetchResult = fetchRepository(credentialsProvider, repository);

         repository.close();

      }

      return result;

@@ -147,13 +224,14 @@
    * Fetch updates from the remote repository. If refSpecs is unspecifed,

    * remote heads, tags, and notes are retrieved.

    * 

    * @param credentialsProvider

    * @param repository

    * @param refSpecs

    * @return FetchResult

    * @throws Exception

    */

   public static FetchResult fetchRepository(Repository repository, RefSpec... refSpecs)

         throws Exception {

   public static FetchResult fetchRepository(CredentialsProvider credentialsProvider,

         Repository repository, RefSpec... refSpecs) throws Exception {

      Git git = new Git(repository);

      FetchCommand fetch = git.fetch();

      List<RefSpec> specs = new ArrayList<RefSpec>();

@@ -164,9 +242,12 @@
      } else {

         specs.addAll(Arrays.asList(refSpecs));

      }

      if (credentialsProvider != null) {

         fetch.setCredentialsProvider(credentialsProvider);

      }

      fetch.setRefSpecs(specs);

      FetchResult result = fetch.call();

      return result;

      FetchResult fetchRes = fetch.call();

      return fetchRes;

   }



   /**

@@ -185,22 +266,22 @@
    * Returns a list of repository names in the specified folder.

    * 

    * @param repositoriesFolder

    * @param exportAll

    *            if true, all repositories are listed. If false only the

    *            repositories with a "git-daemon-export-ok" file are included

    * @param onlyBare

    *            if true, only bare repositories repositories are listed. If

    *            false all repositories are included.

    * @param searchSubfolders

    *            recurse into subfolders to find grouped repositories

    * @return list of repository names

    */

   public static List<String> getRepositoryList(File repositoriesFolder, boolean exportAll,

   public static List<String> getRepositoryList(File repositoriesFolder, boolean onlyBare,

         boolean searchSubfolders) {

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

      if (repositoriesFolder == null || !repositoriesFolder.exists()) {

         return list;

      }

      list.addAll(getRepositoryList(repositoriesFolder.getAbsolutePath(), repositoriesFolder,

            exportAll, searchSubfolders));

      Collections.sort(list);

            onlyBare, searchSubfolders));

      StringUtils.sortRepositorynames(list);

      return list;

   }



@@ -211,33 +292,30 @@
    *            basePath is stripped from the repository name as repositories

    *            are relative to this path

    * @param searchFolder

    * @param exportAll

    *            if true all repositories are listed. If false only the

    *            repositories with a "git-daemon-export-ok" file are included

    * @param onlyBare

    *            if true only bare repositories will be listed. if false all

    *            repositories are included.

    * @param searchSubfolders

    *            recurse into subfolders to find grouped repositories

    * @return

    */

   private static List<String> getRepositoryList(String basePath, File searchFolder,

         boolean exportAll, boolean searchSubfolders) {

         boolean onlyBare, boolean searchSubfolders) {

      File baseFile = new File(basePath);

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

      for (File file : searchFolder.listFiles()) {

         if (file.isDirectory()) {

            File gitDir = FileKey.resolve(new File(searchFolder, file.getName()), FS.DETECTED);

            if (gitDir != null) {

               boolean exportRepository = exportAll

                     || new File(gitDir, "git-daemon-export-ok").exists();



               if (!exportRepository) {

               if (onlyBare && gitDir.getName().equals(".git")) {

                  continue;

               }

               // determine repository name relative to base path

               String repository = StringUtils.getRelativePath(basePath,

                     file.getAbsolutePath());

               String repository = FileUtils.getRelativePath(baseFile, file);

               list.add(repository);

            } else if (searchSubfolders) {

            } else if (searchSubfolders && file.canRead()) {

               // look for repositories in subfolders

               list.addAll(getRepositoryList(basePath, file, exportAll, searchSubfolders));

               list.addAll(getRepositoryList(basePath, file, onlyBare, searchSubfolders));

            }

         }

      }

@@ -257,19 +335,24 @@
      if (!hasCommits(repository)) {

         return null;

      }

      if (StringUtils.isEmpty(branch)) {

         branch = Constants.HEAD;

      }

      RevCommit commit = null;

      try {

         // resolve branch

         ObjectId branchObject;

         if (StringUtils.isEmpty(branch)) {

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(branch);

         }



         RevWalk walk = new RevWalk(repository);

         walk.sort(RevSort.REVERSE);

         RevCommit head = walk.parseCommit(repository.resolve(branch));

         RevCommit head = walk.parseCommit(branchObject);

         walk.markStart(head);

         commit = walk.next();

         walk.dispose();

      } catch (Throwable t) {

         LOGGER.error("Failed to determine first commit", t);

         error(t, repository, "{0} failed to determine first commit");

      }

      return commit;

   }

@@ -298,14 +381,14 @@


   /**

    * Determine if a repository has any commits. This is determined by checking

    * the objects/info and objects/pack folders.

    * the for loose and packed objects.

    * 

    * @param repository

    * @return true if the repository has commits

    */

   public static boolean hasCommits(Repository repository) {

      if (repository != null && repository.getDirectory().exists()) {

         return (new File(repository.getDirectory(), "objects/info").list().length > 0)

         return (new File(repository.getDirectory(), "objects").list().length > 2)

               || (new File(repository.getDirectory(), "objects/pack").list().length > 0);

      }

      return false;

@@ -317,11 +400,9 @@
    * last modified date of the repository folder is returned.

    * 

    * @param repository

    * @param branch

    *            if unspecified, HEAD is assumed.

    * @return

    */

   public static Date getLastChange(Repository repository, String branch) {

   public static Date getLastChange(Repository repository) {

      if (!hasCommits(repository)) {

         // null repository

         if (repository == null) {

@@ -330,21 +411,47 @@
         // fresh repository

         return new Date(repository.getDirectory().lastModified());

      }

      if (StringUtils.isEmpty(branch)) {

         branch = Constants.HEAD;



      List<RefModel> branchModels = getLocalBranches(repository, true, -1);

      if (branchModels.size() > 0) {

         // find most recent branch update

         Date lastChange = new Date(0);

         for (RefModel branchModel : branchModels) {

            if (branchModel.getDate().after(lastChange)) {

               lastChange = branchModel.getDate();

            }

         }

         return lastChange;

      }

      RevCommit commit = getCommit(repository, branch);

      return getCommitDate(commit);

		
      // default to the repository folder modification date

      return new Date(repository.getDirectory().lastModified());

   }



   /**

    * Retrieves a Java Date from a Git commit.

    * 

    * @param commit

    * @return date of the commit

    * @return date of the commit or Date(0) if the commit is null

    */

   public static Date getCommitDate(RevCommit commit) {

      if (commit == null) {

         return new Date(0);

      }

      return new Date(commit.getCommitTime() * 1000L);

   }



   /**

    * Retrieves a Java Date from a Git commit.

    * 
    * @param commit

    * @return date of the commit or Date(0) if the commit is null

    */

   public static Date getAuthorDate(RevCommit commit) {

      if (commit == null) {

         return new Date(0);

      }

      return commit.getAuthorIdent().getWhen();

   }



   /**

@@ -362,16 +469,19 @@
      }

      RevCommit commit = null;

      try {

         // resolve object id

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

            objectId = Constants.HEAD;

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }

         ObjectId object = repository.resolve(objectId);

         RevWalk walk = new RevWalk(repository);

         RevCommit rev = walk.parseCommit(object);

         RevCommit rev = walk.parseCommit(branchObject);

         commit = rev;

         walk.dispose();

      } catch (Throwable t) {

         LOGGER.error("Failed to get commit " + objectId, t);

         error(t, repository, "{0} failed to get commit {1}", objectId);

      }

      return commit;

   }

@@ -392,7 +502,7 @@
      byte[] content = null;

      try {

         if (tree == null) {

            ObjectId object = repository.resolve(Constants.HEAD);

            ObjectId object = getDefaultBranch(repository);

            RevCommit commit = rw.parseCommit(object);

            tree = commit.getTree();

         }

@@ -418,7 +528,7 @@
            content = os.toByteArray();

         }

      } catch (Throwable t) {

         LOGGER.error("Can't find " + path + " in tree " + tree.name(), t);

         error(t, repository, "{0} can't find {1} in tree {2}", path, tree.name());

      } finally {

         rw.dispose();

         tw.release();

@@ -467,7 +577,7 @@
         in.close();

         content = os.toByteArray();

      } catch (Throwable t) {

         LOGGER.error("Can't find blob " + objectId, t);

         error(t, repository, "{0} can't find blob {1}", objectId);

      } finally {

         rw.dispose();

      }

@@ -508,7 +618,7 @@
         return list;

      }

      if (commit == null) {

         commit = getCommit(repository, Constants.HEAD);

         commit = getCommit(repository, null);

      }

      final TreeWalk tw = new TreeWalk(repository);

      try {

@@ -537,7 +647,7 @@
            }

         }

      } catch (IOException e) {

         LOGGER.error("Failed to get files for commit " + commit.getName(), e);

         error(e, repository, "{0} failed to get files for commit {1}", commit.getName());

      } finally {

         tw.release();

      }

@@ -562,7 +672,7 @@
      RevWalk rw = new RevWalk(repository);

      try {

         if (commit == null) {

            ObjectId object = repository.resolve(Constants.HEAD);

            ObjectId object = getDefaultBranch(repository);

            commit = rw.parseCommit(object);

         }



@@ -588,6 +698,10 @@
                  list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff

                        .getNewMode().getBits(), commit.getId().getName(), diff

                        .getChangeType()));

               } else if (diff.getChangeType().equals(ChangeType.RENAME)) {

                  list.add(new PathChangeModel(diff.getOldPath(), diff.getNewPath(), 0, diff

                        .getNewMode().getBits(), commit.getId().getName(), diff

                        .getChangeType()));

               } else {

                  list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff

                        .getNewMode().getBits(), commit.getId().getName(), diff

@@ -596,7 +710,7 @@
            }

         }

      } catch (Throwable t) {

         LOGGER.error("failed to determine files in commit!", t);

         error(t, repository, "{0} failed to determine files in commit!");

      } finally {

         rw.dispose();

      }

@@ -604,25 +718,40 @@
   }



   /**

    * Returns the list of files in the repository that match one of the

    * specified extensions. This is a CASE-SENSITIVE search. If the repository

    * does not exist or is empty, an empty list is returned.

    * Returns the list of files in the repository on the default branch that

    * match one of the specified extensions. This is a CASE-SENSITIVE search.

    * If the repository does not exist or is empty, an empty list is returned.

    * 

    * @param repository

    * @param extensions

    * @return list of files in repository with a matching extension

    */

   public static List<PathModel> getDocuments(Repository repository, List<String> extensions) {

      return getDocuments(repository, extensions, null);

   }



   /**

    * Returns the list of files in the repository in the specified commit that

    * match one of the specified extensions. This is a CASE-SENSITIVE search.

    * If the repository does not exist or is empty, an empty list is returned.

    * 
    * @param repository

    * @param extensions

    * @param objectId

    * @return list of files in repository with a matching extension

    */

   public static List<PathModel> getDocuments(Repository repository, List<String> extensions,

         String objectId) {

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

      if (!hasCommits(repository)) {

         return list;

      }

      RevCommit commit = getCommit(repository, Constants.HEAD);

      RevCommit commit = getCommit(repository, objectId);

      final TreeWalk tw = new TreeWalk(repository);

      try {

         tw.addTree(commit.getTree());

         if (extensions != null && extensions.size() > 0) {

            Collection<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();

            List<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();

            for (String extension : extensions) {

               if (extension.charAt(0) == '.') {

                  suffixFilters.add(PathSuffixFilter.create("\\" + extension));

@@ -631,7 +760,12 @@
                  suffixFilters.add(PathSuffixFilter.create("\\." + extension));

               }

            }

            TreeFilter filter = OrTreeFilter.create(suffixFilters);

            TreeFilter filter;

            if (suffixFilters.size() == 1) {

               filter = suffixFilters.get(0);

            } else {

               filter = OrTreeFilter.create(suffixFilters);

            }

            tw.setFilter(filter);

            tw.setRecursive(true);

         }

@@ -639,7 +773,7 @@
            list.add(getPathModel(tw, null, commit));

         }

      } catch (IOException e) {

         LOGGER.error("Failed to get documents for commit " + commit.getName(), e);

         error(e, repository, "{0} failed to get documents for commit {1}", commit.getName());

      } finally {

         tw.release();

      }

@@ -668,7 +802,7 @@
            size = tw.getObjectReader().getObjectSize(tw.getObjectId(0), Constants.OBJ_BLOB);

         }

      } catch (Throwable t) {

         LOGGER.error("Failed to retrieve blob size", t);

         error(t, null, "failed to retrieve blob size for " + tw.getPathString());

      }

      return new PathModel(name, tw.getPathString(), size, tw.getFileMode(0).getBits(),

            commit.getName());

@@ -699,6 +833,45 @@
   }



   /**

    * Returns a list of commits since the minimum date starting from the

    * specified object id.

    * 
    * @param repository

    * @param objectId

    *            if unspecified, HEAD is assumed.

    * @param minimumDate

    * @return list of commits

    */

   public static List<RevCommit> getRevLog(Repository repository, String objectId, Date minimumDate) {

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

      if (!hasCommits(repository)) {

         return list;

      }

      try {

         // resolve branch

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }



         RevWalk rw = new RevWalk(repository);

         rw.markStart(rw.parseCommit(branchObject));

         rw.setRevFilter(CommitTimeRevFilter.after(minimumDate));

         Iterable<RevCommit> revlog = rw;

         for (RevCommit rev : revlog) {

            list.add(rev);

         }

         rw.dispose();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get {1} revlog for minimum date {2}", objectId,

               minimumDate);

      }

      return list;

   }



   /**

    * Returns a list of commits starting from HEAD and working backwards.

    * 

    * @param repository

@@ -707,7 +880,7 @@
    * @return list of commits

    */

   public static List<RevCommit> getRevLog(Repository repository, int maxCount) {

      return getRevLog(repository, Constants.HEAD, 0, maxCount);

      return getRevLog(repository, null, 0, maxCount);

   }



   /**

@@ -756,12 +929,19 @@
         return list;

      }

      try {

         // resolve branch

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

            objectId = Constants.HEAD;

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }

         if (branchObject == null) {

            return list;

         }



         RevWalk rw = new RevWalk(repository);

         ObjectId object = repository.resolve(objectId);

         rw.markStart(rw.parseCommit(object));

         rw.markStart(rw.parseCommit(branchObject));

         if (!StringUtils.isEmpty(path)) {

            TreeFilter filter = AndTreeFilter.create(

                  PathFilterGroup.createFromStrings(Collections.singleton(path)),

@@ -790,27 +970,53 @@
         }

         rw.dispose();

      } catch (Throwable t) {

         LOGGER.error("Failed to get revlog", t);

         error(t, repository, "{0} failed to get {1} revlog for path {2}", objectId, path);

      }

      return list;

   }



   public static enum SearchType {

      AUTHOR, COMMITTER, COMMIT;

   /**

    * Returns a list of commits for the repository within the range specified

    * by startRangeId and endRangeId. If the repository does not exist or is

    * empty, an empty list is returned.

    * 
    * @param repository

    * @param startRangeId

    *            the first commit (not included in results)

    * @param endRangeId

    *            the end commit (included in results)

    * @return a list of commits

    */

   public static List<RevCommit> getRevLog(Repository repository, String startRangeId,

         String endRangeId) {

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

      if (!hasCommits(repository)) {

         return list;

      }

      try {

         ObjectId endRange = repository.resolve(endRangeId);

         ObjectId startRange = repository.resolve(startRangeId);



      public static SearchType forName(String name) {

         for (SearchType type : values()) {

            if (type.name().equalsIgnoreCase(name)) {

               return type;

            }

         RevWalk rw = new RevWalk(repository);

         rw.markStart(rw.parseCommit(endRange));

         if (startRange.equals(ObjectId.zeroId())) {

            // maybe this is a tag or an orphan branch

            list.add(rw.parseCommit(endRange));

            rw.dispose();

            return list;

         } else {

            rw.markUninteresting(rw.parseCommit(startRange));

         }

         return COMMIT;

      }



      @Override

      public String toString() {

         return name().toLowerCase();

         Iterable<RevCommit> revlog = rw;

         for (RevCommit rev : revlog) {

            list.add(rev);

         }

         rw.dispose();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get revlog for {1}..{2}", startRangeId, endRangeId);

      }

      return list;

   }



   /**

@@ -831,7 +1037,7 @@
    * @return matching list of commits

    */

   public static List<RevCommit> searchRevlogs(Repository repository, String objectId,

         String value, final SearchType type, int offset, int maxCount) {

         String value, final com.gitblit.Constants.SearchType type, int offset, int maxCount) {

      final String lcValue = value.toLowerCase();

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

      if (maxCount == 0) {

@@ -841,9 +1047,14 @@
         return list;

      }

      try {

         // resolve branch

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

            objectId = Constants.HEAD;

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }



         RevWalk rw = new RevWalk(repository);

         rw.setRevFilter(new RevFilter() {



@@ -878,8 +1089,7 @@
            }



         });

         ObjectId object = repository.resolve(objectId);

         rw.markStart(rw.parseCommit(object));

         rw.markStart(rw.parseCommit(branchObject));

         Iterable<RevCommit> revlog = rw;

         if (offset > 0) {

            int count = 0;

@@ -902,9 +1112,132 @@
         }

         rw.dispose();

      } catch (Throwable t) {

         LOGGER.error("Failed to search revlogs", t);

         error(t, repository, "{0} failed to {1} search revlogs for {2}", type.name(), value);

      }

      return list;

   }



   /**

    * Returns the default branch to use for a repository. Normally returns

    * whatever branch HEAD points to, but if HEAD points to nothing it returns

    * the most recently updated branch.

    * 
    * @param repository

    * @return the objectid of a branch

    * @throws Exception

    */

   public static ObjectId getDefaultBranch(Repository repository) throws Exception {

      ObjectId object = repository.resolve(Constants.HEAD);

      if (object == null) {

         // no HEAD

         // perhaps non-standard repository, try local branches

         List<RefModel> branchModels = getLocalBranches(repository, true, -1);

         if (branchModels.size() > 0) {

            // use most recently updated branch

            RefModel branch = null;

            Date lastDate = new Date(0);

            for (RefModel branchModel : branchModels) {

               if (branchModel.getDate().after(lastDate)) {

                  branch = branchModel;

                  lastDate = branch.getDate();

               }

            }

            object = branch.getReferencedObjectId();

         }

      }

      return object;

   }



   /**

    * Returns the target of the symbolic HEAD reference for a repository.

    * Normally returns a branch reference name, but when HEAD is detached,

    * the commit is matched against the known tags. The most recent matching

    * tag ref name will be returned if it references the HEAD commit. If

    * no match is found, the SHA1 is returned.

    *

    * @param repository

    * @return the ref name or the SHA1 for a detached HEAD

    */

   public static String getHEADRef(Repository repository) {

      String target = null;

      try {

         target = repository.getFullBranch();

         if (!target.startsWith(Constants.R_HEADS)) {

            // refers to an actual commit, probably a tag

            // find latest tag that matches the commit, if any

            List<RefModel> tagModels = getTags(repository, true, -1);

            if (tagModels.size() > 0) {

               RefModel tag = null;

               Date lastDate = new Date(0);

               for (RefModel tagModel : tagModels) {

                  if (tagModel.getReferencedObjectId().getName().equals(target) &&

                        tagModel.getDate().after(lastDate)) {

                     tag = tagModel;

                     lastDate = tag.getDate();

                  }

               }

               target = tag.getName();

            }

         }

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get symbolic HEAD target");

      }

      return target;

   }

	
   /**

    * Sets the symbolic ref HEAD to the specified target ref. The

    * HEAD will be detached if the target ref is not a branch.

    *

    * @param repository

    * @param targetRef

    * @return true if successful

    */

   public static boolean setHEADtoRef(Repository repository, String targetRef) {

      try {

          // detach HEAD if target ref is not a branch

         boolean detach = !targetRef.startsWith(Constants.R_HEADS);

         RefUpdate.Result result;

         RefUpdate head = repository.updateRef(Constants.HEAD, detach);

         if (detach) { // Tag

            RevCommit commit = getCommit(repository, targetRef);

            head.setNewObjectId(commit.getId());

            result = head.forceUpdate();

         } else {

            result = head.link(targetRef);

         }

         switch (result) {

         case NEW:

         case FORCED:

         case NO_CHANGE:

         case FAST_FORWARD:

            return true;				
         default:

            LOGGER.error(MessageFormat.format("{0} HEAD update to {1} returned result {2}",

                  repository.getDirectory().getAbsolutePath(), targetRef, result));

         }

      } catch (Throwable t) {

         error(t, repository, "{0} failed to set HEAD to {1}", targetRef);

      }

      return false;

   }

	
   /**

    * Get the full branch and tag ref names for any potential HEAD targets.

    *

    * @param repository

    * @return a list of ref names

    */

   public static List<String> getAvailableHeadTargets(Repository repository) {

      List<String> targets = new ArrayList<String>();

      for (RefModel branchModel : JGitUtils.getLocalBranches(repository, true, -1)) {

         targets.add(branchModel.getName());

      }



      for (RefModel tagModel : JGitUtils.getTags(repository, true, -1)) {

         targets.add(tagModel.getName());

      }

      return targets;

   }



   /**

@@ -1035,9 +1368,53 @@
            list = new ArrayList<RefModel>(list.subList(0, maxCount));

         }

      } catch (IOException e) {

         LOGGER.error("Failed to retrieve " + refs, e);

         error(e, repository, "{0} failed to retrieve {1}", refs);

      }

      return list;

   }



   /**

    * Returns a RefModel for the gh-pages branch in the repository. If the

    * branch can not be found, null is returned.

    * 
    * @param repository

    * @return a refmodel for the gh-pages branch or null

    */

   public static RefModel getPagesBranch(Repository repository) {

      return getBranch(repository, "gh-pages");

   }



   /**

    * Returns a RefModel for a specific branch name in the repository. If the

    * branch can not be found, null is returned.

    * 
    * @param repository

    * @return a refmodel for the branch or null

    */

   public static RefModel getBranch(Repository repository, String name) {

      RefModel branch = null;

      try {

         // search for the branch in local heads

         for (RefModel ref : JGitUtils.getLocalBranches(repository, false, -1)) {

            if (ref.displayName.endsWith(name)) {

               branch = ref;

               break;

            }

         }



         // search for the branch in remote heads

         if (branch == null) {

            for (RefModel ref : JGitUtils.getRemoteBranches(repository, false, -1)) {

               if (ref.displayName.endsWith(name)) {

                  branch = ref;

                  break;

               }

            }

         }

      } catch (Throwable t) {

         LOGGER.error(MessageFormat.format("Failed to find {0} branch!", name), t);

      }

      return branch;

   }



   /**

@@ -1057,10 +1434,23 @@
      List<RefModel> noteBranches = getNoteBranches(repository, true, -1);

      for (RefModel notesRef : noteBranches) {

         RevTree notesTree = JGitUtils.getCommit(repository, notesRef.getName()).getTree();

         // flat notes list

         String notePath = commit.getName();

         String text = getStringContent(repository, notesTree, notePath);

         if (!StringUtils.isEmpty(text)) {

            List<RevCommit> history = getRevLog(repository, notesRef.getName(), notePath, 0, -1);

            RefModel noteRef = new RefModel(notesRef.displayName, null, history.get(history

                  .size() - 1));

            GitNote gitNote = new GitNote(noteRef, text);

            list.add(gitNote);

            continue;

         }

			
         // folder structure

         StringBuilder sb = new StringBuilder(commit.getName());

         sb.insert(2, '/');

         String notePath = sb.toString();

         String text = getStringContent(repository, notesTree, notePath);

         notePath = sb.toString();

         text = getStringContent(repository, notesTree, notePath);

         if (!StringUtils.isEmpty(text)) {

            List<RevCommit> history = getRevLog(repository, notesRef.getName(), notePath, 0, -1);

            RefModel noteRef = new RefModel(notesRef.displayName, null, history.get(history

@@ -1070,6 +1460,77 @@
         }

      }

      return list;

   }



   /**

    * Create an orphaned branch in a repository.

    * 
    * @param repository

    * @param branchName

    * @param author

    *            if unspecified, Gitblit will be the author of this new branch

    * @return true if successful

    */

   public static boolean createOrphanBranch(Repository repository, String branchName,

         PersonIdent author) {

      boolean success = false;

      String message = "Created branch " + branchName;

      if (author == null) {

         author = new PersonIdent("Gitblit", "gitblit@localhost");

      }

      try {

         ObjectInserter odi = repository.newObjectInserter();

         try {

            // Create a blob object to insert into a tree

            ObjectId blobId = odi.insert(Constants.OBJ_BLOB,

                  message.getBytes(Constants.CHARACTER_ENCODING));



            // Create a tree object to reference from a commit

            TreeFormatter tree = new TreeFormatter();

            tree.append(".branch", FileMode.REGULAR_FILE, blobId);

            ObjectId treeId = odi.insert(tree);



            // Create a commit object

            CommitBuilder commit = new CommitBuilder();

            commit.setAuthor(author);

            commit.setCommitter(author);

            commit.setEncoding(Constants.CHARACTER_ENCODING);

            commit.setMessage(message);

            commit.setTreeId(treeId);



            // Insert the commit into the repository

            ObjectId commitId = odi.insert(commit);

            odi.flush();



            RevWalk revWalk = new RevWalk(repository);

            try {

               RevCommit revCommit = revWalk.parseCommit(commitId);

               if (!branchName.startsWith("refs/")) {

                  branchName = "refs/heads/" + branchName;

               }

               RefUpdate ru = repository.updateRef(branchName);

               ru.setNewObjectId(commitId);

               ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);

               Result rc = ru.forceUpdate();

               switch (rc) {

               case NEW:

               case FORCED:

               case FAST_FORWARD:

                  success = true;

                  break;

               default:

                  success = false;

               }

            } finally {

               revWalk.release();

            }

         } finally {

            odi.release();

         }

      } catch (Throwable t) {

         error(t, repository, "Failed to create orphan branch {1} in repository {0}", branchName);

      }

      return success;

   }



   /**

@@ -1083,9 +1544,9 @@
      try {

         c.load();

      } catch (ConfigInvalidException cex) {

         LOGGER.error("Repository configuration is invalid!", cex);

         error(cex, repository, "{0} configuration is invalid!");

      } catch (IOException cex) {

         LOGGER.error("Could not open repository configuration!", cex);

         error(cex, repository, "Could not open configuration for {0}!");

      }

      return c;

   }

@@ -1145,7 +1606,7 @@
         zos.finish();

         success = true;

      } catch (IOException e) {

         LOGGER.error("Failed to zip files from commit " + commit.getName(), e);

         error(e, repository, "{0} failed to zip files from commit {1}", commit.getName());

      } finally {

         tw.release();

         rw.dispose();