Attachment #98352 for bug #185168

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 185168
Collapse All | Expand All

Lines 55-61 Link Here

(-)a/cnd.gotodeclaration/nbproject/project.xml (-1 / +1 lines)
55	<compile-dependency/>	55	<compile-dependency/>
56	<run-dependency>	56	<run-dependency>
57	<release-version>1</release-version>	57	<release-version>1</release-version>
58	<specification-version>1.2</specification-version>	58	<specification-version>1.17</specification-version>
59	</run-dependency>	59	</run-dependency>
60	</dependency>	60	</dependency>
61	<dependency>	61	<dependency>




 */
package org.netbeans.modules.cnd.gotodeclaration.matcher;

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.netbeans.modules.cnd.api.model.services.CsmSelect;
import org.netbeans.spi.jumpto.support.NameMatcher;
import org.netbeans.spi.jumpto.type.SearchType;

/**

 * @author Vladimir Kvashin
 */
public class NameMatcherFactory {

    private NameMatcherFactory() {
    }
    
    private static abstract class BaseNameMatcher implements NameMatcher {
	
        protected String patternText;
	
	protected BaseNameMatcher(String patternText) {
	    this.patternText = patternText;
	}
    }
    
    
    private static final class ExactNameMatcher extends BaseNameMatcher implements NameMatcher {
	
	public ExactNameMatcher(String patternText) {
	    super(patternText);
	}

        @Override
	public final boolean accept(String name) {
	    return patternText.equals(name);
	}
    }

    private static final class CaseInsensitiveExactNameMatcher extends BaseNameMatcher implements NameMatcher {
	
	public CaseInsensitiveExactNameMatcher(String patternText) {
	    super(patternText);
	}

        @Override
	public final boolean accept(String name) {
	    return patternText.equalsIgnoreCase(name);
	}
    }

    private static final class PrefixNameMatcher extends BaseNameMatcher implements NameMatcher {
	
	public PrefixNameMatcher(String patternText) {
	    super(patternText);
	}
	
        @Override
	public final boolean accept(String name) {
	    return name != null && name.startsWith(patternText);
	}
    }

    private static final class CaseInsensitivePrefixNameMatcher extends BaseNameMatcher implements NameMatcher {
	
	public CaseInsensitivePrefixNameMatcher(String patternText) {
	    super(patternText.toLowerCase());
	}
	
        @Override
	public final boolean accept(String name) {
	    return name != null && name.toLowerCase().startsWith(patternText);
	}
    }

    private static final class RegExpNameMatcher implements NameMatcher {

	Pattern pattern;
	
	public RegExpNameMatcher(String patternText, boolean caseSensitive) {
	    pattern = Pattern.compile(patternText, caseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
	}
	
        @Override
	public final boolean accept(String name) {
	    return name != null && pattern.matcher(name).matches();
	}
    }

    private static final class CamelCaseNameMatcher implements NameMatcher {

	Pattern pattern;
	
	public CamelCaseNameMatcher(String name) {
            if (name.length() == 0) {
                throw new IllegalArgumentException ();
            }        
            final StringBuilder patternString = new StringBuilder ();                        
            for (int i=0; i<name.length(); i++) {
                char c = name.charAt(i);
                patternString.append(c);
                if (i == name.length()-1) {
                    patternString.append("\\w*");  // NOI18N
                }
                else {
                    patternString.append("[\\p{Lower}\\p{Digit}]*");  // NOI18N
                }
            }
            pattern = Pattern.compile(patternString.toString());
	}
	
        @Override
	public final boolean accept(String name) {
	    return name != null && pattern.matcher(name).matches();
	}
    }

    /**
     * Get a name
     */
    public static NameMatcher createNameMatcher(String text, SearchType type) {
        try {
            switch( type ) {
                case EXACT_NAME:
                    return new ExactNameMatcher(text);
                case CASE_INSENSITIVE_EXACT_NAME:
                    return new CaseInsensitiveExactNameMatcher(text);
                case PREFIX:
                    return new PrefixNameMatcher(text);
                case REGEXP:
                    return new RegExpNameMatcher(text, true);
                case CASE_INSENSITIVE_REGEXP:
                    return new RegExpNameMatcher(text, false);
                case CASE_INSENSITIVE_PREFIX:
                     return new CaseInsensitivePrefixNameMatcher(text);
                case CAMEL_CASE:
                    return new CamelCaseNameMatcher(text);
                default:
                    return null;
            }
        }
        catch( PatternSyntaxException ex ) {
            return null;
        }
    }    
    
    public static CsmSelect.CsmFilter createNameFilter(String text, SearchType type) {
        final NameMatcher matcher = org.netbeans.spi.jumpto.support.NameMatcherFactory.createNameMatcher(text, type);
        if( matcher != null ) {
            CsmSelect.NameAcceptor acceptor = new CsmSelect.NameAcceptor() {
                @Override




import org.netbeans.modules.cnd.api.model.services.CsmSelect.NameAcceptor;
import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;
import org.netbeans.modules.cnd.api.project.NativeProject;
import org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcher;
import org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcherFactory;
import org.netbeans.modules.cnd.utils.CndUtils;
import org.netbeans.spi.jumpto.support.NameMatcher;
import org.netbeans.spi.jumpto.support.NameMatcherFactory;
import org.netbeans.spi.jumpto.symbol.SymbolProvider;
import org.netbeans.spi.jumpto.type.SearchType;
import org.openide.util.NbBundle;


    private CsmSelect.NameAcceptor createNameAcceptor(final Context context) {
        final NameMatcher nameMatcher = NameMatcherFactory.createNameMatcher(context.getText(), context.getSearchType());
        return new CsmSelect.NameAcceptor() {
            public boolean accept(CharSequence name) {
                return nameMatcher.accept(name.toString());
            }
        };
                    return nameMatcher.accept(name.toString());
                }
            };
        }
    }

