com.sun.faces.application.ApplicationAssociate Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jsf-impl Show documentation
Show all versions of jsf-impl Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.
The newest version!
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. 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 packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* 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.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* 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 don't 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.
*/
package com.sun.faces.application;
import com.sun.faces.RIConstants;
import com.sun.faces.scripting.groovy.GroovyHelper;
import com.sun.faces.application.resource.ResourceCache;
import com.sun.faces.application.resource.ResourceManager;
import com.sun.faces.application.annotation.AnnotationManager;
import com.sun.faces.application.annotation.FacesComponentUsage;
import com.sun.faces.config.ConfigManager;
import com.sun.faces.config.WebConfiguration;
import com.sun.faces.facelets.compiler.Compiler;
import com.sun.faces.facelets.compiler.SAXCompiler;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.SystemEvent;
import javax.faces.view.facelets.TagDecorator;
import com.sun.faces.facelets.tag.composite.CompositeLibrary;
import com.sun.faces.facelets.tag.jstl.core.JstlCoreLibrary;
import com.sun.faces.facelets.tag.jstl.fn.JstlFunction;
import com.sun.faces.facelets.tag.ui.UILibrary;
import com.sun.faces.facelets.tag.jsf.core.CoreLibrary;
import com.sun.faces.facelets.tag.jsf.html.HtmlLibrary;
import com.sun.faces.facelets.util.ReflectionUtil;
import com.sun.faces.facelets.util.FunctionLibrary;
import com.sun.faces.facelets.util.DevTools;
import javax.faces.view.facelets.ResourceResolver;
import javax.faces.view.facelets.FaceletCache;
import com.sun.faces.facelets.impl.DefaultResourceResolver;
import com.sun.faces.facelets.impl.DefaultFaceletFactory;
import com.sun.faces.mgbean.BeanManager;
import com.sun.faces.spi.InjectionProvider;
import com.sun.faces.util.MessageUtils;
import com.sun.faces.util.Util;
import com.sun.faces.util.FacesLogger;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter;
import static com.sun.faces.config.WebConfiguration.WebContextInitParameter.*;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.DisableFaceletJSFViewHandler;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.EnableLazyBeanValidation;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.EnableFaceletsResourceResolverResolveCompositeComponents;
import com.sun.faces.el.DemuxCompositeELResolver;
import com.sun.faces.el.ELUtils;
import com.sun.faces.el.FacesCompositeELResolver;
import com.sun.faces.el.VariableResolverChainWrapper;
import com.sun.faces.facelets.PrivateApiFaceletCacheAdapter;
import com.sun.faces.facelets.tag.jsf.PassThroughAttributeLibrary;
import com.sun.faces.facelets.tag.jsf.PassThroughElementLibrary;
import com.sun.faces.lifecycle.ELResolverInitPhaseListener;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import javax.el.CompositeELResolver;
import javax.el.ELResolver;
import javax.el.ExpressionFactory;
import javax.faces.component.UIViewRoot;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.el.PropertyResolver;
import javax.faces.el.VariableResolver;
import javax.faces.application.ProjectStage;
import javax.faces.event.PreDestroyCustomScopeEvent;
import javax.faces.event.ScopeContext;
import javax.servlet.ServletContext;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.LinkedHashSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.concurrent.ConcurrentHashMap;
import javax.faces.FacesException;
import javax.faces.FactoryFinder;
import javax.faces.application.Application;
import javax.faces.application.NavigationCase;
import javax.faces.application.ViewHandler;
import javax.faces.component.FacesComponent;
import javax.faces.event.PostConstructApplicationEvent;
import javax.faces.event.SystemEventListener;
import javax.faces.flow.FlowHandler;
import javax.faces.flow.FlowHandlerFactory;
import javax.faces.view.facelets.FaceletCacheFactory;
import javax.faces.view.facelets.FaceletsResourceResolver;
/**
* Break out the things that are associated with the Application, but
* need to be present even when the user has replaced the Application
* instance.
*
* For example: the user replaces ApplicationFactory, and wants to
* intercept calls to createValueExpression() and createMethodExpression() for
* certain kinds of expressions, but allow the existing application to
* handle the rest.
*/
public class ApplicationAssociate {
private static final Logger LOGGER = FacesLogger.APPLICATION.getLogger();
private ApplicationImpl app = null;
/**
* Overall Map containing from-view-id key and
* Set of NavigationCase
* objects for that key; The from-view-id strings in
* this map will be stored as specified in the configuration file -
* some of them will have a trailing asterisk "*" signifying wild
* card, and some may be specified as an asterisk "*".
*/
private Map> navigationMap = null;
/*
* The FacesComponentTagLibrary uses the information in this map
* to help it fabricate tag handlers for components annotated with
* FacesComponent.
* Key: namespace
*/
private Map> facesComponentsByNamespace = null;
// Flag indicating that a response has been rendered.
private boolean responseRendered = false;
private static final String ASSOCIATE_KEY = RIConstants.FACES_PREFIX +
"ApplicationAssociate";
private static ThreadLocal instance =
new ThreadLocal() {
protected ApplicationAssociate initialValue() {
return (null);
}
};
private List elResolversFromFacesConfig = null;
@SuppressWarnings("deprecation")
private VariableResolver legacyVRChainHead = null;
private VariableResolverChainWrapper legacyVRChainHeadWrapperForJsp = null;
private VariableResolverChainWrapper legacyVRChainHeadWrapperForFaces = null;
@SuppressWarnings("deprecation")
private PropertyResolver legacyPRChainHead = null;
private ExpressionFactory expressionFactory = null;
@SuppressWarnings("deprecation")
private PropertyResolver legacyPropertyResolver = null;
@SuppressWarnings("deprecation")
private VariableResolver legacyVariableResolver = null;
private FacesCompositeELResolver facesELResolverForJsp = null;
private InjectionProvider injectionProvider;
private ResourceCache resourceCache;
private String contextName;
private boolean requestServiced;
private boolean errorPagePresent;
private BeanManager beanManager;
private GroovyHelper groovyHelper;
private AnnotationManager annotationManager;
private boolean devModeEnabled;
private Compiler compiler;
private DefaultFaceletFactory faceletFactory;
private ResourceManager resourceManager;
private ApplicationStateInfo applicationStateInfo;
private PropertyEditorHelper propertyEditorHelper;
private NamedEventManager namedEventManager;
private WebConfiguration webConfig;
private FlowHandler flowHandler;
private Map definingDocumentIdsToTruncatedJarUrls;
private long timeOfInstantiation;
public ApplicationAssociate(ApplicationImpl appImpl) {
app = appImpl;
propertyEditorHelper = new PropertyEditorHelper(appImpl);
FacesContext ctx = FacesContext.getCurrentInstance();
if (ctx == null) {
throw new IllegalStateException(
"ApplicationAssociate ctor not called in same callstack as ConfigureListener.contextInitialized()");
}
ExternalContext externalContext = ctx.getExternalContext();
if (null != externalContext.getApplicationMap().get(ASSOCIATE_KEY)) {
throw new IllegalStateException(
MessageUtils.getExceptionMessageString(
MessageUtils.APPLICATION_ASSOCIATE_EXISTS_ID));
}
Map appMap = externalContext.getApplicationMap();
appMap.put(ASSOCIATE_KEY, this);
//noinspection CollectionWithoutInitialCapacity
navigationMap = new ConcurrentHashMap>();
injectionProvider = (InjectionProvider) ctx.getAttributes().get(ConfigManager.INJECTION_PROVIDER_KEY);
webConfig = WebConfiguration.getInstance(externalContext);
beanManager = new BeanManager(injectionProvider,
webConfig.isOptionEnabled(
EnableLazyBeanValidation));
// install the bean manager as a system event listener for custom
// scopes being destoryed.
app.subscribeToEvent(PreDestroyCustomScopeEvent.class,
ScopeContext.class,
beanManager);
annotationManager = new AnnotationManager();
groovyHelper = GroovyHelper.getCurrentInstance();
devModeEnabled = (appImpl.getProjectStage() == ProjectStage.Development);
if (!devModeEnabled) {
resourceCache = new ResourceCache();
}
resourceManager = new ResourceManager(appMap, resourceCache);
namedEventManager = new NamedEventManager();
applicationStateInfo = new ApplicationStateInfo();
appImpl.subscribeToEvent(PostConstructApplicationEvent.class,
Application.class, new PostConstructApplicationListener());
definingDocumentIdsToTruncatedJarUrls = new ConcurrentHashMap();
timeOfInstantiation = System.currentTimeMillis();
}
public Application getApplication() {
return app;
}
private Map> resourceLibraryContracts;
public void setResourceLibraryContracts(HashMap> map) {
this.resourceLibraryContracts = map;
}
private class PostConstructApplicationListener implements SystemEventListener {
@Override
public boolean isListenerForSource(Object source) {
return source instanceof Application;
}
@Override
public void processEvent(SystemEvent event) throws AbortProcessingException {
ApplicationAssociate.this.initializeFacelets();
if (null == ApplicationAssociate.this.flowHandler) {
FlowHandlerFactory flowHandlerFactory = (FlowHandlerFactory) FactoryFinder.getFactory(FactoryFinder.FLOW_HANDLER_FACTORY);
ApplicationAssociate.this.flowHandler = flowHandlerFactory.createFlowHandler(FacesContext.getCurrentInstance());
}
FacesContext context = FacesContext.getCurrentInstance();
if (Util.isCDIAvailable(context.getExternalContext().getApplicationMap())) {
try {
JavaFlowLoaderHelper flowLoader = new JavaFlowLoaderHelper();
flowLoader.loadFlows(context, ApplicationAssociate.this.flowHandler);
} catch (IOException ex) {
LOGGER.log(Level.SEVERE, null, ex);
}
}
// cause the Facelet VDL to be instantiated eagerly, so it can
// become aware of the resource library contracts
ViewHandler viewHandler = context.getApplication().getViewHandler();
// FindBugs: ignore the return value, this is just to get the
// ctor called at this time.
viewHandler.getViewDeclarationLanguage(context,
RIConstants.FACES_PREFIX + "xhtml");
}
}
public void initializeFacelets() {
if (null != compiler) {
return;
}
FacesContext ctx = FacesContext.getCurrentInstance();
if (!webConfig.isOptionEnabled(DisableFaceletJSFViewHandler)) {
Map appMap = ctx.getExternalContext().getApplicationMap();
compiler = createCompiler(appMap, webConfig);
faceletFactory = createFaceletFactory(ctx, compiler, webConfig);
}
}
public static ApplicationAssociate getInstance(ExternalContext
externalContext) {
if (externalContext == null) {
return null;
}
Map applicationMap = externalContext.getApplicationMap();
return ((ApplicationAssociate)
applicationMap.get(ASSOCIATE_KEY));
}
public long getTimeOfInstantiation() {
return timeOfInstantiation;
}
public static ApplicationAssociate getInstance(ServletContext context) {
if (context == null) {
return null;
}
return (ApplicationAssociate) context.getAttribute(ASSOCIATE_KEY);
}
public static void setCurrentInstance(ApplicationAssociate associate) {
if (associate == null) {
instance.remove();
} else {
instance.set(associate);
}
}
public static ApplicationAssociate getCurrentInstance() {
ApplicationAssociate associate = instance.get();
if (associate == null) {
// Fallback to ExternalContext lookup
FacesContext fc = FacesContext.getCurrentInstance();
if (fc != null) {
ExternalContext extContext = fc.getExternalContext();
if (extContext != null) {
return ApplicationAssociate.getInstance(extContext);
}
}
}
return associate;
}
public ApplicationStateInfo getApplicationStateInfo() {
return applicationStateInfo;
}
public ResourceManager getResourceManager() {
return resourceManager;
}
// Return the resource library contracts and mappings from the
// application configuration resources
public Map> getResourceLibraryContracts() {
return resourceLibraryContracts;
}
public void setResourceManager(ResourceManager resourceManager) {
this.resourceManager = resourceManager;
}
public ResourceCache getResourceCache() {
return resourceCache;
}
public AnnotationManager getAnnotationManager() {
return annotationManager;
}
public Compiler getCompiler() {
if (null == compiler) {
initializeFacelets();
}
return compiler;
}
public boolean isErrorPagePresent() {
return errorPagePresent;
}
public void setErrorPagePresent(boolean errorPagePresent) {
this.errorPagePresent = errorPagePresent;
}
public DefaultFaceletFactory getFaceletFactory() {
return faceletFactory;
}
public static void clearInstance(ExternalContext
externalContext) {
Map applicationMap = externalContext.getApplicationMap();
ApplicationAssociate me = (ApplicationAssociate) applicationMap.get(ASSOCIATE_KEY);
if (null != me && null != me.resourceBundles) {
me.resourceBundles.clear();
}
applicationMap.remove(ASSOCIATE_KEY);
}
public static void clearInstance(ServletContext sc) {
ApplicationAssociate me = (ApplicationAssociate) sc.getAttribute(ASSOCIATE_KEY);
if (null != me && null != me.resourceBundles) {
me.resourceBundles.clear();
}
sc.removeAttribute(ASSOCIATE_KEY);
}
public BeanManager getBeanManager() {
return beanManager;
}
public GroovyHelper getGroovyHelper() {
return groovyHelper;
}
public void initializeELResolverChains() {
// 1. initialize the chains with default values
if (null == app.compositeELResolver) {
app.compositeELResolver =
new DemuxCompositeELResolver(
FacesCompositeELResolver.ELResolverChainType.Faces);
ELUtils.buildFacesResolver(app.compositeELResolver, this);
ELResolverInitPhaseListener.populateFacesELResolverForJsp(app,
this);
}
}
public void installProgrammaticallyAddedResolvers() {
// Ensure custom resolvers are inserted at the correct place.
VariableResolver vr = this.getLegacyVariableResolver();
if (null != vr) {
assert(null != this.getLegacyVRChainHeadWrapperForJsp());
this.getLegacyVRChainHeadWrapperForJsp().setWrapped(vr);
assert(null != this.getLegacyVRChainHeadWrapperForFaces());
this.getLegacyVRChainHeadWrapperForFaces().setWrapped(vr);
}
}
public boolean isDevModeEnabled() {
return devModeEnabled;
}
/**
* Obtain the PropertyEditorHelper instance for this app.
*
* @return The PropertyEditorHeler instance for this app.
*/
public PropertyEditorHelper getPropertyEditorHelper() {
return propertyEditorHelper;
}
/**
* This method is called by ConfigureListener and will
* contain any VariableResolvers defined within
* faces-config configuration files.
*
* @param resolver VariableResolver
*/
@SuppressWarnings("deprecation")
public void setLegacyVRChainHead(VariableResolver resolver) {
this.legacyVRChainHead = resolver;
}
@SuppressWarnings("deprecation")
public VariableResolver getLegacyVRChainHead() {
return legacyVRChainHead;
}
public VariableResolverChainWrapper getLegacyVRChainHeadWrapperForJsp() {
return legacyVRChainHeadWrapperForJsp;
}
public void setLegacyVRChainHeadWrapperForJsp(VariableResolverChainWrapper legacyVRChainHeadWrapper) {
this.legacyVRChainHeadWrapperForJsp = legacyVRChainHeadWrapper;
}
public VariableResolverChainWrapper getLegacyVRChainHeadWrapperForFaces() {
return legacyVRChainHeadWrapperForFaces;
}
public void setLegacyVRChainHeadWrapperForFaces(VariableResolverChainWrapper legacyVRChainHeadWrapperForFaces) {
this.legacyVRChainHeadWrapperForFaces = legacyVRChainHeadWrapperForFaces;
}
/**
* This method is called by ConfigureListener and will
* contain any PropertyResolvers defined within
* faces-config configuration files.
*
* @param resolver PropertyResolver
*/
@SuppressWarnings("deprecation")
public void setLegacyPRChainHead(PropertyResolver resolver) {
this.legacyPRChainHead = resolver;
}
@SuppressWarnings("deprecation")
public PropertyResolver getLegacyPRChainHead() {
return legacyPRChainHead;
}
public FacesCompositeELResolver getFacesELResolverForJsp() {
return facesELResolverForJsp;
}
public FlowHandler getFlowHandler() {
return flowHandler;
}
public void setFlowHandler(FlowHandler flowHandler) {
this.flowHandler = flowHandler;
}
public void setFacesELResolverForJsp(FacesCompositeELResolver celr) {
facesELResolverForJsp = celr;
}
public void setELResolversFromFacesConfig(List resolvers) {
this.elResolversFromFacesConfig = resolvers;
}
public List getELResolversFromFacesConfig() {
return elResolversFromFacesConfig;
}
public void setExpressionFactory(ExpressionFactory expressionFactory) {
this.expressionFactory = expressionFactory;
}
public ExpressionFactory getExpressionFactory() {
return this.expressionFactory;
}
public CompositeELResolver getApplicationELResolvers() {
return app.getApplicationELResolvers();
}
public InjectionProvider getInjectionProvider() {
return injectionProvider;
}
public void setContextName(String contextName) {
this.contextName = contextName;
}
public String getContextName() {
return contextName;
}
/**
* Maintains the PropertyResolver called through
* Application.setPropertyResolver()
* @param resolver PropertyResolver
*/
@SuppressWarnings("deprecation")
public void setLegacyPropertyResolver(PropertyResolver resolver) {
this.legacyPropertyResolver = resolver;
}
/**
* @return the PropertyResolver called through
* Application.getPropertyResolver()
*/
@SuppressWarnings("deprecation")
public PropertyResolver getLegacyPropertyResolver() {
return legacyPropertyResolver;
}
/**
* Maintains the PropertyResolver called through
* Application.setVariableResolver()
* @param resolver VariableResolver
*/
@SuppressWarnings("deprecation")
public void setLegacyVariableResolver(VariableResolver resolver) {
this.legacyVariableResolver = resolver;
}
/**
* @return the VariableResolver called through
* Application.getVariableResolver()
*/
@SuppressWarnings("deprecation")
public VariableResolver getLegacyVariableResolver() {
return legacyVariableResolver;
}
/**
* Called by application code to indicate we've processed the
* first request to the application.
*/
public void setRequestServiced() {
this.requestServiced = true;
}
/**
* @return true if we've processed a request, otherwise
* false
*/
public boolean hasRequestBeenServiced() {
return requestServiced;
}
public void addFacesComponent(FacesComponentUsage facesComponentUsage) {
FacesComponent facesComponent = facesComponentUsage.getAnnotation();
assert(facesComponent.createTag());
if (null == facesComponentsByNamespace) {
facesComponentsByNamespace = new HashMap>();
}
List componentsInNamespace = null;
final String namespace = facesComponent.namespace();
if (!facesComponentsByNamespace.containsKey(facesComponent.namespace())) {
componentsInNamespace = new ArrayList();
facesComponentsByNamespace.put(namespace, componentsInNamespace);
} else {
componentsInNamespace = facesComponentsByNamespace.get(namespace);
}
componentsInNamespace.add(facesComponentUsage);
}
public List getComponentsForNamespace(String ns) {
List result = Collections.emptyList();
if (null != facesComponentsByNamespace && facesComponentsByNamespace.containsKey(ns)) {
result = facesComponentsByNamespace.get(ns);
}
return result;
}
/**
* Add a navigation case to the internal case set. If a case set
* does not already exist in the case list map containing this case
* (identified by from-view-id), start a new list,
* add the case to it, and store the set in the case set map.
* If a case set already exists, overwrite the previous case.
*
* @param navigationCase the navigation case containing navigation
* mapping information from the configuration file.
*/
public void addNavigationCase(NavigationCase navigationCase) {
String fromViewId = navigationCase.getFromViewId();
Set caseSet = navigationMap.get(fromViewId);
if (caseSet == null) {
//noinspection CollectionWithoutInitialCapacity
caseSet = new LinkedHashSet();
caseSet.add(navigationCase);
navigationMap.put(fromViewId, caseSet);
} else {
// if there already is a case existing for the
// fromviewid/fromaction.fromoutcome combination,
// replace it ... (last one wins).
caseSet.add(navigationCase);
}
}
public NamedEventManager getNamedEventManager() {
return namedEventManager;
}
/**
* Return a Map of navigation mappings loaded from
* the configuration system. The key for the returned Map
* is from-view-id, and the value is a List
* of navigation cases.
*
* @return Map the map of navigation mappings.
*/
public Map> getNavigationCaseListMappings() {
if (navigationMap == null) {
return Collections.emptyMap();
}
return navigationMap;
}
public ResourceBundle getResourceBundle(FacesContext context,
String var) {
ApplicationResourceBundle bundle = resourceBundles.get(var);
if (bundle == null) {
return null;
}
UIViewRoot root;
// Start out with the default locale
Locale locale;
Locale defaultLocale = Locale.getDefault();
locale = defaultLocale;
// See if this FacesContext has a ViewRoot
root = context.getViewRoot();
if (null != root) {
locale = root.getLocale();
if (null == root.getLocale()){
// If the ViewRoot has no Locale, fall back to the default.
locale = defaultLocale;
}
}
assert (null != locale);
//ResourceBundleBean bean = resourceBundles.get(var);
return bundle.getResourceBundle(locale);
}
/**
* keys: element from faces-config
*
* values: ResourceBundleBean instances.
*/
@SuppressWarnings({"CollectionWithoutInitialCapacity"})
Map resourceBundles =
new HashMap();
public void addResourceBundle(String var, ApplicationResourceBundle bundle) {
resourceBundles.put(var, bundle);
}
public Map getResourceBundles() {
return resourceBundles;
}
// This is called by ViewHandlerImpl.renderView().
public void responseRendered() {
responseRendered = true;
}
public boolean isResponseRendered() {
return responseRendered;
}
public boolean urlIsRelatedToDefiningDocumentInJar(URL candidateUrl, String definingDocumentId) {
boolean result = false;
String match = definingDocumentIdsToTruncatedJarUrls.get(definingDocumentId);
if (null != match) {
String candidate = candidateUrl.toExternalForm();
if (null != candidate && null != match) {
int i = candidate.lastIndexOf("/META-INF");
if (-1 == i) {
throw new FacesException("Invalid url for application configuration resources file with respect to faces flows");
}
candidate = candidate.substring(0, i);
result = candidate.equals(match);
}
}
return result;
}
public void relateUrlToDefiningDocumentInJar(URL url, String definingDocumentId) {
String candidate = url.toExternalForm();
int i = candidate.lastIndexOf("/META-INF");
if (-1 == i) {
return;
}
candidate = candidate.substring(0, i);
definingDocumentIdsToTruncatedJarUrls.put(definingDocumentId, candidate);
}
protected DefaultFaceletFactory createFaceletFactory(FacesContext ctx,
Compiler c, WebConfiguration webConfig) {
// refresh period
boolean isProduction = app.getProjectStage() == ProjectStage.Production;
String refreshPeriod;
if (webConfig.isSet(FaceletsDefaultRefreshPeriod) || webConfig.isSet(FaceletsDefaultRefreshPeriodDeprecated)) {
refreshPeriod = webConfig.getOptionValue(FaceletsDefaultRefreshPeriod);
} else if (isProduction) {
refreshPeriod = "-1";
} else {
refreshPeriod = FaceletsDefaultRefreshPeriod.getDefaultValue();
}
long period = Long.parseLong(refreshPeriod);
// resource resolver
ResourceResolver defaultResourceResolver = new DefaultResourceResolver(app.getResourceHandler());
ResourceResolver resolver = defaultResourceResolver;
String resolverName = webConfig.getOptionValue(FaceletsResourceResolver);
if (resolverName != null && resolverName.length() > 0) {
resolver = (ResourceResolver)
ReflectionUtil.decorateInstance(resolverName,
ResourceResolver.class,
resolver);
} else {
Set resourceResolvers =
ConfigManager.getAnnotatedClasses(ctx).get(FaceletsResourceResolver.class);
if ((null != resourceResolvers) && !resourceResolvers.isEmpty()) {
Class resolverClass = resourceResolvers.iterator().next();
if (1 < resourceResolvers.size() && LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "Found more than one class " +
"annotated with FaceletsResourceResolver. Will " +
"use {0} and ignore the others", resolverClass);
}
resolver = (ResourceResolver)
ReflectionUtil.decorateInstance(resolverClass,
ResourceResolver.class,
resolver);
}
}
// If our resourceResolver is not the one we created above
// and the use of this ResousrecResolver for Composite Components
// is acceptable.
if (!(resolver == defaultResourceResolver) && webConfig.isOptionEnabled(EnableFaceletsResourceResolverResolveCompositeComponents)) {
ctx.getExternalContext().getApplicationMap().put(DefaultResourceResolver.NON_DEFAULT_RESOURCE_RESOLVER_PARAM_NAME,
resolver);
}
FaceletCache cache = null;
String faceletCacheName = webConfig.getOptionValue(FaceletCache);
if (faceletCacheName != null && faceletCacheName.length() > 0) {
try {
com.sun.faces.facelets.FaceletCache privateApiCache =
(com.sun.faces.facelets.FaceletCache)ReflectionUtil.forName(faceletCacheName)
.newInstance();
cache = new PrivateApiFaceletCacheAdapter(privateApiCache);
} catch(ClassCastException e) {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO,
"Please remove context-param when using javax.faces.view.facelets.FaceletCache class with name:"
+ faceletCacheName + "and use the new FaceletCacheFactory API", e);
}
} catch(Exception e) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE,
"Error Loading Facelet cache: " + faceletCacheName,
e);
}
}
}
if (null == cache) {
FaceletCacheFactory cacheFactory = (FaceletCacheFactory)
FactoryFinder.getFactory(FactoryFinder.FACELET_CACHE_FACTORY);
cache = cacheFactory.getFaceletCache();
}
// Resource.getResourceUrl(ctx,"/")
DefaultFaceletFactory toReturn = new DefaultFaceletFactory();
toReturn.init(c, resolver, period, cache);
return toReturn;
}
protected Compiler createCompiler(Map appMap, WebConfiguration webConfig) {
Compiler c = new SAXCompiler();
// load decorators
String decParam = webConfig
.getOptionValue(FaceletsDecorators);
if (decParam != null) {
decParam = decParam.trim();
String[] decs = Util.split(appMap, decParam, ";");
TagDecorator decObj;
for (String decorator : decs) {
try {
decObj = (TagDecorator) ReflectionUtil.forName(decorator)
.newInstance();
c.addTagDecorator(decObj);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
"Successfully Loaded Decorator: {0}",
decorator);
}
} catch (Exception e) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE,
"Error Loading Decorator: " + decorator,
e);
}
}
}
}
// skip params?
c.setTrimmingComments(
webConfig.isOptionEnabled(
BooleanWebContextInitParameter.FaceletsSkipComments));
c.addTagLibrary(new CoreLibrary());
c.addTagLibrary(new CoreLibrary(CoreLibrary.XMLNSNamespace));
c.addTagLibrary(new HtmlLibrary());
c.addTagLibrary(new HtmlLibrary(HtmlLibrary.XMLNSNamespace));
c.addTagLibrary(new UILibrary());
c.addTagLibrary(new UILibrary(UILibrary.XMLNSNamespace));
c.addTagLibrary(new JstlCoreLibrary());
c.addTagLibrary(new JstlCoreLibrary(JstlCoreLibrary.IncorrectNamespace));
c.addTagLibrary(new JstlCoreLibrary(JstlCoreLibrary.XMLNSNamespace));
c.addTagLibrary(new PassThroughAttributeLibrary());
c.addTagLibrary(new PassThroughElementLibrary());
c.addTagLibrary(new FunctionLibrary(JstlFunction.class, FunctionLibrary.Namespace));
c.addTagLibrary(new FunctionLibrary(JstlFunction.class, FunctionLibrary.XMLNSNamespace));
if (isDevModeEnabled()) {
c.addTagLibrary(new FunctionLibrary(DevTools.class, DevTools.Namespace));
c.addTagLibrary(new FunctionLibrary(DevTools.class, DevTools.NewNamespace));
}
c.addTagLibrary(new CompositeLibrary());
c.addTagLibrary(new CompositeLibrary(CompositeLibrary.XMLNSNamespace));
return c;
}
}