Attachment #187232 for bug #333903

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 22-24 Link Here

(-)src/org/eclipse/wst/jsdt/web/core/internal/JSPCorePluginResources.properties (+3 lines)
22	JSPDirectiveValidator_2=The prefix {0} is used more than once	22	JSPDirectiveValidator_2=The prefix {0} is used more than once
23	JSPDirectiveValidator_3=A {0} value is required in this directive	23	JSPDirectiveValidator_3=A {0} value is required in this directive
24	JSPBatchValidator_0=Gathering files in {0}	24	JSPBatchValidator_0=Gathering files in {0}
		25
		26	JSWebResourceEventManager=JavaScript Web Resource Event Manager
		27	JsCorePlugin_Initializing_JS_Web_Tools=Initializing JavaScript Web Tools




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.wst.jsdt.web.core.internal;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.ModuleCoreNature;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.jsdt.core.IIncludePathAttribute;
import org.eclipse.wst.jsdt.core.IIncludePathEntry;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.internal.core.ClasspathEntry;
import org.eclipse.wst.jsdt.internal.core.JavaProject;
import org.eclipse.wst.jsdt.web.core.internal.project.ModuleSourcePathProvider;
import org.eclipse.wst.sse.core.indexing.AbstractIndexManager;

/**
 * <p>This is an implementation of the {@link AbstractIndexManager} for the JavaScript Web core plugin.</p>
 * 
 * <p>Current Uses:
 * <ul>
 * <li>listen for .project changes so that JavaScript class paths can be updated
 * if the module core nature is added to a project</li>
 * </ul></p>
 * 
 * <p><b>NOTE:</b> If any other file resource change listening needs to take place in the future
 * in this plugin it should be done here.</p>
 */
public class JSWebResourceEventManager extends AbstractIndexManager {
	/** the singleton instance of the {@link JSWebResourceEventManager} */
	private static JSWebResourceEventManager INSTANCE;
	
	/** the name of the ".project" file where natures are stored */
	private static final String DOT_PROJECT_FILE_NAME = ".project"; //$NON-NLS-1$
	
	/** the location to store state */
	private IPath fWorkingLocation;
	
	/**
	 * <p>Private constructor for the resource event manager</p>
	 */
	private JSWebResourceEventManager() {
		super(JsCoreMessages.JSWebResourceEventManager);
	}
	
	/**
	 * @return the singleton instance of the {@link JSWebResourceEventManager}
	 */
	public static JSWebResourceEventManager getDefault() {
		return INSTANCE != null ? INSTANCE : (INSTANCE = new JSWebResourceEventManager());
	}

	/**
	 * @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#isResourceToIndex(int, org.eclipse.core.runtime.IPath)
	 */
	protected boolean isResourceToIndex(int type, IPath path) {
		String name = path.lastSegment();
		return 
			type == IResource.ROOT ||
			type == IResource.PROJECT || 
			(type == IResource.FILE && name.equals(DOT_PROJECT_FILE_NAME));
	}

	/**
	 * @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#performAction(byte, byte, org.eclipse.core.resources.IResource, org.eclipse.core.runtime.IPath)
	 */
	protected void performAction(byte source, byte action, IResource resource,
			IPath movePath) {
		
		switch(action) {
			case(AbstractIndexManager.ACTION_ADD): {
				if(resource.getName().equals(DOT_PROJECT_FILE_NAME)) {
					updateClassPathEntires(resource.getProject());
				}
				break;
			}
		}

	}

	/**
	 * @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#getWorkingLocation()
	 */
	protected IPath getWorkingLocation() {
		if(this.fWorkingLocation == null) {
			//create path to working area
    		IPath workingLocation =
    			JsCorePlugin.getDefault().getStateLocation().append("JSWebResourceEventManager"); //$NON-NLS-1$

            // ensure that it exists on disk
            File folder = new File(workingLocation.toOSString());
    		if (!folder.isDirectory()) {
    			try {
    				folder.mkdir();
    			}
    			catch (SecurityException e) {
    				Logger.logException(this.getName() +
    						": Error while creating state location: " + folder + //$NON-NLS-1$
    						" This renders the index manager irrevocably broken for this workspace session", //$NON-NLS-1$
    						e);
    			}
    		}
    		
    		this.fWorkingLocation = workingLocation;
    	}
    	
        return this.fWorkingLocation;
	}
	
