Attachment #132519 for bug #227363

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 227363
Collapse All | Expand All

Lines 46-52 Link Here

(-)a/java.source/nbproject/project.properties (-1 / +1 lines)
46	javadoc.title=Java Source	46	javadoc.title=Java Source
47	javadoc.arch=${basedir}/arch.xml	47	javadoc.arch=${basedir}/arch.xml
48	javadoc.apichanges=${basedir}/apichanges.xml	48	javadoc.apichanges=${basedir}/apichanges.xml
49	spec.version.base=0.113	49	spec.version.base=0.114
50	test.qa-functional.cp.extra=${refactoring.java.dir}/modules/ext/nb-javac-api.jar	50	test.qa-functional.cp.extra=${refactoring.java.dir}/modules/ext/nb-javac-api.jar
51	test.unit.run.cp.extra=${o.n.core.dir}/core/core.jar:\	51	test.unit.run.cp.extra=${o.n.core.dir}/core/core.jar:\
52	${o.n.core.dir}/lib/boot.jar:\	52	${o.n.core.dir}/lib/boot.jar:\




import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.lexer.JavaTokenId;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.queries.JavadocForBinaryQuery;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.java.source.ClasspathInfo.PathKind;
import org.netbeans.api.java.source.JavaSource.Phase;
import static org.netbeans.api.java.source.SourceUtils.getDependentRootsImpl;
import org.netbeans.api.java.source.matching.Matcher;
import org.netbeans.api.java.source.matching.Occurrence;
import org.netbeans.api.java.source.matching.Pattern;

import org.netbeans.modules.parsing.api.ResultIterator;
import org.netbeans.modules.parsing.api.UserTask;
import org.netbeans.modules.parsing.api.indexing.IndexingManager;
import org.netbeans.modules.parsing.spi.indexing.support.QuerySupport;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;