    // synchronized is just in case here - it shouldn't be called async





import org.netbeans.api.project.Project;
import org.netbeans.modules.cnd.api.model.services.CsmSelect;
import org.netbeans.spi.jumpto.support.NameMatcher;
import org.netbeans.spi.jumpto.support.NameMatcherFactory;

import org.netbeans.spi.jumpto.type.SearchType;
import org.netbeans.spi.jumpto.type.TypeDescriptor;

	
	
	
	CsmSelect.CsmFilter filter = org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcherFactory.createNameFilter(text, type);
	NameMatcher matcher = NameMatcherFactory.createNameMatcher(text, type);
	if( filter == null) {
	    return;
	}
        




    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>
        <change id="Support">
            <api name="general"/>
            <summary>Added support SPI to implement name filters</summary>
            <version major="1" minor="17"/>
            <date day="5" month="5" year="2010"/>
            <author login="tzezula"/>
            <compatibility addition="yes">
            </compatibility>
            <description>
                Added support SPI to implement common filters used by Go To Type, Go To Symbol,
                Go To File.
            </description>
            <class package="org.netbeans.spi.jumpto.support" name="NameMatcherFactory"/>
            <class package="org.netbeans.spi.jumpto.support" name="NameMatcher"/>
            <issue number="185168"/>
        </change>
        <change id="GoToFile">
            <api name="general"/>
            <summary>Added SPI for Go to File dialog</summary>

Lines 2-6 Link Here

(-)a/jumpto/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.jumpto/1	2	OpenIDE-Module: org.netbeans.modules.jumpto/1
3	OpenIDE-Module-Layer: org/netbeans/modules/jumpto/resources/layer.xml	3	OpenIDE-Module-Layer: org/netbeans/modules/jumpto/resources/layer.xml
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/jumpto/resources/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/jumpto/resources/Bundle.properties
5	OpenIDE-Module-Specification-Version: 1.16	5	OpenIDE-Module-Specification-Version: 1.17
6	AutoUpdate-Show-In-Client: false	6	AutoUpdate-Show-In-Client: false

Lines 225-230 Link Here

(-)a/jumpto/nbproject/project.xml (+1 lines)
225	<package>org.netbeans.spi.jumpto.file</package>	225	<package>org.netbeans.spi.jumpto.file</package>
226	<package>org.netbeans.spi.jumpto.symbol</package>	226	<package>org.netbeans.spi.jumpto.symbol</package>
227	<package>org.netbeans.spi.jumpto.type</package>	227	<package>org.netbeans.spi.jumpto.type</package>
		228	<package>org.netbeans.spi.jumpto.support</package>
228	</friend-packages>	229	</friend-packages>
229	</data>	230	</data>
230	</configuration>	231	</configuration>




import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.swing.AbstractAction;
import javax.swing.DefaultListCellRenderer;

import org.netbeans.spi.jumpto.file.FileDescriptor;
import org.netbeans.spi.jumpto.file.FileProvider;
import org.netbeans.spi.jumpto.file.FileProviderFactory;
import org.netbeans.spi.jumpto.support.NameMatcher;
import org.netbeans.spi.jumpto.support.NameMatcherFactory;
import org.netbeans.spi.jumpto.type.SearchType;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;

                    }
                }
                //Ask GTF providers
                final SearchType jumpToSearchType = toJumpToSearchType(searchType);
                final FileProvider.Context ctx = FileProviderAccessor.getInstance().createContext(text, jumpToSearchType, currentProject);
                final FileProvider.Result fpR = FileProviderAccessor.getInstance().createResult(files,new String[1], ctx);
                for (FileProvider provider : getProviders()) {
                    currentProvider = provider;

                    allFolders = searchSources(root, allFolders, excludes, filters);
                }
                //Looking for matching files in all found folders
                final NameMatcher matcher = NameMatcherFactory.createNameMatcher(text, jumpToSearchType);
                for (FileObject folder: allFolders) {
                    assert folder.isFolder();
                    Enumeration<? extends FileObject> filesInFolder = folder.getData(false);

                        FileObject file = filesInFolder.nextElement();
                        if (file.isFolder()) continue;

                        if (matcher.accept(file.getNameExt())) {
                            Project project = FileOwnerQuery.getOwner(file);
                            boolean preferred = project != null && currentProject != null ? project.getProjectDirectory() == currentProject.getProjectDirectory() : false;
                            String relativePath = FileUtil.getRelativePath(project.getProjectDirectory(), file);

//            }
        }
        return result;
    }

    private boolean isMatchedFileObject(QuerySupport.Kind searchType, FileObject file, String text) {
        boolean isMatched = false;
        switch (searchType) {
            case EXACT: {
                isMatched = file.getNameExt().equals(text);
                break;
            }
            case PREFIX: {
                if (text.length() == 0) {
                    isMatched = true;
                } else {
                    isMatched = file.getNameExt().startsWith(text);
                }
                break;
            }
            case CASE_INSENSITIVE_PREFIX: {
                if (text.length() == 0) {
                    isMatched = true;
                } else {
                    isMatched = file.getNameExt().toLowerCase().startsWith(text.toLowerCase());
                }
                break;
            }
            case CAMEL_CASE: {
                if (text.length() == 0) {
                    throw new IllegalArgumentException ();
                }
                {
                    StringBuilder sb = new StringBuilder();
                    String prefix = null;
                    int lastIndex = 0;
                    int index;
                    do {
                        index = findNextUpper(text, lastIndex + 1);
                        String token = text.substring(lastIndex, index == -1 ? text.length(): index);
                        if ( lastIndex == 0 ) {
                            prefix = token;
                        }
                        sb.append(token);
                        sb.append( index != -1 ?  "[\\p{javaLowerCase}\\p{Digit}_\\$]*" : ".*"); // NOI18N
                        lastIndex = index;
                    }
                    while(index != -1);

                    final Pattern pattern = Pattern.compile(sb.toString());
                    Matcher m = pattern.matcher(file.getNameExt());
                    isMatched = m.matches();
                }
                break;

            }

            case CASE_INSENSITIVE_REGEXP:
                if (text.length() == 0) {
                    throw new IllegalArgumentException ();
                } else {
                    if (Character.isJavaIdentifierStart(text.charAt(0))) {
                        Pattern pattern = Pattern.compile(text,Pattern.CASE_INSENSITIVE);
                        Matcher m = pattern.matcher(file.getNameExt());
                        isMatched = m.matches();
                    }
                    else {
                        Pattern pattern = Pattern.compile(text,Pattern.CASE_INSENSITIVE|Pattern.DOTALL);
                        Matcher m = pattern.matcher(file.getNameExt());
                        isMatched = m.matches();
                    }
                    break;
                }
            case REGEXP:
                if (text.length() == 0) {
                    throw new IllegalArgumentException ();
                } else {
                    if (Character.isJavaIdentifierStart(text.charAt(0))) {
                        final Pattern pattern = Pattern.compile(text);
                        Matcher m = pattern.matcher(file.getNameExt());
                        isMatched = m.matches();
                    }
                    else {
                        final Pattern pattern = Pattern.compile(text,Pattern.DOTALL);
                        Matcher m = pattern.matcher(file.getNameExt());
                        isMatched = m.matches();
                    }
                    break;
                }

            case CASE_INSENSITIVE_CAMEL_CASE: {
                if (text.length() == 0) {
                    throw new IllegalArgumentException ();
                }
                {
                    StringBuilder sb = new StringBuilder();
                    String prefix = null;
                    int lastIndex = 0;
                    int index;
                    do {
                        index = findNextUpper(text, lastIndex + 1);
                        String token = text.substring(lastIndex, index == -1 ? text.length(): index);
                        if ( lastIndex == 0 ) {
                            prefix = token;
                        }
                        sb.append(token);
                        sb.append( index != -1 ?  "[\\p{javaLowerCase}\\p{Digit}_\\$]*" : ".*"); // NOI18N
                        lastIndex = index;
                    }
                    while(index != -1);

                    final Pattern pattern = Pattern.compile(sb.toString(),Pattern.CASE_INSENSITIVE);
                    Matcher m = pattern.matcher(file.getNameExt());
                    isMatched = m.matches();
                }
                break;
            }
            default:
                throw new UnsupportedOperationException (searchType.toString());

        }
        return isMatched;
    }//checkMatch
    private static int findNextUpper(String text, int offset ) {

        for( int i = offset; i < text.length(); i++ ) {
            if ( Character.isUpperCase(text.charAt(i)) ) {
                return i;
            }
        }
        return -1;
    }

    private boolean checkAgainstFilters(FileObject folder, FileObjectFilter[] filters) {




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2007 Sun Microsystems, Inc.
 */

package org.netbeans.spi.jumpto.support;

/**
 * Used for encapsulation of the  different matching algorithms
 * (such as String.equals, String.equalsIgnoreCase, String.startWith, etc)
 */
public interface NameMatcher {

    /**
     * Determine whether the name matches a pattern or not
     * return true
     */
    boolean accept(String name);
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2007 Sun Microsystems, Inc.
 */
package org.netbeans.spi.jumpto.support;

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.netbeans.spi.jumpto.type.SearchType;
import org.openide.util.Parameters;

/**
 * A factory that provides comparators
 * depending on SearchType
 *
 * @author Vladimir Kvashin
 */
public final class NameMatcherFactory {

    private NameMatcherFactory() {
    }

    private static abstract class BaseNameMatcher implements NameMatcher {

        protected final String patternText;

	protected BaseNameMatcher(String patternText) {
	    this.patternText = patternText;
	}
    }

    private static final class ExactNameMatcher extends BaseNameMatcher {

	public ExactNameMatcher(String patternText) {
	    super(patternText);
	}

        @Override
	public final boolean accept(String name) {
	    return patternText.equals(name);
	}
    }

    private static final class CaseInsensitiveExactNameMatcher extends BaseNameMatcher {

	public CaseInsensitiveExactNameMatcher(String patternText) {
	    super(patternText);
	}

        @Override
	public final boolean accept(String name) {
	    return patternText.equalsIgnoreCase(name);
	}
    }

    private static final class PrefixNameMatcher extends BaseNameMatcher {

	public PrefixNameMatcher(String patternText) {
	    super(patternText);
	}

        @Override
	public final boolean accept(String name) {
	    return name != null && name.startsWith(patternText);
	}
    }

    private static final class CaseInsensitivePrefixNameMatcher extends BaseNameMatcher {

	public CaseInsensitivePrefixNameMatcher(String patternText) {
	    super(patternText.toLowerCase());
	}

        @Override
	public final boolean accept(String name) {
	    return name != null && name.toLowerCase().startsWith(patternText);
	}
    }

    private static final class RegExpNameMatcher implements NameMatcher {

	private final Pattern pattern;

	public RegExpNameMatcher(String patternText, boolean caseSensitive) {
	    pattern = Pattern.compile(patternText, caseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
	}

        @Override
	public final boolean accept(String name) {
	    return name != null && pattern.matcher(name).matches();
	}
    }

    private static final class CamelCaseNameMatcher implements NameMatcher {

	private final Pattern pattern;

	public CamelCaseNameMatcher(String name) {
            if (name.length() == 0) {
                throw new IllegalArgumentException ();
            }
            final StringBuilder patternString = new StringBuilder ();
            for (int i=0; i<name.length(); i++) {
                char c = name.charAt(i);
                patternString.append(c);
                if (i == name.length()-1) {
                    patternString.append("\\w*");  // NOI18N
                }
                else {
                    patternString.append("[\\p{Lower}\\p{Digit}]*");  // NOI18N
                }
            }
            pattern = Pattern.compile(patternString.toString());
	}

        @Override
	public final boolean accept(String name) {
	    return name != null && pattern.matcher(name).matches();
	}
    }

    /**
     * Creates a {@link NameMatcher} of given type for text.
     * @param text to create {@link NameMatcher} for
     * @param type of {@link NameMatcher}
     * @return a {@link NameMatcher}
     * @throws IllegalArgumentException when called with unsupported type or
     * regular expression for given text failed.
     */
    public static NameMatcher createNameMatcher(String text, SearchType type) throws IllegalArgumentException {
        Parameters.notNull("text", text);   //NOI18N
        Parameters.notNull("type", type);   //NOI18N
        try {
            switch( type ) {
                case EXACT_NAME:
                    return new ExactNameMatcher(text);
                case CASE_INSENSITIVE_EXACT_NAME:
                    return new CaseInsensitiveExactNameMatcher(text);
                case PREFIX:
                    return new PrefixNameMatcher(text);
                case REGEXP:
                    return new RegExpNameMatcher(text, true);
                case CASE_INSENSITIVE_REGEXP:
                    return new RegExpNameMatcher(text, false);
                case CASE_INSENSITIVE_PREFIX:
                     return new CaseInsensitivePrefixNameMatcher(text);
                case CAMEL_CASE:
                    return new CamelCaseNameMatcher(text);
                default:
                    throw new IllegalArgumentException("Unsupported type: " + type);  //NOI18N
            }
        }
        catch( PatternSyntaxException ex ) {
            throw new IllegalArgumentException(ex);
        }
    }
}

Lines 56-61 Link Here

(-)a/spring.beans/src/org/netbeans/modules/spring/beans/jumpto/SpringBeansTypeProvider.java (-85 / +7 lines)
56	import org.netbeans.modules.spring.api.beans.model.SpringConfigModel;	56	import org.netbeans.modules.spring.api.beans.model.SpringConfigModel;
57	import org.netbeans.modules.spring.api.beans.model.SpringConfigModel.DocumentAccess;	57	import org.netbeans.modules.spring.api.beans.model.SpringConfigModel.DocumentAccess;
58	import org.netbeans.modules.spring.beans.ProjectSpringScopeProvider;	58	import org.netbeans.modules.spring.beans.ProjectSpringScopeProvider;
		59	import org.netbeans.spi.jumpto.support.NameMatcher;
		60	import org.netbeans.spi.jumpto.support.NameMatcherFactory;
59	import org.netbeans.spi.jumpto.type.SearchType;	61	import org.netbeans.spi.jumpto.type.SearchType;
60	import org.netbeans.spi.jumpto.type.TypeProvider;	62	import org.netbeans.spi.jumpto.type.TypeProvider;
61	import org.openide.filesystems.FileObject;	63	import org.openide.filesystems.FileObject;
Lines 92-98 Link Here
92		94
93	final String searchText = context.getText();	95	final String searchText = context.getText();
94	final SearchType searchType = context.getSearchType();	96	final SearchType searchType = context.getSearchType();
95	final Matcher matcher = getMatcher(searchText, searchType);	97	final NameMatcher matcher = NameMatcherFactory.createNameMatcher(searchText, searchType);
96	if (matcher == null) {	98	if (matcher == null) {
97	return;	99	return;
98	}	100	}
Lines 158-176 Link Here
158		160
159	for (SpringBean bean : beans) {	161	for (SpringBean bean : beans) {
160	String id = bean.getId();	162	String id = bean.getId();
161	if (id != null && matcher.match(id)) {	163	if (id != null && matcher.accept(id)) {
162	currCache.add(new BeanTypeDescriptor(id, bean));	164	currCache.add(new BeanTypeDescriptor(id, bean));
163	}	165	}
164		166
165	for (String name : bean.getNames()) {	167	for (String name : bean.getNames()) {
166	if (matcher.match(name)) {	168	if (matcher.accept(name)) {
167	currCache.add(new BeanTypeDescriptor(name, bean));	169	currCache.add(new BeanTypeDescriptor(name, bean));
168	}	170	}
169	}	171	}
170	}	172	}
171		173
172	for (String alias : fileBeans.getAliases()) {	174	for (String alias : fileBeans.getAliases()) {
173	if (matcher.match(alias)) {	175	if (matcher.accept(alias)) {
174	currCache.add(new BeanAliasTypeDescriptor(alias, fo));	176	currCache.add(new BeanAliasTypeDescriptor(alias, fo));
175	}	177	}
176	}	178	}
Lines 192-198 Link Here
192	if (cache != null) {	194	if (cache != null) {
193	ArrayList<AbstractBeanTypeDescriptor> beans = new ArrayList<AbstractBeanTypeDescriptor>(cache.size());	195	ArrayList<AbstractBeanTypeDescriptor> beans = new ArrayList<AbstractBeanTypeDescriptor>(cache.size());
194	for (AbstractBeanTypeDescriptor beanTypeDescriptor : cache) {	196	for (AbstractBeanTypeDescriptor beanTypeDescriptor : cache) {
195	if (cacheRefresh \|\| matcher.match(beanTypeDescriptor.getSimpleName())) {	197	if (cacheRefresh \|\| matcher.accept(beanTypeDescriptor.getSimpleName())) {
196	beans.add(beanTypeDescriptor);	198	beans.add(beanTypeDescriptor);
197	}	199	}
198	}	200	}
Lines 212-295 Link Here
212	lastRefreshText = null;	214	lastRefreshText = null;
213	lastRefreshSearchType = null;	215	lastRefreshSearchType = null;
214	}	216	}
215
216	private interface Matcher {
217
218	boolean match(String str);
219	}
220
221	private static Pattern camelCaseBlock = Pattern.compile("(\\p{javaUpperCase}(?:\\p{javaLowerCase}\|\\d\|\\.\|\\-)*)"); // NOI18N
222
223	private Matcher getMatcher(String searchText, SearchType searchType) {
224	switch (searchType) {
225	case EXACT_NAME:
226	return new StringMatcher(searchText, false, true);
227	case CASE_INSENSITIVE_EXACT_NAME:
228	return new StringMatcher(searchText, false, false);
229	case PREFIX:
230	return new StringMatcher(searchText, true, true);
231	case CASE_INSENSITIVE_PREFIX:
232	return new StringMatcher(searchText, true, false);
233	case REGEXP:
234	String regex = searchText + "*"; // NOI18N
235
236	regex = regex.replace("", ".").replace('?', '.'); // NOI18N
237
238	return new RegExpMatcher(regex, true);
239	case CASE_INSENSITIVE_REGEXP:
240	regex = searchText + "*"; // NOI18N
241
242	regex = regex.replace("", ".").replace('?', '.'); // NOI18N
243
244	return new RegExpMatcher(regex, false);
245	case CAMEL_CASE:
246	java.util.regex.Matcher m = camelCaseBlock.matcher(searchText);
247	StringBuilder sb = new StringBuilder();
248	while (m.find()) {
249	sb.append(m.group()).append("(?:\\p{javaLowerCase}\|\\d\|\\.\|\\-)*"); // NOI18N
250
251	}
252	sb.append(".*"); // NOI18N
253	return new RegExpMatcher(sb.toString(), false);
254	}
255
256	assert false; // probably a new type got added to SearchType, would need fixing on our part
257
258	return null;
259	}
260
261	private static final class RegExpMatcher implements Matcher {
262
263	private final String regex;
264	private final boolean caseSensitive;
265	private final Pattern pattern;
266
267	public RegExpMatcher(String regex, boolean caseSensitive) {
268	this.regex = regex;
269	this.caseSensitive = caseSensitive;
270	this.pattern = caseSensitive ? Pattern.compile(regex) : Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
271	}
272
273	public boolean match(String str) {
274	return pattern.matcher(str).matches();
275	}
276	}
277
278	private static final class StringMatcher implements Matcher {
279
280	private final String searchText;
281	private final boolean prefix;
282	private final boolean caseSensitive;
283
284	public StringMatcher(String searchText, boolean prefix, boolean caseSensitive) {
285	this.searchText = searchText;
286	this.prefix = prefix;
287	this.caseSensitive = caseSensitive;
288	}
289
290	public boolean match(String str) {
291	int length = prefix ? searchText.length() : Math.max(str.length(), searchText.length());
292	return str.regionMatches(caseSensitive, 0, searchText, 0, length);
293	}
294	}
295	}	217	}

Return to bug 185168

Lines 105-110 Link Here

(-)a/jumpto/apichanges.xml (+16 lines)
105	<!-- ACTUAL CHANGES BEGIN HERE: -->	105	<!-- ACTUAL CHANGES BEGIN HERE: -->
106		106
107	<changes>	107	<changes>
		108	<change id="Support">
		109	<api name="general"/>
		110	<summary>Added support SPI to implement name filters</summary>
		111	<version major="1" minor="17"/>
		112	<date day="5" month="5" year="2010"/>
		113	<author login="tzezula"/>
		114	<compatibility addition="yes">
		115	</compatibility>
		116	<description>
		117	Added support SPI to implement common filters used by Go To Type, Go To Symbol,
		118	Go To File.
		119	</description>
		120	<class package="org.netbeans.spi.jumpto.support" name="NameMatcherFactory"/>
		121	<class package="org.netbeans.spi.jumpto.support" name="NameMatcher"/>
		122	<issue number="185168"/>
		123	</change>
108	<change id="GoToFile">	124	<change id="GoToFile">
109	<api name="general"/>	125	<api name="general"/>
110	<summary>Added SPI for Go to File dialog</summary>	126	<summary>Added SPI for Go to File dialog</summary>

Lines 68-75 Link Here

(-)a/jumpto/src/org/netbeans/modules/jumpto/file/FileSearchAction.java (-132 / +6 lines)
68	import java.util.Set;	68	import java.util.Set;
69	import java.util.logging.Level;	69	import java.util.logging.Level;
70	import java.util.logging.Logger;	70	import java.util.logging.Logger;
71	import java.util.regex.Matcher;
72	import java.util.regex.Pattern;
73	import java.util.regex.PatternSyntaxException;	71	import java.util.regex.PatternSyntaxException;
74	import javax.swing.AbstractAction;	72	import javax.swing.AbstractAction;
75	import javax.swing.DefaultListCellRenderer;	73	import javax.swing.DefaultListCellRenderer;
Lines 100-105 Link Here
100	import org.netbeans.spi.jumpto.file.FileDescriptor;	98	import org.netbeans.spi.jumpto.file.FileDescriptor;
101	import org.netbeans.spi.jumpto.file.FileProvider;	99	import org.netbeans.spi.jumpto.file.FileProvider;
102	import org.netbeans.spi.jumpto.file.FileProviderFactory;	100	import org.netbeans.spi.jumpto.file.FileProviderFactory;
		101	import org.netbeans.spi.jumpto.support.NameMatcher;
		102	import org.netbeans.spi.jumpto.support.NameMatcherFactory;
103	import org.netbeans.spi.jumpto.type.SearchType;	103	import org.netbeans.spi.jumpto.type.SearchType;
104	import org.openide.DialogDescriptor;	104	import org.openide.DialogDescriptor;
105	import org.openide.DialogDisplayer;	105	import org.openide.DialogDisplayer;
Lines 467-473 Link Here
467	}	467	}
468	}	468	}
469	//Ask GTF providers	469	//Ask GTF providers
470	final FileProvider.Context ctx = FileProviderAccessor.getInstance().createContext(text, toJumpToSearchType(searchType), currentProject);	470	final SearchType jumpToSearchType = toJumpToSearchType(searchType);
		471	final FileProvider.Context ctx = FileProviderAccessor.getInstance().createContext(text, jumpToSearchType, currentProject);