	/**
	 * <p>Updates the JavaScript class path entries for the given project if
	 * both the Module core and JavaScript natures are installed on that project.</p>
	 *
	 * @param project {@link IProject} to update the JavaScript class path entires for
	 */
	private static void updateClassPathEntires(IProject project) {
		try {
			//if a JS project with Module core check if class path needs to be updated
			if (project.hasNature(JavaScriptCore.NATURE_ID) &&
					ModuleCoreNature.isFlexibleProject(project)) {
				
				JavaProject jsProject = (JavaProject) JavaScriptCore.create(project);
				
				IIncludePathEntry[] oldEntries = jsProject.getRawIncludepath();
				List updatedEntries = new ArrayList();
				boolean foundDefault = false;
				
				List preExistingExclusionPatterns = new ArrayList();
				List preExistingInclusionPatterns = new ArrayList();
				for(int oldEntry = 0; oldEntry < oldEntries.length; ++oldEntry) {
					IIncludePathAttribute[] attrs = oldEntries[oldEntry].getExtraAttributes();
					
					for(int atter = 0; atter < attrs.length; ++atter) {
						if(attrs[atter].getName().equals(ModuleSourcePathProvider.PROVIDER_ATTRIBUTE_KEY_NAME) && 
								attrs[atter].getValue().equals(ModuleSourcePathProvider.PROVIDER_ATTRIBUTE_KEY_VALUE)) {
							foundDefault = true;
							
							//create exclusion paths that are not relative to the parent entry
							IPath[] exclusionPaths = oldEntries[oldEntry].getExclusionPatterns();
							for(int i = 0; i < exclusionPaths.length; ++i) {
								preExistingExclusionPatterns.add(
										oldEntries[oldEntry].getPath().append(exclusionPaths[i]));
							}
							
							//create inclusion paths that are not relative to the parent entry
							IPath[]inclusionPaths = oldEntries[oldEntry].getInclusionPatterns();
							for(int i = 0; i < inclusionPaths.length; ++i) {
								preExistingInclusionPatterns.add(
										oldEntries[oldEntry].getPath().append(inclusionPaths[i]));
							}
						} else {
							updatedEntries.add(oldEntries[oldEntry]);
						}
					}
					
				}
				
				//if found that a default path was added, replace with module core determined path
				if(foundDefault) {
					IResource[] roots = getRoots(project);
					for(int root = 0; root < roots.length; ++root) {
						IPath rootPath = roots[root].getFullPath();

						//find matching pre-existing exclusion patterns
						List exclusionPatterns = new ArrayList();
						for(int i = 0; i < preExistingExclusionPatterns.size(); ++i) {
							IPath parentRelativeExclusionPattern = PathUtils.makePatternRelativeToParent(
									(IPath)preExistingExclusionPatterns.get(i), rootPath);
							
							if(parentRelativeExclusionPattern != null) {
								exclusionPatterns.add(parentRelativeExclusionPattern);
							}
						}
						
						//find matching pre-existing inclusion patterns
						List inclusionPatterns = new ArrayList();
						for(int i = 0; i < preExistingInclusionPatterns.size(); ++i) {
							IPath parentRelativeInclusionPattern = PathUtils.makePatternRelativeToParent(
									(IPath)preExistingInclusionPatterns.get(i), rootPath);
							
							if(parentRelativeInclusionPattern != null) {
								inclusionPatterns.add(parentRelativeInclusionPattern);
							}
						}
						
						//create new entry entry
						IPath[] exclusionPaths = ClasspathEntry.EXCLUDE_NONE;
						if(exclusionPatterns.size() > 0) {
							exclusionPaths = (IPath[])exclusionPatterns.toArray(
									new IPath[exclusionPatterns.size()]);
						}
						IPath[] inclusionPaths = ClasspathEntry.INCLUDE_ALL;
						if(inclusionPatterns.size() > 0) {
							inclusionPaths = (IPath[])inclusionPatterns.toArray(
									new IPath[inclusionPatterns.size()]);
						}
						IIncludePathEntry newEntry = JavaScriptCore.newSourceEntry(
								rootPath,
								inclusionPaths,
								exclusionPaths,
								null);
						updatedEntries.add(newEntry);
					}
					
					//set include path
					jsProject.setRawIncludepath(
							(IIncludePathEntry[])updatedEntries.toArray(
									new IIncludePathEntry[updatedEntries.size()]),
							project.getLocation(), null);
				}
			}
		} catch(CoreException e) {
			Logger.logException("Error while updating JavaScript classpath.", e); //$NON-NLS-1$
		}
	}
	
	/**
	 * <p>Uses module core to get the roots of the given project.</p>
	 *
	 * @param project find the module core roots for this {@link IProject}
	 * @return the module core roots for the given {@link IProject
	 */
	private static IResource[] getRoots(IProject project) {
		IVirtualFile root = ComponentCore.createFile(project, Path.ROOT);
		IResource[] underlyingResources = root.getUnderlyingResources();
		if (underlyingResources == null || underlyingResources.length == 0) {
			underlyingResources = new IResource[]{root.getUnderlyingResource()};
		}
		
		return underlyingResources;
	}
}

Lines 33-38 Link Here

(-)src/org/eclipse/wst/jsdt/web/core/internal/JsCoreMessages.java (+4 lines)
33	public static String JSPFContentPropertiesManager_Updating;	33	public static String JSPFContentPropertiesManager_Updating;
34	public static String JSPIndexManager_0;	34	public static String JSPIndexManager_0;
35	public static String JSPIndexManager_2;	35	public static String JSPIndexManager_2;
		36
		37	public static String JSWebResourceEventManager;
		38	public static String JsCorePlugin_Initializing_JS_Web_Tools;
		39