import org.openide.filesystems.FileObject;

     * incoming root, never returns null.
     * @since 0.10
     */
    @NonNull
    @org.netbeans.api.annotations.common.SuppressWarnings(value = {"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
    public static Set<URL> getDependentRoots (@NonNull final URL root) {
        return getDependentRoots(root, true);
        return getDependentRootsImpl (root, sourceDeps, binaryDeps, true);
    }
    
    /**

     * root, never returns null.
     * @since 0.110
     */
    @NonNull
    @org.netbeans.api.annotations.common.SuppressWarnings(value = {"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
    public static Set<URL> getDependentRoots(
        @NonNull final URL root,
        final boolean filterNonOpenedProjects) {
        final FileObject rootFO = URLMapper.findFileObject(root);
        if (rootFO != null) {
            return mapToURLs(QuerySupport.findDependentRoots(rootFO,filterNonOpenedProjects));
        } else {
            return Collections.<URL>singleton(root);
        }
    }
        
    @org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")    //NOI18N
    static Set<URL> getDependentRootsImpl (final URL root, final Map<URL, List<URL>> sourceDeps, Map<URL, List<URL>> binaryDeps, boolean filterNonOpenedProjects) {
        Set<URL> urls;

        if (sourceDeps.containsKey(root)) {
            urls = findReverseSourceRoots(root, sourceDeps);
        } else {
            FileObject rootFO = URLMapper.findFileObject(root);

            if (rootFO != null) {
                urls = new HashSet<URL>();

                for (URL binary : findBinaryRootsForSourceRoot(rootFO, binaryDeps)) {
                    List<URL> deps = binaryDeps.get(binary);

                    if (deps != null) {
                        urls.addAll(deps);
                    }
                }
            } else {
                urls = new HashSet<URL>();
            }
        }

        if(filterNonOpenedProjects) {
            Set<ClassPath> cps = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
            Set<URL> toRetain = new HashSet<URL>();
            for (ClassPath cp : cps) {
                for (ClassPath.Entry e : cp.entries()) {
                    toRetain.add(e.getURL());
                }
            }
            urls.retainAll(toRetain);
        }
        return urls;
    }    
    
    private static Set<URL> findReverseSourceRoots(final URL thisSourceRoot, Map<URL, List<URL>> deps) {
        //Create inverse dependencies
        final Map<URL, List<URL>> inverseDeps = new HashMap<URL, List<URL>> ();
        for (Map.Entry<URL,List<URL>> entry : deps.entrySet()) {
            final URL u1 = entry.getKey();
            final List<URL> l1 = entry.getValue();
            for (URL u2 : l1) {
                List<URL> l2 = inverseDeps.get(u2);
                if (l2 == null) {
                    l2 = new ArrayList<URL>();
                    inverseDeps.put (u2,l2);
                }
                l2.add (u1);
            }
        }
        //Collect dependencies
        final Set<URL> result = new HashSet<URL>();
        final LinkedList<URL> todo = new LinkedList<URL> ();
        todo.add (thisSourceRoot);
        while (!todo.isEmpty()) {
            final URL u = todo.removeFirst();
            if (!result.contains(u)) {
                result.add (u);
                final List<URL> ideps = inverseDeps.get(u);
                if (ideps != null) {
                    todo.addAll (ideps);
                }
            }
        }

        return result;
    }

    private static Set<URL> findBinaryRootsForSourceRoot(FileObject sourceRoot, Map<URL, List<URL>> binaryDeps) {
        Set<URL> result = new HashSet<URL>();

        for (URL bin : binaryDeps.keySet()) {
            for (FileObject s : SourceForBinaryQuery.findSourceRoots(bin).getRoots()) {
                if (s == sourceRoot) {
                    result.add(bin);
                }
            }
        }

        return result;
    }

    //Helper methods
    
    /**

            return s.toLowerCase();
        }
    }

    @NonNull
    private static Set<URL> mapToURLs(
        @NonNull final Collection<? extends FileObject> fos) {
        final Set<URL> res = new HashSet<URL>(fos.size());
        for (FileObject fo : fos) {
            res.add(fo.toURL());
        }
        return res;
    }
}




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

  <changes>
  <change id="QuerySupport.findDependentRoots">
      <api name="ParsingAPI"/>
      <summary>Added <code>QuerySupport.findDependentRoots</code> to find out source roots depending on given source root.</summary>
      <version major="1" minor="64"/>
      <date day="18" month="3" year="2013"/>
      <author login="tzezula"/>
      <compatibility source="compatible" binary="compatible" semantic="compatible" deletion="no" addition="yes" modification="no"/>
      <description>
          <p>
              Added a <code>QuerySupport.findDependentRoots</code> method returning the dependent source roots for given source root.
              It returns all the source roots which have either direct or transitive dependency on the given source root.
          </p>
      </description>
      <class package="org.netbeans.modules.parsing.spi.indexing.support" name="QuerySupport"/>
      <issue number="227363"/>
  </change>
  <change id="EmbeddingProvider.Registration">
      <api name="ParsingAPI"/>
      <summary>Added <code>EmbeddingProvider.Registration</code> annotation to register <code>EmbeddingProvider</code>s.</summary>

Lines 3-9 Link Here

(-)a/parsing.api/nbproject/project.properties (-1 / +1 lines)
3	javac.source=1.6	3	javac.source=1.6
4	javadoc.apichanges=${basedir}/apichanges.xml	4	javadoc.apichanges=${basedir}/apichanges.xml
5	javadoc.arch=${basedir}/arch.xml	5	javadoc.arch=${basedir}/arch.xml
6	spec.version.base=1.63.0	6	spec.version.base=1.64.0
7		7
8	test.config.stableBTD.includes=*/Test.class	8	test.config.stableBTD.includes=*/Test.class
9	test.config.stableBTD.excludes=\	9	test.config.stableBTD.excludes=\

Lines 60-66 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/spi/indexing/support/QuerySupport.java (-1 / +174 lines)
60	import java.util.concurrent.Callable;	60	import java.util.concurrent.Callable;
61	import java.util.logging.Level;	61	import java.util.logging.Level;
62	import java.util.logging.Logger;	62	import java.util.logging.Logger;
		63	import org.netbeans.api.annotations.common.CheckForNull;
		64	import org.netbeans.api.annotations.common.NonNull;
63	import org.netbeans.api.java.classpath.ClassPath;	65	import org.netbeans.api.java.classpath.ClassPath;
		66	import org.netbeans.api.java.classpath.GlobalPathRegistry;
		67	import org.netbeans.api.java.queries.SourceForBinaryQuery;
64	import org.netbeans.api.project.FileOwnerQuery;	68	import org.netbeans.api.project.FileOwnerQuery;
65	import org.netbeans.api.project.Project;	69	import org.netbeans.api.project.Project;
66	import org.netbeans.modules.parsing.impl.Installer;	70	import org.netbeans.modules.parsing.impl.Installer;
Lines 76-81 Link Here
76	import org.netbeans.modules.parsing.impl.indexing.TransientUpdateSupport;	80	import org.netbeans.modules.parsing.impl.indexing.TransientUpdateSupport;
77	import org.netbeans.modules.parsing.impl.indexing.URLCache;	81	import org.netbeans.modules.parsing.impl.indexing.URLCache;
78	import org.netbeans.modules.parsing.impl.indexing.Util;	82	import org.netbeans.modules.parsing.impl.indexing.Util;
		83	import org.netbeans.modules.parsing.impl.indexing.friendapi.IndexingController;
79	import org.netbeans.modules.parsing.impl.indexing.lucene.LayeredDocumentIndex;	84	import org.netbeans.modules.parsing.impl.indexing.lucene.LayeredDocumentIndex;
80	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;	85	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;
81	import org.netbeans.modules.parsing.lucene.support.DocumentIndex;	86	import org.netbeans.modules.parsing.lucene.support.DocumentIndex;
Lines 83-88 Link Here
83	import org.netbeans.modules.parsing.lucene.support.Queries;	88	import org.netbeans.modules.parsing.lucene.support.Queries;
84	import org.openide.filesystems.FileObject;	89	import org.openide.filesystems.FileObject;
85	import org.openide.filesystems.FileStateInvalidException;	90	import org.openide.filesystems.FileStateInvalidException;
		91	import org.openide.filesystems.URLMapper;
86	import org.openide.util.Parameters;	92	import org.openide.util.Parameters;
87		93
88	/**	94	/**
Lines 155-160 Link Here
155	}	161	}
156		162
157	/**	163	/**
		164	* Returns the dependent source roots for given source root. It returns
		165	* all the source roots which have either direct or transitive dependency on
		166	* the given source root.
		167	*
		168	* @param root to find the dependent roots for
		169	* @param filterNonOpenedProjects if true the results contains only roots of
		170	* opened projects
		171	* @return {@link Collection} of {@link FileObject}s containing at least the incoming
		172	* root, never returns null.
		173	* @since 1.64
		174	*/
		175	@NonNull
		176	@org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
		177	public static Collection<FileObject> findDependentRoots(
		178	@NonNull final FileObject file,
		179	final boolean filterNonOpenedProjects) {
		180	Parameters.notNull("file", file); //NOI18N
		181
		182	final URL root = findOwnerRoot(file);
		183	if (root == null) {
		184	return Collections.<FileObject>emptySet();
		185	}
		186	final IndexingController ic = IndexingController.getDefault();
		187	final Map<URL, List<URL>> binaryDeps = ic.getBinaryRootDependencies();
		188	final Map<URL, List<URL>> sourceDeps = ic.getRootDependencies();
		189	final Map<URL, List<URL>> peerDeps = ic.getRootPeers();
		190	Set<URL> urls;
		191
		192	if (sourceDeps.containsKey(root)) {
		193	urls = findReverseSourceRoots(root, sourceDeps, peerDeps);
		194	} else {
		195	urls = new HashSet<URL>();
		196	final FileObject rootFo = URLMapper.findFileObject(root);
		197	if (rootFo != null) {
		198	for (URL binary : findBinaryRootsForSourceRoot(rootFo, binaryDeps)) {
		199	List<URL> deps = binaryDeps.get(binary);
		200	if (deps != null) {
		201	urls.addAll(deps);
		202	}
		203	}
		204	}
		205	}
		206
		207	if(filterNonOpenedProjects) {
		208	final GlobalPathRegistry gpr = GlobalPathRegistry.getDefault();
		209	final Set<ClassPath> cps = new HashSet<ClassPath>();
		210	for (String id : PathRecognizerRegistry.getDefault().getSourceIds()) {
		211	cps.addAll(gpr.getPaths(id));
		212	}
		213	Set<URL> toRetain = new HashSet<URL>();
		214	for (ClassPath cp : cps) {
		215	for (ClassPath.Entry e : cp.entries()) {
		216	toRetain.add(e.getURL());
		217	}
		218	}
		219	urls.retainAll(toRetain);
		220	}
		221	return mapToFileObjects(urls);
		222	}
		223
		224	/**
158	* Gets classpath roots relevant for a project. This method tries to find	225	* Gets classpath roots relevant for a project. This method tries to find
159	* classpaths with <code>sourcePathIds</code>, <code>libraryPathIds</code> and	226	* classpaths with <code>sourcePathIds</code>, <code>libraryPathIds</code> and
160	* <code>binaryPathIds</code> supplied by the <code>project</code>.	227	* <code>binaryPathIds</code> supplied by the <code>project</code>.
Lines 470-476 Link Here
470	case CASE_INSENSITIVE_CAMEL_CASE: return Queries.QueryKind.CASE_INSENSITIVE_CAMEL_CASE;	537	case CASE_INSENSITIVE_CAMEL_CASE: return Queries.QueryKind.CASE_INSENSITIVE_CAMEL_CASE;
471	default: throw new UnsupportedOperationException (kind.toString());	538	default: throw new UnsupportedOperationException (kind.toString());
472	}	539	}
473	}	540	}
		541
		542	@CheckForNull
		543	private static URL findOwnerRoot(@NonNull final FileObject file) {
		544	final PathRecognizerRegistry regs = PathRecognizerRegistry.getDefault();
		545	URL res = findOwnerRoot(file, regs.getSourceIds());
		546	if (res != null) {
		547	return res;
		548	}
		549	res = findOwnerRoot(file, regs.getBinaryLibraryIds());
		550	if (res != null) {
		551	return res;
		552	}
		553	res = findOwnerRoot(file, regs.getLibraryIds());
		554	if (res != null) {
		555	return res;
		556	}
		557	//Fallback for roots with wrong classpath
		558	return file.isFolder() ? file.toURL() : null;
		559	}
		560
		561	@CheckForNull
		562	private static URL findOwnerRoot(
		563	@NonNull final FileObject file,
		564	@NonNull final Collection<? extends String> ids) {
		565	for (String id : ids) {
		566	final ClassPath cp = ClassPath.getClassPath(file, id);
		567	if (cp != null) {
		568	final FileObject owner = cp.findOwnerRoot(file);
		569	if (owner != null) {
		570	return owner.toURL();
		571	}
		572	}
		573	}
		574	return null;
		575	}
		576
		577	@NonNull
		578	@org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
		579	private static Set<URL> findReverseSourceRoots(
		580	@NonNull final URL thisSourceRoot,
		581	@NonNull final Map<URL, List<URL>> deps,
		582	@NonNull final Map<URL, List<URL>> peers) {
		583	//Create inverse dependencies
		584	final Map<URL, List<URL>> inverseDeps = new HashMap<URL, List<URL>> ();
		585	for (Map.Entry<URL,List<URL>> entry : deps.entrySet()) {
		586	final URL u1 = entry.getKey();
		587	final List<URL> l1 = entry.getValue();
		588	for (URL u2 : l1) {
		589	List<URL> l2 = inverseDeps.get(u2);
		590	if (l2 == null) {
		591	l2 = new ArrayList<URL>();
		592	inverseDeps.put (u2,l2);
		593	}
		594	l2.add (u1);
		595	}
		596	}
		597	//Collect dependencies
		598	final Set<URL> result = new HashSet<URL>();
		599	final LinkedList<URL> todo = new LinkedList<URL> ();
		600	todo.add (thisSourceRoot);
		601	while (!todo.isEmpty()) {
		602	final URL u = todo.removeFirst();
		603	if (!result.contains(u)) {
		604	result.add (u);
605	List<URL> ideps = inverseDeps.get(u);
606	if (ideps != null) {
607	todo.addAll (ideps);
608	}
609	ideps = peers.get(u);
610	if (ideps != null) {
611	todo.addAll (ideps);
612	}
613	}
614	}
615
616	return result;
617	}
618
619	@NonNull
620	@org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
621	private static Set<URL> findBinaryRootsForSourceRoot(
622	@NonNull final FileObject sourceRoot,
623	@NonNull final Map<URL, List<URL>> binaryDeps) {
624	Set<URL> result = new HashSet<URL>();
625	for (URL bin : binaryDeps.keySet()) {
626	for (FileObject fo : SourceForBinaryQuery.findSourceRoots(bin).getRoots()) {
627	if (sourceRoot.equals(fo)) {
628	result.add(bin);
629	}
630	}
631	}
632	return result;
633	}
634
635	@NonNull
636	private static Collection<FileObject> mapToFileObjects(
637	@NonNull final Collection<? extends URL> urls) {
638	final Collection<FileObject> result = new ArrayList<FileObject>(urls.size());
639	for (URL u : urls) {
640	final FileObject fo = URLMapper.findFileObject(u);
641	if (fo != null) {
642	result.add(fo);
643	}
644	}
645	return result;
646	}
474		647
475	/* test */ static final class IndexerQuery {	648	/* test */ static final class IndexerQuery {
476		649

Lines 161-168 Link Here

(-)a/parsing.api/test/unit/src/org/netbeans/modules/parsing/impl/indexing/RepositoryUpdaterTest.java (-3 / +3 lines)
161	public class RepositoryUpdaterTest extends NbTestCase {	161	public class RepositoryUpdaterTest extends NbTestCase {
162		162
163		163
164	static final int TIME = Integer.getInteger("RepositoryUpdaterTest.timeout", 5000); //NOI18N	164	public static final int TIME = Integer.getInteger("RepositoryUpdaterTest.timeout", 5000); //NOI18N
165	static final int NEGATIVE_TIME = Integer.getInteger("RepositoryUpdaterTest.negative-timeout", 5000); //NOI18N	165	public static final int NEGATIVE_TIME = Integer.getInteger("RepositoryUpdaterTest.negative-timeout", 5000); //NOI18N
166	private static final String SOURCES = "FOO_SOURCES";	166	private static final String SOURCES = "FOO_SOURCES";
167	private static final String PLATFORM = "FOO_PLATFORM";	167	private static final String PLATFORM = "FOO_PLATFORM";
168	private static final String LIBS = "FOO_LIBS";	168	private static final String LIBS = "FOO_LIBS";
Lines 335-341 Link Here
335	}	335	}
336	}	336	}
337		337
338	/* package */ static void waitForRepositoryUpdaterInit() throws Exception {	338	public static void waitForRepositoryUpdaterInit() throws Exception {
339	RepositoryUpdater.getDefault().ignoreIndexerCacheEvents(true);	339	RepositoryUpdater.getDefault().ignoreIndexerCacheEvents(true);
340	RepositoryUpdater.getDefault().start(true);	340	RepositoryUpdater.getDefault().start(true);
341	RepositoryUpdater.State state;	341	RepositoryUpdater.State state;




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2013 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle 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]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2013 Sun Microsystems, Inc.
 */
package org.netbeans.modules.parsing.spi.indexing.support;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.event.ChangeListener;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.parsing.impl.indexing.Pair;
import org.netbeans.modules.parsing.impl.indexing.RepositoryUpdater;
import org.netbeans.modules.parsing.impl.indexing.RepositoryUpdaterTest;
import org.netbeans.modules.parsing.impl.indexing.friendapi.IndexingController;
import org.netbeans.modules.parsing.lucene.support.LowMemoryWatcher;
import org.netbeans.modules.parsing.spi.indexing.PathRecognizer;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation2;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;

/**
 *
 * @author Tomas Zezula
 */
public class QuerySupportTest extends NbTestCase {

    private final Map<String, Set<ClassPath>> registeredClasspaths = new HashMap<String, Set<ClassPath>>();

    public QuerySupportTest(String name) {
        super(name);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        clearWorkDir();
        MockServices.setServices(
                JavaLikePathRecognizer.class,
                ScriptingLikePathRecognizer.class,
                ClassPathProviderImpl.class,
                SourceForBinaryQueryImpl.class);
        RepositoryUpdaterTest.waitForRepositoryUpdaterInit();
    }

    @Override
    protected void tearDown() throws Exception {        
        for(String id : registeredClasspaths.keySet()) {
            final Set<ClassPath> classpaths = registeredClasspaths.get(id);
            GlobalPathRegistry.getDefault().unregister(id, classpaths.toArray(new ClassPath[classpaths.size()]));
        }
        registeredClasspaths.clear();
        ClassPathProviderImpl.register(Collections.<FileObject,Map<String,ClassPath>>emptyMap());
        SourceForBinaryQueryImpl.register(Collections.<URL,Pair<Boolean,List<FileObject>>>emptyMap());
        LowMemoryWatcher.getInstance().free();
        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        super.tearDown();
    }



    public void testGetDependentRootsJavaLikeDependenciesAllProjectsOpened() throws IOException, InterruptedException {
        final FileObject wd = FileUtil.toFileObject(getWorkDir());
        final FileObject src1 = FileUtil.createFolder(wd,"src1");   //NOI18N
        final URL build1 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build1"));//NOI18N
        final FileObject src2 = FileUtil.createFolder(wd,"src2");   //NOI18N
        final URL build2 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build2"));    //NOI18N
        final FileObject src3 = FileUtil.createFolder(wd,"src3");   //NOI18N
        final URL build3 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build3"));    //NOI18N
        final FileObject src4 = FileUtil.createFolder(wd,"src4");   //NOI18N
        final URL build4 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build4"));   //NOI18N

        final ClassPath src1Source = ClassPathSupport.createClassPath(src1);
        final ClassPath src2Source = ClassPathSupport.createClassPath(src2);
        final ClassPath src2Compile = ClassPathSupport.createClassPath(build1);
        final ClassPath src3Source = ClassPathSupport.createClassPath(src3);
        final ClassPath src3Compile = ClassPathSupport.createClassPath(build1);
        final ClassPath src4Source = ClassPathSupport.createClassPath(src4);
        final ClassPath src4Compile = ClassPathSupport.createClassPath(build2);

        final Map<URL,Pair<Boolean,List<FileObject>>> sfbq = new HashMap<URL, Pair<Boolean,List<FileObject>>>();
        sfbq.put(build1,Pair.of(true,Collections.singletonList(src1)));
        sfbq.put(build2,Pair.of(true,Collections.singletonList(src2)));
        sfbq.put(build3,Pair.of(true,Collections.singletonList(src3)));
        sfbq.put(build4,Pair.of(true,Collections.singletonList(src4)));
        SourceForBinaryQueryImpl.register(sfbq);


        final ClassPath boot = ClassPath.EMPTY;
        final Map<String,ClassPath> src1cps = new HashMap<String, ClassPath>();
        src1cps.put(JavaLikePathRecognizer.BOOT, boot);
        src1cps.put(JavaLikePathRecognizer.COMPILE, ClassPath.EMPTY);
        src1cps.put(JavaLikePathRecognizer.SRC, src1Source);
        final Map<String,ClassPath> src2cps = new HashMap<String, ClassPath>();
        src2cps.put(JavaLikePathRecognizer.BOOT, boot);
        src2cps.put(JavaLikePathRecognizer.COMPILE, src2Compile);
        src2cps.put(JavaLikePathRecognizer.SRC, src2Source);
        final Map<String,ClassPath> src3cps = new HashMap<String, ClassPath>();
        src3cps.put(JavaLikePathRecognizer.BOOT, boot);
        src3cps.put(JavaLikePathRecognizer.COMPILE, src3Compile);
        src3cps.put(JavaLikePathRecognizer.SRC, src3Source);
        final Map<String,ClassPath> src4cps = new HashMap<String, ClassPath>();
        src4cps.put(JavaLikePathRecognizer.BOOT, boot);
        src4cps.put(JavaLikePathRecognizer.COMPILE, src4Compile);
        src4cps.put(JavaLikePathRecognizer.SRC, src4Source);
        final Map<FileObject,Map<String,ClassPath>> cps = new HashMap<FileObject, Map<String, ClassPath>>();
        cps.put(src1,src1cps);
        cps.put(src2,src2cps);
        cps.put(src3,src3cps);
        cps.put(src4,src4cps);
        ClassPathProviderImpl.register(cps);

        globalPathRegistry_register(
                JavaLikePathRecognizer.BOOT,
                new ClassPath[]{
                    boot
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.COMPILE,
                new ClassPath[]{
                    src2Compile,
                    src3Compile,
                    src4Compile
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.SRC,
                new ClassPath[]{
                    src1Source,
                    src2Source,
                    src3Source,
                    src4Source
                });

        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        assertEquals(
                IndexingController.getDefault().getRootDependencies().keySet().toString(),
                4,
                IndexingController.getDefault().getRootDependencies().size());

        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, true));
        assertEquals(new FileObject[] {src3}, QuerySupport.findDependentRoots(src3, true));
        assertEquals(new FileObject[] {src2, src4}, QuerySupport.findDependentRoots(src2, true));
        assertEquals(new FileObject[] {src1, src2, src3, src4}, QuerySupport.findDependentRoots(src1, true));


        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, false));
        assertEquals(new FileObject[] {src3}, QuerySupport.findDependentRoots(src3, false));
        assertEquals(new FileObject[] {src2, src4}, QuerySupport.findDependentRoots(src2, false));
        assertEquals(new FileObject[] {src1, src2, src3, src4}, QuerySupport.findDependentRoots(src1, false));
    }


    public void testGetDependentRootsJavaLikeDependenciesProjectsClosed() throws IOException, InterruptedException {
        final FileObject wd = FileUtil.toFileObject(getWorkDir());
        final FileObject src1 = FileUtil.createFolder(wd,"src1");   //NOI18N
        final URL build1 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build1"));//NOI18N
        final FileObject src2 = FileUtil.createFolder(wd,"src2");   //NOI18N
        final URL build2 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build2"));    //NOI18N
        final FileObject src3 = FileUtil.createFolder(wd,"src3");   //NOI18N
        final URL build3 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build3"));    //NOI18N
        final FileObject src4 = FileUtil.createFolder(wd,"src4");   //NOI18N
        final URL build4 = FileUtil.urlForArchiveOrDir(new File (getWorkDir(),"build4"));   //NOI18N

        final ClassPath src1Source = ClassPathSupport.createClassPath(src1);
        final ClassPath src2Source = ClassPathSupport.createClassPath(src2);
        final ClassPath src2Compile = ClassPathSupport.createClassPath(build1);
        final ClassPath src3Source = ClassPathSupport.createClassPath(src3);
        final ClassPath src3Compile = ClassPathSupport.createClassPath(build1);
        final ClassPath src4Source = ClassPathSupport.createClassPath(src4);
        final ClassPath src4Compile = ClassPathSupport.createClassPath(build2);

        final Map<URL,Pair<Boolean,List<FileObject>>> sfbq = new HashMap<URL, Pair<Boolean,List<FileObject>>>();
        sfbq.put(build1,Pair.of(true,Collections.singletonList(src1)));
        sfbq.put(build2,Pair.of(true,Collections.singletonList(src2)));
        sfbq.put(build3,Pair.of(true,Collections.singletonList(src3)));
        sfbq.put(build4,Pair.of(true,Collections.singletonList(src4)));
        SourceForBinaryQueryImpl.register(sfbq);


        final ClassPath boot = ClassPath.EMPTY;
        final Map<String,ClassPath> src1cps = new HashMap<String, ClassPath>();
        src1cps.put(JavaLikePathRecognizer.BOOT, boot);
        src1cps.put(JavaLikePathRecognizer.COMPILE, ClassPath.EMPTY);
        src1cps.put(JavaLikePathRecognizer.SRC, src1Source);
        final Map<String,ClassPath> src2cps = new HashMap<String, ClassPath>();
        src2cps.put(JavaLikePathRecognizer.BOOT, boot);
        src2cps.put(JavaLikePathRecognizer.COMPILE, src2Compile);
        src2cps.put(JavaLikePathRecognizer.SRC, src2Source);
        final Map<String,ClassPath> src3cps = new HashMap<String, ClassPath>();
        src3cps.put(JavaLikePathRecognizer.BOOT, boot);
        src3cps.put(JavaLikePathRecognizer.COMPILE, src3Compile);
        src3cps.put(JavaLikePathRecognizer.SRC, src3Source);
        final Map<String,ClassPath> src4cps = new HashMap<String, ClassPath>();
        src4cps.put(JavaLikePathRecognizer.BOOT, boot);
        src4cps.put(JavaLikePathRecognizer.COMPILE, src4Compile);
        src4cps.put(JavaLikePathRecognizer.SRC, src4Source);
        final Map<FileObject,Map<String,ClassPath>> cps = new HashMap<FileObject, Map<String, ClassPath>>();
        cps.put(src1,src1cps);
        cps.put(src2,src2cps);
        cps.put(src3,src3cps);
        cps.put(src4,src4cps);
        ClassPathProviderImpl.register(cps);

        globalPathRegistry_register(
                JavaLikePathRecognizer.BOOT,
                new ClassPath[]{
                    boot
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.COMPILE,
                new ClassPath[]{
                    src4Compile
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.SRC,
                new ClassPath[]{
                    src4Source
                });

        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        assertEquals(
                IndexingController.getDefault().getRootDependencies().keySet().toString(),
                3,
                IndexingController.getDefault().getRootDependencies().size());

        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, true));       
        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src2, true));
        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src1, true));


        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, false));
        assertEquals(new FileObject[] {src2, src4}, QuerySupport.findDependentRoots(src2, false));
        assertEquals(new FileObject[] {src1, src2, src4}, QuerySupport.findDependentRoots(src1, false));
    }


    public void testGetDependentRootsJavaLikeBinaryDependencies() throws IOException, InterruptedException {

        IndexingController.getDefault().getRootDependencies().keySet();

        final FileObject wd = FileUtil.toFileObject(getWorkDir());
        final FileObject bin1 = FileUtil.createFolder(wd, "bin1");  //NOI18N
        final FileObject bin1Sources = FileUtil.createFolder(wd, "bin1src");    //NOI18N
        final FileObject src1 = FileUtil.createFolder(wd,"src1");   //NOI18N
        final FileObject src2 = FileUtil.createFolder(wd,"src2");   //NOI18N
        final FileObject src3 = FileUtil.createFolder(wd,"src3");   //NOI18N

        final ClassPath src1Source = ClassPathSupport.createClassPath(src1);
        final ClassPath src1Compile = ClassPathSupport.createClassPath(bin1);
        final ClassPath src2Source = ClassPathSupport.createClassPath(src2);
        final ClassPath src2Compile = ClassPathSupport.createClassPath(bin1);
        final ClassPath src3Source = ClassPathSupport.createClassPath(src3);        

        final Map<URL,Pair<Boolean,List<FileObject>>> sfbq = new HashMap<URL, Pair<Boolean,List<FileObject>>>();
        sfbq.put(bin1.toURL(),Pair.of(false,Collections.singletonList(bin1Sources)));
        SourceForBinaryQueryImpl.register(sfbq);


        final ClassPath boot = ClassPath.EMPTY;
        final Map<String,ClassPath> src1cps = new HashMap<String, ClassPath>();
        src1cps.put(JavaLikePathRecognizer.BOOT, boot);
        src1cps.put(JavaLikePathRecognizer.COMPILE, src1Compile);
        src1cps.put(JavaLikePathRecognizer.SRC, src1Source);
        final Map<String,ClassPath> src2cps = new HashMap<String, ClassPath>();
        src2cps.put(JavaLikePathRecognizer.BOOT, boot);
        src2cps.put(JavaLikePathRecognizer.COMPILE, src2Compile);
        src2cps.put(JavaLikePathRecognizer.SRC, src2Source);
        final Map<String,ClassPath> src3cps = new HashMap<String, ClassPath>();
        src3cps.put(JavaLikePathRecognizer.BOOT, boot);
        src3cps.put(JavaLikePathRecognizer.COMPILE, ClassPath.EMPTY);
        src3cps.put(JavaLikePathRecognizer.SRC, src3Source);        
        final Map<FileObject,Map<String,ClassPath>> cps = new HashMap<FileObject, Map<String, ClassPath>>();
        cps.put(src1,src1cps);
        cps.put(src2,src2cps);
        cps.put(src3,src3cps);
        ClassPathProviderImpl.register(cps);

        globalPathRegistry_register(
                JavaLikePathRecognizer.BOOT,
                new ClassPath[]{
                    boot
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.COMPILE,
                new ClassPath[]{
                    src1Compile,
                    src2Compile                    
                });
        globalPathRegistry_register(
                JavaLikePathRecognizer.SRC,
                new ClassPath[]{
                    src1Source,
                    src2Source,
                    src3Source
                });

        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        assertEquals(
                IndexingController.getDefault().getRootDependencies().keySet().toString(),
                3,
                IndexingController.getDefault().getRootDependencies().size());

        assertEquals(new FileObject[] {src1, src2}, QuerySupport.findDependentRoots(bin1Sources, true));
    }

    public void testGetDependentRootsJavaLikeDependenciesWithPeerRoots() throws IOException, InterruptedException {
        final FileObject wd = FileUtil.toFileObject(getWorkDir());
        final FileObject src1a = FileUtil.createFolder(wd,"src1a");   //NOI18N
        final FileObject src1b = FileUtil.createFolder(wd,"src1b");   //NOI18N

        final ClassPath src1Source = ClassPathSupport.createClassPath(src1a, src1b);


        final ClassPath boot = ClassPath.EMPTY;
        final Map<String,ClassPath> src1cps = new HashMap<String, ClassPath>();
        src1cps.put(JavaLikePathRecognizer.BOOT, boot);
        src1cps.put(JavaLikePathRecognizer.COMPILE, ClassPath.EMPTY);
        src1cps.put(JavaLikePathRecognizer.SRC, src1Source);        
        final Map<FileObject,Map<String,ClassPath>> cps = new HashMap<FileObject, Map<String, ClassPath>>();
        cps.put(src1a,src1cps);
        cps.put(src1b,src1cps);
        ClassPathProviderImpl.register(cps);

        globalPathRegistry_register(
                JavaLikePathRecognizer.BOOT,
                new ClassPath[]{
                    boot
                });        
        globalPathRegistry_register(
                JavaLikePathRecognizer.SRC,
                new ClassPath[]{
                    src1Source
                });

        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        assertEquals(
                IndexingController.getDefault().getRootDependencies().keySet().toString(),
                2,
                IndexingController.getDefault().getRootDependencies().size());

        assertEquals(new FileObject[] {src1a, src1b}, QuerySupport.findDependentRoots(src1a, true));
        assertEquals(new FileObject[] {src1a, src1b}, QuerySupport.findDependentRoots(src1b, true));

        assertEquals(new FileObject[] {src1a, src1b}, QuerySupport.findDependentRoots(src1a, false));
        assertEquals(new FileObject[] {src1a, src1b}, QuerySupport.findDependentRoots(src1b, false));
    }

    public void testGetDependentRootsScriptingLikeDependenciesAllProjectsOpened() throws IOException, InterruptedException {
        final FileObject wd = FileUtil.toFileObject(getWorkDir());
        final FileObject libSrc = FileUtil.createFolder(wd,"libSrc");   //NOI18N
        final FileObject src1 = FileUtil.createFolder(wd,"src1");   //NOI18N
        final FileObject src2 = FileUtil.createFolder(wd,"src2");   //NOI18N
        final FileObject src3 = FileUtil.createFolder(wd,"src3");   //NOI18N
        final FileObject src4 = FileUtil.createFolder(wd,"src4");   //NOI18N

        final ClassPath src1Source = ClassPathSupport.createClassPath(src1);
        final ClassPath src1Compile = ClassPathSupport.createClassPath(libSrc);
        final ClassPath src2Source = ClassPathSupport.createClassPath(src2);
        final ClassPath src2Compile = ClassPathSupport.createClassPath(src1);
        final ClassPath src3Source = ClassPathSupport.createClassPath(src3);
        final ClassPath src3Compile = ClassPathSupport.createClassPath(src1);
        final ClassPath src4Source = ClassPathSupport.createClassPath(src4);
        final ClassPath src4Compile = ClassPathSupport.createClassPath(src2);


        final Map<String,ClassPath> src1cps = new HashMap<String, ClassPath>();
        src1cps.put(ScriptingLikePathRecognizer.COMPILE, src1Compile);
        src1cps.put(ScriptingLikePathRecognizer.SRC, src1Source);
        final Map<String,ClassPath> src2cps = new HashMap<String, ClassPath>();
        src2cps.put(ScriptingLikePathRecognizer.COMPILE, src2Compile);
        src2cps.put(ScriptingLikePathRecognizer.SRC, src2Source);
        final Map<String,ClassPath> src3cps = new HashMap<String, ClassPath>();
        src3cps.put(ScriptingLikePathRecognizer.COMPILE, src3Compile);
        src3cps.put(ScriptingLikePathRecognizer.SRC, src3Source);
        final Map<String,ClassPath> src4cps = new HashMap<String, ClassPath>();
        src4cps.put(ScriptingLikePathRecognizer.COMPILE, src4Compile);
        src4cps.put(ScriptingLikePathRecognizer.SRC, src4Source);
        final Map<FileObject,Map<String,ClassPath>> cps = new HashMap<FileObject, Map<String, ClassPath>>();
        cps.put(src1,src1cps);
        cps.put(src2,src2cps);
        cps.put(src3,src3cps);
        cps.put(src4,src4cps);
        ClassPathProviderImpl.register(cps);

        globalPathRegistry_register(
                ScriptingLikePathRecognizer.COMPILE,
                new ClassPath[]{
                    src2Compile,
                    src3Compile,
                    src4Compile
                });
        globalPathRegistry_register(
                ScriptingLikePathRecognizer.SRC,
                new ClassPath[]{
                    src1Source,
                    src2Source,
                    src3Source,
                    src4Source
                });

        RepositoryUpdater.getDefault().waitUntilFinished(RepositoryUpdaterTest.TIME);
        assertEquals(
                IndexingController.getDefault().getRootDependencies().keySet().toString(),
                5,
                IndexingController.getDefault().getRootDependencies().size());

        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, true));
        assertEquals(new FileObject[] {src3}, QuerySupport.findDependentRoots(src3, true));
        assertEquals(new FileObject[] {src2, src4}, QuerySupport.findDependentRoots(src2, true));
        assertEquals(new FileObject[] {src1, src2, src3, src4}, QuerySupport.findDependentRoots(src1, true));
        assertEquals(new FileObject[] {src1, src2, src3, src4}, QuerySupport.findDependentRoots(libSrc, true));

        assertEquals(new FileObject[] {src4}, QuerySupport.findDependentRoots(src4, false));
        assertEquals(new FileObject[] {src3}, QuerySupport.findDependentRoots(src3, false));
        assertEquals(new FileObject[] {src2, src4}, QuerySupport.findDependentRoots(src2, false));
        assertEquals(new FileObject[] {src1, src2, src3, src4}, QuerySupport.findDependentRoots(src1, false));
        assertEquals(new FileObject[] {libSrc, src1, src2, src3, src4}, QuerySupport.findDependentRoots(libSrc, false));
    }

    private void assertEquals(FileObject[] expected, Collection<FileObject> res) {
        final Set<FileObject> set = new HashSet<FileObject>();
        Collections.addAll(set, expected);
        for (FileObject fo : res) {
            assertTrue(
                String.format("expected: %s res: %s", Arrays.toString(expected), res),  //NOI18N
                set.remove(fo));
        }
        assertTrue(
            String.format("expected: %s res: %s", Arrays.toString(expected), res),      //NOI8N
            set.isEmpty());
    }

    private void globalPathRegistry_register(String id, ClassPath [] classpaths) {
        Set<ClassPath> set = registeredClasspaths.get(id);
        if (set == null) {
            set = Collections.newSetFromMap(new IdentityHashMap<ClassPath, Boolean>());
            registeredClasspaths.put(id, set);
        }
        for (ClassPath cp :  classpaths) {
            set.add(cp);
        }
        GlobalPathRegistry.getDefault().register(id, classpaths);
    }    

    public static final class JavaLikePathRecognizer extends PathRecognizer {

        public static final String SRC = "source";          //NOI18N
        public static final String COMPILE = "compile";     //NOI18N
        public static final String BOOT = "boot";           //NOI18N
        public static final String MIME_JAVA = "text/x-java";   //NOI18N

        @Override
        public Set<String> getSourcePathIds() {
            return Collections.singleton(SRC);
        }

        @Override
        public Set<String> getLibraryPathIds() {
            return Collections.<String>emptySet();
        }

        @Override
        public Set<String> getBinaryLibraryPathIds() {
            return new HashSet<String>(Arrays.asList(BOOT, COMPILE));
        }

        @Override
        public Set<String> getMimeTypes() {
            return Collections.singleton(MIME_JAVA);
        }

    }

    public static final class ScriptingLikePathRecognizer extends PathRecognizer {

        public static final String SRC = "scripts";          //NOI18N
        public static final String COMPILE = "included";     //NOI18N
        public static final String MIME_JAVA = "text/x-script";   //NOI18N

        @Override
        public Set<String> getSourcePathIds() {
            return Collections.singleton(SRC);
        }

        @Override
        public Set<String> getLibraryPathIds() {
            return Collections.singleton(COMPILE);
        }

        @Override
        public Set<String> getBinaryLibraryPathIds() {
            return Collections.<String>emptySet();
        }

        @Override
        public Set<String> getMimeTypes() {
            return Collections.singleton(MIME_JAVA);
        }

    }

    public static final class ClassPathProviderImpl implements ClassPathProvider {

        private static volatile Map<FileObject,Map<String,ClassPath>> cps = Collections.emptyMap();

        @Override
        public ClassPath findClassPath(FileObject file, String type) {
            for (Map.Entry<FileObject,Map<String,ClassPath>> e : cps.entrySet()) {
                if (e.getKey().equals(file) || FileUtil.isParentOf(e.getKey(), file)) {
                    return e.getValue().get(type);
                }
            }
            return null;
        }

        static void register(Map<FileObject,Map<String,ClassPath>> newClassPaths) {
            cps = newClassPaths;
        }

    }

    public static final class SourceForBinaryQueryImpl implements SourceForBinaryQueryImplementation2 {

        private static volatile Map<URL, Pair<Boolean,List<FileObject>>> mapping = Collections.emptyMap();

        @Override
        public Result findSourceRoots2(final URL binaryRoot) {
            final Pair<Boolean,List<FileObject>> sources = mapping.get(binaryRoot);
            if (sources == null) {
                return null;
            }
            return new Result() {
                @Override
                public boolean preferSources() {
                    return sources.first;
                }

                @Override
                public FileObject[] getRoots() {
                    return sources.second.toArray(new FileObject[sources.second.size()]);
                }

                @Override
                public void addChangeListener(ChangeListener l) {
                }

                @Override
                public void removeChangeListener(ChangeListener l) {
                }
            };
        }

        @Override
        public SourceForBinaryQuery.Result findSourceRoots(URL binaryRoot) {
            return findSourceRoots2(binaryRoot);
        }

        static void register(Map<URL,Pair<Boolean,List<FileObject>>> newMapping) {
            mapping = newMapping;
        }

    }    

}

