| /******************************************************************************* |
| * Copyright (c) 2001, 2010 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 |
| * Jens Lukowski/Innoopract - initial renaming/restructuring |
| * |
| *******************************************************************************/ |
| package org.eclipse.jst.jsp.core.internal.validation; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceVisitor; |
| import org.eclipse.core.resources.ProjectScope; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.preferences.DefaultScope; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.core.runtime.preferences.IPreferencesService; |
| import org.eclipse.core.runtime.preferences.IScopeContext; |
| import org.eclipse.core.runtime.preferences.InstanceScope; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jst.jsp.core.internal.JSPCoreMessages; |
| import org.eclipse.jst.jsp.core.internal.JSPCorePlugin; |
| import org.eclipse.jst.jsp.core.internal.Logger; |
| import org.eclipse.jst.jsp.core.internal.contenttype.DeploymentDescriptorPropertyCache; |
| import org.eclipse.jst.jsp.core.internal.preferences.JSPCorePreferenceNames; |
| import org.eclipse.jst.jsp.core.internal.provisional.JSP11Namespace; |
| import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts; |
| import org.eclipse.jst.jsp.core.internal.util.FacetModuleCoreSupport; |
| import org.eclipse.jst.jsp.core.taglib.IJarRecord; |
| import org.eclipse.jst.jsp.core.taglib.ITLDRecord; |
| import org.eclipse.jst.jsp.core.taglib.ITagDirRecord; |
| import org.eclipse.jst.jsp.core.taglib.ITaglibRecord; |
| import org.eclipse.jst.jsp.core.taglib.IURLRecord; |
| import org.eclipse.jst.jsp.core.taglib.TaglibIndex; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.wst.html.core.internal.contentmodel.JSP20Namespace; |
| import org.eclipse.wst.html.core.internal.preferences.HTMLCorePreferenceNames; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion; |
| import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion; |
| import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionContainer; |
| import org.eclipse.wst.sse.core.internal.text.IRegionComparible; |
| import org.eclipse.wst.sse.core.internal.validate.ValidationMessage; |
| import org.eclipse.wst.sse.core.utils.StringUtils; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| import org.eclipse.wst.validation.internal.provisional.core.IReporter; |
| import org.eclipse.wst.validation.internal.provisional.core.IValidator; |
| |
| import com.ibm.icu.text.Collator; |
| |
| /** |
| * Checks for: - duplicate taglib prefix values and reserved taglib prefix |
| * values in the same file |
| */ |
| public class JSPDirectiveValidator extends JSPValidator { |
| /** |
| * |
| */ |
| private static final String PREFERENCE_NODE_QUALIFIER = JSPCorePlugin.getDefault().getBundle().getSymbolicName(); |
| |
| private static Collator collator = Collator.getInstance(Locale.US); |
| |
| private static final boolean DEBUG = Boolean.valueOf(Platform.getDebugOption("org.eclipse.jst.jsp.core/debug/jspvalidator")).booleanValue(); //$NON-NLS-1$ |
| |
| private IValidator fMessageOriginator; |
| private IEclipsePreferences fPreferences = null; |
| |
| private IPreferencesService fPreferencesService = null; |
| private HashMap fPrefixValueRegionToDocumentRegionMap = new HashMap(); |
| private IJavaProject fProject = null; |
| private HashMap fReservedPrefixes = new HashMap(); |
| private IScopeContext[] fScopes = null; |
| private int fSeverityIncludeFileMissing = -1; |
| private int fSeverityIncludeFileNotSpecified = -1; |
| private int fSeveritySuperClassNotFound = -1; |
| private int fSeverityTagdirUnresolvableURI = -1; |
| private int fSeverityTaglibDuplicatePrefixWithDifferentURIs = -1; |
| |
| private int fSeverityTaglibDuplicatePrefixWithSameURIs = -1; |
| private int fSeverityTaglibMissingPrefix = -1; |
| |
| private int fSeverityTaglibMissingURI = -1; |
| |
| |
| private int fSeverityTaglibUnresolvableURI = -1; |
| |
| private HashMap fTaglibPrefixesInUse = new HashMap(); |
| |
| public JSPDirectiveValidator() { |
| initReservedPrefixes(); |
| fMessageOriginator = this; |
| } |
| |
| public JSPDirectiveValidator(IValidator validator) { |
| initReservedPrefixes(); |
| this.fMessageOriginator = validator; |
| } |
| |
| /** |
| * Record that the currently validating resource depends on the given |
| * file. Only possible during batch (not source) validation. |
| * |
| * @param file |
| */ |
| void addDependsOn(IResource file) { |
| if (fMessageOriginator instanceof JSPBatchValidator) { |
| ((JSPBatchValidator) fMessageOriginator).addDependsOn(file); |
| } |
| } |
| |
| public void cleanup(IReporter reporter) { |
| super.cleanup(reporter); |
| fTaglibPrefixesInUse.clear(); |
| fPrefixValueRegionToDocumentRegionMap.clear(); |
| } |
| |
| private void collectTaglibPrefix(IStructuredDocumentRegion documentRegion, ITextRegion valueRegion, String taglibPrefix) { |
| fPrefixValueRegionToDocumentRegionMap.put(valueRegion, documentRegion); |
| |
| Object o = fTaglibPrefixesInUse.get(taglibPrefix); |
| if (o == null) { |
| // prefix doesn't exist, remember it |
| fTaglibPrefixesInUse.put(taglibPrefix, valueRegion); |
| } |
| else { |
| List regionList = null; |
| // already a List |
| if (o instanceof List) { |
| regionList = (List) o; |
| } |
| /* |
| * a single value region, create a new List and add previous |
| * valueRegion |
| */ |
| else { |
| regionList = new ArrayList(); |
| regionList.add(o); |
| fTaglibPrefixesInUse.put(taglibPrefix, regionList); |
| } |
| regionList.add(valueRegion); |
| } |
| } |
| |
| int getMessageSeverity(String key) { |
| int sev = fPreferencesService.getInt(PREFERENCE_NODE_QUALIFIER, key, IMessage.NORMAL_SEVERITY, fScopes); |
| switch (sev) { |
| case ValidationMessage.ERROR : |
| return IMessage.HIGH_SEVERITY; |
| case ValidationMessage.WARNING : |
| return IMessage.NORMAL_SEVERITY; |
| case ValidationMessage.INFORMATION : |
| return IMessage.LOW_SEVERITY; |
| case ValidationMessage.IGNORE : |
| return ValidationMessage.IGNORE; |
| } |
| return IMessage.NORMAL_SEVERITY; |
| } |
| private void initReservedPrefixes() { |
| fReservedPrefixes.put("jsp", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("jspx", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("java", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("javax", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("servlet", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("sun", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| fReservedPrefixes.put("sunw", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| private boolean isReservedTaglibPrefix(String name) { |
| return fReservedPrefixes.get(name) != null; |
| } |
| |
| private void loadPreferences(IFile file) { |
| fScopes = new IScopeContext[]{new InstanceScope(), new DefaultScope()}; |
| |
| fPreferencesService = Platform.getPreferencesService(); |
| if (file != null && file.isAccessible()) { |
| ProjectScope projectScope = new ProjectScope(file.getProject()); |
| if (projectScope.getNode(PREFERENCE_NODE_QUALIFIER).getBoolean(JSPCorePreferenceNames.VALIDATION_USE_PROJECT_SETTINGS, false)) { |
| fScopes = new IScopeContext[]{projectScope, new InstanceScope(), new DefaultScope()}; |
| } |
| } |
| |
| fSeverityIncludeFileMissing = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_INCLUDE_FILE_NOT_FOUND); |
| fSeverityIncludeFileNotSpecified = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_INCLUDE_NO_FILE_SPECIFIED); |
| fSeverityTaglibDuplicatePrefixWithDifferentURIs = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_DUPLICATE_PREFIXES_DIFFERENT_URIS); |
| fSeverityTaglibDuplicatePrefixWithSameURIs = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_DUPLICATE_PREFIXES_SAME_URIS); |
| fSeverityTaglibMissingPrefix = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_MISSING_PREFIX); |
| fSeverityTaglibMissingURI = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_MISSING_URI_OR_TAGDIR); |
| fSeverityTaglibUnresolvableURI = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_UNRESOLVABLE_URI_OR_TAGDIR); |
| fSeverityTagdirUnresolvableURI = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_TAGLIB_UNRESOLVABLE_URI_OR_TAGDIR); |
| fSeveritySuperClassNotFound = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_DIRECTIVE_PAGE_SUPERCLASS_NOT_FOUND); |
| |
| } |
| |
| protected void performValidation(IFile f, IReporter reporter, IStructuredDocument sDoc) { |
| loadPreferences(f); |
| |
| |
| setProject(f.getProject()); |
| /* |
| * when validating an entire file need to clear dupes or else you're |
| * comparing between files |
| */ |
| fPrefixValueRegionToDocumentRegionMap.clear(); |
| fTaglibPrefixesInUse.clear(); |
| |
| IRegionComparible comparer = null; |
| if (sDoc instanceof IRegionComparible) |
| comparer = (IRegionComparible) sDoc; |
| |
| // iterate all document regions |
| IStructuredDocumentRegion region = sDoc.getFirstStructuredDocumentRegion(); |
| while (region != null && !reporter.isCancelled()) { |
| // only checking directives |
| if (region.getType() == DOMJSPRegionContexts.JSP_DIRECTIVE_NAME) { |
| processDirective(reporter, f, sDoc, region); |
| } |
| // requires tag name, attribute, equals, and value |
| else if (comparer != null && region.getNumberOfRegions() > 4) { |
| ITextRegion nameRegion = region.getRegions().get(1); |
| if (comparer.regionMatches(region.getStartOffset(nameRegion), nameRegion.getTextLength(), "jsp:include")) { //$NON-NLS-1$ |
| processInclude(reporter, f, sDoc, region, JSP11Namespace.ATTR_NAME_PAGE); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=295950 |
| else if (comparer.regionMatches(region.getStartOffset(nameRegion), 14, "jsp:directive.")) { //$NON-NLS-1$ |
| processDirective(reporter, f, sDoc, region); |
| } |
| |
| } |
| region = region.getNext(); |
| } |
| |
| if (!reporter.isCancelled()) { |
| reportTaglibDuplicatePrefixes(f, reporter, sDoc); |
| } |
| |
| fPrefixValueRegionToDocumentRegionMap.clear(); |
| fTaglibPrefixesInUse.clear(); |
| setProject(null); |
| unloadPreferences(); |
| } |
| |
| private void processDirective(IReporter reporter, IFile file, IStructuredDocument sDoc, IStructuredDocumentRegion documentRegion) { |
| String directiveName = getDirectiveName(documentRegion); |
| |
| if (directiveName.endsWith("taglib")) { //$NON-NLS-1$ |
| processTaglibDirective(reporter, file, sDoc, documentRegion); |
| } |
| else if (directiveName.equals("jsp:include")) { //$NON-NLS-1$ |
| processInclude(reporter, file, sDoc, documentRegion, JSP11Namespace.ATTR_NAME_PAGE); |
| } |
| else if (directiveName.endsWith("include")) { //$NON-NLS-1$ |
| processInclude(reporter, file, sDoc, documentRegion, JSP11Namespace.ATTR_NAME_FILE); |
| } |
| else if (directiveName.endsWith("page")) { //$NON-NLS-1$ |
| processPageDirective(reporter, file, sDoc, documentRegion); |
| } |
| } |
| |
| private void processInclude(IReporter reporter, IFile file, IStructuredDocument sDoc, IStructuredDocumentRegion documentRegion, String attrName) { |
| ITextRegion fileValueRegion = getAttributeValueRegion(documentRegion, attrName); |
| // There is a file and it isn't a nested region which could contain a JSP expression |
| if (fileValueRegion != null && !hasNestedRegion(fileValueRegion)) { |
| // file specified |
| String fileValue = documentRegion.getText(fileValueRegion); |
| fileValue = StringUtils.stripQuotes(fileValue); |
| |
| if (fileValue.length() == 0 && fSeverityIncludeFileNotSpecified != ValidationMessage.IGNORE) { |
| // file value is specified but empty |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, attrName); |
| LocalizedMessage message = new LocalizedMessage(fSeverityIncludeFileNotSpecified, msgText, file); |
| int start = documentRegion.getStartOffset(fileValueRegion); |
| int length = fileValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| else if (DeploymentDescriptorPropertyCache.getInstance().getURLMapping(file.getFullPath(), fileValue) == null) { |
| IPath testPath = FacetModuleCoreSupport.resolve(file.getFullPath(), fileValue); |
| if (testPath.segmentCount() > 1) { |
| IFile testFile = file.getWorkspace().getRoot().getFile(testPath); |
| addDependsOn(testFile); |
| if (!testFile.isAccessible()) { |
| if (fSeverityIncludeFileMissing != ValidationMessage.IGNORE) { |
| // File not found |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_4, new String[]{fileValue, testPath.toString()}); |
| LocalizedMessage message = new LocalizedMessage(fSeverityIncludeFileMissing, msgText, file); |
| int start = documentRegion.getStartOffset(fileValueRegion); |
| int length = fileValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| } |
| } |
| } |
| else if (fileValueRegion == null && fSeverityIncludeFileNotSpecified != ValidationMessage.IGNORE) { |
| // file is not specified at all |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, attrName); |
| LocalizedMessage message = new LocalizedMessage(fSeverityIncludeFileNotSpecified, msgText, file); |
| int start = documentRegion.getStartOffset(); |
| int length = documentRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| |
| /** |
| * @param reporter |
| * @param file |
| * @param doc |
| * @param documentRegion |
| */ |
| private void processPageDirective(IReporter reporter, IFile file, IStructuredDocument doc, IStructuredDocumentRegion documentRegion) { |
| ITextRegion superclassValueRegion = getAttributeValueRegion(documentRegion, JSP11Namespace.ATTR_NAME_EXTENDS); |
| if (superclassValueRegion != null) { |
| // file specified |
| String superclassName = documentRegion.getText(superclassValueRegion); |
| superclassName = StringUtils.stripQuotes(superclassName); |
| |
| IType superClass = null; |
| if (superclassName != null && superclassName.length() > 0 && fProject != null && fProject.exists()) { |
| try { |
| superClass = fProject.findType(superclassName.trim(), new NullProgressMonitor()); |
| } |
| catch (JavaModelException e) { |
| Logger.logException(e); |
| } |
| } |
| |
| if (superClass == null && fSeveritySuperClassNotFound != ValidationMessage.IGNORE) { |
| // superclass not found |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_8, superclassName); |
| LocalizedMessage message = new LocalizedMessage(fSeveritySuperClassNotFound, msgText, file); |
| int start = documentRegion.getStartOffset(superclassValueRegion); |
| int length = superclassValueRegion.getTextLength(); |
| int lineNo = doc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| } |
| |
| private void processTaglibDirective(IReporter reporter, IFile file, IStructuredDocument sDoc, IStructuredDocumentRegion documentRegion) { |
| ITextRegion prefixValueRegion = null; |
| ITextRegion uriValueRegion = getAttributeValueRegion(documentRegion, JSP11Namespace.ATTR_NAME_URI); |
| ITextRegion tagdirValueRegion = getAttributeValueRegion(documentRegion, JSP20Namespace.ATTR_NAME_TAGDIR); |
| if (uriValueRegion != null) { |
| // URI is specified |
| String uri = documentRegion.getText(uriValueRegion); |
| |
| if (file != null) { |
| uri = StringUtils.stripQuotes(uri); |
| if (uri.length() > 0) { |
| ITaglibRecord reference = TaglibIndex.resolve(file.getFullPath().toString(), uri, false); |
| if (reference != null) { |
| switch (reference.getRecordType()) { |
| case (ITaglibRecord.TLD) : { |
| ITLDRecord record = (ITLDRecord) reference; |
| IResource tldfile = ResourcesPlugin.getWorkspace().getRoot().getFile(record.getPath()); |
| addDependsOn(tldfile); |
| } |
| break; |
| case (ITaglibRecord.JAR) : { |
| IJarRecord record = (IJarRecord) reference; |
| IFile[] foundFilesForLocation = ResourcesPlugin.getWorkspace().getRoot().findFilesForLocation(record.getLocation()); |
| for (int i = 0; i < foundFilesForLocation.length; i++) { |
| addDependsOn(foundFilesForLocation[i]); |
| } |
| } |
| break; |
| case (ITaglibRecord.TAGDIR) : { |
| ITagDirRecord record = (ITagDirRecord) reference; |
| IPath path = record.getPath(); |
| IResource found = ResourcesPlugin.getWorkspace().getRoot().findMember(path, false); |
| |
| try { |
| found.accept(new IResourceVisitor() { |
| public boolean visit(IResource resource) throws CoreException { |
| if (resource.getType() == IResource.FILE) { |
| addDependsOn(resource); |
| } |
| return true; |
| } |
| }); |
| } |
| catch (CoreException e) { |
| Logger.logException(e); |
| } |
| } |
| break; |
| case (ITaglibRecord.URL) : { |
| IURLRecord record = (IURLRecord) reference; |
| String baseLocation = record.getBaseLocation(); |
| if (baseLocation != null && baseLocation.indexOf("://") < 0) { |
| IResource found = ResourcesPlugin.getWorkspace().getRoot().findMember(baseLocation, false); |
| if (found != null) { |
| try { |
| found.accept(new IResourceVisitor() { |
| public boolean visit(IResource resource) throws CoreException { |
| if (resource.getType() == IResource.FILE) { |
| addDependsOn(resource); |
| } |
| return true; |
| } |
| }); |
| } |
| catch (CoreException e) { |
| Logger.logException(e); |
| } |
| } |
| else { |
| IFile externalJar = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(baseLocation)); |
| if (externalJar != null) { |
| addDependsOn(externalJar); |
| } |
| } |
| } |
| } |
| break; |
| } |
| } |
| if (reference == null && fSeverityTaglibUnresolvableURI != ValidationMessage.IGNORE) { |
| // URI specified but does not resolve |
| String msgText = null; |
| // provide better messages for typical "http:*" URIs |
| if (uri.startsWith("http:") && DeploymentDescriptorPropertyCache.getInstance().getJSPVersion(file.getFullPath()) < 1.2) { //$NON-NLS-1$ |
| if (FacetModuleCoreSupport.isDynamicWebProject(file.getProject())) { |
| msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_9, uri); |
| } |
| else { |
| msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_10, uri); |
| } |
| } |
| else { |
| msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_1, uri); |
| } |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibUnresolvableURI, msgText, file); |
| int start = documentRegion.getStartOffset(uriValueRegion); |
| int length = uriValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| message.setAttribute("PROBLEM_ID", new Integer(611)); //$NON-NLS-1$ |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| else if (fSeverityTaglibMissingURI != ValidationMessage.IGNORE) { |
| // URI specified but empty string |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, JSP11Namespace.ATTR_NAME_URI); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibMissingURI, msgText, file); |
| int start = documentRegion.getStartOffset(uriValueRegion); |
| int length = uriValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| } |
| else if (tagdirValueRegion != null) { |
| // URI is specified |
| String tagdir = documentRegion.getText(tagdirValueRegion); |
| |
| if (file != null) { |
| tagdir = StringUtils.stripQuotes(tagdir); |
| if (tagdir.length() <= 0 && fSeverityTaglibMissingURI != ValidationMessage.IGNORE) { |
| // tagdir specified but empty string |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, JSP20Namespace.ATTR_NAME_TAGDIR); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibMissingURI, msgText, file); |
| int start = documentRegion.getStartOffset(tagdirValueRegion); |
| int length = tagdirValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| else if (TaglibIndex.resolve(file.getFullPath().toString(), tagdir, false) == null && fSeverityTagdirUnresolvableURI != ValidationMessage.IGNORE) { |
| // URI specified but does not resolve |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_11, tagdir); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibUnresolvableURI, msgText, file); |
| int start = documentRegion.getStartOffset(tagdirValueRegion); |
| int length = tagdirValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| } |
| else if (fSeverityTaglibMissingURI != ValidationMessage.IGNORE) { |
| // URI not specified or empty string |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_7, new String[]{JSP20Namespace.ATTR_NAME_TAGDIR, JSP11Namespace.ATTR_NAME_URI}); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibMissingURI, msgText, file); |
| int start = documentRegion.getStartOffset(); |
| int length = documentRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| |
| prefixValueRegion = getAttributeValueRegion(documentRegion, JSP11Namespace.ATTR_NAME_PREFIX); |
| if (prefixValueRegion != null) { |
| // prefix specified |
| String taglibPrefix = documentRegion.getText(prefixValueRegion); |
| taglibPrefix = StringUtils.stripQuotes(taglibPrefix); |
| |
| collectTaglibPrefix(documentRegion, prefixValueRegion, taglibPrefix); |
| |
| if (isReservedTaglibPrefix(taglibPrefix)) { |
| // prefix is a reserved prefix |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_0, taglibPrefix); |
| int sev = IMessage.HIGH_SEVERITY; |
| LocalizedMessage message = (file == null ? new LocalizedMessage(sev, msgText) : new LocalizedMessage(sev, msgText, file)); |
| int start = documentRegion.getStartOffset(prefixValueRegion); |
| int length = prefixValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| if (taglibPrefix.length() == 0 && fSeverityTaglibMissingPrefix != ValidationMessage.IGNORE) { |
| // prefix is specified but empty |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, JSP11Namespace.ATTR_NAME_PREFIX); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibMissingPrefix, msgText, file); |
| int start = documentRegion.getStartOffset(prefixValueRegion); |
| int length = prefixValueRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| else if (fSeverityTaglibMissingPrefix != ValidationMessage.IGNORE) { |
| // prefix is not specified |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_3, JSP11Namespace.ATTR_NAME_PREFIX); |
| LocalizedMessage message = new LocalizedMessage(fSeverityTaglibMissingPrefix, msgText, file); |
| int start = documentRegion.getStartOffset(); |
| int length = documentRegion.getTextLength(); |
| int lineNo = sDoc.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| |
| private void reportTaglibDuplicatePrefixes(IFile file, IReporter reporter, IStructuredDocument document) { |
| if (fSeverityTaglibDuplicatePrefixWithDifferentURIs == ValidationMessage.IGNORE && fSeverityTaglibDuplicatePrefixWithSameURIs == ValidationMessage.IGNORE) |
| return; |
| |
| String[] prefixes = (String[]) fTaglibPrefixesInUse.keySet().toArray(new String[0]); |
| for (int prefixNumber = 0; prefixNumber < prefixes.length; prefixNumber++) { |
| int severity = fSeverityTaglibDuplicatePrefixWithSameURIs; |
| |
| Object o = fTaglibPrefixesInUse.get(prefixes[prefixNumber]); |
| /* |
| * Only care if it's a List (because there was more than one |
| * directive with that prefix) and if we're supposed to report |
| * duplicates |
| */ |
| if (o instanceof List) { |
| List valueRegions = (List) o; |
| String uri = null; |
| for (int regionNumber = 0; regionNumber < valueRegions.size(); regionNumber++) { |
| IStructuredDocumentRegion documentRegion = (IStructuredDocumentRegion) fPrefixValueRegionToDocumentRegionMap.get(valueRegions.get(regionNumber)); |
| ITextRegion uriValueRegion = getAttributeValueRegion(documentRegion, JSP11Namespace.ATTR_NAME_URI); |
| if (uriValueRegion == null) { |
| uriValueRegion = getAttributeValueRegion(documentRegion, JSP20Namespace.ATTR_NAME_TAGDIR); |
| } |
| if (uriValueRegion != null) { |
| String uri2 = StringUtils.stripQuotes(documentRegion.getText(uriValueRegion)); |
| if (uri == null) { |
| uri = uri2; |
| } |
| else { |
| if (collator.compare(uri, uri2) != 0) { |
| severity = fSeverityTaglibDuplicatePrefixWithDifferentURIs; |
| } |
| } |
| } |
| } |
| |
| if (severity != ValidationMessage.IGNORE) { |
| String msgText = NLS.bind(JSPCoreMessages.JSPDirectiveValidator_2, prefixes[prefixNumber]); //$NON-NLS-2$ //$NON-NLS-1$ |
| |
| // Report an error in all directives using this prefix |
| for (int regionNumber = 0; regionNumber < valueRegions.size(); regionNumber++) { |
| |
| ITextRegion valueRegion = (ITextRegion) valueRegions.get(regionNumber); |
| IStructuredDocumentRegion documentRegion = (IStructuredDocumentRegion) fPrefixValueRegionToDocumentRegionMap.get(valueRegion); |
| LocalizedMessage message = (file == null ? new LocalizedMessage(severity, msgText) : new LocalizedMessage(severity, msgText, file)); |
| |
| // if there's a message, there was an error found |
| int start = documentRegion.getStartOffset(valueRegion); |
| int length = valueRegion.getTextLength(); |
| int lineNo = document.getLineOfOffset(start); |
| message.setLineNo(lineNo + 1); |
| message.setOffset(start); |
| message.setLength(length); |
| |
| reporter.addMessage(fMessageOriginator, message); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * @param project |
| */ |
| private void setProject(IProject project) { |
| boolean useProject = false; |
| if (project != null) { |
| fProject = JavaCore.create(project); |
| fPreferences = new ProjectScope(fProject.getProject()).getNode(PREFERENCE_NODE_QUALIFIER); |
| useProject = fPreferences.getBoolean(HTMLCorePreferenceNames.USE_PROJECT_SETTINGS, false); |
| } |
| else { |
| fProject = null; |
| } |
| |
| if (!useProject) { |
| fPreferences = new InstanceScope().getNode(PREFERENCE_NODE_QUALIFIER); |
| } |
| } |
| |
| private void unloadPreferences() { |
| fPreferencesService = null; |
| fScopes = null; |
| } |
| |
| /** |
| * True if container has nested regions, meaning container is probably too |
| * complicated (like JSP expressions or EL) to validate with this validator. |
| */ |
| private boolean hasNestedRegion(ITextRegion container) { |
| return (container instanceof ITextRegionContainer && ((ITextRegionContainer) container).getRegions() != null); |
| } |
| |
| /** |
| * batch validation call |
| */ |
| protected void validateFile(IFile f, IReporter reporter) { |
| if (DEBUG) { |
| Logger.log(Logger.INFO, getClass().getName() + " validating: " + f); //$NON-NLS-1$ |
| } |
| |
| IStructuredModel sModel = null; |
| try { |
| sModel = StructuredModelManager.getModelManager().getModelForRead(f); |
| if (sModel != null && !reporter.isCancelled()) { |
| performValidation(f, reporter, sModel.getStructuredDocument()); |
| } |
| } |
| catch (Exception e) { |
| Logger.logException(e); |
| } |
| finally { |
| if (sModel != null) |
| sModel.releaseFromRead(); |
| } |
| } |
| } |