36	/**	40	/**
37	* @deprecated	41	* @deprecated
38	*/	42	*/

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/web/core/internal/JsCorePlugin.java (-5 / +142 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 IBM Corporation and others.	2	* Copyright (c) 2004, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-16 Link Here
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.web.core.internal;	11	package org.eclipse.wst.jsdt.web.core.internal;
12		12
		13	import org.eclipse.core.resources.IResourceChangeEvent;
		14	import org.eclipse.core.resources.IResourceChangeListener;
		15	import org.eclipse.core.resources.ISaveContext;
		16	import org.eclipse.core.resources.ISaveParticipant;
		17	import org.eclipse.core.resources.ISavedState;
		18	import org.eclipse.core.resources.IWorkspace;
		19	import org.eclipse.core.resources.IWorkspaceRunnable;
		20	import org.eclipse.core.resources.ResourcesPlugin;
		21	import org.eclipse.core.runtime.CoreException;
		22	import org.eclipse.core.runtime.IProgressMonitor;
		23	import org.eclipse.core.runtime.IStatus;
13	import org.eclipse.core.runtime.Plugin;	24	import org.eclipse.core.runtime.Plugin;
		25	import org.eclipse.core.runtime.Status;
		26	import org.eclipse.core.runtime.jobs.Job;
14	import org.eclipse.wst.jsdt.web.core.javascript.search.JsIndexManager;	27	import org.eclipse.wst.jsdt.web.core.javascript.search.JsIndexManager;
15	import org.osgi.framework.BundleContext;	28	import org.osgi.framework.BundleContext;
16		29
Lines 27-38 Link Here
27	public static final String PLUGIN_ID = "org.eclipse.wst.jsdt.web.core"; //$NON-NLS-1$	40	public static final String PLUGIN_ID = "org.eclipse.wst.jsdt.web.core"; //$NON-NLS-1$
28		41
29	/**	42	/**
		43	* <p>Job used to finish tasks needed to start up the plugin but that did not have
		44	* to block the plugin start up process.</p>
		45	*/
		46	private Job fPluginInitializerJob;
		47
		48	/**
30	* Returns the shared instance.	49	* Returns the shared instance.
31	*
32	* @deprecated - will be removed. Currently used to get "model preferences",
33	* but there are other, better ways.
34	*/	50	*/
35
36	public static JsCorePlugin getDefault() {	51	public static JsCorePlugin getDefault() {
37	return JsCorePlugin.plugin;	52	return JsCorePlugin.plugin;
38	}	53	}
Lines 43-48 Link Here
43	public JsCorePlugin() {	58	public JsCorePlugin() {
44	super();	59	super();
45	JsCorePlugin.plugin = this;	60	JsCorePlugin.plugin = this;
		61	this.fPluginInitializerJob = new PluginInitializerJob();
46	}	62	}
47		63
48	/*	64	/*
Lines 58-63 Link Here
58	// listen for classpath changes	74	// listen for classpath changes
59	JsIndexManager.getInstance().initialize();	75	JsIndexManager.getInstance().initialize();
60	// listen for resource changes to update content properties keys	76	// listen for resource changes to update content properties keys
		77
		78	//schedule delayed initialization
		79	this.fPluginInitializerJob.schedule(2000);
		80
61	}	81	}
62		82
63	/*	83	/*
Lines 71-76 Link Here
71	// keys	91	// keys
72	// stop any indexing	92	// stop any indexing
73	JsIndexManager.getInstance().shutdown();	93	JsIndexManager.getInstance().shutdown();
		94
		95	//Stop the resource event manager
		96	JSWebResourceEventManager.getDefault().stop();
		97
74	super.stop(context);	98	super.stop(context);
75	}	99	}
		100
		101	/**
		102	* <p>A {@link Job} used to perform delayed initialization for the plugin</p>
		103	*/
		104	private static class PluginInitializerJob extends Job {
		105	/**
		106	* <p>Default constructor to set up this {@link Job} as a
		107	* long running system {@link Job}</p>
		108	*/
		109	protected PluginInitializerJob() {
		110	super(JsCoreMessages.JsCorePlugin_Initializing_JS_Web_Tools);
		111
		112	this.setUser(false);
		113	this.setSystem(true);
		114	this.setPriority(Job.LONG);
		115	}
		116
		117	/**
		118	* <p>Perform delayed initialization for the plugin</p>
		119	*
		120	* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		121	*/
		122	protected IStatus run(IProgressMonitor monitor) {
		123	IStatus status = Status.OK_STATUS;
		124	final IWorkspace workspace = ResourcesPlugin.getWorkspace();
		125	try {
		126	/*
		127	* Restore save state and process any events that happened before
		128	* plug-in loaded. Don't do it immediately since adding the save
		129	* participant requires a lock on the workspace to compute the
		130	* accumulated deltas, and if the tree is not already locked it
		131	* becomes a blocking call.
		132	*/
		133	workspace.run(new IWorkspaceRunnable() {
		134	public void run(final IProgressMonitor worspaceMonitor) throws CoreException {
		135	ISavedState savedState = null;
		136
		137	try {
		138	//add the save participant for this bundle
		139	savedState = ResourcesPlugin.getWorkspace().addSaveParticipant(
		140	JsCorePlugin.plugin.getBundle().getSymbolicName(), new SaveParticipant());
		141	} catch (CoreException e) {
		142	Logger.logException("JSP Core Plugin failed at loading previously saved state." + //$NON-NLS-1$
		143	" All componenets dependent on this state will start as if first workspace load.", e); //$NON-NLS-1$
		144	}
		145
		146	//if there is a saved state start up using that, else start up cold
		147	if(savedState != null) {
		148	try {
		149	Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
		150	} finally {
		151	savedState.processResourceChangeEvents(new IResourceChangeListener() {
		152	/**
		153	* @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
		154	*/
		155	public void resourceChanged(IResourceChangeEvent event) {
		156	JSWebResourceEventManager.getDefault().start(event.getDelta(), worspaceMonitor);
		157	}
		158	});
		159	}
		160	} else {
		161	JSWebResourceEventManager.getDefault().start(null, worspaceMonitor);
		162	}
		163	}
164	}, monitor);
165	} catch(CoreException e) {
166	status = e.getStatus();
167	}
168
169	return status;
170	}
171
172	}
173
174	/**
175	* Used so that all of the IResourceChangeEvents that occurred before
176	* this plugin loaded can be processed.
177	*/
178	private static class SaveParticipant implements ISaveParticipant {
179	/**
180	* <p>Default constructor</p>
181	*/
182	protected SaveParticipant() {
183	}
184
185	/**
186	* @see org.eclipse.core.resources.ISaveParticipant#doneSaving(org.eclipse.core.resources.ISaveContext)
187	*/
188	public void doneSaving(ISaveContext context) {
189	//ignore
190	}
191
192	/**
193	* @see org.eclipse.core.resources.ISaveParticipant#prepareToSave(org.eclipse.core.resources.ISaveContext)
194	*/
195	public void prepareToSave(ISaveContext context) throws CoreException {
196	//ignore
197	}
198
199	/**
200	* @see org.eclipse.core.resources.ISaveParticipant#rollback(org.eclipse.core.resources.ISaveContext)
201	*/
202	public void rollback(ISaveContext context) {
203	//ignore
204	}
205
206	/**
207	* @see org.eclipse.core.resources.ISaveParticipant#saving(org.eclipse.core.resources.ISaveContext)
208	*/
209	public void saving(ISaveContext context) throws CoreException {
210	context.needDelta();
211	}
212	}
76	}	213	}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.wst.jsdt.web.core.internal;

