FeatureBranchSettings.java

package com.proalpha.pds.gitutils.mylyn;
 
import java.util.List;
 
import org.eclipse.jgit.lib.Repository;
import org.eclipse.mylyn.tasks.core.ITask;
 
import com.proalpha.git.util.PaBranchName;
import com.proalpha.git.util.PaRepository;
 
public class FeatureBranchSettings {
 
    private ITask task;
    private Repository repository;
    private String taskEpic = "";
    private String taskSprint = "";
    private String taskParent = "";
    private String targetBranch;
    private String sourceBranch;
    private String dbCommit = "";
    private String artifactsCommit = "";
    private boolean updateTargetBranch = true;
    private boolean updateSourceBranch = true;
    private CheckoutAction checkoutAction = CheckoutAction.LOAD_XML;
 
    public CheckoutAction getCheckoutAction() {
        return checkoutAction;
    }
 
    public void setCheckoutAction(CheckoutAction checkoutAction) {
        this.checkoutAction = checkoutAction;
    }
 
    public Repository getRepository() {
        return repository;
    }
 
    public void setRepository(Repository repository) {
        this.repository = repository;
    }
 
    public boolean isUpdateTargetBranch() {
        return updateTargetBranch;
    }
 
    public void setUpdateTargetBranch(boolean updateTargetBranch) {
        this.updateTargetBranch = updateTargetBranch;
    }
 
    public boolean isUpdateSourceBranch() {
        return updateSourceBranch;
    }
 
    public void setUpdateSourceBranch(boolean updateSourceBranch) {
        this.updateSourceBranch = updateSourceBranch;
    }
 
    public String getTargetBranch() {
        return targetBranch;
    }
 
    public void setTargetBranch(String targetBranch) {
        this.targetBranch = targetBranch;
    }
 
    public String getSourceBranch() {
        return sourceBranch;
    }
 
    public void setSourceBranch(String sourceBranch) {
        this.sourceBranch = sourceBranch;
    }
 
    public ITask getTask() {
        return task;
    }
 
    public void setTask(ITask task) {
        this.task = task;
    }
 
    public String getTaskEpic() {
        return taskEpic;
    }
 
    public void setTaskEpic(String taskEpic) {
        this.taskEpic = taskEpic;
    }
 
    public String getTaskSprint() {
        return taskSprint;
    }
 
    public void setTaskSprint(String taskSprint) {
        this.taskSprint = taskSprint;
    }
 
    public String getTaskParent() {
        return taskParent;
    }
 
    public void setTaskParent(String taskParent) {
        this.taskParent = taskParent;
    }
 
    public String getDbCommit() {
        return dbCommit;
    }
 
    public void setDbCommit(String dbCommit) {
        this.dbCommit = dbCommit;
    }
 
    public String getArtifactsCommit() {
        return artifactsCommit;
    }
 
    public void setArtifactsCommit(String artifactsCommit) {
        this.artifactsCommit = artifactsCommit;
    }
 
    public void deriveDefaults() {
        this.deriveDefaultSourceBranch();
        this.deriveDefaultTargetBranch();
    }
 
    public void deriveDefaultSourceBranch() {
        List<String> branches = PaRepository.getMasterBranches(this.getRepository());
 
        if (!branches.isEmpty()) {
            // Just load the first found master branch.
            // We expect that each local repository only has one master branch
            String version = PaBranchName.getVersion(branches.get(0), this.getRepository());
            if (version != null) {
                this.setSourceBranch(version + ".master");
                return;
            }
 
        } else {
 
            // Determine source branch by a code-freeze branch
            branches = PaRepository.getCodeFreezeBranches(this.getRepository());
            if (!branches.isEmpty()) {
                String version = PaBranchName.getVersion(branches.get(0), this.getRepository());
                if (version != null) {
                    this.setSourceBranch(version);
                    return;
                }
            }
        }
 
        // Fallback: Just set name to master
        this.setSourceBranch("master");
 
    }
 
    public void deriveTargetBranch(String branchSuffix) {
        String version = "";
 
        List<String> branches = PaRepository.getMasterBranches(this.getRepository());
        if (branches.isEmpty())
            // No master available? But possibly a code-freeze branch
            branches = PaRepository.getCodeFreezeBranches(this.getRepository());
 
        if (!branches.isEmpty()) {
            version = PaBranchName.getVersion(branches.get(0), this.getRepository());
            if (version != null) {
                this.setTargetBranch(version + "." + branchSuffix);
                return;
            }
        }
 
        // Fallback - just the key of the task
        this.setTargetBranch(branchSuffix);
    }
    
    public void deriveDefaultTargetBranch() {
        this.deriveTargetBranch(task.getTaskKey());
    }
 
}