Change build identifiers

James Moger

2012-01-13 c508386dba5dd84de1f83fef8781b06acf903f15

 src/com/gitblit/utils/JGitUtils.java

@@ -24,7 +24,6 @@
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;

@@ -47,15 +46,20 @@
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;

@@ -743,25 +747,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, null);

      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));

@@ -770,7 +789,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);

         }

@@ -1360,37 +1384,74 @@
   }



   /**

    * Create an orphaned branch in a repository. This code does not work.

    * Create an orphaned branch in a repository.

    * 

    * @param repository

    * @param name

    * @return

    * @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 name) {

      return true;

      // boolean success = false;

      // try {

      // ObjectId prev = repository.resolve(Constants.HEAD + "^1");

      // // create the orphan branch

      // RefUpdate orphanRef = repository.updateRef(Constants.R_HEADS + name);

      // orphanRef.setNewObjectId(prev);

      // orphanRef.setExpectedOldObjectId(ObjectId.zeroId());

      // Result updateResult = orphanRef.update();

      //

      // switch (updateResult) {

      // case NEW:

      // success = true;

      // break;

      // case NO_CHANGE:

      // default:

      // break;

      // }

      //

      // } catch (Throwable t) {

      // error(t, repository, "{0} failed to create orphaned branch {1}",

      // name);

      // }

      // return success;

   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("NEWBRANCH", 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;

   }



   /**