import java.io.File;

import org.eclipse.core.runtime.IPath;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;

/**
 * <p>Utility class dealing with {@link IPath}s.</p>
 */
public class PathUtils {
	/** represents the * pattern in a path pattern */
	private static final String STAR = "*"; //$NON-NLS-1$
	
	/** represents the ** pattern in a path pattern */
	private static final String STAR_STAR = "**"; //$NON-NLS-1$
	
	/**
	 * <p>Counts the number of segments in a given pattern that match segments in a given parent path.
	 * This counting takes place from the beginning of both the pattern and parent and stops when
	 * they no longer match.  The pattern can contain **, * and ? wild cards.</p>
	 *
	 * @param pattern count the number of segments of this pattern that match the given <code>parent</code>
	 * @param parent count the number of segments in the given <code>pattern</code> that match this path
	 * @return the number of segments from the beginning of the given <code>pattern</code> {@link IPath}
	 * that match the beginning segments of the given <code>parent</code> {@link IPath}
	 */
	public static int countPatternSegmentsThatMatchParent(IPath pattern, IPath parent) {
		int matchingSegments = 0;
		
		//ignore a pattern that is just ** or *
		if(!(pattern.segmentCount() == 1 &&
				(pattern.segment(0).equals(STAR_STAR) || pattern.segment(0).equals(STAR)))) {
			
			int patternSegmentIndex = 0;
			int parentSegmentIndex = 0;
			boolean starStarMode = false;
			while(patternSegmentIndex < pattern.segmentCount() &&
					parentSegmentIndex < parent.segmentCount()) {
				
				String patternSegment = pattern.segment(patternSegmentIndex);
				String parentSegment = parent.segment(parentSegmentIndex);
				
				/* if matching on wild
				 * else if wild match on multiple path segments
				 * else if wild match on one path segment or path segments are equal
				 * else not equal so stop comparing
				 */
				if(starStarMode) {
					/* if parent segment equals first pattern segment after a ** stop matching on it
					 * else still matching on **
					 */
					if(pathSegmentMatchesPattern(patternSegment, parentSegment)) {
						starStarMode = false;
						matchingSegments++;
						patternSegmentIndex++;
						parentSegmentIndex++;
					} else {
						parentSegmentIndex++;
					}
				
				} else if(patternSegment.equals(STAR_STAR)) { //$NON-NLS-1$
					starStarMode = true;
					
					//find the first pattern segment after the ** that is not another ** or *
					matchingSegments++;
					parentSegmentIndex++;
					
					for(int i = patternSegmentIndex+1; i < pattern.segmentCount(); ++i) {
						
						if(!(pattern.segment(i).equals(STAR_STAR) || //$NON-NLS-1$
								pattern.segment(i).equals(STAR))) { //$NON-NLS-1$
							
							patternSegmentIndex = i;
							break;
						}
					}
				} else if(patternSegment.equals("*") || //$NON-NLS-1$
						pathSegmentMatchesPattern(patternSegment, parentSegment)){
					
					matchingSegments++;
					patternSegmentIndex++;
					parentSegmentIndex++;
				} else {
					break;
				}
			}
		}
		
		return matchingSegments;
	}
	
	/**
	 * <p>Given a pattern path and a parent path attempts to truncate the given pattern path such
	 * that it is relative to the given parent path.</p>
	 *
	 * @param pattern attempt to truncate this {@link IPath} such that it is relative to the given
	 * <code>parent</code> {@link IPath}
	 * @param parent attempt to truncate the given <code>pattern</code> {@link IPath} such that it
	 * is relative to this {@link IPath}
	 * @return either a truncated version of the given <code>pattern</code> {@link IPath} that is
	 * relative to the given <code>parent</code> {@link IPath}, or <code>null</code> if the given
	 * <code>pattern</code> {@link IPath} could not be truncated to be relative to the given
	 * <code>parent</code> {@link IPath}
	 */
	public static IPath makePatternRelativeToParent(IPath pattern, IPath parent) {
		int matchedSegments = countPatternSegmentsThatMatchParent(pattern, parent);
		
		IPath relativePattern = null;
		if(matchedSegments != 0) {
			relativePattern = pattern.removeFirstSegments(matchedSegments);
			
			if(relativePattern.segmentCount() == 0) {
				relativePattern = null;
			} else {
				relativePattern.makeRelative();
			}
		}
		
		return relativePattern;
	}
	
