RepositoryTools.java

package com.proalpha.pds.gitutils.checks;
 
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
 
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.egit.ui.internal.repository.tree.RepositoryTreeNode;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.Status;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.ui.handlers.HandlerUtil;
 
import com.proalpha.git.util.PaRepository;
import com.proalpha.pds.gitutils.Activator;
import com.proalpha.pds.paconnector.PaProject;
 
@SuppressWarnings("restriction")
public class RepositoryTools {
 
    private Repository repository = null;
 
    public RepositoryTools(Repository repository) {
        this.repository = repository;
    }
 
    public RepositoryTools(ExecutionEvent event) {
        RepositoryTreeNode<?> treenode = null;
        try {
            treenode = (RepositoryTreeNode<?>) getSelectedNodes(event).get(0);
        } catch (ExecutionException e) {
            Activator.logToConsole(String.format("Error in Constructor of class RepositoryTools: %s", e.getMessage()));
        }
        if (treenode != null) {
            repository = treenode.getRepository();
        }
    }
 
    public List<?> getSelectedNodes(ExecutionEvent event) throws ExecutionException {
        ISelection selection = HandlerUtil.getCurrentSelectionChecked(event);
        if (selection instanceof IStructuredSelection)
            return ((IStructuredSelection) selection).toList();
        else {
            Activator.logToConsole(String.format(
                    "Event %s is no instance of IStructuredSelection. Returning empty list.", event.toString()));
            return Collections.emptyList();
        }
    }
 
    public List<String> getStagedFiles() {
 
        Status status = null;
        List<String> stagesFiles = new ArrayList<>();
 
        try (Git git = new Git(repository)) {
            status = git.status().call();
 
            for (String file : status.getChanged()) {
                if (file.contains("/")) {
                    stagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    stagesFiles.add(file);
                }
            }
 
            for (String file : status.getAdded()) {
                if (file.contains("/")) {
                    stagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    stagesFiles.add(file);
                }
            }
 
            for (String file : status.getRemoved()) {
 
                if (file.contains("/")) {
                    stagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    stagesFiles.add(file);
                }
            }
        } catch (NoWorkTreeException | GitAPIException e) {
            Activator.logToConsole(String.format("Error in Method getStagedFiles: %s", e.getMessage()));
            return Collections.emptyList();
        }
 
        return stagesFiles;
    }
 
    public List<String> getUnstagedFiles() {
 
        Status status = null;
        List<String> unStagesFiles = new ArrayList<>();
 
        try (Git git = new Git(repository)) {
            status = git.status().call();
 
            for (String file : status.getUntracked()) {
                if (file.contains("/")) {
                    unStagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    unStagesFiles.add(file);
                }
            }
 
            for (String file : status.getModified()) {
                if (file.contains("/")) {
                    unStagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    unStagesFiles.add(file);
                }
            }
 
            for (String file : status.getConflicting()) {
                if (file.contains("/")) {
                    unStagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    unStagesFiles.add(file);
                }
            }
 
            for (String file : status.getMissing()) {
                if (file.contains("/")) {
                    unStagesFiles.add(file.substring(file.lastIndexOf('/') + 1));
                } else {
                    unStagesFiles.add(file);
                }
            }
        } catch (NoWorkTreeException | GitAPIException e) {
            Activator.logToConsole(String.format("Error in Method getUnstagedFiles: %s", e.getMessage()));
            return Collections.emptyList();
        }
 
        return unStagesFiles;
    }
 
    public List<String> getChangedFilesWithPath() {
 
        Status status = null;
        List<String> changedFiles = new ArrayList<>();
 
        try (Git git = new Git(repository)) {
            status = git.status().call();
 
            for (String file : status.getModified()) {
 
                if (file.contains("src/")) {
                    changedFiles.add(file.substring(file.lastIndexOf("src/") + 4));
                } else {
                    changedFiles.add(file);
                }
            }
 
            for (String file : status.getConflicting()) {
 
                if (file.contains("src/")) {
                    changedFiles.add(file.substring(file.lastIndexOf("src/") + 4));
                } else {
                    changedFiles.add(file);
                }
            }
            for (String file : status.getAdded()) {
 
                if (file.contains("src/")) {
                    changedFiles.add(file.substring(file.lastIndexOf("src/") + 4));
                } else {
                    changedFiles.add(file);
                }
            }
        } catch (NoWorkTreeException | GitAPIException e) {
            Activator.logToConsole(String.format("Error in Method getChangedFilesWithPath: %s", e.getMessage()));
            return Collections.emptyList();
        }
 
        return changedFiles;
    }
 
    public String getDirectory() {
        return this.repository.getDirectory().getPath();
    }
 
    public String getBranch() {
        try {
            return this.repository.getBranch();
        } catch (IOException e) {
            Activator.logToConsole(String.format("Error in Method getBranch: %s", e.getMessage()));
            return "";
        }
    }
 
    public PaProject getPaProject() {
 
        long countSeparator = repository.getDirectory().getAbsolutePath().codePoints()
                .filter(ch -> ch == System.getProperty("file.separator").toCharArray()[0]).count();
        String[] filePathArray = repository.getDirectory().getAbsolutePath()
                .split(Matcher.quoteReplacement(System.getProperty("file.separator")));
        IProject project = null;
 
        if (countSeparator > 3) {
            project = ResourcesPlugin.getWorkspace().getRoot().getProject(
                    filePathArray[filePathArray.length - 4] + "-" + filePathArray[filePathArray.length - 3]);
        } else {
            project = ResourcesPlugin.getWorkspace().getRoot().getProject(
                    filePathArray[filePathArray.length - 2] + "-" + filePathArray[filePathArray.length - 1]);
        }
 
        return com.proalpha.pds.paconnector.Activator.getDefault().getProjectManager().getPaProject(project);
 
    }
 