Return to bug 227363

Lines 91-102 Link Here

(-)a/java.source/src/org/netbeans/api/java/source/SourceUtils.java (-98 / +27 lines)
91	import org.netbeans.api.editor.mimelookup.MimePath;	91	import org.netbeans.api.editor.mimelookup.MimePath;
92	import org.netbeans.api.java.classpath.ClassPath;	92	import org.netbeans.api.java.classpath.ClassPath;
93	import org.netbeans.api.java.lexer.JavaTokenId;	93	import org.netbeans.api.java.lexer.JavaTokenId;
94	import org.netbeans.api.java.classpath.GlobalPathRegistry;
95	import org.netbeans.api.java.queries.JavadocForBinaryQuery;	94	import org.netbeans.api.java.queries.JavadocForBinaryQuery;
96	import org.netbeans.api.java.queries.SourceForBinaryQuery;	95	import org.netbeans.api.java.queries.SourceForBinaryQuery;
97	import org.netbeans.api.java.source.ClasspathInfo.PathKind;	96	import org.netbeans.api.java.source.ClasspathInfo.PathKind;
98	import org.netbeans.api.java.source.JavaSource.Phase;	97	import org.netbeans.api.java.source.JavaSource.Phase;
99	import static org.netbeans.api.java.source.SourceUtils.getDependentRootsImpl;
100	import org.netbeans.api.java.source.matching.Matcher;	98	import org.netbeans.api.java.source.matching.Matcher;
101	import org.netbeans.api.java.source.matching.Occurrence;	99	import org.netbeans.api.java.source.matching.Occurrence;
102	import org.netbeans.api.java.source.matching.Pattern;	100	import org.netbeans.api.java.source.matching.Pattern;
Lines 120-126 Link Here
120	import org.netbeans.modules.parsing.api.ResultIterator;	118	import org.netbeans.modules.parsing.api.ResultIterator;
121	import org.netbeans.modules.parsing.api.UserTask;	119	import org.netbeans.modules.parsing.api.UserTask;
122	import org.netbeans.modules.parsing.api.indexing.IndexingManager;	120	import org.netbeans.modules.parsing.api.indexing.IndexingManager;
123	import org.netbeans.modules.parsing.impl.indexing.friendapi.IndexingController;	121	import org.netbeans.modules.parsing.spi.indexing.support.QuerySupport;
124	import org.netbeans.spi.java.classpath.support.ClassPathSupport;	122	import org.netbeans.spi.java.classpath.support.ClassPathSupport;
125		123
126	import org.openide.filesystems.FileObject;	124	import org.openide.filesystems.FileObject;
Lines 672-682 Link Here
672	* incoming root, never returns null.	670	* incoming root, never returns null.
673	* @since 0.10	671	* @since 0.10
674	*/	672	*/
675	@org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part") //NOI18N	673	@NonNull
676	public static Set<URL> getDependentRoots (final URL root) {	674	@org.netbeans.api.annotations.common.SuppressWarnings(value = {"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
677	final Map<URL, List<URL>> sourceDeps = IndexingController.getDefault().getRootDependencies();	675	public static Set<URL> getDependentRoots (@NonNull final URL root) {
678	final Map<URL, List<URL>> binaryDeps = IndexingController.getDefault().getBinaryRootDependencies();	676	return getDependentRoots(root, true);
679	return getDependentRootsImpl (root, sourceDeps, binaryDeps, true);
680	}	677	}
681		678
682	/**	679	/**
Lines 691-787 Link Here
691	* root, never returns null.	688	* root, never returns null.
692	* @since 0.110	689	* @since 0.110
693	*/	690	*/
694	@org.netbeans.api.annotations.common.SuppressWarnings(value = {"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part") //NOI18N	691	@NonNull
695	public static Set<URL> getDependentRoots(final URL root, boolean filterNonOpenedProjects) {	692	@org.netbeans.api.annotations.common.SuppressWarnings(value = {"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part")
696	final Map<URL, List<URL>> sourceDeps = IndexingController.getDefault().getRootDependencies();	693	public static Set<URL> getDependentRoots(
697	final Map<URL, List<URL>> binaryDeps = IndexingController.getDefault().getBinaryRootDependencies();	694	@NonNull final URL root,
698	return getDependentRootsImpl(root, sourceDeps, binaryDeps, filterNonOpenedProjects);	695	final boolean filterNonOpenedProjects) {
		696	final FileObject rootFO = URLMapper.findFileObject(root);
		697	if (rootFO != null) {
		698	return mapToURLs(QuerySupport.findDependentRoots(rootFO,filterNonOpenedProjects));
		699	} else {
		700	return Collections.<URL>singleton(root);
		701	}
699	}	702	}
700		703
701	@org.netbeans.api.annotations.common.SuppressWarnings(value={"DMI_COLLECTION_OF_URLS"}, justification="URLs have never host part") //NOI18N
702	static Set<URL> getDependentRootsImpl (final URL root, final Map<URL, List<URL>> sourceDeps, Map<URL, List<URL>> binaryDeps, boolean filterNonOpenedProjects) {
703	Set<URL> urls;
704
705	if (sourceDeps.containsKey(root)) {
706	urls = findReverseSourceRoots(root, sourceDeps);
707	} else {
708	FileObject rootFO = URLMapper.findFileObject(root);
709
710	if (rootFO != null) {
711	urls = new HashSet<URL>();
712
713	for (URL binary : findBinaryRootsForSourceRoot(rootFO, binaryDeps)) {
714	List<URL> deps = binaryDeps.get(binary);
715
716	if (deps != null) {
717	urls.addAll(deps);
718	}
719	}
720	} else {
721	urls = new HashSet<URL>();
722	}
723	}
724
725	if(filterNonOpenedProjects) {
726	Set<ClassPath> cps = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
727	Set<URL> toRetain = new HashSet<URL>();
728	for (ClassPath cp : cps) {
729	for (ClassPath.Entry e : cp.entries()) {
730	toRetain.add(e.getURL());
731	}
732	}
733	urls.retainAll(toRetain);
734	}
735	return urls;
736	}
737
738	private static Set<URL> findReverseSourceRoots(final URL thisSourceRoot, Map<URL, List<URL>> deps) {
739	//Create inverse dependencies
740	final Map<URL, List<URL>> inverseDeps = new HashMap<URL, List<URL>> ();
741	for (Map.Entry<URL,List<URL>> entry : deps.entrySet()) {
742	final URL u1 = entry.getKey();
743	final List<URL> l1 = entry.getValue();
744	for (URL u2 : l1) {
745	List<URL> l2 = inverseDeps.get(u2);
746	if (l2 == null) {
747	l2 = new ArrayList<URL>();
748	inverseDeps.put (u2,l2);
749	}
750	l2.add (u1);
751	}
752	}
753	//Collect dependencies
754	final Set<URL> result = new HashSet<URL>();
755	final LinkedList<URL> todo = new LinkedList<URL> ();
756	todo.add (thisSourceRoot);
757	while (!todo.isEmpty()) {
758	final URL u = todo.removeFirst();
759	if (!result.contains(u)) {
760	result.add (u);
761	final List<URL> ideps = inverseDeps.get(u);
762	if (ideps != null) {
763	todo.addAll (ideps);
764	}
765	}
766	}
767
768	return result;
769	}
770
771	private static Set<URL> findBinaryRootsForSourceRoot(FileObject sourceRoot, Map<URL, List<URL>> binaryDeps) {
772	Set<URL> result = new HashSet<URL>();
773
774	for (URL bin : binaryDeps.keySet()) {
775	for (FileObject s : SourceForBinaryQuery.findSourceRoots(bin).getRoots()) {
776	if (s == sourceRoot) {
777	result.add(bin);
778	}
779	}
780	}
781
782	return result;
783	}
784
785	//Helper methods	704	//Helper methods
786		705
787	/**	706	/**
Lines 1267-1270 Link Here
1267	return s.toLowerCase();	1186	return s.toLowerCase();
1268	}	1187	}
1269	}	1188	}
		1189
		1190	@NonNull
		1191	private static Set<URL> mapToURLs(
		1192	@NonNull final Collection<? extends FileObject> fos) {
		1193	final Set<URL> res = new HashSet<URL>(fos.size());
		1194	for (FileObject fo : fos) {
		1195	res.add(fo.toURL());
		1196	}
		1197	return res;
		1198	}
1270	}	1199	}

Lines 110-115 Link Here

(-)a/parsing.api/apichanges.xml (+16 lines)
110	<!-- ACTUAL CHANGES BEGIN HERE: -->	110	<!-- ACTUAL CHANGES BEGIN HERE: -->
111		111
112	<changes>	112	<changes>
		113	<change id="QuerySupport.findDependentRoots">
		114	<api name="ParsingAPI"/>
		115	<summary>Added <code>QuerySupport.findDependentRoots</code> to find out source roots depending on given source root.</summary>
		116	<version major="1" minor="64"/>
		117	<date day="18" month="3" year="2013"/>
		118	<author login="tzezula"/>
		119	<compatibility source="compatible" binary="compatible" semantic="compatible" deletion="no" addition="yes" modification="no"/>
		120	<description>
		121	<p>
		122	Added a <code>QuerySupport.findDependentRoots</code> method returning the dependent source roots for given source root.
		123	It returns all the source roots which have either direct or transitive dependency on the given source root.
		124	</p>
		125	</description>
		126	<class package="org.netbeans.modules.parsing.spi.indexing.support" name="QuerySupport"/>
		127	<issue number="227363"/>
		128	</change>
113	<change id="EmbeddingProvider.Registration">	129	<change id="EmbeddingProvider.Registration">
114	<api name="ParsingAPI"/>	130	<api name="ParsingAPI"/>
115	<summary>Added <code>EmbeddingProvider.Registration</code> annotation to register <code>EmbeddingProvider</code>s.</summary>	131	<summary>Added <code>EmbeddingProvider.Registration</code> annotation to register <code>EmbeddingProvider</code>s.</summary>