	/**
	 * <p>A convenience method for checking the matching of one segment from a pattern path with
	 * one segment from a path.</p>
	 *Bug 334922 - CharOperation#match does not work as expected when isCaseSensitive is passed as false
	 * @param patternSegment check if this pattern segment is a match with the given path segment.
	 * @param segment check if this path segment matches with the given pattern segment
	 * @return <code>true</code> if the segments match, <code>false</code> otherwise
	 */
	private static boolean pathSegmentMatchesPattern(String patternSegment, String segment) {
		return CharOperation.pathMatch(patternSegment.toCharArray(), segment.toCharArray(),
				false, File.separatorChar);
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/web/core/internal/project/ModuleSourcePathProvider.java (-3 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.	2	* Copyright (c) 2010, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 21-33 Link Here
21	import org.eclipse.wst.jsdt.core.IIncludePathAttribute;	21	import org.eclipse.wst.jsdt.core.IIncludePathAttribute;
22	import org.eclipse.wst.jsdt.core.IIncludePathEntry;	22	import org.eclipse.wst.jsdt.core.IIncludePathEntry;
23	import org.eclipse.wst.jsdt.core.JavaScriptCore;	23	import org.eclipse.wst.jsdt.core.JavaScriptCore;
		24	import org.eclipse.wst.jsdt.internal.core.ClasspathEntry;
24	import org.eclipse.wst.jsdt.internal.core.util.DefaultSourcePathProvider;	25	import org.eclipse.wst.jsdt.internal.core.util.DefaultSourcePathProvider;
25		26
26	public class ModuleSourcePathProvider extends DefaultSourcePathProvider {	27	public class ModuleSourcePathProvider extends DefaultSourcePathProvider {
27		28
		29	public static final String PROVIDER_ATTRIBUTE_KEY_NAME = "provider"; //$NON-NLS-1$
		30	public static final String PROVIDER_ATTRIBUTE_KEY_VALUE = ModuleSourcePathProvider.class.getName(); //$NON-NLS-1$
		31
28	static final IPath VIRTUAL_CONTAINER_PATH = new Path("org.eclipse.wst.jsdt.launching.WebProject"); //$NON-NLS-1$	32	static final IPath VIRTUAL_CONTAINER_PATH = new Path("org.eclipse.wst.jsdt.launching.WebProject"); //$NON-NLS-1$
29	static final IIncludePathEntry VIRTUAL_SCOPE_ENTRY = JavaScriptCore.newContainerEntry(VIRTUAL_CONTAINER_PATH, new IAccessRule[0], new IIncludePathAttribute[]{IIncludePathAttribute.HIDE}, false);	33	static final IIncludePathEntry VIRTUAL_SCOPE_ENTRY = JavaScriptCore.newContainerEntry(VIRTUAL_CONTAINER_PATH, new IAccessRule[0], new IIncludePathAttribute[]{IIncludePathAttribute.HIDE}, false);
30		34
31	public ModuleSourcePathProvider() {	35	public ModuleSourcePathProvider() {
32	}	36	}
33		37
Lines 53-58 Link Here
53	}	57	}
54	}	58	}
55	}	59	}
56	return super.getDefaultSourcePaths(p);	60
		61	return new IIncludePathEntry[]{JavaScriptCore.newSourceEntry(p.getFullPath(),
		62	ClasspathEntry.INCLUDE_ALL,ClasspathEntry.EXCLUDE_NONE,null,
		63	new IIncludePathAttribute[]{JavaScriptCore.newIncludepathAttribute(PROVIDER_ATTRIBUTE_KEY_NAME, PROVIDER_ATTRIBUTE_KEY_VALUE)})};
57	}	64	}
58	}	65	}




/*******************************************************************************
 * Copyright (c) 2009, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.wst.jsdt.web.core.tests;

import junit.framework.Test;


		//$JUnit-END$
		suite.addTestSuite(TestHtmlTranslation.class);
		suite.addTestSuite(PathUtilsTests.class);
		return suite;
	}





/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.wst.jsdt.web.core.tests;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.jsdt.web.core.internal.PathUtils;

import junit.framework.Assert;
import junit.framework.TestCase;

/**
 * <p>Unit tests for the {@link PathUtils} class.</p>
 *
 */
public class PathUtilsTests extends TestCase {

	/**
	 * <p>Default constructor</p>
	 */
	public PathUtilsTests() {
		super("Path Utils Tests");
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("foo", "foo", 1);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_SegmentCountTest_1() {
		runCountPatternSegmentsThatMatchParentTest("/foo", "foo", 1);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_SegmentCountTest_2() {
		runCountPatternSegmentsThatMatchParentTest("/foo", "foo", 1);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_SegmentCountTest_3() {
		runCountPatternSegmentsThatMatchParentTest("foo", "/foo", 1);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_SegmentCountTest_4() {
		runCountPatternSegmentsThatMatchParentTest("/foo", "/foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("foo/bar", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_1() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_2() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_3() {
		runCountPatternSegmentsThatMatchParentTest("foo/bar", "/foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_4() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar", "/foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_5() {
		runCountPatternSegmentsThatMatchParentTest("foo/bar/", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_6() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar/", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_7() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar/", "foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_8() {
		runCountPatternSegmentsThatMatchParentTest("foo/bar/", "/foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_9() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar/", "/foo", 1);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_SegmentCountTest_10() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar/", "/boo", 0);
	}
	
	public void testTwoSegmentParentWithThreeSegmentPattern_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("/foo/bar/blarg", "/foo/bar", 2);
	}
	
	public void testStar_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("/foo/*/blarg", "foo/bar", 2);
	}
	
	public void testStar_SegmentCountTest_1() {
		runCountPatternSegmentsThatMatchParentTest("/foo/*", "foo", 1);
	}
	
	public void testStar_SegmentCountTest_2() {
		runCountPatternSegmentsThatMatchParentTest("/foo/*", "foo/blarg", 2);
	}
	
	public void testStar_SegmentCountTest_3() {
		runCountPatternSegmentsThatMatchParentTest("/foo/*", "foo", 1);
	}
	
	public void testStarStar_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**", "foo", 1);
	}
	
	public void testStarStar_SegmentCountTest_1() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**", "foo/bar", 2);
	}
	
	public void testStarStar_SegmentCountTest_2() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**", "foo/bar/blarg", 3);
	}
	
	public void testStarStar_SegmentCountTest_3() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**/blarg", "foo/bar/blarg", 3);
	}
	
	public void testStarStar_SegmentCountTest_4() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**/blarg", "foo/bar/boo/blarg", 3);
	}
	
