/*******************************************************************************
* Copyright (C) 2015, Max Hohenegger <eclipse@hohenegger.eu>
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*******************************************************************************/
package org.eclipse.egit.gitflow;
import static org.eclipse.jgit.lib.Constants.HEAD;
import static org.eclipse.jgit.lib.Constants.R_HEADS;
import static org.eclipse.jgit.lib.Constants.R_TAGS;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.egit.gitflow.internal.CoreText;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.RevisionSyntaxException;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
/**
* Wrapper for JGit repository.
*
* @since 4.0
*/
public class GitFlowRepository {
private Repository repository;
private GitFlowConfig config;
/**
* @param repository
*/
public GitFlowRepository(@NonNull Repository repository) {
this.repository = repository;
this.config = new GitFlowConfig(repository);
}
/**
* @return Whether or not this repository has branches.
*/
public boolean hasBranches() {
List<Ref> branches;
try {
branches = Git.wrap(repository).branchList().call();
return !branches.isEmpty();
} catch (GitAPIException e) {
throw new RuntimeException(e);
}
}
/**
* @param branch
* @return Whether or not branch exists in this repository.
* @throws GitAPIException
*/
public boolean hasBranch(String branch) throws GitAPIException {
String fullBranchName = R_HEADS + branch;
List<Ref> branchList = Git.wrap(repository).branchList().call();
for (Ref ref : branchList) {
if (fullBranchName.equals(ref.getTarget().getName())) {
return true;
}
}
return false;
}
/**
* @param branchName
* @return Ref for branchName.
* @throws IOException
*/
public Ref findBranch(String branchName) throws IOException {
return repository.exactRef(R_HEADS + branchName);
}
/**
* @return current branch has feature-prefix?
* @throws IOException
*/
public boolean isFeature() throws IOException {
String branch = repository.getBranch();
return branch != null
&& branch.startsWith(getConfig().getFeaturePrefix());
}
/**
* @return branch name has name "develop"?
* @throws IOException
*/
public boolean isDevelop() throws IOException {
String branch = repository.getBranch();
return branch != null && branch.equals(getConfig().getDevelop());
}
/**
* @return branch name has name "master"?
* @throws IOException
*/
public boolean isMaster() throws IOException {
String branch = repository.getBranch();
return branch != null && branch.equals(getConfig().getMaster());
}
/**
* @return current branchs has release-prefix?
* @throws IOException
*/
public boolean isRelease() throws IOException {
String branch = repository.getBranch();
return branch != null
&& branch.startsWith(getConfig().getReleasePrefix());
}
/**
* @return current branchs has hotfix-prefix?
* @throws IOException
*/
public boolean isHotfix() throws IOException {
String branch = repository.getBranch();
return branch != null
&& branch.startsWith(getConfig().getHotfixPrefix());
}
/**
* @return HEAD commit
* @throws WrongGitFlowStateException
*/
public RevCommit findHead() throws WrongGitFlowStateException {
try (RevWalk walk = new RevWalk(repository)) {
try {
ObjectId head = repository.resolve(HEAD);
if (head == null) {
throw new WrongGitFlowStateException(
CoreText.GitFlowRepository_gitFlowRepositoryMayNotBeEmpty);
}
return walk.parseCommit(head);
} catch (MissingObjectException e) {
throw new WrongGitFlowStateException(CoreText.GitFlowRepository_gitFlowRepositoryMayNotBeEmpty);
} catch (RevisionSyntaxException | IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @param branchName
* @return HEAD commit on branch branchName or {@literal null} if
* {@code branchName} could not be resolved.
*/
public @Nullable RevCommit findHead(String branchName) {
try (RevWalk walk = new RevWalk(repository)) {
try {
String revstr = R_HEADS + branchName;
ObjectId head = repository.resolve(revstr);
if (head == null) {
return null;
}
return walk.parseCommit(head);
} catch (RevisionSyntaxException | IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @param sha1
* @return Commit for SHA1
*/
public RevCommit findCommit(String sha1) {
try (RevWalk walk = new RevWalk(repository)) {
try {
ObjectId head = repository.resolve(sha1);
return walk.parseCommit(head);
} catch (RevisionSyntaxException | IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @return JGit repository
*/
public Repository getRepository() {
return repository;
}
/**
* @return git flow feature branches
*/
public List<Ref> getFeatureBranches() {
return getPrefixBranches(R_HEADS + getConfig().getFeaturePrefix());
}
/**
* @return git flow release branches
*/
public List<Ref> getReleaseBranches() {
return getPrefixBranches(R_HEADS + getConfig().getReleasePrefix());
}
/**
* @return git flow hotfix branches
*/
public List<Ref> getHotfixBranches() {
return getPrefixBranches(R_HEADS + getConfig().getHotfixPrefix());
}
private List<Ref> getPrefixBranches(String prefix) {
try {
List<Ref> branches = Git.wrap(repository).branchList().call();
List<Ref> prefixBranches = new ArrayList<Ref>();
for (Ref ref : branches) {
if (ref.getName().startsWith(prefix)) {
prefixBranches.add(ref);
}
}
return prefixBranches;
} catch (GitAPIException e) {
throw new RuntimeException(e);
}
}
/**
* @param ref
* @return branch name for ref
*/
public String getFeatureBranchName(Ref ref) {
return ref.getName().substring(
(R_HEADS + getConfig().getFeaturePrefix()).length());
}
/**
* @param tagName
* @return commit tag tagName points to
* @throws MissingObjectException
* @throws IncorrectObjectTypeException
* @throws IOException
*/
public RevCommit findCommitForTag(String tagName)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
try (RevWalk revWalk = new RevWalk(repository)) {
Ref tagRef = repository.exactRef(R_TAGS + tagName);
if (tagRef == null) {
return null;
}
return revWalk.parseCommit(tagRef.getObjectId());
}
}
/**
* @param featureName
* @param value
* @throws IOException
*/
public void setRemote(String featureName, String value) throws IOException {
getConfig().setRemote(featureName, value);
}
/**
* @param featureName
* @param value
* @throws IOException
*/
public void setUpstreamBranchName(String featureName, String value) throws IOException {
getConfig().setUpstreamBranchName(featureName, value);
}
/**
* @param featureName
* @return Upstream branch name
*/
public String getUpstreamBranchName(String featureName) {
return getConfig().getUpstreamBranchName(featureName);
}
/**
* @return the configuration of this repository
*/
public GitFlowConfig getConfig() {
return this.config;
}
/**
* Check if the given commit is an ancestor of the current HEAD on the
* develop branch.
*
* @param selectedCommit
* @return Whether or not the selected commit is on the develop branch.
* @throws IOException
* @since 4.3
*/
public boolean isOnDevelop(@NonNull RevCommit selectedCommit) throws IOException {
String develop = config.getDevelopFull();
return isOnBranch(selectedCommit, develop);
}
private boolean isOnBranch(RevCommit commit, String fullBranch)
throws IOException {
Ref branchRef = repository.exactRef(fullBranch);
if (branchRef == null) {
return false;
}
try {
List<Ref> list = Git.wrap(repository).branchList().setContains(commit.name()).call();
return list.contains(branchRef);
} catch (GitAPIException e) {
// ListBranchCommand can only throw a wrapped IOException
throw new IOException(e);
}
}
}