githubFork/gitblit.git - Solinfo Gitblit

			@@ -20,24 +20,23 @@
			import java.io.IOException;
			import java.io.InputStream;
			import java.io.OutputStream;
			import java.nio.charset.Charset;
			import java.text.DateFormat;
			import java.text.ParseException;
			import java.text.SimpleDateFormat;
			import java.text.MessageFormat;
			import java.util.ArrayList;
			import java.util.Collection;
			import java.util.Arrays;
			import java.util.Collections;
			import java.util.Date;
			import java.util.HashMap;
			import java.util.List;
			import java.util.Map;
			import java.util.Map.Entry;
			import java.util.Set;
			import java.util.concurrent.atomic.AtomicInteger;
			import java.util.regex.Pattern;
			import java.util.zip.ZipEntry;
			import java.util.zip.ZipOutputStream;

			import org.eclipse.jgit.api.CloneCommand;
			import org.eclipse.jgit.api.FetchCommand;
			import org.eclipse.jgit.api.Git;
			import org.eclipse.jgit.api.errors.GitAPIException;
			import org.eclipse.jgit.diff.DiffEntry;
			import org.eclipse.jgit.diff.DiffEntry.ChangeType;
			import org.eclipse.jgit.diff.DiffFormatter;
			@@ -46,22 +45,32 @@
			import org.eclipse.jgit.errors.IncorrectObjectTypeException;
			import org.eclipse.jgit.errors.MissingObjectException;
			import org.eclipse.jgit.errors.StopWalkException;
			import org.eclipse.jgit.lib.AnyObjectId;
			import org.eclipse.jgit.lib.BlobBasedConfig;
			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.StoredConfig;
			import org.eclipse.jgit.lib.RepositoryCache.FileKey;
			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;
			import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
			import org.eclipse.jgit.treewalk.filter.OrTreeFilter;
			@@ -69,205 +78,479 @@
			import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
			import org.eclipse.jgit.treewalk.filter.PathSuffixFilter;
			import org.eclipse.jgit.treewalk.filter.TreeFilter;
			import org.eclipse.jgit.util.FS;
			import org.eclipse.jgit.util.io.DisabledOutputStream;
			import org.slf4j.Logger;
			import org.slf4j.LoggerFactory;

			import com.gitblit.models.Metric;
			import com.gitblit.models.GitNote;
			import com.gitblit.models.PathModel;
			import com.gitblit.models.RefModel;
			import com.gitblit.models.TicketModel;
			import com.gitblit.models.PathModel.PathChangeModel;
			import com.gitblit.models.TicketModel.Comment;
			import com.gitblit.models.RefModel;
			import com.gitblit.models.SubmoduleModel;

			/**
			* Collection of static methods for retrieving information from a repository.
			*
			* @author James Moger
			*
			*/
			public class JGitUtils {

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

			public static Repository createRepository(File repositoriesFolder, String name, boolean bare) {
			Git git = Git.init().setDirectory(new File(repositoriesFolder, name)).setBare(bare).call();
			return git.getRepository();
			/**
			* 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);
			}

			public static List<String> getRepositoryList(File repositoriesFolder, boolean exportAll,
			boolean readNested) {
			List<String> list = new ArrayList<String>();
			list.addAll(getNestedRepositories(repositoriesFolder, repositoriesFolder, exportAll,
			readNested));
			Collections.sort(list);
			return list;
			/**
			* Returns the displayable name of the person in the form "Real Name <email
			* address>". If the email address is empty, just "Real Name" is returned.
			*
			* @param person
			* @return "Real Name <email address>" or "Real Name"
			*/
			public static String getDisplayName(PersonIdent person) {
			if (StringUtils.isEmpty(person.getEmailAddress())) {
			return person.getName();
			}
			final StringBuilder r = new StringBuilder();
			r.append(person.getName());
			r.append(" <");
			r.append(person.getEmailAddress());
			r.append('>');
			return r.toString().trim();
			}

			public static List<String> getNestedRepositories(File repositoriesFolder, File folder,
			boolean exportAll, boolean readNested) {
			String basefile = repositoriesFolder.getAbsolutePath();
			/**
			* 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.
			*
			* @param repositoriesFolder
			* @param name
			* @param fromUrl
			* @return CloneResult
			* @throws Exception
			*/
			public static CloneResult cloneRepository(File repositoriesFolder, String name, String fromUrl)
			throws Exception {
			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.fetchResult = fetchRepository(credentialsProvider, repository);
			repository.close();
			} else {
			CloneCommand clone = new CloneCommand();
			clone.setBare(bare);
			clone.setCloneAllBranches(true);
			clone.setURI(fromUrl);
			clone.setDirectory(folder);
			if (credentialsProvider != null) {
			clone.setCredentialsProvider(credentialsProvider);
			}
			Repository repository = clone.call().getRepository();

			// Now we have to fetch because CloneCommand doesn't fetch
			// refs/notes nor does it allow manual RefSpec.
			result.createdRepository = true;
			result.fetchResult = fetchRepository(credentialsProvider, repository);
			repository.close();
			}
			return result;
			}

			/**
			* 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(CredentialsProvider credentialsProvider,
			Repository repository, RefSpec... refSpecs) throws Exception {
			Git git = new Git(repository);
			FetchCommand fetch = git.fetch();
			List<RefSpec> specs = new ArrayList<RefSpec>();
			if (refSpecs == null \|\| refSpecs.length == 0) {
			specs.add(new RefSpec("+refs/heads/:refs/remotes/origin/"));
			specs.add(new RefSpec("+refs/tags/:refs/tags/"));
			specs.add(new RefSpec("+refs/notes/:refs/notes/"));
			} else {
			specs.addAll(Arrays.asList(refSpecs));
			}
			if (credentialsProvider != null) {
			fetch.setCredentialsProvider(credentialsProvider);
			}
			fetch.setRefSpecs(specs);
			FetchResult fetchRes = fetch.call();
			return fetchRes;
			}

			/**
			* Creates a bare repository.
			*
			* @param repositoriesFolder
			* @param name
			* @return Repository
			*/
			public static Repository createRepository(File repositoriesFolder, String name) {
			try {
			Git git = Git.init().setDirectory(new File(repositoriesFolder, name)).setBare(true).call();
			return git.getRepository();
			} catch (GitAPIException e) {
			throw new RuntimeException(e);
			}
			}

			/**
			* Returns a list of repository names in the specified folder.
			*
			* @param repositoriesFolder
			* @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
			* @param depth
			* optional recursion depth, -1 = infinite recursion
			* @param exclusions
			* list of regex exclusions for matching to folder names
			* @return list of repository names
			*/
			public static List<String> getRepositoryList(File repositoriesFolder, boolean onlyBare,
			boolean searchSubfolders, int depth, List<String> exclusions) {
			List<String> list = new ArrayList<String>();
			if (folder == null \|\| !folder.exists()) {
			if (repositoriesFolder == null \|\| !repositoriesFolder.exists()) {
			return list;
			}
			for (File file : folder.listFiles()) {
			if (file.isDirectory() && !file.getName().equalsIgnoreCase(Constants.DOT_GIT)) {
			// if this is a git repository add it to the list
			//
			// first look for standard folder/.git structure
			File gitFolder = new File(file, Constants.DOT_GIT);
			boolean isGitRepository = gitFolder.exists() && gitFolder.isDirectory();
			List<Pattern> patterns = new ArrayList<Pattern>();
			if (!ArrayUtils.isEmpty(exclusions)) {
			for (String regex : exclusions) {
			patterns.add(Pattern.compile(regex));
			}
			}
			list.addAll(getRepositoryList(repositoriesFolder.getAbsolutePath(), repositoriesFolder,
			onlyBare, searchSubfolders, depth, patterns));
			StringUtils.sortRepositorynames(list);
			return list;
			}

			// then look for folder.git/HEAD or folder/HEAD and
			// folder/config
			if (!isGitRepository) {
			if ((file.getName().endsWith(Constants.DOT_GIT_EXT) && new File(file,
			Constants.HEAD).exists())
			\|\| (new File(file, "config").exists() && new File(file, Constants.HEAD)
			.exists())) {
			gitFolder = file;
			isGitRepository = true;
			/**
			* Recursive function to find git repositories.
			*
			* @param basePath
			* basePath is stripped from the repository name as repositories
			* are relative to this path
			* @param searchFolder
			* @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
			* @param depth
			* recursion depth, -1 = infinite recursion
			* @param patterns
			* list of regex patterns for matching to folder names
			* @return
			*/
			private static List<String> getRepositoryList(String basePath, File searchFolder,
			boolean onlyBare, boolean searchSubfolders, int depth, List<Pattern> patterns) {
			File baseFile = new File(basePath);
			List<String> list = new ArrayList<String>();
			if (depth == 0) {
			return list;
			}

			int nextDepth = (depth == -1) ? -1 : depth - 1;
			for (File file : searchFolder.listFiles()) {
			if (file.isDirectory()) {
			boolean exclude = false;
			for (Pattern pattern : patterns) {
			String path = FileUtils.getRelativePath(baseFile, file).replace('\\', '/');
			if (pattern.matcher(path).matches()) {
			LOGGER.debug(MessageFormat.format("excluding {0} because of rule {1}", path, pattern.pattern()));
			exclude = true;
			break;
			}
			}
			boolean exportRepository = isGitRepository
			&& (exportAll \|\| new File(gitFolder, "git-daemon-export-ok").exists());

			if (exportRepository) {
			// determine repository name relative to repositories folder
			String filename = file.getAbsolutePath();
			String repo = filename.substring(basefile.length()).replace('\\', '/');
			if (repo.charAt(0) == '/') {
			repo = repo.substring(1);
			}
			list.add(repo);
			if (exclude) {
			// skip to next file
			continue;
			}

			// look for nested repositories
			if (readNested) {
			list.addAll(getNestedRepositories(repositoriesFolder, file, exportAll,
			readNested));
			File gitDir = FileKey.resolve(new File(searchFolder, file.getName()), FS.DETECTED);
			if (gitDir != null) {
			if (onlyBare && gitDir.getName().equals(".git")) {
			continue;
			}
			if (gitDir.equals(file) \|\| gitDir.getParentFile().equals(file)) {
			// determine repository name relative to base path
			String repository = FileUtils.getRelativePath(baseFile, file);
			list.add(repository);
			} else if (searchSubfolders && file.canRead()) {
			// look for repositories in subfolders
			list.addAll(getRepositoryList(basePath, file, onlyBare, searchSubfolders,
			nextDepth, patterns));
			}
			} else if (searchSubfolders && file.canRead()) {
			// look for repositories in subfolders
			list.addAll(getRepositoryList(basePath, file, onlyBare, searchSubfolders,
			nextDepth, patterns));
			}
			}
			}
			return list;
			}

			public static RevCommit getFirstCommit(Repository r, String branch) {
			if (!hasCommits(r)) {
			/**
			* Returns the first commit on a branch. If the repository does not exist or
			* is empty, null is returned.
			*
			* @param repository
			* @param branch
			* if unspecified, HEAD is assumed.
			* @return RevCommit
			*/
			public static RevCommit getFirstCommit(Repository repository, String branch) {
			if (!hasCommits(repository)) {
			return null;
			}
			if (StringUtils.isEmpty(branch)) {
			branch = Constants.HEAD;
			}
			try {
			RevWalk walk = new RevWalk(r);
			walk.sort(RevSort.REVERSE);
			RevCommit head = walk.parseCommit(r.resolve(branch));
			walk.markStart(head);
			RevCommit commit = walk.next();
			walk.dispose();
			return commit;
			} catch (Throwable t) {
			LOGGER.error("Failed to determine first commit", t);
			}
			return null;
			}

			public static Date getFirstChange(Repository r, String branch) {
			try {
			RevCommit commit = getFirstCommit(r, branch);
			if (commit == null) {
			// fresh repository
			return new Date(r.getDirectory().lastModified());
			}
			return getCommitDate(commit);
			} catch (Throwable t) {
			LOGGER.error("Failed to determine first change", t);
			}
			return null;
			}

			public static boolean hasCommits(Repository r) {
			if (r != null && r.getDirectory().exists()) {
			return new File(r.getDirectory(), Constants.R_HEADS).list().length > 0;
			}
			return false;
			}

			public static Date getLastChange(Repository r) {
			if (!hasCommits(r)) {
			// null repository
			if (r == null) {
			return new Date(0);
			}
			// fresh repository
			return new Date(r.getDirectory().lastModified());
			}
			RevCommit commit = getCommit(r, Constants.HEAD);
			return getCommitDate(commit);
			}

			public static RevCommit getCommit(Repository r, String objectId) {
			RevCommit commit = null;
			if (!hasCommits(r)) {
			return null;
			}
			try {
			if (objectId == null \|\| objectId.trim().length() == 0) {
			objectId = Constants.HEAD;
			// resolve branch
			ObjectId branchObject;
			if (StringUtils.isEmpty(branch)) {
			branchObject = getDefaultBranch(repository);
			} else {
			branchObject = repository.resolve(branch);
			}
			ObjectId object = r.resolve(objectId);
			RevWalk walk = new RevWalk(r);
			RevCommit rev = walk.parseCommit(object);
			commit = rev;

			RevWalk walk = new RevWalk(repository);
			walk.sort(RevSort.REVERSE);
			RevCommit head = walk.parseCommit(branchObject);
			walk.markStart(head);
			commit = walk.next();
			walk.dispose();
			} catch (Throwable t) {
			LOGGER.error("Failed to get commit " + objectId, t);
			error(t, repository, "{0} failed to determine first commit");
			}
			return commit;
			}

			public static Map<ObjectId, List<String>> getAllRefs(Repository r) {
			Map<ObjectId, List<String>> refs = new HashMap<ObjectId, List<String>>();
			Map<AnyObjectId, Set<Ref>> allRefs = r.getAllRefsByPeeledObjectId();
			for (Entry<AnyObjectId, Set<Ref>> setRefs : allRefs.entrySet()) {
			List<String> list = new ArrayList<String>();
			for (Ref setRef : setRefs.getValue()) {
			String name = setRef.getName();
			list.add(name);
			/**
			* Returns the date of the first commit on a branch. If the repository does
			* not exist, Date(0) is returned. If the repository does exist bit is
			* empty, the last modified date of the repository folder is returned.
			*
			* @param repository
			* @param branch
			* if unspecified, HEAD is assumed.
			* @return Date of the first commit on a branch
			*/
			public static Date getFirstChange(Repository repository, String branch) {
			RevCommit commit = getFirstCommit(repository, branch);
			if (commit == null) {
			if (repository == null \|\| !repository.getDirectory().exists()) {
			return new Date(0);
			}
			refs.put(setRefs.getKey().toObjectId(), list);
			// fresh repository
			return new Date(repository.getDirectory().lastModified());
			}
			return refs;
			}

			public static Map<ObjectId, List<String>> getRefs(Repository r, String baseRef) {
			Map<ObjectId, List<String>> refs = new HashMap<ObjectId, List<String>>();
			Map<AnyObjectId, Set<Ref>> allRefs = r.getAllRefsByPeeledObjectId();
			for (Entry<AnyObjectId, Set<Ref>> setRefs : allRefs.entrySet()) {
			List<String> list = new ArrayList<String>();
			for (Ref setRef : setRefs.getValue()) {
			String name = setRef.getName();
			if (name.startsWith(baseRef)) {
			list.add(name);
			}
			}
			refs.put(setRefs.getKey().toObjectId(), list);
			}
			return refs;
			return getCommitDate(commit);
			}

			/**
			* Lookup an entry stored in a tree, failing if not present.
			* Determine if a repository has any commits. This is determined by checking
			* the for loose and packed objects.
			*
			* @param tree
			* the tree to search.
			* @param path
			* the path to find the entry of.
			* @return the parsed object entry at this path
			* @throws Exception
			* @param repository
			* @return true if the repository has commits
			*/
			public static RevObject getRevObject(Repository r, final RevTree tree, final String path) {
			RevObject ro = null;
			RevWalk rw = new RevWalk(r);
			TreeWalk tw = new TreeWalk(r);
			tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
			public static boolean hasCommits(Repository repository) {
			if (repository != null && repository.getDirectory().exists()) {
			return (new File(repository.getDirectory(), "objects").list().length > 2)
			\|\| (new File(repository.getDirectory(), "objects/pack").list().length > 0);
			}
			return false;
			}

			/**
			* Returns the date of the most recent commit on a branch. If the repository
			* does not exist Date(0) is returned. If it does exist but is empty, the
			* last modified date of the repository folder is returned.
			*
			* @param repository
			* @return
			*/
			public static Date getLastChange(Repository repository) {
			if (!hasCommits(repository)) {
			// null repository
			if (repository == null) {
			return new Date(0);
			}
			// fresh repository
			return new Date(repository.getDirectory().lastModified());
			}

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

			// 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 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();
			}

			/**
			* Returns the specified commit from the repository. If the repository does
			* not exist or is empty, null is returned.
			*
			* @param repository
			* @param objectId
			* if unspecified, HEAD is assumed.
			* @return RevCommit
			*/
			public static RevCommit getCommit(Repository repository, String objectId) {
			if (!hasCommits(repository)) {
			return null;
			}
			RevCommit commit = null;
			try {
			// resolve object id
			ObjectId branchObject;
			if (StringUtils.isEmpty(objectId)) {
			branchObject = getDefaultBranch(repository);
			} else {
			branchObject = repository.resolve(objectId);
			}
			RevWalk 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);
			}
			return commit;
			}

			/**
			* Retrieves the raw byte content of a file in the specified tree.
			*
			* @param repository
			* @param tree
			* if null, the RevTree from HEAD is assumed.
			* @param path
			* @return content as a byte []
			*/
			public static byte[] getByteContent(Repository repository, RevTree tree, final String path) {
			RevWalk rw = new RevWalk(repository);
			TreeWalk tw = new TreeWalk(repository);
			tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
			byte[] content = null;
			try {
			if (tree == null) {
			ObjectId object = getDefaultBranch(repository);
			RevCommit commit = rw.parseCommit(object);
			tree = commit.getTree();
			}
			tw.reset(tree);
			while (tw.next()) {
			if (tw.isSubtree() && !path.equals(tw.getPathString())) {
			@@ -276,221 +559,317 @@
			}
			ObjectId entid = tw.getObjectId(0);
			FileMode entmode = tw.getFileMode(0);
			ro = rw.lookupAny(entid, entmode.getObjectType());
			rw.parseBody(ro);
			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();
			}
			}
			} 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 {
			if (rw != null) {
			rw.dispose();
			}
			rw.dispose();
			tw.release();
			}
			return ro;
			return content;
			}

			public static byte[] getRawContent(Repository r, RevBlob blob) {
			ByteArrayOutputStream os = new ByteArrayOutputStream();
			/**
			* Returns the UTF-8 string content of a file in the specified tree.
			*
			* @param repository
			* @param tree
			* if null, the RevTree from HEAD is assumed.
			* @param blobPath
			* @param charsets optional
			* @return UTF-8 string content
			*/
			public static String getStringContent(Repository repository, RevTree tree, String blobPath, String... charsets) {
			byte[] content = getByteContent(repository, tree, blobPath);
			if (content == null) {
			return null;
			}
			return StringUtils.decodeString(content, charsets);
			}

			/**
			* Gets the raw byte content of the specified blob object.
			*
			* @param repository
			* @param objectId
			* @return byte [] blob content
			*/
			public static byte[] getByteContent(Repository repository, String objectId) {
			RevWalk rw = new RevWalk(repository);
			byte[] content = null;
			try {
			ObjectLoader ldr = r.open(blob.getId(), Constants.OBJ_BLOB);
			byte[] tmp = new byte[1024];
			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();
			} catch (Throwable t) {
			LOGGER.error("Failed to read raw content", t);
			error(t, repository, "{0} can't find blob {1}", objectId);
			} finally {
			rw.dispose();
			}
			return os.toByteArray();
			return content;
			}

			public static String getRawContentAsString(Repository r, RevBlob blob) {
			byte[] content = getRawContent(r, blob);
			return new String(content, Charset.forName(Constants.CHARACTER_ENCODING));
			/**
			* Gets the UTF-8 string content of the blob specified by objectId.
			*
			* @param repository
			* @param objectId
			* @param charsets optional
			* @return UTF-8 string content
			*/
			public static String getStringContent(Repository repository, String objectId, String... charsets) {
			byte[] content = getByteContent(repository, objectId);
			if (content == null) {
			return null;
			}
			return StringUtils.decodeString(content, charsets);
			}

			public static String getRawContentAsString(Repository r, RevCommit commit, String blobPath) {
			RevObject obj = getRevObject(r, commit.getTree(), blobPath);
			byte[] content = getRawContent(r, (RevBlob) obj);
			return new String(content, Charset.forName(Constants.CHARACTER_ENCODING));
			}

			public static List<PathModel> getFilesInPath(Repository r, String basePath, String objectId) {
			RevCommit commit = getCommit(r, objectId);
			return getFilesInPath(r, basePath, commit);
			}

			public static List<PathModel> getFilesInPath(Repository r, String basePath, RevCommit commit) {
			/**
			* 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.
			*
			* @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> getFilesInPath(Repository repository, String path,
			RevCommit commit) {
			List<PathModel> list = new ArrayList<PathModel>();
			if (commit == null) {
			if (!hasCommits(repository)) {
			return list;
			}
			final TreeWalk walk = new TreeWalk(r);
			if (commit == null) {
			commit = getCommit(repository, null);
			}
			final TreeWalk tw = new TreeWalk(repository);
			try {
			walk.addTree(commit.getTree());
			if (basePath != null && basePath.length() > 0) {
			PathFilter f = PathFilter.create(basePath);
			walk.setFilter(f);
			walk.setRecursive(false);
			tw.addTree(commit.getTree());
			if (!StringUtils.isEmpty(path)) {
			PathFilter f = PathFilter.create(path);
			tw.setFilter(f);
			tw.setRecursive(false);
			boolean foundFolder = false;
			while (walk.next()) {
			if (!foundFolder && walk.isSubtree()) {
			walk.enterSubtree();
			while (tw.next()) {
			if (!foundFolder && tw.isSubtree()) {
			tw.enterSubtree();
			}
			if (walk.getPathString().equals(basePath)) {
			if (tw.getPathString().equals(path)) {
			foundFolder = true;
			continue;
			}
			if (foundFolder) {
			list.add(getPathModel(walk, basePath, commit));
			list.add(getPathModel(tw, path, commit));
			}
			}
			} else {
			walk.setRecursive(false);
			while (walk.next()) {
			list.add(getPathModel(walk, null, commit));
			tw.setRecursive(false);
			while (tw.next()) {
			list.add(getPathModel(tw, null, commit));
			}
			}
			} 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 {
			walk.release();
			tw.release();
			}
			Collections.sort(list);
			return list;
			}

			public static List<PathChangeModel> getFilesInCommit(Repository r, String commitId) {
			RevCommit commit = getCommit(r, commitId);
			return getFilesInCommit(r, commit);
			}

			public static List<PathChangeModel> getFilesInCommit(Repository r, RevCommit commit) {
			/**
			* 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 commit
			* if null, HEAD is assumed.
			* @return list of files changed in a commit
			*/
			public static List<PathChangeModel> getFilesInCommit(Repository repository, RevCommit commit) {
			List<PathChangeModel> list = new ArrayList<PathChangeModel>();
			if (commit == null) {
			LOGGER.warn("getFilesInCommit for NULL commit");
			if (!hasCommits(repository)) {
			return list;
			}
			RevWalk rw = new RevWalk(repository);
			try {
			final RevWalk rw = new RevWalk(r);
			RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
			RevTree parentTree = parent.getTree();
			RevTree commitTree = commit.getTree();
			if (commit == null) {
			ObjectId object = getDefaultBranch(repository);
			commit = rw.parseCommit(object);
			}

			final TreeWalk walk = new TreeWalk(r);
			walk.reset();
			walk.setRecursive(true);
			walk.addTree(parentTree);
			walk.addTree(commitTree);
			walk.setFilter(TreeFilter.ANY_DIFF);
			if (commit.getParentCount() == 0) {
			TreeWalk tw = new TreeWalk(repository);
			tw.reset();
			tw.setRecursive(true);
			tw.addTree(commit.getTree());
			while (tw.next()) {
			list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), 0, tw
			.getRawMode(0), tw.getObjectId(0).getName(), commit.getId().getName(),
			ChangeType.ADD));
			}
			tw.release();
			} else {
			RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
			DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
			df.setRepository(repository);
			df.setDiffComparator(RawTextComparator.DEFAULT);
			df.setDetectRenames(true);
			List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
			for (DiffEntry diff : diffs) {
			String objectId = null;
			if (FileMode.GITLINK.equals(diff.getNewMode())) {
			objectId = diff.getNewId().name();
			}

			RawTextComparator cmp = RawTextComparator.DEFAULT;
			DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
			df.setRepository(r);
			df.setDiffComparator(cmp);
			df.setDetectRenames(true);
			List<DiffEntry> diffs = df.scan(parentTree, commitTree);
			for (DiffEntry diff : diffs) {
			if (diff.getChangeType().equals(ChangeType.DELETE)) {
			list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 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.getChangeType()));
			if (diff.getChangeType().equals(ChangeType.DELETE)) {
			list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff
			.getNewMode().getBits(), objectId, commit.getId().getName(), diff
			.getChangeType()));
			} else if (diff.getChangeType().equals(ChangeType.RENAME)) {
			list.add(new PathChangeModel(diff.getOldPath(), diff.getNewPath(), 0, diff
			.getNewMode().getBits(), objectId, commit.getId().getName(), diff
			.getChangeType()));
			} else {
			list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff
			.getNewMode().getBits(), objectId, commit.getId().getName(), diff
			.getChangeType()));
			}
			}
			}
			} 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();
			}
			return list;
			}

			public static List<PathModel> getDocuments(Repository r, List<String> extensions) {
			/**
			* 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>();
			RevCommit commit = getCommit(r, Constants.HEAD);
			final TreeWalk walk = new TreeWalk(r);
			if (!hasCommits(repository)) {
			return list;
			}
			RevCommit commit = getCommit(repository, objectId);
			final TreeWalk tw = new TreeWalk(repository);
			try {
			walk.addTree(commit.getTree());
			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));
			suffixFilters.add(PathSuffixFilter.create("\\" + extension));
			} else {
			// escape the . since this is a regexp filter
			suffixFilters.add(PathSuffixFilter.create("\\." + extension));
			}
			}
			TreeFilter filter = OrTreeFilter.create(suffixFilters);
			walk.setFilter(filter);
			walk.setRecursive(true);
			while (walk.next()) {
			list.add(getPathModel(walk, null, commit));
			TreeFilter filter;
			if (suffixFilters.size() == 1) {
			filter = suffixFilters.get(0);
			} else {
			filter = OrTreeFilter.create(suffixFilters);
			}
			} else {
			while (walk.next()) {
			list.add(getPathModel(walk, null, commit));
			}
			tw.setFilter(filter);
			tw.setRecursive(true);
			}
			while (tw.next()) {
			list.add(getPathModel(tw, null, commit));
			}
			} catch (IOException e) {
			LOGGER.error("Failed to get files for commit " + commit.getName(), e);
			error(e, repository, "{0} failed to get documents for commit {1}", commit.getName());
			} finally {
			walk.release();
			tw.release();
			}
			Collections.sort(list);
			return list;
			}

			public static Map<ChangeType, AtomicInteger> getChangedPathsStats(List<PathChangeModel> paths) {
			Map<ChangeType, AtomicInteger> stats = new HashMap<ChangeType, AtomicInteger>();
			for (PathChangeModel path : paths) {
			if (!stats.containsKey(path.changeType)) {
			stats.put(path.changeType, new AtomicInteger(0));
			}
			stats.get(path.changeType).incrementAndGet();
			}
			return stats;
			}

			public static enum DiffOutputType {
			PLAIN, GITWEB, GITBLIT;

			public static DiffOutputType forName(String name) {
			for (DiffOutputType type : values()) {
			if (type.name().equalsIgnoreCase(name)) {
			return type;
			}
			}
			return null;
			}
			}

			private static PathModel getPathModel(TreeWalk walk, String basePath, RevCommit commit) {
			/**
			* Returns a path model of the current file in the treewalk.
			*
			* @param tw
			* @param basePath
			* @param commit
			* @return a path model of the current file in the treewalk
			*/
			private static PathModel getPathModel(TreeWalk tw, String basePath, RevCommit commit) {
			String name;
			long size = 0;
			if (basePath == null) {
			name = walk.getPathString();
			if (StringUtils.isEmpty(basePath)) {
			name = tw.getPathString();
			} else {
			try {
			name = walk.getPathString().substring(basePath.length() + 1);
			} catch (Throwable t) {
			name = walk.getPathString();
			}
			name = tw.getPathString().substring(basePath.length() + 1);
			}
			ObjectId objectId = tw.getObjectId(0);
			try {
			if (!walk.isSubtree()) {
			size = walk.getObjectReader()
			.getObjectSize(walk.getObjectId(0), Constants.OBJ_BLOB);
			if (!tw.isSubtree() && (tw.getFileMode(0) != FileMode.GITLINK)) {
			size = tw.getObjectReader().getObjectSize(objectId, 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, walk.getPathString(), size, walk.getFileMode(0).getBits(),
			commit.getName());
			return new PathModel(name, tw.getPathString(), size, tw.getFileMode(0).getBits(),
			objectId.getName(), commit.getName());
			}

			/**
			* Returns a permissions representation of the mode bits.
			*
			* @param mode
			* @return string representation of the mode bits
			*/
			public static String getPermissionsFromMode(int mode) {
			if (FileMode.TREE.equals(mode)) {
			return "drwxr-xr-x";
			@@ -499,50 +878,130 @@
			} else if (FileMode.EXECUTABLE_FILE.equals(mode)) {
			return "-rwxr-xr-x";
			} else if (FileMode.SYMLINK.equals(mode)) {
			// FIXME symlink permissions
			return "symlink";
			} else if (FileMode.GITLINK.equals(mode)) {
			// FIXME gitlink permissions
			return "gitlink";
			} else if (FileMode.MISSING.equals(mode)) {
			// FIXME missing permissions
			return "missing";
			return "submodule";
			}
			return "" + mode;
			return "missing";
			}

			public static boolean isTreeFromMode(int mode) {
			return FileMode.TREE.equals(mode);
			}

			public static List<RevCommit> getRevLog(Repository r, int maxCount) {
			return getRevLog(r, Constants.HEAD, 0, maxCount);
			}

			public static List<RevCommit> getRevLog(Repository r, String objectId, int offset, int maxCount) {
			return getRevLog(r, objectId, null, offset, maxCount);
			}

			public static List<RevCommit> getRevLog(Repository r, String objectId, String path, int offset,
			int maxCount) {
			/**
			* 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(r)) {
			if (!hasCommits(repository)) {
			return list;
			}
			try {
			if (objectId == null \|\| objectId.trim().length() == 0) {
			objectId = Constants.HEAD;
			// resolve branch
			ObjectId branchObject;
			if (StringUtils.isEmpty(objectId)) {
			branchObject = getDefaultBranch(repository);
			} else {
			branchObject = repository.resolve(objectId);
			}
			RevWalk walk = new RevWalk(r);
			ObjectId object = r.resolve(objectId);
			walk.markStart(walk.parseCommit(object));

			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
			* @param maxCount
			* if < 0, all commits for the repository are returned.
			* @return list of commits
			*/
			public static List<RevCommit> getRevLog(Repository repository, int maxCount) {
			return getRevLog(repository, null, 0, maxCount);
			}

			/**
			* Returns a list of commits starting from the specified objectId using an
			* offset and maxCount for paging. This is similar to LIMIT n OFFSET p in
			* SQL. If the repository does not exist or is empty, an empty list is
			* returned.
			*
			* @param repository
			* @param objectId
			* if unspecified, HEAD is assumed.
			* @param offset
			* @param maxCount
			* if < 0, all commits are returned.
			* @return a paged list of commits
			*/
			public static List<RevCommit> getRevLog(Repository repository, String objectId, int offset,
			int maxCount) {
			return getRevLog(repository, objectId, null, offset, maxCount);
			}

			/**
			* Returns a list of commits for the repository or a path within the
			* repository. Caller may specify ending revision with objectId. Caller may
			* specify offset and maxCount to achieve pagination of results. If the
			* repository does not exist or is empty, an empty list is returned.
			*
			* @param repository
			* @param objectId
			* if unspecified, HEAD is assumed.
			* @param path
			* if unspecified, commits for repository are returned. If
			* specified, commits for the path are returned.
			* @param offset
			* @param maxCount
			* if < 0, all commits are returned.
			* @return a paged list of commits
			*/
			public static List<RevCommit> getRevLog(Repository repository, String objectId, String path,
			int offset, int maxCount) {
			List<RevCommit> list = new ArrayList<RevCommit>();
			if (maxCount == 0) {
			return list;
			}
			if (!hasCommits(repository)) {
			return list;
			}
			try {
			// resolve branch
			ObjectId branchObject;
			if (StringUtils.isEmpty(objectId)) {
			branchObject = getDefaultBranch(repository);
			} else {
			branchObject = repository.resolve(objectId);
			}
			if (branchObject == null) {
			return list;
			}

			RevWalk rw = new RevWalk(repository);
			rw.markStart(rw.parseCommit(branchObject));
			if (!StringUtils.isEmpty(path)) {
			TreeFilter filter = AndTreeFilter.create(
			PathFilterGroup.createFromStrings(Collections.singleton(path)),
			TreeFilter.ANY_DIFF);
			walk.setTreeFilter(filter);
			rw.setTreeFilter(filter);
			}
			Iterable<RevCommit> revlog = walk;
			Iterable<RevCommit> revlog = rw;
			if (offset > 0) {
			int count = 0;
			for (RevCommit rev : revlog) {
			@@ -562,71 +1021,129 @@
			}
			}
			}
			walk.dispose();
			rw.dispose();
			} catch (Throwable t) {
			LOGGER.error("Failed to determine last change", t);
			error(t, repository, "{0} failed to get {1} revlog for path {2}", objectId, path);
			}
			return list;
			}

			public static enum SearchType {
			AUTHOR, COMMITTER, COMMIT;

			public static SearchType forName(String name) {
			for (SearchType type : values()) {
			if (type.name().equalsIgnoreCase(name)) {
			return type;
			}
			}
			return null;
			}

			public String toString() {
			return name().toLowerCase();
			}
			}

			public static List<RevCommit> searchRevlogs(Repository r, String objectId, String value,
			final SearchType type, int offset, int maxCount) {
			final String lcValue = value.toLowerCase();
			/**
			* 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(r)) {
			if (!hasCommits(repository)) {
			return list;
			}
			try {
			if (objectId == null \|\| objectId.trim().length() == 0) {
			objectId = Constants.HEAD;
			ObjectId endRange = repository.resolve(endRangeId);
			ObjectId startRange = repository.resolve(startRangeId);

			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));
			}
			RevWalk walk = new RevWalk(r);
			walk.setRevFilter(new RevFilter() {

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

			/**
			* Search the commit history for a case-insensitive match to the value.
			* Search results require a specified SearchType of AUTHOR, COMMITTER, or
			* COMMIT. Results may be paginated using offset and maxCount. If the
			* repository does not exist or is empty, an empty list is returned.
			*
			* @param repository
			* @param objectId
			* if unspecified, HEAD is assumed.
			* @param value
			* @param type
			* AUTHOR, COMMITTER, COMMIT
			* @param offset
			* @param maxCount
			* if < 0, all matches are returned
			* @return matching list of commits
			*/
			public static List<RevCommit> searchRevlogs(Repository repository, String objectId,
			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) {
			return list;
			}
			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.setRevFilter(new RevFilter() {

			@Override
			public RevFilter clone() {
			// FindBugs complains about this method name.
			// This is part of JGit design and unrelated to Cloneable.
			return this;
			}

			@Override
			public boolean include(RevWalk walker, RevCommit commit) throws StopWalkException,
			MissingObjectException, IncorrectObjectTypeException, IOException {
			boolean include = false;
			switch (type) {
			case AUTHOR:
			return (commit.getAuthorIdent().getName().toLowerCase().indexOf(lcValue) > -1)
			include = (commit.getAuthorIdent().getName().toLowerCase().indexOf(lcValue) > -1)
			\|\| (commit.getAuthorIdent().getEmailAddress().toLowerCase()
			.indexOf(lcValue) > -1);
			break;
			case COMMITTER:
			return (commit.getCommitterIdent().getName().toLowerCase().indexOf(lcValue) > -1)
			include = (commit.getCommitterIdent().getName().toLowerCase()
			.indexOf(lcValue) > -1)
			\|\| (commit.getCommitterIdent().getEmailAddress().toLowerCase()
			.indexOf(lcValue) > -1);
			break;
			case COMMIT:
			return commit.getFullMessage().toLowerCase().indexOf(lcValue) > -1;
			include = commit.getFullMessage().toLowerCase().indexOf(lcValue) > -1;
			break;
			}
			return false;
			return include;
			}

			});
			ObjectId object = r.resolve(objectId);
			walk.markStart(walk.parseCommit(object));
			Iterable<RevCommit> revlog = walk;
			rw.markStart(rw.parseCommit(branchObject));
			Iterable<RevCommit> revlog = rw;
			if (offset > 0) {
			int count = 0;
			for (RevCommit rev : revlog) {
			@@ -646,116 +1163,614 @@
			}
			}
			}
			walk.dispose();
			rw.dispose();
			} catch (Throwable t) {
			LOGGER.error("Failed to determine last change", t);
			error(t, repository, "{0} failed to {1} search revlogs for {2}", type.name(), value);
			}
			return list;
			}

			public static List<RefModel> getTags(Repository r, int maxCount) {
			return getRefs(r, Constants.R_TAGS, maxCount);
			/**
			* 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;
			}

			public static List<RefModel> getLocalBranches(Repository r, int maxCount) {
			return getRefs(r, Constants.R_HEADS, maxCount);
			}

			public static List<RefModel> getRemoteBranches(Repository r, int maxCount) {
			return getRefs(r, Constants.R_REMOTES, maxCount);
			}

			public static List<RefModel> getRefs(Repository r, String refs, int maxCount) {
			List<RefModel> list = new ArrayList<RefModel>();
			/**
			* 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 {
			Map<String, Ref> map = r.getRefDatabase().getRefs(refs);
			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;
			}

			/**
			* Sets the local branch ref to point to the specified commit id.
			*
			* @param repository
			* @param branch
			* @param commitId
			* @return true if successful
			*/
			public static boolean setBranchRef(Repository repository, String branch, String commitId) {
			String branchName = branch;
			if (!branchName.startsWith(Constants.R_HEADS)) {
			branchName = Constants.R_HEADS + branch;
			}

			try {
			RefUpdate refUpdate = repository.updateRef(branchName, false);
			refUpdate.setNewObjectId(ObjectId.fromString(commitId));
			RefUpdate.Result result = refUpdate.forceUpdate();

			switch (result) {
			case NEW:
			case FORCED:
			case NO_CHANGE:
			case FAST_FORWARD:
			return true;
			default:
			LOGGER.error(MessageFormat.format("{0} {1} update to {2} returned result {3}",
			repository.getDirectory().getAbsolutePath(), branchName, commitId, result));
			}
			} catch (Throwable t) {
			error(t, repository, "{0} failed to set {1} to {2}", branchName, commitId);
			}
			return false;
			}

			/**
			* Deletes the specified branch ref.
			*
			* @param repository
			* @param branch
			* @return true if successful
			*/
			public static boolean deleteBranchRef(Repository repository, String branch) {
			String branchName = branch;
			if (!branchName.startsWith(Constants.R_HEADS)) {
			branchName = Constants.R_HEADS + branch;
			}

			try {
			RefUpdate refUpdate = repository.updateRef(branchName, false);
			refUpdate.setForceUpdate(true);
			RefUpdate.Result result = refUpdate.delete();
			switch (result) {
			case NEW:
			case FORCED:
			case NO_CHANGE:
			case FAST_FORWARD:
			return true;
			default:
			LOGGER.error(MessageFormat.format("{0} failed to delete to {1} returned result {2}",
			repository.getDirectory().getAbsolutePath(), branchName, result));
			}
			} catch (Throwable t) {
			error(t, repository, "{0} failed to delete {1}", branchName);
			}
			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;
			}

			/**
			* Returns all refs grouped by their associated object id.
			*
			* @param repository
			* @return all refs grouped by their referenced object id
			*/
			public static Map<ObjectId, List<RefModel>> getAllRefs(Repository repository) {
			return getAllRefs(repository, true);
			}

			/**
			* Returns all refs grouped by their associated object id.
			*
			* @param repository
			* @param includeRemoteRefs
			* @return all refs grouped by their referenced object id
			*/
			public static Map<ObjectId, List<RefModel>> getAllRefs(Repository repository, boolean includeRemoteRefs) {
			List<RefModel> list = getRefs(repository, org.eclipse.jgit.lib.RefDatabase.ALL, true, -1);
			Map<ObjectId, List<RefModel>> refs = new HashMap<ObjectId, List<RefModel>>();
			for (RefModel ref : list) {
			if (!includeRemoteRefs && ref.getName().startsWith(Constants.R_REMOTES)) {
			continue;
			}
			ObjectId objectid = ref.getReferencedObjectId();
			if (!refs.containsKey(objectid)) {
			refs.put(objectid, new ArrayList<RefModel>());
			}
			refs.get(objectid).add(ref);
			}
			return refs;
			}

			/**
			* 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
			* @return list of tags
			*/
			public static List<RefModel> getTags(Repository repository, boolean fullName, int maxCount) {
			return getRefs(repository, Constants.R_TAGS, fullName, maxCount);
			}

			/**
			* Returns the list of local branches in the repository. If repository does
			* not exist or is empty, an empty list is returned.
			*
			* @param repository
			* @param fullName
			* if true, /refs/heads/yadayadayada is returned. If false,
			* yadayadayada is returned.
			* @param maxCount
			* if < 0, all local branches are returned
			* @return list of local branches
			*/
			public static List<RefModel> getLocalBranches(Repository repository, boolean fullName,
			int maxCount) {
			return getRefs(repository, Constants.R_HEADS, fullName, maxCount);
			}

			/**
			* Returns the list of remote branches in the repository. If repository does
			* not exist or is empty, an empty list is returned.
			*
			* @param repository
			* @param fullName
			* if true, /refs/remotes/yadayadayada is returned. If false,
			* yadayadayada is returned.
			* @param maxCount
			* if < 0, all remote branches are returned
			* @return list of remote branches
			*/
			public static List<RefModel> getRemoteBranches(Repository repository, boolean fullName,
			int maxCount) {
			return getRefs(repository, Constants.R_REMOTES, fullName, maxCount);
			}

			/**
			* Returns the list of note branches. If repository does not exist or is
			* empty, an empty list is returned.
			*
			* @param repository
			* @param fullName
			* if true, /refs/notes/yadayadayada is returned. If false,
			* yadayadayada is returned.
			* @param maxCount
			* if < 0, all note branches are returned
			* @return list of note branches
			*/
			public static List<RefModel> getNoteBranches(Repository repository, boolean fullName,
			int maxCount) {
			return getRefs(repository, Constants.R_NOTES, fullName, maxCount);
			}

			/**
			* 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
			* @return list of references
			*/
			private static List<RefModel> getRefs(Repository repository, String refs, boolean fullName,
			int maxCount) {
			List<RefModel> list = new ArrayList<RefModel>();
			if (maxCount == 0) {
			return list;
			}
			if (!hasCommits(repository)) {
			return list;
			}
			try {
			Map<String, Ref> map = repository.getRefDatabase().getRefs(refs);
			RevWalk rw = new RevWalk(repository);
			for (Entry<String, Ref> entry : map.entrySet()) {
			Ref ref = entry.getValue();
			RevCommit commit = getCommit(r, ref.getObjectId().getName());
			list.add(new RefModel(entry.getKey(), ref, commit));
			RevObject object = rw.parseAny(ref.getObjectId());
			String name = entry.getKey();
			if (fullName && !StringUtils.isEmpty(refs)) {
			name = refs + name;
			}
			list.add(new RefModel(name, ref, object));
			}
			rw.dispose();
			Collections.sort(list);
			Collections.reverse(list);
			if (maxCount > 0 && list.size() > maxCount) {
			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;
			}

			public static Ref getRef(Repository r, String id) {
			// FIXME
			/**
			* 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 {
			Map<String, Ref> map = r.getRefDatabase().getRefs(id);
			for (Entry<String, Ref> entry : map.entrySet()) {
			return entry.getValue();
			// search for the branch in local heads
			for (RefModel ref : JGitUtils.getLocalBranches(repository, false, -1)) {
			if (ref.displayName.endsWith(name)) {
			branch = ref;
			break;
			}
			}
			} catch (IOException e) {
			LOGGER.error("Failed to retrieve ref " + id, e);

			// 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;
			}

			/**
			* Returns the list of submodules for this repository.
			*
			* @param repository
			* @param commit
			* @return list of submodules
			*/
			public static List<SubmoduleModel> getSubmodules(Repository repository, String commitId) {
			RevCommit commit = getCommit(repository, commitId);
			return getSubmodules(repository, commit.getTree());
			}

			/**
			* Returns the list of submodules for this repository.
			*
			* @param repository
			* @param commit
			* @return list of submodules
			*/
			public static List<SubmoduleModel> getSubmodules(Repository repository, RevTree tree) {
			List<SubmoduleModel> list = new ArrayList<SubmoduleModel>();
			byte [] blob = getByteContent(repository, tree, ".gitmodules");
			if (blob == null) {
			return list;
			}
			try {
			BlobBasedConfig config = new BlobBasedConfig(repository.getConfig(), blob);
			for (String module : config.getSubsections("submodule")) {
			String path = config.getString("submodule", module, "path");
			String url = config.getString("submodule", module, "url");
			list.add(new SubmoduleModel(module, path, url));
			}
			} catch (ConfigInvalidException e) {
			LOGGER.error("Failed to load .gitmodules file for " + repository.getDirectory(), e);
			}
			return list;
			}

			/**
			* Returns the submodule definition for the specified path at the specified
			* commit. If no module is defined for the path, null is returned.
			*
			* @param repository
			* @param commit
			* @param path
			* @return a submodule definition or null if there is no submodule
			*/
			public static SubmoduleModel getSubmoduleModel(Repository repository, String commitId, String path) {
			for (SubmoduleModel model : getSubmodules(repository, commitId)) {
			if (model.path.equals(path)) {
			return model;
			}
			}
			return null;
			}

			public static Date getCommitDate(RevCommit commit) {
			return new Date(commit.getCommitTime() * 1000L);
			/**
			* Returns the list of notes entered about the commit from the refs/notes
			* namespace. If the repository does not exist or is empty, an empty list is
			* returned.
			*
			* @param repository
			* @param commit
			* @return list of notes
			*/
			public static List<GitNote> getNotesOnCommit(Repository repository, RevCommit commit) {
			List<GitNote> list = new ArrayList<GitNote>();
			if (!hasCommits(repository)) {
			return list;
			}
			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, '/');
			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
			.size() - 1));
			GitNote gitNote = new GitNote(noteRef, text);
			list.add(gitNote);
			}
			}
			return list;
			}

			public static String getDisplayName(PersonIdent person) {
			final StringBuilder r = new StringBuilder();
			r.append(person.getName());
			r.append(" <");
			r.append(person.getEmailAddress());
			r.append('>');
			return r.toString();
			}

			public static StoredConfig readConfig(Repository r) {
			StoredConfig c = r.getConfig();
			if (c != null) {
			/**
			* 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 {
			c.load();
			} catch (ConfigInvalidException cex) {
			LOGGER.error("Repository configuration is invalid!", cex);
			} catch (IOException cex) {
			LOGGER.error("Could not open repository configuration!", cex);
			// 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();
			}
			return c;
			} catch (Throwable t) {
			error(t, repository, "Failed to create orphan branch {1} in repository {0}", branchName);
			}
			return null;
			return success;
			}

			public static boolean zip(Repository r, String basePath, String objectId, OutputStream os)
			throws Exception {
			RevCommit commit = getCommit(r, objectId);
			/**
			* Zips the contents of the tree at the (optionally) specified revision and
			* the (optionally) specified basepath to the supplied outputstream.
			*
			* @param repository
			* @param basePath
			* if unspecified, entire repository is assumed.
			* @param objectId
			* if unspecified, HEAD is assumed.
			* @param os
			* @return true if repository was successfully zipped to supplied output
			* stream
			*/
			public static boolean zip(Repository repository, String basePath, String objectId,
			OutputStream os) {
			RevCommit commit = getCommit(repository, objectId);
			if (commit == null) {
			return false;
			}
			final RevWalk rw = new RevWalk(r);
			final TreeWalk walk = new TreeWalk(r);
			boolean success = false;
			RevWalk rw = new RevWalk(repository);
			TreeWalk tw = new TreeWalk(repository);
			try {
			walk.addTree(commit.getTree());
			tw.addTree(commit.getTree());
			ZipOutputStream zos = new ZipOutputStream(os);
			zos.setComment("Generated by Git:Blit");
			if (basePath != null && basePath.length() > 0) {
			zos.setComment("Generated by Gitblit");
			if (!StringUtils.isEmpty(basePath)) {
			PathFilter f = PathFilter.create(basePath);
			walk.setFilter(f);
			tw.setFilter(f);
			}
			walk.setRecursive(true);
			while (walk.next()) {
			ZipEntry entry = new ZipEntry(walk.getPathString());
			entry.setSize(walk.getObjectReader().getObjectSize(walk.getObjectId(0),
			tw.setRecursive(true);
			while (tw.next()) {
			if (tw.getFileMode(0) == FileMode.GITLINK) {
			continue;
			}
			ZipEntry entry = new ZipEntry(tw.getPathString());
			entry.setSize(tw.getObjectReader().getObjectSize(tw.getObjectId(0),
			Constants.OBJ_BLOB));
			entry.setComment(commit.getName());
			zos.putNextEntry(entry);

			ObjectId entid = walk.getObjectId(0);
			FileMode entmode = walk.getFileMode(0);
			ObjectId entid = tw.getObjectId(0);
			FileMode entmode = tw.getFileMode(0);
			RevBlob blob = (RevBlob) rw.lookupAny(entid, entmode.getObjectType());
			rw.parseBody(blob);

			ObjectLoader ldr = r.open(blob.getId(), Constants.OBJ_BLOB);
			ObjectLoader ldr = repository.open(blob.getId(), Constants.OBJ_BLOB);
			byte[] tmp = new byte[4096];
			InputStream in = ldr.openStream();
			int n;
			@@ -765,175 +1780,13 @@
			in.close();
			}
			zos.finish();
			return true;
			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 {
			walk.release();
			tw.release();
			rw.dispose();
			}
			return false;
			}

			public static List<Metric> getDateMetrics(Repository r) {
			Metric total = new Metric("TOTAL");
			final Map<String, Metric> metricMap = new HashMap<String, Metric>();

			if (hasCommits(r)) {
			final List<RefModel> tags = getTags(r, -1);
			final Map<ObjectId, RefModel> tagMap = new HashMap<ObjectId, RefModel>();
			for (RefModel tag : tags) {
			tagMap.put(tag.getCommitId(), tag);
			}
			try {
			RevWalk walk = new RevWalk(r);
			ObjectId object = r.resolve(Constants.HEAD);

			RevCommit firstCommit = getFirstCommit(r, Constants.HEAD);
			RevCommit lastCommit = walk.parseCommit(object);
			int diffDays = (lastCommit.getCommitTime() - firstCommit.getCommitTime())
			/ (60 * 60 * 24);
			total.duration = diffDays;
			DateFormat df;
			if (diffDays <= 90) {
			// Days
			df = new SimpleDateFormat("yyyy-MM-dd");
			} else if (diffDays > 90 && diffDays < 365) {
			// Weeks
			df = new SimpleDateFormat("yyyy-MM (w)");
			} else {
			// Months
			df = new SimpleDateFormat("yyyy-MM");
			}
			walk.markStart(lastCommit);

			Iterable<RevCommit> revlog = walk;
			for (RevCommit rev : revlog) {
			Date d = getCommitDate(rev);
			String p = df.format(d);
			if (!metricMap.containsKey(p)) {
			metricMap.put(p, new Metric(p));
			}
			Metric m = metricMap.get(p);
			m.count++;
			total.count++;
			if (tagMap.containsKey(rev.getId())) {
			m.tag++;
			total.tag++;
			}
			}
			} catch (Throwable t) {
			LOGGER.error("Failed to mine log history for metrics", t);
			}
			}
			List<String> keys = new ArrayList<String>(metricMap.keySet());
			Collections.sort(keys);
			List<Metric> metrics = new ArrayList<Metric>();
			for (String key : keys) {
			metrics.add(metricMap.get(key));
			}
			metrics.add(0, total);
			return metrics;
			}

			public static RefModel getTicketsBranch(Repository r) {
			RefModel ticgitBranch = null;
			try {
			// search for ticgit branch in local heads
			for (RefModel ref : getLocalBranches(r, -1)) {
			if (ref.displayName.endsWith("ticgit")) {
			ticgitBranch = ref;
			break;
			}
			}

			// search for ticgit branch in remote heads
			if (ticgitBranch == null) {
			for (RefModel ref : getRemoteBranches(r, -1)) {
			if (ref.displayName.endsWith("ticgit")) {
			ticgitBranch = ref;
			break;
			}
			}
			}
			} catch (Throwable t) {
			LOGGER.error("Failed to find ticgit branch!", t);
			}
			return ticgitBranch;
			}

			public static List<TicketModel> getTickets(Repository r) {
			RefModel ticgitBranch = getTicketsBranch(r);
			List<PathModel> paths = getFilesInPath(r, null, ticgitBranch.commit);
			List<TicketModel> tickets = new ArrayList<TicketModel>();
			for (PathModel ticketFolder : paths) {
			if (ticketFolder.isTree()) {
			try {
			TicketModel t = new TicketModel(ticketFolder.name);
			readTicketContents(r, ticgitBranch, t);
			tickets.add(t);
			} catch (Throwable t) {
			LOGGER.error("Failed to get a ticket!", t);
			}
			}
			}
			Collections.sort(tickets);
			Collections.reverse(tickets);
			return tickets;
			}

			public static TicketModel getTicket(Repository r, String ticketFolder) {
			RefModel ticketsBranch = getTicketsBranch(r);
			if (ticketsBranch != null) {
			try {
			TicketModel ticket = new TicketModel(ticketFolder);
			readTicketContents(r, ticketsBranch, ticket);
			return ticket;
			} catch (Throwable t) {
			LOGGER.error("Failed to get ticket " + ticketFolder, t);
			}
			}
			return null;
			}

			private static void readTicketContents(Repository r, RefModel ticketsBranch, TicketModel ticket) {
			List<PathModel> ticketFiles = getFilesInPath(r, ticket.name, ticketsBranch.commit);
			for (PathModel file : ticketFiles) {
			String content = getRawContentAsString(r, ticketsBranch.commit, file.path).trim();
			if (file.name.equals("TICKET_ID")) {
			ticket.id = content;
			} else if (file.name.equals("TITLE")) {
			ticket.title = content;
			} else {
			String[] chunks = file.name.split("_");
			if (chunks[0].equals("ASSIGNED")) {
			ticket.handler = content;
			} else if (chunks[0].equals("COMMENT")) {
			try {
			Comment c = new Comment(file.name, content);
			ticket.comments.add(c);
			} catch (ParseException e) {
			e.printStackTrace();
			}
			} else if (chunks[0].equals("TAG")) {
			if (content.startsWith("TAG_")) {
			ticket.tags.add(content.substring(4));
			} else {
			ticket.tags.add(content);
			}
			} else if (chunks[0].equals("STATE")) {
			ticket.state = content;
			}
			}
			}
			Collections.sort(ticket.comments);
			}

			public static String getTicketContent(Repository r, String filePath) {
			RefModel ticketsBranch = getTicketsBranch(r);
			if (ticketsBranch != null) {
			return getRawContentAsString(r, ticketsBranch.commit, filePath);
			}
			return "";
			return success;
			}
			}