/**
* Copyright (C) 2005 - 2013 Eric Van Dewoestine
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.eclim.plugin.dltk.command.search;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.eclim.annotation.Command;
import org.eclim.command.CommandLine;
import org.eclim.command.Options;
import org.eclim.plugin.core.command.AbstractCommand;
import org.eclim.plugin.core.project.ProjectManagement;
import org.eclim.plugin.core.project.ProjectManager;
import org.eclim.plugin.core.util.ProjectUtils;
import org.eclim.plugin.dltk.project.DltkProjectManager;
import org.eclim.util.file.Position;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.search.IDLTKSearchConstants;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.core.search.SearchMatch;
import org.eclipse.dltk.core.search.SearchParticipant;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.internal.corext.util.SearchUtils;
import org.eclipse.dltk.internal.ui.search.DLTKSearchScopeFactory;
/**
* Command for dltk project search requests.
*
* @author Eric Van Dewoestine
*/
@Command(
name = "dltk_search",
options =
"OPTIONAL n project ARG," +
"OPTIONAL f file ARG," +
"OPTIONAL o offset ARG," +
"OPTIONAL l length ARG," +
"OPTIONAL e encoding ARG," +
"OPTIONAL p pattern ARG," +
"OPTIONAL t type ARG," +
"OPTIONAL x context ARG," +
"OPTIONAL s scope ARG," +
"OPTIONAL i case_insensitive NOARG"
)
public class SearchCommand
extends AbstractCommand
{
public static final String CONTEXT_ALL = "all";
public static final String CONTEXT_DECLARATIONS = "declarations";
//public static final String CONTEXT_IMPLEMENTORS = "implementors";
public static final String CONTEXT_REFERENCES = "references";
public static final String SCOPE_ALL = "all";
public static final String SCOPE_PROJECT = "project";
public static final String TYPE_CLASS = "class";
public static final String TYPE_METHOD = "method";
public static final String TYPE_FUNCTION = "function";
public static final String TYPE_FIELD = "field";
@Override
public Object execute(CommandLine commandLine)
throws Exception
{
String projectName = commandLine.getValue(Options.NAME_OPTION);
String file = commandLine.getValue(Options.FILE_OPTION);
String offset = commandLine.getValue(Options.OFFSET_OPTION);
String length = commandLine.getValue(Options.LENGTH_OPTION);
String pattern = commandLine.getValue(Options.PATTERN_OPTION);
int type = getType(commandLine.getValue(Options.TYPE_OPTION));
int context = getContext(commandLine.getValue(Options.CONTEXT_OPTION));
IProject project = projectName != null ?
ProjectUtils.getProject(projectName) : null;
IDLTKSearchScope scope = getScope(
commandLine.getValue(Options.SCOPE_OPTION), type, project);
SearchEngine engine = new SearchEngine();
//IProject[] projects = DLTKSearchScopeFactory.getInstance().getProjects(scope);
IDLTKLanguageToolkit toolkit = scope.getLanguageToolkit();
SearchPattern searchPattern = null;
// element search
if(file != null && offset != null && length != null){
IFile ifile = ProjectUtils.getFile(project, file);
ISourceModule src = DLTKCore.createSourceModuleFrom(ifile);
IModelElement[] elements = getElements(
src, getOffset(commandLine), Integer.parseInt(length));
IModelElement element = null;
if(elements != null && elements.length > 0){
element = elements[0];
}
//ScriptModelUtil.reconcile(src);
if (element != null && element.exists()) {
searchPattern = SearchPattern.createPattern(
element, context, SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE, toolkit);
}
}else{
int mode = getMode(pattern) | SearchPattern.R_ERASURE_MATCH;
boolean caseSensitive =
!commandLine.hasOption(Options.CASE_INSENSITIVE_OPTION);
if (caseSensitive){
mode |= SearchPattern.R_CASE_SENSITIVE;
}
if (type == IDLTKSearchConstants.UNKNOWN){
SearchPattern byType = SearchPattern.createPattern(
pattern, IDLTKSearchConstants.TYPE, context, mode, toolkit);
SearchPattern byMethod = SearchPattern.createPattern(
pattern, IDLTKSearchConstants.METHOD, context, mode, toolkit);
SearchPattern byField = SearchPattern.createPattern(
pattern, IDLTKSearchConstants.FIELD, context, mode, toolkit);
searchPattern = SearchPattern.createOrPattern(
byType, SearchPattern.createOrPattern(byMethod, byField));
}else{
searchPattern = SearchPattern.createPattern(
pattern, type, context, mode, toolkit);
}
}
if (searchPattern != null){
SearchRequestor requestor = new SearchRequestor();
engine.search(
searchPattern,
new SearchParticipant[]{SearchEngine.getDefaultSearchParticipant()},
scope,
requestor,
new NullProgressMonitor());
return requestor.getMatches();
}
return null;
}
/**
* Find the elements at the given offset.
*
* @param src The source to find the elements in.
* @param offset The offset to find the elements at.
* @param length The length of the element.
* @return Array of IModelElement.
*/
protected IModelElement[] getElements(ISourceModule src, int offset, int length)
throws Exception
{
return src.codeSelect(offset, length);
}
/**
* Gets the search scope to use.
*
* @param scope The string name of the scope.
* @param type The type to search for.
* @param project The current project.
*
* @return The IDLTKSearchScope.
*/
protected IDLTKSearchScope getScope(String scope, int type, IProject project)
throws Exception
{
boolean includeInterpreterEnvironment = false;
DLTKSearchScopeFactory factory = DLTKSearchScopeFactory.getInstance();
IDLTKLanguageToolkit toolkit = null;
ProjectManager manager = ProjectManagement.getProjectManager(getNature());
if(manager instanceof DltkProjectManager){
DltkProjectManager dltkManager = (DltkProjectManager)manager;
toolkit = dltkManager.getLanguageToolkit(dltkManager.getNatureId());
}
if (toolkit == null && project != null){
for(String nature : ProjectManagement.getProjectManagerNatures()){
if(project.hasNature(nature)){
manager = ProjectManagement.getProjectManager(nature);
if(manager instanceof DltkProjectManager){
DltkProjectManager dltkManager = (DltkProjectManager)manager;
toolkit = dltkManager.getLanguageToolkit(dltkManager.getNatureId());
break;
}
}
}
}
IDLTKSearchScope searchScope = null;
if (SCOPE_PROJECT.equals(scope)){
String[] names = new String[]{project.getName()};
searchScope = factory.createProjectSearchScope(
names, includeInterpreterEnvironment, toolkit);
}else{ // workspace
searchScope = factory.createWorkspaceScope(
includeInterpreterEnvironment, toolkit);
}
return searchScope;
}
/**
* Gets the nature to use for the current search.
*
* @return The eclipse nature.
*/
protected String getNature()
{
return null;
}
/**
* Translates the string context to the int equivalent.
*
* @param context The String context.
* @return The int context
*/
protected int getContext(String context)
{
if(CONTEXT_ALL.equals(context)){
return IDLTKSearchConstants.ALL_OCCURRENCES;
//}else if(CONTEXT_IMPLEMENTORS.equals(context)){
// return IDLTKSearchConstants.IMPLEMENTORS;
}else if(CONTEXT_REFERENCES.equals(context)){
return IDLTKSearchConstants.REFERENCES;
}
return IDLTKSearchConstants.DECLARATIONS;
}
/**
* Translates the string type to the int equivalent.
*
* @param type The String type.
* @return The int type.
*/
protected int getType(String type)
{
if(TYPE_CLASS.equals(type)){
return IDLTKSearchConstants.TYPE;
}else if(TYPE_METHOD.equals(type) || TYPE_FUNCTION.equals(type)){
return IDLTKSearchConstants.METHOD;
}else if(TYPE_FIELD.equals(type)){
return IDLTKSearchConstants.FIELD;
}
return IDLTKSearchConstants.UNKNOWN;
}
/**
* Determines the pattern mode to use based on the supplied search pattern.
*
* @param pattern The search pattern
* @return The pattern matching mode.
*/
private int getMode(String pattern)
{
if (pattern.indexOf('*') != -1 || pattern.indexOf('?') != -1) {
return SearchPattern.R_PATTERN_MATCH;
}
if (SearchUtils.isCamelCasePattern(pattern)) {
return SearchPattern.R_CAMELCASE_MATCH;
}
return SearchPattern.R_EXACT_MATCH;
}
/**
* Get the search result element name for the given element.
*
* @param el The search result element.
* @return The name.
*/
protected String getElement(Object el)
{
IModelElement element = (IModelElement)el;
ArrayList<IModelElement> lineage = new ArrayList<IModelElement>();
while (element.getElementType() != IModelElement.SOURCE_MODULE){
lineage.add(0, element);
element = element.getParent();
}
StringBuffer fullyQualified = new StringBuffer();
for(IModelElement e : lineage){
if (fullyQualified.length() != 0){
fullyQualified.append(getElementSeparator());
}
if (e.getElementType() == IModelElement.TYPE){
fullyQualified.append(getElementTypeName()).append(' ');
}
if (e.getElementType() == IModelElement.FIELD){
fullyQualified.append(getElementFieldName()).append(' ');
}
if (e.getElementType() == IModelElement.METHOD){
if (e.getParent().getElementType() == IModelElement.TYPE){
fullyQualified.append(getElementMethodName()).append(' ');
}else{
fullyQualified.append(getElementFunctionName()).append(' ');
}
}
fullyQualified.append(e.getElementName());
}
return fullyQualified.toString();
}
protected String getElementSeparator()
{
return " ";
}
protected String getElementTypeName()
{
return "type";
}
protected String getElementFieldName()
{
return "field";
}
protected String getElementMethodName()
{
return "method";
}
protected String getElementFunctionName()
{
return "function";
}
private class SearchRequestor
extends org.eclipse.dltk.core.search.SearchRequestor
{
private ArrayList<Position> matches = new ArrayList<Position>();
@Override
public void acceptSearchMatch(SearchMatch match)
throws CoreException
{
if (match.getAccuracy() == SearchMatch.A_ACCURATE){
IModelElement element = (IModelElement)match.getElement();
ArrayList<IModelElement> lineage = new ArrayList<IModelElement>();
while (element.getElementType() != IModelElement.SOURCE_MODULE){
lineage.add(0, element);
element = element.getParent();
}
StringBuffer fullyQualified = new StringBuffer();
for(IModelElement el : lineage){
if (fullyQualified.length() != 0){
fullyQualified.append(" -> ");
}
if (el.getElementType() == IModelElement.TYPE){
fullyQualified.append("type ");
}
if (el.getElementType() == IModelElement.METHOD){
fullyQualified.append("method ");
}
fullyQualified.append(el.getElementName());
}
String filename = match.getResource()
.getLocation().toOSString().replace('\\', '/');
File file = new File(filename);
if (!file.exists() || !file.isFile()){
// ignoring results that don't have a file that exists.
return;
}
Position position = Position.fromOffset(
filename, StringUtils.EMPTY, match.getOffset(), match.getLength());
int index = matches.indexOf(position);
String name = SearchCommand.this.getElement(match.getElement());
if(index == -1){
position.setMessage(name);
if(!matches.contains(position)){
matches.add(position);
}
}else if (!StringUtils.EMPTY.equals(name)){
// the second occurrence should be the one with the name.
position = matches.get(index);
position.setMessage(name);
}
}
}
/**
* Gets a list of all the matches found.
*
* @return List of SearchMatch.
*/
public List<Position> getMatches()
{
//Collections.sort(matches, MATCH_COMPARATOR);
return matches;
}
}
}