471	final FileProvider.Result fpR = FileProviderAccessor.getInstance().createResult(files,new String[1], ctx);	472	final FileProvider.Result fpR = FileProviderAccessor.getInstance().createResult(files,new String[1], ctx);
472	for (FileProvider provider : getProviders()) {	473	for (FileProvider provider : getProviders()) {
473	currentProvider = provider;	474	currentProvider = provider;
Lines 497-502 Link Here
497	allFolders = searchSources(root, allFolders, excludes, filters);	498	allFolders = searchSources(root, allFolders, excludes, filters);
498	}	499	}
499	//Looking for matching files in all found folders	500	//Looking for matching files in all found folders
		501	final NameMatcher matcher = NameMatcherFactory.createNameMatcher(text, jumpToSearchType);
500	for (FileObject folder: allFolders) {	502	for (FileObject folder: allFolders) {
501	assert folder.isFolder();	503	assert folder.isFolder();
502	Enumeration<? extends FileObject> filesInFolder = folder.getData(false);	504	Enumeration<? extends FileObject> filesInFolder = folder.getData(false);
Lines 504-510 Link Here
504	FileObject file = filesInFolder.nextElement();	506	FileObject file = filesInFolder.nextElement();
505	if (file.isFolder()) continue;	507	if (file.isFolder()) continue;
506		508
507	if (isMatchedFileObject(searchType, file, text)) {	509	if (matcher.accept(file.getNameExt())) {
508	Project project = FileOwnerQuery.getOwner(file);	510	Project project = FileOwnerQuery.getOwner(file);
509	boolean preferred = project != null && currentProject != null ? project.getProjectDirectory() == currentProject.getProjectDirectory() : false;	511	boolean preferred = project != null && currentProject != null ? project.getProjectDirectory() == currentProject.getProjectDirectory() : false;
510	String relativePath = FileUtil.getRelativePath(project.getProjectDirectory(), file);	512	String relativePath = FileUtil.getRelativePath(project.getProjectDirectory(), file);
Lines 564-697 Link Here
564	// }	566	// }
565	}	567	}
566	return result;	568	return result;
567	}
568
569	private boolean isMatchedFileObject(QuerySupport.Kind searchType, FileObject file, String text) {
570	boolean isMatched = false;
571	switch (searchType) {
572	case EXACT: {
573	isMatched = file.getNameExt().equals(text);
574	break;
575	}
576	case PREFIX: {
577	if (text.length() == 0) {
578	isMatched = true;
579	} else {
580	isMatched = file.getNameExt().startsWith(text);
581	}
582	break;
583	}
584	case CASE_INSENSITIVE_PREFIX: {
585	if (text.length() == 0) {
586	isMatched = true;
587	} else {
588	isMatched = file.getNameExt().toLowerCase().startsWith(text.toLowerCase());
589	}
590	break;
591	}
592	case CAMEL_CASE: {
593	if (text.length() == 0) {
594	throw new IllegalArgumentException ();
595	}
596	{
597	StringBuilder sb = new StringBuilder();
598	String prefix = null;
599	int lastIndex = 0;
600	int index;
601	do {
602	index = findNextUpper(text, lastIndex + 1);
603	String token = text.substring(lastIndex, index == -1 ? text.length(): index);
604	if ( lastIndex == 0 ) {
605	prefix = token;
606	}
607	sb.append(token);
608	sb.append( index != -1 ? "[\\p{javaLowerCase}\\p{Digit}_\\$]" : "."); // NOI18N
609	lastIndex = index;
610	}
611	while(index != -1);
612
613	final Pattern pattern = Pattern.compile(sb.toString());
614	Matcher m = pattern.matcher(file.getNameExt());
615	isMatched = m.matches();
616	}
617	break;
618
619	}
620
621	case CASE_INSENSITIVE_REGEXP:
622	if (text.length() == 0) {
623	throw new IllegalArgumentException ();
624	} else {
625	if (Character.isJavaIdentifierStart(text.charAt(0))) {
626	Pattern pattern = Pattern.compile(text,Pattern.CASE_INSENSITIVE);
627	Matcher m = pattern.matcher(file.getNameExt());
628	isMatched = m.matches();
629	}
630	else {
631	Pattern pattern = Pattern.compile(text,Pattern.CASE_INSENSITIVE\|Pattern.DOTALL);
632	Matcher m = pattern.matcher(file.getNameExt());
633	isMatched = m.matches();
634	}
635	break;
636	}
637	case REGEXP:
638	if (text.length() == 0) {
639	throw new IllegalArgumentException ();
640	} else {
641	if (Character.isJavaIdentifierStart(text.charAt(0))) {
642	final Pattern pattern = Pattern.compile(text);
643	Matcher m = pattern.matcher(file.getNameExt());
644	isMatched = m.matches();
645	}
646	else {
647	final Pattern pattern = Pattern.compile(text,Pattern.DOTALL);
648	Matcher m = pattern.matcher(file.getNameExt());
649	isMatched = m.matches();
650	}
651	break;
652	}
653
654	case CASE_INSENSITIVE_CAMEL_CASE: {
655	if (text.length() == 0) {
656	throw new IllegalArgumentException ();
657	}
658	{
659	StringBuilder sb = new StringBuilder();
660	String prefix = null;
661	int lastIndex = 0;
662	int index;
663	do {
664	index = findNextUpper(text, lastIndex + 1);
665	String token = text.substring(lastIndex, index == -1 ? text.length(): index);
666	if ( lastIndex == 0 ) {
667	prefix = token;
668	}
669	sb.append(token);
670	sb.append( index != -1 ? "[\\p{javaLowerCase}\\p{Digit}_\\$]" : "."); // NOI18N
671	lastIndex = index;
672	}
673	while(index != -1);
674
675	final Pattern pattern = Pattern.compile(sb.toString(),Pattern.CASE_INSENSITIVE);
676	Matcher m = pattern.matcher(file.getNameExt());
677	isMatched = m.matches();
678	}
679	break;
680	}
681	default:
682	throw new UnsupportedOperationException (searchType.toString());
683
684	}
685	return isMatched;
686	}//checkMatch
687	private static int findNextUpper(String text, int offset ) {
688
689	for( int i = offset; i < text.length(); i++ ) {
690	if ( Character.isUpperCase(text.charAt(i)) ) {
691	return i;
692	}
693	}
694	return -1;
695	}	569	}
696		570
697	private boolean checkAgainstFilters(FileObject folder, FileObjectFilter[] filters) {	571	private boolean checkAgainstFilters(FileObject folder, FileObjectFilter[] filters) {

Lines 27-35 Link Here

(-)a/cnd.gotodeclaration/src/org/netbeans/modules/cnd/gotodeclaration/matcher/NameMatcherFactory.java (-135 / +2 lines)
27	*/	27	*/
28	package org.netbeans.modules.cnd.gotodeclaration.matcher;	28	package org.netbeans.modules.cnd.gotodeclaration.matcher;
29		29
30	import java.util.regex.Pattern;
31	import java.util.regex.PatternSyntaxException;
32	import org.netbeans.modules.cnd.api.model.services.CsmSelect;	30	import org.netbeans.modules.cnd.api.model.services.CsmSelect;
		31	import org.netbeans.spi.jumpto.support.NameMatcher;
33	import org.netbeans.spi.jumpto.type.SearchType;	32	import org.netbeans.spi.jumpto.type.SearchType;
34		33
35	/**	34	/**
Lines 39-179 Link Here
39	* @author Vladimir Kvashin	38	* @author Vladimir Kvashin
40	*/	39	*/
41	public class NameMatcherFactory {	40	public class NameMatcherFactory {
42
43	private NameMatcherFactory() {
44	}
45
46	private static abstract class BaseNameMatcher implements NameMatcher {
47
48	protected String patternText;
49
50	protected BaseNameMatcher(String patternText) {
51	this.patternText = patternText;
52	}
53	}
54
55
56	private static final class ExactNameMatcher extends BaseNameMatcher implements NameMatcher {
57
58	public ExactNameMatcher(String patternText) {
59	super(patternText);
60	}
61
62	@Override
63	public final boolean accept(String name) {
64	return patternText.equals(name);
65	}
66	}
67
68	private static final class CaseInsensitiveExactNameMatcher extends BaseNameMatcher implements NameMatcher {
69
70	public CaseInsensitiveExactNameMatcher(String patternText) {
71	super(patternText);
72	}
73
74	@Override
75	public final boolean accept(String name) {
76	return patternText.equalsIgnoreCase(name);
77	}
78	}
79
80	private static final class PrefixNameMatcher extends BaseNameMatcher implements NameMatcher {
81
82	public PrefixNameMatcher(String patternText) {
83	super(patternText);
84	}
85
86	@Override
87	public final boolean accept(String name) {
88	return name != null && name.startsWith(patternText);
89	}
90	}
91
92	private static final class CaseInsensitivePrefixNameMatcher extends BaseNameMatcher implements NameMatcher {
93
94	public CaseInsensitivePrefixNameMatcher(String patternText) {
95	super(patternText.toLowerCase());
96	}
97
98	@Override
99	public final boolean accept(String name) {
100	return name != null && name.toLowerCase().startsWith(patternText);
101	}
102	}
103
104	private static final class RegExpNameMatcher implements NameMatcher {
105
106	Pattern pattern;
107
108	public RegExpNameMatcher(String patternText, boolean caseSensitive) {
109	pattern = Pattern.compile(patternText, caseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
110	}
111
112	@Override
113	public final boolean accept(String name) {
114	return name != null && pattern.matcher(name).matches();
115	}
116	}
117
118	private static final class CamelCaseNameMatcher implements NameMatcher {
119
120	Pattern pattern;
121
122	public CamelCaseNameMatcher(String name) {
123	if (name.length() == 0) {
124	throw new IllegalArgumentException ();
125	}
126	final StringBuilder patternString = new StringBuilder ();
127	for (int i=0; i<name.length(); i++) {
128	char c = name.charAt(i);
129	patternString.append(c);
130	if (i == name.length()-1) {
131	patternString.append("\\w*"); // NOI18N
132	}
133	else {
134	patternString.append("[\\p{Lower}\\p{Digit}]*"); // NOI18N
135	}
136	}
137	pattern = Pattern.compile(patternString.toString());
138	}
139
140	@Override
141	public final boolean accept(String name) {
142	return name != null && pattern.matcher(name).matches();
143	}
144	}
145
146	/**
147	* Get a name
148	*/
149	public static NameMatcher createNameMatcher(String text, SearchType type) {
150	try {
151	switch( type ) {
152	case EXACT_NAME:
153	return new ExactNameMatcher(text);
154	case CASE_INSENSITIVE_EXACT_NAME:
155	return new CaseInsensitiveExactNameMatcher(text);
156	case PREFIX:
157	return new PrefixNameMatcher(text);
158	case REGEXP:
159	return new RegExpNameMatcher(text, true);
160	case CASE_INSENSITIVE_REGEXP:
161	return new RegExpNameMatcher(text, false);
162	case CASE_INSENSITIVE_PREFIX:
163	return new CaseInsensitivePrefixNameMatcher(text);
164	case CAMEL_CASE:
165	return new CamelCaseNameMatcher(text);
166	default:
167	return null;
168	}
169	}
170	catch( PatternSyntaxException ex ) {
171	return null;
172	}
173	}
174		41
175	public static CsmSelect.CsmFilter createNameFilter(String text, SearchType type) {	42	public static CsmSelect.CsmFilter createNameFilter(String text, SearchType type) {
176	final NameMatcher matcher = createNameMatcher(text, type);	43	final NameMatcher matcher = org.netbeans.spi.jumpto.support.NameMatcherFactory.createNameMatcher(text, type);
177	if( matcher != null ) {	44	if( matcher != null ) {
178	CsmSelect.NameAcceptor acceptor = new CsmSelect.NameAcceptor() {	45	CsmSelect.NameAcceptor acceptor = new CsmSelect.NameAcceptor() {
179	@Override	46	@Override

Lines 32-39 Link Here

(-)a/cnd.gotodeclaration/src/org/netbeans/modules/cnd/gotodeclaration/type/CppTypeProvider.java (-4 / +4 lines)
32		32
33	import org.netbeans.api.project.Project;	33	import org.netbeans.api.project.Project;
34	import org.netbeans.modules.cnd.api.model.services.CsmSelect;	34	import org.netbeans.modules.cnd.api.model.services.CsmSelect;
35	import org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcher;	35	import org.netbeans.spi.jumpto.support.NameMatcher;
36	import org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcherFactory;	36	import org.netbeans.spi.jumpto.support.NameMatcherFactory;
37		37
38	import org.netbeans.spi.jumpto.type.SearchType;	38	import org.netbeans.spi.jumpto.type.SearchType;
39	import org.netbeans.spi.jumpto.type.TypeDescriptor;	39	import org.netbeans.spi.jumpto.type.TypeDescriptor;
Lines 77-85 Link Here
77		77
78		78
79		79
80	CsmSelect.CsmFilter filter = NameMatcherFactory.createNameFilter(text, type);	80	CsmSelect.CsmFilter filter = org.netbeans.modules.cnd.gotodeclaration.matcher.NameMatcherFactory.createNameFilter(text, type);
81	NameMatcher matcher = NameMatcherFactory.createNameMatcher(text, type);	81	NameMatcher matcher = NameMatcherFactory.createNameMatcher(text, type);
82	if( filter == null \|\| matcher == null) {	82	if( filter == null) {
83	return;	83	return;
84	}	84	}
85		85

Line 0 Link Here

(-)a/jumpto/src/org/netbeans/spi/jumpto/support/NameMatcher.java (+42 lines)
	1	/*
	2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
	3	*
	4	* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
	5	*
	6	* The contents of this file are subject to the terms of either the GNU
	7	* General Public License Version 2 only ("GPL") or the Common
	8	* Development and Distribution License("CDDL") (collectively, the
	9	* "License"). You may not use this file except in compliance with the
	10	* License. You can obtain a copy of the License at
	11	* http://www.netbeans.org/cddl-gplv2.html
	12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
	13	* specific language governing permissions and limitations under the
	14	* License. When distributing the software, include this License Header
	15	* Notice in each file and include the License file at
	16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
	17	* particular file as subject to the "Classpath" exception as provided
	18	* by Sun in the GPL Version 2 section of the License file that
	19	* accompanied this code. If applicable, add the following below the
	20	* License Header, with the fields enclosed by brackets [] replaced by
	21	* your own identifying information:
	22	* "Portions Copyrighted [year] [name of copyright owner]"
	23	*
	24	* Contributor(s):
	25	*
	26	* Portions Copyrighted 2007 Sun Microsystems, Inc.
	27	*/
	28
	29	package org.netbeans.spi.jumpto.support;
	30
	31	/**
	32	* Used for encapsulation of the different matching algorithms
	33	* (such as String.equals, String.equalsIgnoreCase, String.startWith, etc)
	34	*/
	35	public interface NameMatcher {
	36
	37	/**
	38	* Determine whether the name matches a pattern or not
	39	* return true
	40	*/
	41	boolean accept(String name);
	42	}