	public void testStarStar_SegmentCountTest_5() {
		runCountPatternSegmentsThatMatchParentTest("/foo/**/blarg/nerg", "foo/bar/boo/blarg", 3);
	}
	
	public void testQuestionMark_SegmentCountTest_0() {
		runCountPatternSegmentsThatMatchParentTest("foo?bar", "/fooZbar", 1);
	}
	
	public void testQuestionMark_SegmentCountTest_1() {
		runCountPatternSegmentsThatMatchParentTest("foo?bar", "/foobar", 0);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("foo", "foo", null);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_TransformPatternTest_1() {
		runMakePatternRelativeToParentTest("/foo", "foo", null);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_TransformPatternTest_2() {
		runMakePatternRelativeToParentTest("/foo", "foo", null);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_TransformPatternTest_3() {
		runMakePatternRelativeToParentTest("foo", "foo", null);
	}
	
	public void testOneSegmentParentWithOneSegmentPattern_TransformPatternTest_4() {
		runMakePatternRelativeToParentTest("/foo", "foo", null);
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("foo/bar", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_1() {
		runMakePatternRelativeToParentTest("/foo/bar", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_2() {
		runMakePatternRelativeToParentTest("/foo/bar", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_3() {
		runMakePatternRelativeToParentTest("foo/bar", "/foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_4() {
		runMakePatternRelativeToParentTest("/foo/bar", "/foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_5() {
		runMakePatternRelativeToParentTest("foo/bar/", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_6() {
		runMakePatternRelativeToParentTest("/foo/bar/", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_7() {
		runMakePatternRelativeToParentTest("/foo/bar/", "foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_8() {
		runMakePatternRelativeToParentTest("foo/bar/", "/foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_9() {
		runMakePatternRelativeToParentTest("/foo/bar/", "/foo", "bar/");
	}
	
	public void testOneSegmentParentWithTwoSegmentPattern_TransformPatternTest_10() {
		runMakePatternRelativeToParentTest("/foo/bar/", "/boo", null);
	}
	
	public void testTwoSegmentParentWithThreeSegmentPattern_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("/foo/bar/blarg", "/foo/bar", "blarg/");
	}
	
	public void testStar_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("/foo/*/blarg", "foo/bar", "blarg/");
	}
	
	public void testStar_TransformPatternTest_1() {
		runMakePatternRelativeToParentTest("/foo/*", "foo", "*/");
	}
	
	public void testStar_TransformPatternTest_2() {
		runMakePatternRelativeToParentTest("/foo/*", "foo/blarg/", null);
	}
	
	public void testStar_TransformPatternTest_3() {
		runMakePatternRelativeToParentTest("/foo/*", "foo", "*/");
	}
	
	public void testStarStar_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("/foo/**", "foo", "**/");
	}
	
	public void testStarStar_TransformPatternTest_1() {
		runMakePatternRelativeToParentTest("/foo/**", "foo/bar/", null);
	}
	
	public void testStarStar_TransformPatternTest_2() {
		runMakePatternRelativeToParentTest("/foo/**", "foo/bar/blarg/", null);
	}
	
	public void testStarStar_TransformPatternTest_3() {
		runMakePatternRelativeToParentTest("/foo/**/blarg", "foo/bar/blarg/", null);
	}
	
	public void testStarStar_TransformPatternTest_4() {
		runMakePatternRelativeToParentTest("/foo/**/blarg", "foo/bar/boo/blarg/", null);
	}
	
	public void testStarStar_TransformPatternTest_5() {
		runMakePatternRelativeToParentTest("/foo/**/blarg/nerg", "foo/bar/boo/blarg", "nerg/");
	}
	
	public void testQuestionMark_TransformPatternTest_0() {
		runMakePatternRelativeToParentTest("foo?bar", "/fooZbar", null);
	}
	
	public void testQuestionMark_TransformPatternTest_1() {
		runMakePatternRelativeToParentTest("foo?bar", "/foobar", null);
	}
	
	public void testQuestionMark_TransformPatternTest_2() {
		runMakePatternRelativeToParentTest("foo?bar/awesome", "/fooZbar", "awesome/");
	}
	
	public void testQuestionMark_TransformPatternTest_3() {
		runMakePatternRelativeToParentTest("foo?bar/awesome", "/foobar", null);
	}
	
	/**
	 * <p>Runs a test on {@link PathUtils#countPatternSegmentsThatMatchParent(IPath, IPath)}</p>
	 *
	 * @param pattern the pattern path to test
	 * @param parentPath the parent path to test
	 * @param expectedMatchedSegments the expected number of segments in the pattern that match the parent
	 */
	private static void runCountPatternSegmentsThatMatchParentTest(String pattern, String parentPath,
			int expectedMatchedSegments) {
		int matchedSegments = PathUtils.countPatternSegmentsThatMatchParent(
				new Path(pattern), new Path(parentPath));
		
		Assert.assertEquals("Number of matched path segments does not equal expected.", //$NON-NLS-1$
				expectedMatchedSegments, matchedSegments);
	}
	
	/**
	 * 
	 * <p>Runs a test on {@link PathUtils#makePatternRelativeToParent(IPath, IPath)}</p>
	 *
	 * @param pattern the pattern path to test
	 * @param parent the parent path to test
	 * @param expected the expected pattern path made relative to the parent path
	 */
	private static void runMakePatternRelativeToParentTest(String pattern, String parent, String expected) {
		IPath transformedPattern = PathUtils.makePatternRelativeToParent(
				new Path(pattern), new Path(parent));
		
		IPath expectedPath = null;
		if(expected != null) {
			expectedPath = new Path(expected);
		}
		
		Assert.assertEquals("Transformed pattern does not match expected.",
				expectedPath, transformedPattern);
	}
}

Return to bug 333903

Added Link Here

(-)src/org/eclipse/wst/jsdt/web/core/internal/JSWebResourceEventManager.java (+249 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*
11	*******************************************************************************/
12	package org.eclipse.wst.jsdt.web.core.internal;
13
14	import java.io.File;
15	import java.util.ArrayList;
16	import java.util.List;
17
18	import org.eclipse.core.resources.IProject;
19	import org.eclipse.core.resources.IResource;
20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.Path;
23	import org.eclipse.wst.common.componentcore.ComponentCore;
24	import org.eclipse.wst.common.componentcore.ModuleCoreNature;
25	import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
26	import org.eclipse.wst.jsdt.core.IIncludePathAttribute;
27	import org.eclipse.wst.jsdt.core.IIncludePathEntry;
28	import org.eclipse.wst.jsdt.core.JavaScriptCore;
29	import org.eclipse.wst.jsdt.internal.core.ClasspathEntry;
30	import org.eclipse.wst.jsdt.internal.core.JavaProject;
31	import org.eclipse.wst.jsdt.web.core.internal.project.ModuleSourcePathProvider;
32	import org.eclipse.wst.sse.core.indexing.AbstractIndexManager;
33
34	/**
35	* <p>This is an implementation of the {@link AbstractIndexManager} for the JavaScript Web core plugin.</p>
36	*
37	* <p>Current Uses:
38	* <ul>
39	* <li>listen for .project changes so that JavaScript class paths can be updated
40	* if the module core nature is added to a project</li>
41	* </ul></p>
42	*
43	* <p><b>NOTE:</b> If any other file resource change listening needs to take place in the future
44	* in this plugin it should be done here.</p>
45	*/
46	public class JSWebResourceEventManager extends AbstractIndexManager {
47	/** the singleton instance of the {@link JSWebResourceEventManager} */
48	private static JSWebResourceEventManager INSTANCE;
49
50	/** the name of the ".project" file where natures are stored */
51	private static final String DOT_PROJECT_FILE_NAME = ".project"; //$NON-NLS-1$
52
53	/** the location to store state */
54	private IPath fWorkingLocation;
55
56	/**
57	* <p>Private constructor for the resource event manager</p>
58	*/
59	private JSWebResourceEventManager() {
60	super(JsCoreMessages.JSWebResourceEventManager);
61	}
62
63	/**
64	* @return the singleton instance of the {@link JSWebResourceEventManager}
65	*/
66	public static JSWebResourceEventManager getDefault() {
67	return INSTANCE != null ? INSTANCE : (INSTANCE = new JSWebResourceEventManager());
68	}
69
70	/**
71	* @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#isResourceToIndex(int, org.eclipse.core.runtime.IPath)
72	*/
73	protected boolean isResourceToIndex(int type, IPath path) {
74	String name = path.lastSegment();
75	return
76	type == IResource.ROOT \|\|
77	type == IResource.PROJECT \|\|
78	(type == IResource.FILE && name.equals(DOT_PROJECT_FILE_NAME));
79	}
80
81	/**
82	* @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#performAction(byte, byte, org.eclipse.core.resources.IResource, org.eclipse.core.runtime.IPath)
83	*/
84	protected void performAction(byte source, byte action, IResource resource,
85	IPath movePath) {
86
87	switch(action) {
88	case(AbstractIndexManager.ACTION_ADD): {
89	if(resource.getName().equals(DOT_PROJECT_FILE_NAME)) {
90	updateClassPathEntires(resource.getProject());
91	}
92	break;
93	}
94	}
95
96	}
97
98	/**
99	* @see org.eclipse.wst.sse.core.indexing.AbstractIndexManager#getWorkingLocation()
100	*/
101	protected IPath getWorkingLocation() {
102	if(this.fWorkingLocation == null) {
103	//create path to working area
104	IPath workingLocation =
105	JsCorePlugin.getDefault().getStateLocation().append("JSWebResourceEventManager"); //$NON-NLS-1$
106
107	// ensure that it exists on disk
108	File folder = new File(workingLocation.toOSString());
109	if (!folder.isDirectory()) {
110	try {
111	folder.mkdir();
112	}
113	catch (SecurityException e) {
114	Logger.logException(this.getName() +
115	": Error while creating state location: " + folder + //$NON-NLS-1$
116	" This renders the index manager irrevocably broken for this workspace session", //$NON-NLS-1$
117	e);
118	}
119	}
120
121	this.fWorkingLocation = workingLocation;
122	}
123
124	return this.fWorkingLocation;
125	}
126
127	/**
128	* <p>Updates the JavaScript class path entries for the given project if
129	* both the Module core and JavaScript natures are installed on that project.</p>
130	*
131	* @param project {@link IProject} to update the JavaScript class path entires for
132	*/
133	private static void updateClassPathEntires(IProject project) {
134	try {
135	//if a JS project with Module core check if class path needs to be updated
136	if (project.hasNature(JavaScriptCore.NATURE_ID) &&
137	ModuleCoreNature.isFlexibleProject(project)) {
138
139	JavaProject jsProject = (JavaProject) JavaScriptCore.create(project);
140
141	IIncludePathEntry[] oldEntries = jsProject.getRawIncludepath();
142	List updatedEntries = new ArrayList();
143	boolean foundDefault = false;
144
145	List preExistingExclusionPatterns = new ArrayList();
146	List preExistingInclusionPatterns = new ArrayList();
147	for(int oldEntry = 0; oldEntry < oldEntries.length; ++oldEntry) {
148	IIncludePathAttribute[] attrs = oldEntries[oldEntry].getExtraAttributes();
149
150	for(int atter = 0; atter < attrs.length; ++atter) {
151	if(attrs[atter].getName().equals(ModuleSourcePathProvider.PROVIDER_ATTRIBUTE_KEY_NAME) &&
152	attrs[atter].getValue().equals(ModuleSourcePathProvider.PROVIDER_ATTRIBUTE_KEY_VALUE)) {
153	foundDefault = true;
154
155	//create exclusion paths that are not relative to the parent entry
156	IPath[] exclusionPaths = oldEntries[oldEntry].getExclusionPatterns();
157	for(int i = 0; i < exclusionPaths.length; ++i) {
158	preExistingExclusionPatterns.add(
159	oldEntries[oldEntry].getPath().append(exclusionPaths[i]));
160	}
161
162	//create inclusion paths that are not relative to the parent entry
163	IPath[]inclusionPaths = oldEntries[oldEntry].getInclusionPatterns();
164	for(int i = 0; i < inclusionPaths.length; ++i) {
165	preExistingInclusionPatterns.add(
166	oldEntries[oldEntry].getPath().append(inclusionPaths[i]));
167	}
168	} else {
169	updatedEntries.add(oldEntries[oldEntry]);
170	}
171	}
172
173	}
174
175	//if found that a default path was added, replace with module core determined path
176	if(foundDefault) {
177	IResource[] roots = getRoots(project);
178	for(int root = 0; root < roots.length; ++root) {
179	IPath rootPath = roots[root].getFullPath();
180
181	//find matching pre-existing exclusion patterns
182	List exclusionPatterns = new ArrayList();
183	for(int i = 0; i < preExistingExclusionPatterns.size(); ++i) {
184	IPath parentRelativeExclusionPattern = PathUtils.makePatternRelativeToParent(
185	(IPath)preExistingExclusionPatterns.get(i), rootPath);
186
187	if(parentRelativeExclusionPattern != null) {
188	exclusionPatterns.add(parentRelativeExclusionPattern);
189	}
190	}
191
192	//find matching pre-existing inclusion patterns
193	List inclusionPatterns = new ArrayList();
194	for(int i = 0; i < preExistingInclusionPatterns.size(); ++i) {
195	IPath parentRelativeInclusionPattern = PathUtils.makePatternRelativeToParent(
196	(IPath)preExistingInclusionPatterns.get(i), rootPath);
197
198	if(parentRelativeInclusionPattern != null) {
199	inclusionPatterns.add(parentRelativeInclusionPattern);
200	}
201	}
202
203	//create new entry entry
204	IPath[] exclusionPaths = ClasspathEntry.EXCLUDE_NONE;
205	if(exclusionPatterns.size() > 0) {
206	exclusionPaths = (IPath[])exclusionPatterns.toArray(
207	new IPath[exclusionPatterns.size()]);
208	}
209	IPath[] inclusionPaths = ClasspathEntry.INCLUDE_ALL;
210	if(inclusionPatterns.size() > 0) {
211	inclusionPaths = (IPath[])inclusionPatterns.toArray(
212	new IPath[inclusionPatterns.size()]);
213	}
214	IIncludePathEntry newEntry = JavaScriptCore.newSourceEntry(
215	rootPath,
216	inclusionPaths,
217	exclusionPaths,
218	null);
219	updatedEntries.add(newEntry);
220	}
221
222	//set include path
223	jsProject.setRawIncludepath(
224	(IIncludePathEntry[])updatedEntries.toArray(
225	new IIncludePathEntry[updatedEntries.size()]),
226	project.getLocation(), null);
227	}
228	}
229	} catch(CoreException e) {
230	Logger.logException("Error while updating JavaScript classpath.", e); //$NON-NLS-1$
231	}
232	}
233
234	/**
235	* <p>Uses module core to get the roots of the given project.</p>
236	*
237	* @param project find the module core roots for this {@link IProject}
238	* @return the module core roots for the given {@link IProject
239	*/
240	private static IResource[] getRoots(IProject project) {
241	IVirtualFile root = ComponentCore.createFile(project, Path.ROOT);
242	IResource[] underlyingResources = root.getUnderlyingResources();
243	if (underlyingResources == null \|\| underlyingResources.length == 0) {
244	underlyingResources = new IResource[]{root.getUnderlyingResource()};
245	}
246
247	return underlyingResources;
248	}
249	}

Lines 1-3 Link Here

(-)src/org/eclipse/wst/jsdt/web/core/tests/AllWebCoreTests.java (+12 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2009, 2011 IBM Corporation and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* IBM Corporation - initial API and implementation
		10	*
		11	*******************************************************************************/
1	package org.eclipse.wst.jsdt.web.core.tests;	12	package org.eclipse.wst.jsdt.web.core.tests;
2		13
3	import junit.framework.Test;	14	import junit.framework.Test;
Lines 17-22 Link Here
17		28
18	//$JUnit-END$	29	//$JUnit-END$
19	suite.addTestSuite(TestHtmlTranslation.class);	30	suite.addTestSuite(TestHtmlTranslation.class);
		31	suite.addTestSuite(PathUtilsTests.class);
20	return suite;	32	return suite;
21	}	33	}
22		34