Friendly URL for EditFile Page #974

Paul Martin

2016-03-27 795ce2765773156da868720303a6b2638d14820b

 src/main/java/com/gitblit/utils/JGitUtils.java

@@ -15,14 +15,13 @@
 */

package com.gitblit.utils;



import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.text.DecimalFormat;

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;

@@ -30,6 +29,7 @@
import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.regex.Matcher;

import java.util.regex.Pattern;



import org.apache.commons.io.filefilter.TrueFileFilter;

@@ -37,15 +37,21 @@
import org.eclipse.jgit.api.FetchCommand;

import org.eclipse.jgit.api.Git;

import org.eclipse.jgit.api.TagCommand;

import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;

import org.eclipse.jgit.api.errors.GitAPIException;

import org.eclipse.jgit.api.errors.JGitInternalException;

import org.eclipse.jgit.diff.DiffEntry;

import org.eclipse.jgit.diff.DiffEntry.ChangeType;

import org.eclipse.jgit.diff.DiffFormatter;

import org.eclipse.jgit.diff.RawTextComparator;

import org.eclipse.jgit.dircache.DirCache;

import org.eclipse.jgit.dircache.DirCacheEntry;

import org.eclipse.jgit.errors.ConfigInvalidException;

import org.eclipse.jgit.errors.IncorrectObjectTypeException;

import org.eclipse.jgit.errors.LargeObjectException;

import org.eclipse.jgit.errors.MissingObjectException;

import org.eclipse.jgit.errors.StopWalkException;

import org.eclipse.jgit.internal.JGitText;

import org.eclipse.jgit.lib.BlobBasedConfig;

import org.eclipse.jgit.lib.CommitBuilder;

import org.eclipse.jgit.lib.Constants;

@@ -61,6 +67,9 @@
import org.eclipse.jgit.lib.RepositoryCache.FileKey;

import org.eclipse.jgit.lib.StoredConfig;

import org.eclipse.jgit.lib.TreeFormatter;

import org.eclipse.jgit.merge.MergeStrategy;

import org.eclipse.jgit.merge.RecursiveMerger;

import org.eclipse.jgit.merge.ThreeWayMerger;

import org.eclipse.jgit.revwalk.RevBlob;

import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.jgit.revwalk.RevObject;

@@ -73,6 +82,7 @@
import org.eclipse.jgit.transport.CredentialsProvider;

import org.eclipse.jgit.transport.FetchResult;

import org.eclipse.jgit.transport.RefSpec;

import org.eclipse.jgit.treewalk.CanonicalTreeParser;

import org.eclipse.jgit.treewalk.TreeWalk;

import org.eclipse.jgit.treewalk.filter.AndTreeFilter;

import org.eclipse.jgit.treewalk.filter.OrTreeFilter;

@@ -84,11 +94,17 @@
import org.slf4j.Logger;

import org.slf4j.LoggerFactory;



import com.gitblit.GitBlit;

import com.gitblit.GitBlitException;

import com.gitblit.manager.GitblitManager;

import com.gitblit.models.FilestoreModel;

import com.gitblit.models.GitNote;

import com.gitblit.models.PathModel;

import com.gitblit.models.PathModel.PathChangeModel;

import com.gitblit.models.RefModel;

import com.gitblit.models.SubmoduleModel;

import com.gitblit.servlet.FilestoreServlet;

import com.google.common.base.Strings;



