SelectBranchesPage.java

package com.proalpha.pds.gitutils.mylyn;
 
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
 
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.util.PaBranchName;
import com.proalpha.git.util.PaRepository;
import com.proalpha.pds.gitutils.Activator;
 
public class SelectBranchesPage extends WizardPage {
 
    private final Logger logger = LoggerFactory.getLogger(SelectBranchesPage.class);
 
    private static final String BRANCH_TYPE_STORY = "Story";
    private static final String BRANCH_TYPE_SUBTASK = "Sub-task";
    private static final String BRANCH_TYPE_EPIC = "Epic";
    private static final String BRANCH_TYPE_SPRINT = "Sprint";
 
    private FeatureBranchSettings settings;
    private Text txtSrcBranch;
    private Text txtTargetBranch;
    private Button btnUpdateSrcBranch;
    private Button btnUpdateTargetBranch;
    private Button btnEditSrcBranchname;
    private Button btnEditTargetBranchname;
    private Combo cmbTargetBranch;
    private Label lblSrcBranchInfo;
    private Label lblTargetBranchInfo;
 
    private TargetBranchStatus targetBranchStatus;
 
    private List<String> serverBranches;
    private List<String> targetBranchSelection = new ArrayList<>();
 
    private enum TargetBranchStatus {
        UNKNOWN, LOCAL, REMOTE, MISSING
    }
 
    public SelectBranchesPage(FeatureBranchSettings settings) {
        super(SelectBranchesPage.class.getName());
 
        this.settings = settings;
 
        setTitle("Branch Selection");
        setMessage("Select the branches to checkout or rather create", INFORMATION);
        URL url = FileLocator.find(Platform.getBundle(Activator.PLUGIN_ID), new Path("icons/pA-logox72.png"),
                Collections.emptyMap());
 
        setImageDescriptor(ImageDescriptor.createFromURL(url));
    }
 
    @Override
    public void createControl(Composite parent) {
 
        Composite container = new Composite(parent, SWT.NULL);
        setControl(container);
        container.setLayout(new GridLayout(1, false));
        container.setBackgroundMode(SWT.INHERIT_DEFAULT);
 
        GridData gdGrp = new GridData(SWT.CENTER, SWT.TOP, true, false, 1, 1);
        gdGrp.heightHint = 303;
        gdGrp.widthHint = 450;
 
        Group grp = new Group(container, SWT.NONE);
        grp.setLayoutData(gdGrp);
        grp.setText("Branch settings");
        grp.setBackgroundMode(SWT.INHERIT_DEFAULT);
 
        setSourceBranchSettings(container, grp);
        setTargetBranchSettings(container, grp);
    }
 
