GitGrepSearchQuery.java

package com.proalpha.pds.gitutils.search;
 
import java.io.IOException;
import java.util.List;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.search.ui.ISearchQuery;
import org.eclipse.search.ui.ISearchResult;
import org.eclipse.search.ui.text.Match;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.exceptions.PaGitGrepException;
import com.proalpha.git.grep.GitCliGrep;
import com.proalpha.git.grep.GrepConfig;
import com.proalpha.git.model.grep.Result;
import com.proalpha.pds.gitutils.Activator;
import com.proalpha.pds.gitutils.PreferencesConstants;
 
public class GitGrepSearchQuery implements ISearchQuery {
 
    private final Logger logger = LoggerFactory.getLogger(GitGrepSearchQuery.class);
    private GitGrepSearchSettings searchSettings;
    private GitGrepSearchResult searchResult = new GitGrepSearchResult(this);
 
    public GitGrepSearchQuery(GitGrepSearchSettings settings) {
        this.searchSettings = settings;
    }
 
    @Override
    public IStatus run(IProgressMonitor monitor) throws OperationCanceledException {
        try {
            monitor.beginTask("pA GitGrep Search Result", 3);
            monitor.worked(1);
            fillSearchResultElements();
            monitor.worked(1);
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            monitor.done();
            return Status.OK_STATUS;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return Status.CANCEL_STATUS;
        }
    }
 
    private void fillSearchResultElements() {
 
        GrepConfig config = new GrepConfig();
 
        config.setLimit(searchSettings.getMaxFinds());
        config.setBranch(searchSettings.getBranchName());
        config.setFileFilter(searchSettings.getFileNamePhrase());
 
        switch (searchSettings.getFileType()) {
        case "ALL":
            config.setSearchScope(GrepConfig.SearchScope.ALL);
            break;
 
        case "PDI":
            config.setSearchScope(GrepConfig.SearchScope.PDI);
            break;
 
        case "SRC":
            config.setSearchScope(GrepConfig.SearchScope.SRC);
            break;
        case "SRC_PDI":
            config.setSearchScope(GrepConfig.SearchScope.SRC_PDI);
            break;
        }
 
        config.setWordBoundaries(false);
        config.setIgnoreCase(!searchSettings.isCaseSensitive());
 
        GitCliGrep grep = null;
 
        try {
            grep = new GitCliGrep(searchSettings.getRepositoryPath(), searchSettings.getTextPhrase(), config);
 
            grep.setGitCLI(Activator.getDefault().getPreferenceStore().getString(PreferencesConstants.GIT_EXE));
            List<Result> results = grep.getResults();
 
            for (Result r : results) {
 
                int indexOfLastPathDelimiter = r.getContext().getFile().lastIndexOf('/');
                String trimmedPath = indexOfLastPathDelimiter >= 0
                        ? r.getContext().getFile().substring(indexOfLastPathDelimiter + 1)
                        : "";
 
                GitGrepSearchResultElement elem = new GitGrepSearchResultElement(trimmedPath,
                        Integer.toString(r.getLineNo()), r.getHit(), r.getContext().getContext());
 
                int indexOfLastRepositoryDelimiter = searchSettings.getRepositoryPath().lastIndexOf('\\');
 
                elem.setAbsolutePath(
                        searchSettings.getRepositoryPath()
                                .substring(0,
                                        indexOfLastRepositoryDelimiter > 0 ? indexOfLastRepositoryDelimiter + 1
                                                : searchSettings.getRepositoryPath().length())
                                + r.getContext().getFile());
                searchResult.addMatch(new Match(elem, 0, 0));
            }
        } catch (PaGitGrepException | IOException e) {
            logger.error(e.getMessage(), e);
        }
    }
 
    @Override
    public String getLabel() {
        return "pA GitGrep Search";
    }
 
    @Override
    public boolean canRerun() {
        return true;
    }
 
    @Override
    public boolean canRunInBackground() {
        return true;
    }
 
    @Override
    public ISearchResult getSearchResult() {
        return searchResult;
    }
 
    public String getSearchPhrase() {
        return searchSettings.getTextPhrase();
    }
 
    public String getRepository() {
        return searchSettings.getRepositoryPath();
    }
}