/**

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

@@ -689,7 +705,10 @@
      if (commit == null) {

         return new Date(0);

      }

      return commit.getAuthorIdent().getWhen();

      if (commit.getAuthorIdent() != null) {

         return commit.getAuthorIdent().getWhen();

      }

      return getCommitDate(commit);

   }



   /**

@@ -706,20 +725,27 @@
         return null;

      }

      RevCommit commit = null;

      RevWalk walk = null;

      try {

         // resolve object id

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

         if (StringUtils.isEmpty(objectId) || "HEAD".equalsIgnoreCase(objectId)) {

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }

         RevWalk walk = new RevWalk(repository);

         if (branchObject == null) {

            return null;

         }

         walk = new RevWalk(repository);

         RevCommit rev = walk.parseCommit(branchObject);

         commit = rev;

         walk.dispose();

      } catch (Throwable t) {

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

      } finally {

         if (walk != null) {

            walk.dispose();

         }

      }

      return commit;

   }

@@ -755,18 +781,8 @@
            ObjectId entid = tw.getObjectId(0);

            FileMode entmode = tw.getFileMode(0);

            if (entmode != FileMode.GITLINK) {

               RevObject ro = rw.lookupAny(entid, entmode.getObjectType());

               rw.parseBody(ro);

               ByteArrayOutputStream os = new ByteArrayOutputStream();

               ObjectLoader ldr = repository.open(ro.getId(), Constants.OBJ_BLOB);

               byte[] tmp = new byte[4096];

               InputStream in = ldr.openStream();

               int n;

               while ((n = in.read(tmp)) > 0) {

                  os.write(tmp, 0, n);

               }

               in.close();

               content = os.toByteArray();

               ObjectLoader ldr = repository.open(entid, Constants.OBJ_BLOB);

               content = ldr.getCachedBytes();

            }

         }

      } catch (Throwable t) {

@@ -775,7 +791,7 @@
         }

      } finally {

         rw.dispose();

         tw.release();

         tw.close();

      }

      return content;

   }

@@ -810,17 +826,8 @@
      byte[] content = null;

      try {

         RevBlob blob = rw.lookupBlob(ObjectId.fromString(objectId));

         rw.parseBody(blob);

         ByteArrayOutputStream os = new ByteArrayOutputStream();

         ObjectLoader ldr = repository.open(blob.getId(), Constants.OBJ_BLOB);

         byte[] tmp = new byte[4096];

         InputStream in = ldr.openStream();

         int n;

         while ((n = in.read(tmp)) > 0) {

            os.write(tmp, 0, n);

         }

         in.close();

         content = os.toByteArray();

         content = ldr.getCachedBytes();

      } catch (Throwable t) {

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

      } finally {

@@ -895,7 +902,64 @@
      } catch (IOException e) {

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

      } finally {

         tw.release();

         tw.close();

      }

      Collections.sort(list);

      return list;

   }



   /**

    * Returns the list of files in the specified folder at the specified

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

    * returned.

    *

    * This is modified version that implements path compression feature.

    *

    * @param repository

    * @param path

    *            if unspecified, root folder is assumed.

    * @param commit

    *            if null, HEAD is assumed.

    * @return list of files in specified path

    */

   public static List<PathModel> getFilesInPath2(Repository repository, String path, RevCommit commit) {



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

      if (!hasCommits(repository)) {

         return list;

      }

      if (commit == null) {

         commit = getCommit(repository, null);

      }

      final TreeWalk tw = new TreeWalk(repository);

      try {



         tw.addTree(commit.getTree());

         final boolean isPathEmpty = Strings.isNullOrEmpty(path);



         if (!isPathEmpty) {

            PathFilter f = PathFilter.create(path);

            tw.setFilter(f);

         }



         tw.setRecursive(true);

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



         while (tw.next()) {

               String child = isPathEmpty ? tw.getPathString()

                     : tw.getPathString().replaceFirst(String.format("%s/", path), "");

               paths.add(child);

         }



         for(String p: PathUtils.compressPaths(paths)) {

            String pathString = isPathEmpty ? p : String.format("%s/%s", path, p);

            list.add(getPathModel(repository, pathString, path, commit));

         }



      } catch (IOException e) {

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

      } finally {

         tw.close();

      }

      Collections.sort(list);

      return list;

@@ -943,23 +1007,40 @@
            tw.setRecursive(true);

            tw.addTree(commit.getTree());

            while (tw.next()) {

               list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), 0, tw

                     .getRawMode(0), tw.getObjectId(0).getName(), commit.getId().getName(),

               long size = 0;

               FilestoreModel filestoreItem = null;

               ObjectId objectId = tw.getObjectId(0);

					
               try {

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



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



                     if (isPossibleFilestoreItem(size)) {

                        filestoreItem = getFilestoreItem(tw.getObjectReader().open(objectId));

                     }

                  }

               } catch (Throwable t) {

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

               }

					
               list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(),filestoreItem, size, tw

                     .getRawMode(0), objectId.getName(), commit.getId().getName(),

                     ChangeType.ADD));

            }

            tw.release();

            tw.close();

         } else {

            RevCommit parent = rw.parseCommit(commit.getParent(0).getId());

            DiffStatFormatter df = new DiffStatFormatter(commit.getName());

            DiffStatFormatter df = new DiffStatFormatter(commit.getName(), repository);

            df.setRepository(repository);

            df.setDiffComparator(RawTextComparator.DEFAULT);

            df.setDetectRenames(true);

            List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());

            for (DiffEntry diff : diffs) {

               // create the path change model

               PathChangeModel pcm = PathChangeModel.from(diff, commit.getName());



               if (calculateDiffStat) {

               PathChangeModel pcm = PathChangeModel.from(diff, commit.getName(), repository);

						
                  if (calculateDiffStat) {

                  // update file diffstats

                  df.format(diff);

                  PathChangeModel pathStat = df.getDiffStat().getPath(pcm.path);

@@ -990,6 +1071,36 @@
    *            most recent commit. if null, HEAD is assumed.

    * @return list of files changed in a commit range

    */

   public static List<PathChangeModel> getFilesInRange(Repository repository, String startCommit, String endCommit) {

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

      if (!hasCommits(repository)) {

         return list;

      }

      try {

         ObjectId startRange = repository.resolve(startCommit);

         ObjectId endRange = repository.resolve(endCommit);

         RevWalk rw = new RevWalk(repository);

         RevCommit start = rw.parseCommit(startRange);

         RevCommit end = rw.parseCommit(endRange);

         list.addAll(getFilesInRange(repository, start, end));

         rw.close();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to determine files in range {1}..{2}!", startCommit, endCommit);

      }

      return list;

   }



   /**

    * Returns the list of files changed in a specified commit. If the

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

    *

    * @param repository

    * @param startCommit

    *            earliest commit

    * @param endCommit

    *            most recent commit. if null, HEAD is assumed.

    * @return list of files changed in a commit range

    */

   public static List<PathChangeModel> getFilesInRange(Repository repository, RevCommit startCommit, RevCommit endCommit) {

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

      if (!hasCommits(repository)) {

@@ -1003,7 +1114,7 @@


         List<DiffEntry> diffEntries = df.scan(startCommit.getTree(), endCommit.getTree());

         for (DiffEntry diff : diffEntries) {

            PathChangeModel pcm = PathChangeModel.from(diff,  null);

            PathChangeModel pcm = PathChangeModel.from(diff,  endCommit.getName(), repository);

            list.add(pcm);

         }

         Collections.sort(list);

@@ -1070,7 +1181,7 @@
      } catch (IOException e) {

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

      } finally {

         tw.release();

         tw.close();

      }

      Collections.sort(list);

      return list;

@@ -1087,22 +1198,100 @@
   private static PathModel getPathModel(TreeWalk tw, String basePath, RevCommit commit) {

      String name;

      long size = 0;

		
      if (StringUtils.isEmpty(basePath)) {

         name = tw.getPathString();

      } else {

         name = tw.getPathString().substring(basePath.length() + 1);

      }

      ObjectId objectId = tw.getObjectId(0);

      FilestoreModel filestoreItem = null;

		
      try {

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



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



            if (isPossibleFilestoreItem(size)) {

               filestoreItem = getFilestoreItem(tw.getObjectReader().open(objectId));

            }

         }

      } catch (Throwable t) {

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

      }

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

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

            objectId.getName(), commit.getName());

   }

	
   public static boolean isPossibleFilestoreItem(long size) {

      return (   (size >= com.gitblit.Constants.LEN_FILESTORE_META_MIN) 
            && (size <= com.gitblit.Constants.LEN_FILESTORE_META_MAX));

   }

	
   /**

    * 
    * @return Representative FilestoreModel if valid, otherwise null

    */

   public static FilestoreModel getFilestoreItem(ObjectLoader obj){

      try {

         final byte[] blob = obj.getCachedBytes(com.gitblit.Constants.LEN_FILESTORE_META_MAX);

         final String meta = new String(blob, "UTF-8");

		
         return FilestoreModel.fromMetaString(meta);



      } catch (LargeObjectException e) {

         //Intentionally failing silent

      } catch (Exception e) {

         error(e, null, "failed to retrieve filestoreItem " + obj.toString());

      }

		
      return null;

   }



   /**

    * Returns a path model by path string

    *

    * @param repo

    * @param path

    * @param filter

    * @param commit

    * @return a path model of the specified object

    */

   private static PathModel getPathModel(Repository repo, String path, String filter, RevCommit commit)

         throws IOException {



      long size = 0;

      FilestoreModel filestoreItem = null;

      TreeWalk tw = TreeWalk.forPath(repo, path, commit.getTree());

      String pathString = path;



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



         pathString = PathUtils.getLastPathComponent(pathString);

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

			
         if (isPossibleFilestoreItem(size)) {

            filestoreItem = getFilestoreItem(tw.getObjectReader().open(tw.getObjectId(0)));

         }

      } else if (tw.isSubtree()) {



         // do not display dirs that are behind in the path

         if (!Strings.isNullOrEmpty(filter)) {

            pathString = path.replaceFirst(filter + "/", "");

         }



         // remove the last slash from path in displayed link

         if (pathString != null && pathString.charAt(pathString.length()-1) == '/') {

            pathString = pathString.substring(0, pathString.length()-1);

         }

      }



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

            tw.getObjectId(0).getName(), commit.getName());



   }





   /**

    * Returns a permissions representation of the mode bits.

@@ -1470,23 +1659,6 @@
      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");

      }

@@ -1666,6 +1838,24 @@
   }



   /**

    * Returns the list of tags in the repository. If repository does not exist

    * or is empty, an empty list is returned.

    *

    * @param repository

    * @param fullName

    *            if true, /refs/tags/yadayadayada is returned. If false,

    *            yadayadayada is returned.

    * @param maxCount

    *            if < 0, all tags are returned

    * @param offset

    *            if maxCount provided sets the starting point of the records to return

    * @return list of tags

    */

   public static List<RefModel> getTags(Repository repository, boolean fullName, int maxCount, int offset) {

      return getRefs(repository, Constants.R_TAGS, fullName, maxCount, offset);

   }



   /**

    * Returns the list of local branches in the repository. If repository does

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

    *

@@ -1746,6 +1936,27 @@
    */

   private static List<RefModel> getRefs(Repository repository, String refs, boolean fullName,

         int maxCount) {

      return getRefs(repository, refs, fullName, maxCount, 0);

   }



   /**

    * Returns a list of references in the repository matching "refs". If the

    * repository is null or empty, an empty list is returned.

    *

    * @param repository

    * @param refs

    *            if unspecified, all refs are returned

    * @param fullName

    *            if true, /refs/something/yadayadayada is returned. If false,

    *            yadayadayada is returned.

    * @param maxCount

    *            if < 0, all references are returned

    * @param offset

    *            if maxCount provided sets the starting point of the records to return

    * @return list of references

    */

   private static List<RefModel> getRefs(Repository repository, String refs, boolean fullName,

         int maxCount, int offset) {

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

      if (maxCount == 0) {

         return list;

@@ -1769,7 +1980,14 @@
         Collections.sort(list);

         Collections.reverse(list);

         if (maxCount > 0 && list.size() > maxCount) {

            list = new ArrayList<RefModel>(list.subList(0, maxCount));

            if (offset < 0) {

               offset = 0;

            }

            int endIndex = offset + maxCount;

            if (endIndex > list.size()) {

               endIndex = list.size();

            }

            list = new ArrayList<RefModel>(list.subList(offset, endIndex));

         }

      } catch (IOException e) {

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

@@ -1898,7 +2116,7 @@
         error(t, repository, "{0} can't find {1} in commit {2}", path, commit.name());

      } finally {

         rw.dispose();

         tw.release();

         tw.close();

      }

      return commitId;

   }