    public List<String> getBranchDiffFiles() {
 
        // get the diff files between current branch and Master HEAD commit
 
        try {
            // get current branch
            String branch = extendBanchName(getBranch());
            // default for the master branch
            String master_branch = extendBanchName(this.getMasterBranch());
 
            AbstractTreeIterator oldTreeParser = prepareTreeParser(repository, branch);
            AbstractTreeIterator newTreeParser = prepareTreeParser(repository, master_branch);
 
            return getTreeDiffs(oldTreeParser, newTreeParser);
 
        } catch (IOException e) {
            Activator.logToConsole(String.format("Error in Method getBranchDiffFiles: %s", e.getMessage()));
            // return empty list
            return Collections.emptyList();
        }
    }
 
    public List<String> getBranchesDiffs(String branch1, String branch2) {
        try {
            // get the differences between given branches
            AbstractTreeIterator oldTreeParser = prepareTreeParser(repository, branch1);
            AbstractTreeIterator newTreeParser = prepareTreeParser(repository, branch2);
 
            return getTreeDiffs(oldTreeParser, newTreeParser);
 
        } catch (IOException e) {
            Activator.logToConsole(String.format("Error in Method getBranchesDiffs: %s", e.getMessage()));
            // return empty list
            return Collections.emptyList();
        }
    }
 
    private List<String> getTreeDiffs(AbstractTreeIterator oldTreeParser, AbstractTreeIterator newTreeParser) {
        // if one of tree parser is null branch not found. Return a empty list
        if (oldTreeParser == null || newTreeParser == null)
            return Collections.emptyList();
        // create a result list
        List<DiffEntry> diff;
        // get the diffs from both tree parser
        try (Git git = new Git(repository)) {
 
            diff = git.diff().setOldTree(oldTreeParser).setNewTree(newTreeParser).call();
 
        } catch (GitAPIException e) {
            Activator.logToConsole(String.format("Error in Method getTreeDiffs: %s" + e.getMessage()));
            return Collections.emptyList();
        }
        List<String> changedFiles = new ArrayList<>();
 
        // go over all changed Files
        for (DiffEntry entry : diff) {
 
            // get state of change
            String change_type = entry.getChangeType().toString();
 
            // use new path with changed or new files
            if (change_type.equals("ADD") || change_type.equals("MODIFY"))
                changedFiles.add(Paths.get(entry.getNewPath()).getFileName().toString());
            else
                // use old path with deleted files
                changedFiles.add(Paths.get(entry.getOldPath()).getFileName().toString());
        }
 
        return changedFiles;
    }
 
    private static AbstractTreeIterator prepareTreeParser(Repository repository, String branch) throws IOException {
 
        // initialize the tree parser with the current commit of a Branch
 
        // get the reference of current branch
        Ref branchref = repository.exactRef(branch);
 
        // if branch reference is valid
        if (branchref != null) {
 
            try (RevWalk walk = new RevWalk(repository)) {
                RevCommit commit = walk.parseCommit(branchref.getObjectId());
                RevTree tree = walk.parseTree(commit.getTree().getId());
 
                CanonicalTreeParser cronTreeParser = new CanonicalTreeParser();
                try (ObjectReader reader = repository.newObjectReader()) {
                    cronTreeParser.reset(reader, tree.getId());
                }
 
                walk.dispose();
 
                return cronTreeParser;
            }
        } else {
            Activator.logToConsole(String.format("Branch not found: %s", branch));
            return null;
        }
 
    }
 
    private AbstractTreeIterator getTreeParserbyCommit(RevCommit commit)
            throws MissingObjectException, IncorrectObjectTypeException, IOException {
        // initialize the tree parser with the given commit id
        if (commit != null) {
            try (RevWalk walk = new RevWalk(repository)) {
                RevTree tree = walk.parseTree(commit.getTree().getId());
 
                CanonicalTreeParser cronTreeParser = new CanonicalTreeParser();
                try (ObjectReader reader = repository.newObjectReader()) {
                    cronTreeParser.reset(reader, tree.getId());
                }
 
                walk.dispose();
 
                return cronTreeParser;
            }
        } else {
            Activator.logToConsole("commit is null. can not init Tree parser");
            return null;
        }
 
    }
 
    public String extendBanchName(String branch) {
        if (!branch.startsWith("refs/heads/"))
            branch = "refs/heads/" + branch;
        return branch;
    }
 
    private RevCommit getCurrentBranchCommit(String branchName) throws IOException {
 
        Ref branchref = repository.exactRef(branchName);
 
        // get the start commit of a Branch
        if (branchref != null) {
 
            try (RevWalk walk = new RevWalk(repository)) {
                return walk.parseCommit(branchref.getObjectId());
            }
 
        } else
            return null;
 
    }
 
    public String getMasterBranch() {
        List<String> branches = PaRepository.getMasterBranches(this.repository);
 
        // same code in gitutils CherryPickPage
        String mainBranch = null;
 
        if (branches != null && !branches.isEmpty())
            mainBranch = branches.get(0);
        else {
            branches = PaRepository.getCodeFreezeBranches(this.repository);
            if (branches != null && !branches.isEmpty())
                mainBranch = branches.get(0);
        }
 
        return mainBranch;
 
    }
 
    public Repository getRepository() {
        // return the repository object
        return this.repository;
    }
}