GitUtilsPropertyTester.java

package com.proalpha.pds.gitutils;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Set;
 
import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.egit.ui.internal.repository.tree.RepositoryTreeNode;
import org.eclipse.jgit.api.CherryPickResult.CherryPickStatus;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
 
import com.proalpha.git.model.PaCherryPickResult;
import com.proalpha.pds.gitutils.cherrypick.CherryPick;
import com.proalpha.pds.gitutils.common.Repository;
 
public class GitUtilsPropertyTester extends PropertyTester {
 
    @Override
    public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
        if (property.equals("isConflict")) {
            PaCherryPickResult result = CherryPick.getInstance().getCherryPickResult();
            if (result == null)
                return false;
            return (result.getStatus() == CherryPickStatus.CONFLICTING);
        }
 
        // Returns true if on the selected repository, a conflict is found
        // and the conflict is marked as mergetool applicable
        if (property.equals("isMergetoolApplicable")) {
            if (receiver instanceof RepositoryTreeNode) {
                RepositoryTreeNode node = (RepositoryTreeNode) receiver;
                org.eclipse.jgit.lib.Repository repository = node.getRepository();
 
                Git git = new Git(repository);
                try {
                    Set<String> conflictingFiles = git.status().call().getConflicting();
                    Repository.getInstance().setConflictingFiles(new ArrayList<String>(conflictingFiles));
                    return !conflictingFiles.isEmpty();
                } catch (NoWorkTreeException e) {
                    e.printStackTrace();
                    return false;
                } catch (GitAPIException e) {
                    e.printStackTrace();
                    return false;
                }
            }
        }
 
        // Returns true if on the selected repository, a cherry pick is running
        // (in particular, if the selected repository is the repository, where a
        // conflict occurs
        if (property.equals("isOngoingCherryPick")) {
 
            if (CherryPick.getInstance().getCherryPickCommand() != null) {
                org.eclipse.jgit.lib.Repository cpRepo = CherryPick.getInstance().getCherryPickCommand().getRepository();
 
                if (receiver instanceof RepositoryTreeNode) {
                    RepositoryTreeNode node = (RepositoryTreeNode) receiver;
                    org.eclipse.jgit.lib.Repository repository = node.getRepository();
 
                    if (repository != null)
                        return cpRepo.equals(repository);
                }
            }
            System.out.println("Property tester: " + property + "=" + "false");
            return false;
        }
 
        // Returns true if a new cherry pick operation can start (i.e., if there is
        // no ongoing cherry pick operation)
        if (property.equals("canStartNewCherryPick")) {
            return (CherryPick.getInstance().getCherryPickCommand() == null);
        }
        
        if (property.equals("isConsRepo")) {
            
            if (receiver instanceof RepositoryTreeNode) {
                RepositoryTreeNode node = (RepositoryTreeNode) receiver;
                org.eclipse.jgit.lib.Repository repository = node.getRepository();
                String workspace = repository.getDirectory().getParent();
                
                JSONParser jsonParser = new JSONParser();
                try (FileReader reader = new FileReader(workspace + "/pa_config_project.json"))
                {
                    JSONObject obj = (JSONObject) jsonParser.parse(reader);
                    if (obj.containsKey("repository_type")) {
                        String repositoryType = (String) obj.get("repository_type");
                        if(repositoryType.equals("cons")) return true;
                    }
                    return false;
         
                } catch (FileNotFoundException e) {
                    return false;
                } catch(ClassCastException e) {
                    return false;
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }
 
        return false;
    }
 
}