@@ -2072,10 +2290,10 @@
                  success = false;

               }

            } finally {

               revWalk.release();

               revWalk.close();

            }

         } finally {

            odi.release();

            odi.close();

         }

      } catch (Throwable t) {

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

@@ -2096,4 +2314,435 @@
      }

      return StringUtils.decodeString(content);

   }



   /**

    * Automatic repair of (some) invalid refspecs.  These are the result of a

    * bug in JGit cloning where a double forward-slash was injected.  :(

    *

    * @param repository

    * @return true, if the refspecs were repaired

    */

   public static boolean repairFetchSpecs(Repository repository) {

      StoredConfig rc = repository.getConfig();



      // auto-repair broken fetch ref specs

      for (String name : rc.getSubsections("remote")) {

         int invalidSpecs = 0;

         int repairedSpecs = 0;

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

         for (String spec : rc.getStringList("remote", name, "fetch")) {

            try {

               RefSpec rs = new RefSpec(spec);

               // valid spec

               specs.add(spec);

            } catch (IllegalArgumentException e) {

               // invalid spec

               invalidSpecs++;

               if (spec.contains("//")) {

                  // auto-repair this known spec bug

                  spec = spec.replace("//", "/");

                  specs.add(spec);

                  repairedSpecs++;

               }

            }

         }



         if (invalidSpecs == repairedSpecs && repairedSpecs > 0) {

            // the fetch specs were automatically repaired

            rc.setStringList("remote", name, "fetch", specs);

            try {

               rc.save();

               rc.load();

               LOGGER.debug("repaired {} invalid fetch refspecs for {}", repairedSpecs, repository.getDirectory());

               return true;

            } catch (Exception e) {

               LOGGER.error(null, e);

            }

         } else if (invalidSpecs > 0) {

            LOGGER.error("mirror executor found {} invalid fetch refspecs for {}", invalidSpecs, repository.getDirectory());

         }

      }

      return false;

   }



   /**

    * Returns true if the commit identified by commitId is an ancestor or the

    * the commit identified by tipId.

    *

    * @param repository

    * @param commitId

    * @param tipId

    * @return true if there is the commit is an ancestor of the tip

    */

   public static boolean isMergedInto(Repository repository, String commitId, String tipId) {

      try {

         return isMergedInto(repository, repository.resolve(commitId), repository.resolve(tipId));

      } catch (Exception e) {

         LOGGER.error("Failed to determine isMergedInto", e);

      }

      return false;

   }



   /**

    * Returns true if the commit identified by commitId is an ancestor or the

    * the commit identified by tipId.

    *

    * @param repository

    * @param commitId

    * @param tipId

    * @return true if there is the commit is an ancestor of the tip

    */

   public static boolean isMergedInto(Repository repository, ObjectId commitId, ObjectId tipCommitId) {

      // traverse the revlog looking for a commit chain between the endpoints

      RevWalk rw = new RevWalk(repository);

      try {

         // must re-lookup RevCommits to workaround undocumented RevWalk bug

         RevCommit tip = rw.lookupCommit(tipCommitId);

         RevCommit commit = rw.lookupCommit(commitId);

         return rw.isMergedInto(commit, tip);

      } catch (Exception e) {

         LOGGER.error("Failed to determine isMergedInto", e);

      } finally {

         rw.dispose();

      }

      return false;

   }



   /**

    * Returns the merge base of two commits or null if there is no common

    * ancestry.

    *

    * @param repository

    * @param commitIdA

    * @param commitIdB

    * @return the commit id of the merge base or null if there is no common base

    */

   public static String getMergeBase(Repository repository, ObjectId commitIdA, ObjectId commitIdB) {

      RevWalk rw = new RevWalk(repository);

      try {

         RevCommit a = rw.lookupCommit(commitIdA);

         RevCommit b = rw.lookupCommit(commitIdB);



         rw.setRevFilter(RevFilter.MERGE_BASE);

         rw.markStart(a);

         rw.markStart(b);

         RevCommit mergeBase = rw.next();

         if (mergeBase == null) {

            return null;

         }

         return mergeBase.getName();

      } catch (Exception e) {

         LOGGER.error("Failed to determine merge base", e);

      } finally {

         rw.dispose();

      }

      return null;

   }



   public static enum MergeStatus {

      MISSING_INTEGRATION_BRANCH, MISSING_SRC_BRANCH, NOT_MERGEABLE, FAILED, ALREADY_MERGED, MERGEABLE, MERGED;

   }



   /**

    * Determines if we can cleanly merge one branch into another.  Returns true

    * if we can merge without conflict, otherwise returns false.

    *

    * @param repository

    * @param src

    * @param toBranch

    * @return true if we can merge without conflict

    */

   public static MergeStatus canMerge(Repository repository, String src, String toBranch) {

      RevWalk revWalk = null;

      try {

         revWalk = new RevWalk(repository);

         ObjectId branchId = repository.resolve(toBranch);

         if (branchId == null) {

            return MergeStatus.MISSING_INTEGRATION_BRANCH;

         }

         ObjectId srcId = repository.resolve(src);

         if (srcId == null) {

            return MergeStatus.MISSING_SRC_BRANCH;

         }

         RevCommit branchTip = revWalk.lookupCommit(branchId);

         RevCommit srcTip = revWalk.lookupCommit(srcId);

         if (revWalk.isMergedInto(srcTip, branchTip)) {

            // already merged

            return MergeStatus.ALREADY_MERGED;

         } else if (revWalk.isMergedInto(branchTip, srcTip)) {

            // fast-forward

            return MergeStatus.MERGEABLE;

         }

         RecursiveMerger merger = (RecursiveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);

         boolean canMerge = merger.merge(branchTip, srcTip);

         if (canMerge) {

            return MergeStatus.MERGEABLE;

         }

      } catch (NullPointerException e) {

         LOGGER.error("Failed to determine canMerge", e);

      } catch (IOException e) {

         LOGGER.error("Failed to determine canMerge", e);

      } finally {

         if (revWalk != null) {

            revWalk.close();

         }

      }

      return MergeStatus.NOT_MERGEABLE;

   }





   public static class MergeResult {

      public final MergeStatus status;

      public final String sha;



      MergeResult(MergeStatus status, String sha) {

         this.status = status;

         this.sha = sha;

      }

   }



   /**

    * Tries to merge a commit into a branch.  If there are conflicts, the merge

    * will fail.

    *

    * @param repository

    * @param src

    * @param toBranch

    * @param committer

    * @param message

    * @return the merge result

    */

   public static MergeResult merge(Repository repository, String src, String toBranch,

         PersonIdent committer, String message) {



      if (!toBranch.startsWith(Constants.R_REFS)) {

         // branch ref doesn't start with ref, assume this is a branch head

         toBranch = Constants.R_HEADS + toBranch;

      }



      RevWalk revWalk = null;

      try {

         revWalk = new RevWalk(repository);

         RevCommit branchTip = revWalk.lookupCommit(repository.resolve(toBranch));

         RevCommit srcTip = revWalk.lookupCommit(repository.resolve(src));

         if (revWalk.isMergedInto(srcTip, branchTip)) {

            // already merged

            return new MergeResult(MergeStatus.ALREADY_MERGED, null);

         }

         RecursiveMerger merger = (RecursiveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);

         boolean merged = merger.merge(branchTip, srcTip);

         if (merged) {

            // create a merge commit and a reference to track the merge commit

            ObjectId treeId = merger.getResultTreeId();

            ObjectInserter odi = repository.newObjectInserter();

            try {

               // Create a commit object

               CommitBuilder commitBuilder = new CommitBuilder();

               commitBuilder.setCommitter(committer);

               commitBuilder.setAuthor(committer);

               commitBuilder.setEncoding(Constants.CHARSET);

               if (StringUtils.isEmpty(message)) {

                  message = MessageFormat.format("merge {0} into {1}", srcTip.getName(), branchTip.getName());

               }

               commitBuilder.setMessage(message);

               commitBuilder.setParentIds(branchTip.getId(), srcTip.getId());

               commitBuilder.setTreeId(treeId);



               // Insert the merge commit into the repository

               ObjectId mergeCommitId = odi.insert(commitBuilder);

               odi.flush();



               // set the merge ref to the merge commit

               RevCommit mergeCommit = revWalk.parseCommit(mergeCommitId);

               RefUpdate mergeRefUpdate = repository.updateRef(toBranch);

               mergeRefUpdate.setNewObjectId(mergeCommitId);

               mergeRefUpdate.setRefLogMessage("commit: " + mergeCommit.getShortMessage(), false);

               RefUpdate.Result rc = mergeRefUpdate.update();

               switch (rc) {

               case FAST_FORWARD:

                  // successful, clean merge

                  break;

               default:

                  throw new GitBlitException(MessageFormat.format("Unexpected result \"{0}\" when merging commit {1} into {2} in {3}",

                        rc.name(), srcTip.getName(), branchTip.getName(), repository.getDirectory()));

               }



               // return the merge commit id

               return new MergeResult(MergeStatus.MERGED, mergeCommitId.getName());

            } finally {

               odi.close();

            }

         }

      } catch (IOException e) {

         LOGGER.error("Failed to merge", e);

      } finally {

         if (revWalk != null) {

            revWalk.close();

         }

      }

      return new MergeResult(MergeStatus.FAILED, null);

   }

	
	
   /**

    * Returns the LFS URL for the given oid 
    * Currently assumes that the Gitblit Filestore is used 
    *

    * @param baseURL

    * @param repository name

    * @param oid of lfs item

    * @return the lfs item URL

    */

   public static String getLfsRepositoryUrl(String baseURL, String repositoryName, String oid) {

		
      if (baseURL.length() > 0 && baseURL.charAt(baseURL.length() - 1) == '/') {

         baseURL = baseURL.substring(0, baseURL.length() - 1);

      }

		
      return baseURL + com.gitblit.Constants.R_PATH 
                  + repositoryName + "/" 
                  + com.gitblit.Constants.R_LFS 
                  + "objects/" + oid;

		
   }

	
   /**

    * Returns all tree entries that do not match the ignore paths.

    *

    * @param db

    * @param ignorePaths

    * @param dcBuilder

    * @throws IOException

    */

   public static List<DirCacheEntry> getTreeEntries(Repository db, String branch, Collection<String> ignorePaths) throws IOException {

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

      TreeWalk tw = null;

      try {

         ObjectId treeId = db.resolve(branch + "^{tree}");

         if (treeId == null) {

            // branch does not exist yet

            return list;

         }

         tw = new TreeWalk(db);

         int hIdx = tw.addTree(treeId);

         tw.setRecursive(true);



         while (tw.next()) {

            String path = tw.getPathString();

            CanonicalTreeParser hTree = null;

            if (hIdx != -1) {

               hTree = tw.getTree(hIdx, CanonicalTreeParser.class);

            }

            if (!ignorePaths.contains(path)) {

               // add all other tree entries

               if (hTree != null) {

                  final DirCacheEntry entry = new DirCacheEntry(path);

                  entry.setObjectId(hTree.getEntryObjectId());

                  entry.setFileMode(hTree.getEntryFileMode());

                  list.add(entry);

               }

            }

         }

      } finally {

         if (tw != null) {

            tw.close();

         }

      }

      return list;

   }

	
   public static boolean commitIndex(Repository db, String branch, DirCache index,

                             ObjectId parentId, boolean forceCommit,

                             String author, String authorEmail, String message) throws IOException, ConcurrentRefUpdateException {

      boolean success = false;



      ObjectId headId = db.resolve(branch + "^{commit}");

      ObjectId baseId = parentId;

      if (baseId == null || headId == null) { return false; }

		
      ObjectInserter odi = db.newObjectInserter();

      try {

         // Create the in-memory index of the new/updated ticket

         ObjectId indexTreeId = index.writeTree(odi);



         // Create a commit object

         PersonIdent ident = new PersonIdent(author, authorEmail);

			
         if (forceCommit == false) {

            ThreeWayMerger merger = MergeStrategy.RECURSIVE.newMerger(db, true);

            merger.setObjectInserter(odi);

            merger.setBase(baseId);

            boolean mergeSuccess = merger.merge(indexTreeId, headId);

				
            if (mergeSuccess) {

               indexTreeId = merger.getResultTreeId();

             } else {

               //Manual merge required

               return false; 
             }

         }

			
         CommitBuilder commit = new CommitBuilder();

         commit.setAuthor(ident);

         commit.setCommitter(ident);

         commit.setEncoding(com.gitblit.Constants.ENCODING);

         commit.setMessage(message);

         commit.setParentId(headId);

         commit.setTreeId(indexTreeId);



         // Insert the commit into the repository

         ObjectId commitId = odi.insert(commit);

         odi.flush();



         RevWalk revWalk = new RevWalk(db);

         try {

            RevCommit revCommit = revWalk.parseCommit(commitId);

            RefUpdate ru = db.updateRef(branch);

            ru.setForceUpdate(forceCommit);

            ru.setNewObjectId(commitId);

            ru.setExpectedOldObjectId(headId);

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

            Result rc = ru.update();



            switch (rc) {

            case NEW:

            case FORCED:

            case FAST_FORWARD:

               success = true;

               break;

            case REJECTED:

            case LOCK_FAILURE:

               throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD,

                     ru.getRef(), rc);

            default:

               throw new JGitInternalException(MessageFormat.format(

                     JGitText.get().updatingRefFailed, branch, commitId.toString(),

                     rc));

            }

         } finally {

            revWalk.close();

         }

      } finally {

         odi.close();

      }

      return success;

   }

	
   /**

    * Returns true if the commit identified by commitId is at the tip of it's branch.

    *

    * @param repository

    * @param commitId

    * @return true if the given commit is the tip

    */

   public static boolean isTip(Repository repository, String commitId) {

      try {

         RefModel tip = getBranch(repository, commitId);

         return (tip != null);	
      } catch (Exception e) {

         LOGGER.error("Failed to determine isTip", e);

      }

      return false;

   }



}