    private void setTargetBranchSettings(Composite container, Group grp) {
        Label lblTargetBranch = new Label(grp, SWT.WRAP);
        lblTargetBranch.setText("Target");
        lblTargetBranch.setBounds(10, 123, 60, 15);
 
        /* Target branch selector */
        cmbTargetBranch = new Combo(grp, SWT.CHECK);
        cmbTargetBranch.addSelectionListener(new SelectionListener() {
            public void widgetSelected(SelectionEvent selectedItem) {
                String targetBranchSelected = null;
                if (selectedItem != null) {
                    targetBranchSelected = ((Combo) selectedItem.getSource()).getText();
                    if (targetBranchSelected != null) {
                        // Update the target branch according to selected entry
                        updateTargetBranchSelection(targetBranchSelected);
                    }
                }
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                // We don't need this
            }
        });
        cmbTargetBranch.setBounds(76, 120, 100, 16);
 
        txtTargetBranch = new Text(grp, SWT.BORDER);
        txtTargetBranch.setBounds(76, 145, 212, 21);
        txtTargetBranch.setEnabled(false);
        txtTargetBranch.setText((settings.getTargetBranch() == null) ? "" : settings.getTargetBranch());
        txtTargetBranch.addModifyListener(modifyEvent -> {
            if (txtTargetBranch.getText().length() != 0)
                settings.setTargetBranch(txtTargetBranch.getText());
            updateTargetBranchStatus();
            updateDependentFields();
 
            setPageComplete(targetBranchStatus == TargetBranchStatus.LOCAL
                    || targetBranchStatus == TargetBranchStatus.REMOTE || isSourceBranchValid());
        });
 
        btnEditTargetBranchname = new Button(grp, SWT.CHECK);
        btnEditTargetBranchname.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                txtTargetBranch.setEnabled(btnEditTargetBranchname.getSelection());
                if (!btnEditTargetBranchname.getSelection()) {
                    settings.deriveDefaultTargetBranch();
                    txtTargetBranch.setText(settings.getTargetBranch());
                }
            }
        });
        btnEditTargetBranchname.setBounds(314, 123, 60, 16);
        btnEditTargetBranchname.setText("modify");
 
        btnUpdateTargetBranch = new Button(grp, SWT.CHECK);
        btnUpdateTargetBranch.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                settings.setUpdateTargetBranch(btnUpdateTargetBranch.getSelection());
 
                updateDependentFields();
            }
        });
        btnUpdateTargetBranch.setBounds(384, 123, 60, 16);
        btnUpdateTargetBranch.setText("update");
 
        lblTargetBranchInfo = new Label(grp, SWT.WRAP);
        lblTargetBranchInfo.setBounds(76, 170, 330, 60);
        lblTargetBranchInfo.setForeground(container.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));
    }
 
    private void setSourceBranchSettings(Composite container, Group grp) {
        Label lblSrcBranch = new Label(grp, SWT.WRAP);
        lblSrcBranch.setText("Source");
        lblSrcBranch.setBounds(10, 22, 60, 15);
 
        txtSrcBranch = new Text(grp, SWT.BORDER);
        txtSrcBranch.setBounds(76, 19, 212, 21);
        txtSrcBranch.setText((settings.getSourceBranch() == null) ? "" : settings.getSourceBranch());
        txtSrcBranch.setEnabled(false);
        txtSrcBranch.addModifyListener(modifyEvent -> {
            if (txtSrcBranch.getText().length() != 0)
                settings.setSourceBranch(txtSrcBranch.getText());
            updateDependentFields();
            setPageComplete(targetBranchStatus == TargetBranchStatus.LOCAL
                    || targetBranchStatus == TargetBranchStatus.REMOTE || isSourceBranchValid());
        });
 
        btnEditSrcBranchname = new Button(grp, SWT.CHECK);
        btnEditSrcBranchname.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                txtSrcBranch.setEnabled(btnEditSrcBranchname.getSelection());
                if (!btnEditSrcBranchname.getSelection()) {
                    settings.deriveDefaultSourceBranch();
                    txtSrcBranch.setText(settings.getSourceBranch());
                }
            }
        });
        btnEditSrcBranchname.setBounds(314, 22, 60, 16);
        btnEditSrcBranchname.setText("modify");
 
        btnUpdateSrcBranch = new Button(grp, SWT.CHECK);
        btnUpdateSrcBranch.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                settings.setUpdateSourceBranch(btnUpdateSrcBranch.getSelection());
                updateDependentFields();
            }
        });
        btnUpdateSrcBranch.setBounds(384, 22, 60, 16);
        btnUpdateSrcBranch.setText("update");
 
        lblSrcBranchInfo = new Label(grp, SWT.WRAP);
        lblSrcBranchInfo.setBounds(76, 49, 330, 60);
        lblSrcBranchInfo.setForeground(container.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));
    }
 
    @Override
    public void setVisible(boolean visible) {
        super.setVisible(visible);
 
        if (visible) {
            initialize();
        }
    }
 
    private void initialize() {
        serverBranches = getBranchesFromServer();
        updateTargetBranchStatus();
 
        txtSrcBranch.setText((settings.getSourceBranch() == null) ? "" : settings.getSourceBranch());
 
        btnUpdateSrcBranch.setSelection(settings.isUpdateSourceBranch());
        btnUpdateTargetBranch.setSelection(settings.isUpdateTargetBranch());
 
        targetBranchSelection.clear();
 
        if (!settings.getTask().getTaskKind().isEmpty() && settings.getTask().getTaskKind().equals(BRANCH_TYPE_SUBTASK))
            targetBranchSelection.add(BRANCH_TYPE_SUBTASK);
        targetBranchSelection.add(BRANCH_TYPE_STORY);
        if (!settings.getTaskEpic().isEmpty())
            targetBranchSelection.add(BRANCH_TYPE_EPIC);
        if (!settings.getTaskSprint().isEmpty())
            targetBranchSelection.add(BRANCH_TYPE_SPRINT);
        cmbTargetBranch.setItems(targetBranchSelection.stream().toArray(String[]::new));
        cmbTargetBranch.setText(BRANCH_TYPE_STORY);
        updateTargetBranchSelection(BRANCH_TYPE_STORY);
    }
 
    private void updateDependentFields() {
        StringBuilder sb = new StringBuilder();
 
        for (String s : getSourceBranchInfo()) {
            sb.append(s);
            sb.append("\n");
        }
 
        lblSrcBranchInfo.setText(sb.toString());
 
        sb = new StringBuilder();
        for (String s : getTargetBranchInfo()) {
            sb.append(s);
            sb.append("\n");
        }
 
        lblTargetBranchInfo.setText(sb.toString());
 
    }
 
    private boolean isSourceBranchValid() {
        if (this.settings == null)
            return false;
 
        return PaRepository.getLocalBranches(this.settings.getRepository()).contains(this.settings.getSourceBranch());
    }
 
    private void updateTargetBranchSelection(String selectedBranchValue) {
 
        switch (selectedBranchValue) {
 
        case BRANCH_TYPE_SUBTASK:
            settings.deriveDefaultTargetBranch();
            break;
 
        case BRANCH_TYPE_STORY:
            if (settings.getTask().getTaskKind().equals(BRANCH_TYPE_SUBTASK))
                settings.deriveTargetBranch(settings.getTaskParent());
            else
                settings.deriveDefaultTargetBranch();
            break;
 
        case BRANCH_TYPE_EPIC:
            settings.deriveTargetBranch(settings.getTaskEpic());
            break;
 
        case BRANCH_TYPE_SPRINT:
            settings.deriveTargetBranch(settings.getTaskSprint());
            break;
 
        default:
            txtTargetBranch.setText(settings.getTargetBranch());
        }
 
        txtTargetBranch.setText(settings.getTargetBranch());
 
        updateTargetBranchStatus();
        updateDependentFields();
 
        setPageComplete(targetBranchStatus == TargetBranchStatus.LOCAL
                || targetBranchStatus == TargetBranchStatus.REMOTE || isSourceBranchValid());
    }
 
    private void updateTargetBranchStatus() {
        if (this.settings.getRepository() == null)
            this.targetBranchStatus = TargetBranchStatus.UNKNOWN;
 
        // Target branch exists as local branch
        if (PaRepository.isValidRef(this.settings.getRepository(), settings.getTargetBranch()) && PaRepository
                .getLocalBranches(this.settings.getRepository()).contains(this.settings.getTargetBranch())) {
            this.targetBranchStatus = TargetBranchStatus.LOCAL;
        } else {
            // Target branch exists as remote-tracking branch or branch on the server
            if (PaRepository.getRemoteBranches(this.settings.getRepository()).contains(this.settings.getTargetBranch())
                    || this.serverBranches.contains(this.settings.getTargetBranch()))
                this.targetBranchStatus = TargetBranchStatus.REMOTE;
 
            else {
                this.targetBranchStatus = TargetBranchStatus.MISSING;
            }
        }
    }
 
    private List<String> getSourceBranchInfo() {
        List<String> infos = new ArrayList<>();
 
        if (!isSourceBranchValid()) {
            infos.add("The source branch does not exist!");
        }
 
        // Target branch exists as local branch
        if (this.targetBranchStatus == TargetBranchStatus.LOCAL
                || this.targetBranchStatus == TargetBranchStatus.REMOTE) {
            infos.add("The source branch will not be used, because the target branch exists.");
 
        }
        // Target branch must be created
        else if (this.targetBranchStatus == TargetBranchStatus.MISSING) {
            infos.add("The source branch will be branched off.");
 
            if (!settings.isUpdateSourceBranch()) {
                infos.add(
                        "Warning: Your new target branch is probably not based on the newest version of the source branch.");
            }
        }
 
        return infos;
    }
 
    private List<String> getTargetBranchInfo() {
        List<String> infos = new ArrayList<>();
 
        if (this.targetBranchStatus == TargetBranchStatus.UNKNOWN)
            return infos;
 
        // Target branch exists as local branch
        if (this.targetBranchStatus == TargetBranchStatus.LOCAL) {
            infos.add("The target branch already exists in the local repository and will be checked out.");
 
            if (!settings.isUpdateTargetBranch()) {
                infos.add("Warning: The target branch will not be updated. It is probably outdated.");
            }
        } else {
            // Target branch exists as remote-tracking branch or branch on the server
            if (this.targetBranchStatus == TargetBranchStatus.REMOTE)
                infos.add("The target branch already exists on server and will be fetched/checked out.");
 
            else {
                infos.add("The target branch does not exist and will be created.");
            }
        }
 
        return infos;
    }
 
    private List<String> getBranchesFromServer() {
 
        List<String> branches = new ArrayList<>();
        try {
 
            String remote;
            Set<String> remotes = this.settings.getRepository().getRemoteNames();
            if (remotes.iterator().hasNext()) {
                remote = remotes.iterator().next();
                String url = this.settings.getRepository().getConfig().getString("remote", remote, "url");
                Collection<Ref> refs = Git.lsRemoteRepository().setRemote(url).setHeads(true).call();
 
                for (Ref ref : refs) {
                    branches.add(PaBranchName.getShortBranchName(ref.getName(), this.settings.getRepository()));
                }
            }
        } catch (GitAPIException e) {
            logger.error("InvalidRemoteException occured", e);
        }
        return branches;
    }
 
}