// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.apache.tapestry5.internal.services.javascript;
import org.apache.tapestry5.SymbolConstants;
import org.apache.tapestry5.dom.Element;
import org.apache.tapestry5.internal.InternalConstants;
import org.apache.tapestry5.internal.services.assets.ResourceChangeTracker;
import org.apache.tapestry5.ioc.Messages;
import org.apache.tapestry5.ioc.Resource;
import org.apache.tapestry5.ioc.annotations.PostInjection;
import org.apache.tapestry5.ioc.annotations.Symbol;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.json.JSONArray;
import org.apache.tapestry5.json.JSONLiteral;
import org.apache.tapestry5.json.JSONObject;
import org.apache.tapestry5.services.AssetSource;
import org.apache.tapestry5.services.PathConstructor;
import org.apache.tapestry5.services.ResponseCompressionAnalyzer;
import org.apache.tapestry5.services.assets.StreamableResourceSource;
import org.apache.tapestry5.services.javascript.JavaScriptModuleConfiguration;
import org.apache.tapestry5.services.javascript.ModuleConfigurationCallback;
import org.apache.tapestry5.services.javascript.ModuleManager;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class ModuleManagerImpl implements ModuleManager
{
private final ResponseCompressionAnalyzer compressionAnalyzer;
private final Messages globalMessages;
private final boolean compactJSON;
private final Map<String, Resource> shimModuleNameToResource = CollectionFactory.newMap();
private final Resource classpathRoot;
private final Set<String> extensions;
// Note: ConcurrentHashMap does not support null as a value, alas. We use classpathRoot as a null.
private final Map<String, Resource> cache = CollectionFactory.newConcurrentMap();
private final JSONObject baseConfig;
private final String basePath, compressedBasePath;
public ModuleManagerImpl(ResponseCompressionAnalyzer compressionAnalyzer,
AssetSource assetSource,
Map<String, JavaScriptModuleConfiguration> configuration,
Messages globalMessages,
StreamableResourceSource streamableResourceSource,
@Symbol(SymbolConstants.COMPACT_JSON)
boolean compactJSON,
@Symbol(SymbolConstants.PRODUCTION_MODE)
boolean productionMode,
@Symbol(SymbolConstants.MODULE_PATH_PREFIX)
String modulePathPrefix,
PathConstructor pathConstructor)
{
this.compressionAnalyzer = compressionAnalyzer;
this.globalMessages = globalMessages;
this.compactJSON = compactJSON;
basePath = pathConstructor.constructClientPath(modulePathPrefix);
compressedBasePath = pathConstructor.constructClientPath(modulePathPrefix + ".gz");
classpathRoot = assetSource.resourceForPath("");
extensions = CollectionFactory.newSet("js");
extensions.addAll(streamableResourceSource.fileExtensionsForContentType(InternalConstants.JAVASCRIPT_CONTENT_TYPE));
baseConfig = buildBaseConfig(configuration, !productionMode);
}
private String buildRequireJSConfig(List<ModuleConfigurationCallback> callbacks)
{
// This is the part that can vary from one request to another, based on the capabilities of the client.
JSONObject config = baseConfig.copy().put("baseUrl", getBaseURL());
// TAP5-2196: allow changes to the configuration in a per-request basis.
for (ModuleConfigurationCallback callback : callbacks)
{
config = callback.configure(config);
assert config != null;
}
// This part gets written out before any libraries are loaded (including RequireJS).
return String.format("var require = %s;\n", config.toString(compactJSON));
}
private JSONObject buildBaseConfig(Map<String, JavaScriptModuleConfiguration> configuration, boolean devMode)
{
JSONObject config = new JSONObject();
// In DevMode, wait up to five minutes for a script, as the developer may be using the debugger.
if (devMode)
{
config.put("waitSeconds", 300);
}
for (String name : configuration.keySet())
{
JavaScriptModuleConfiguration module = configuration.get(name);
shimModuleNameToResource.put(name, module.resource);
// Some modules (particularly overrides) just need an alternate location for their content
// on the server.
if (module.getNeedsConfiguration())
{
// Others are libraries being shimmed as AMD modules, and need some configuration
// to ensure that everything hooks up properly on the client.
addModuleToConfig(config, name, module);
}
}
return config;
}
private String getBaseURL()
{
return compressionAnalyzer.isGZipSupported() ? compressedBasePath : basePath;
}
private void addModuleToConfig(JSONObject config, String name, JavaScriptModuleConfiguration module)
{
JSONObject shimConfig = config.in("shim");
boolean nestDependencies = false;
String exports = module.getExports();
if (exports != null)
{
shimConfig.in(name).put("exports", exports);
nestDependencies = true;
}
String initExpression = module.getInitExpression();
if (initExpression != null)
{
String function = String.format("function() { return %s; }", initExpression);
shimConfig.in(name).put("init", new JSONLiteral(function));
nestDependencies = true;
}
List<String> dependencies = module.getDependencies();
if (dependencies != null)
{
JSONObject container = nestDependencies ? shimConfig.in(name) : shimConfig;
String key = nestDependencies ? "deps" : name;
for (String dep : dependencies)
{
container.append(key, dep);
}
}
}
@PostInjection
public void setupInvalidation(ResourceChangeTracker tracker)
{
tracker.clearOnInvalidation(cache);
}
public void writeConfiguration(Element body,
List<ModuleConfigurationCallback> callbacks)
{
Element element = body.element("script", "type", "text/javascript");
// Build it each time because we don't know if the client supports GZip or not, and
// (in development mode) URLs for some referenced assets could change (due to URLs
// containing a checksum on the resource content).
element.raw(buildRequireJSConfig(callbacks));
}
public void writeInitialization(Element body, List<String> libraryURLs, List<?> inits)
{
Element element = body.element("script", "type", "text/javascript");
element.raw(globalMessages.format("private-core-page-initialization-template",
convert(libraryURLs),
convert(inits)));
}
private String convert(List<?> input)
{
return new JSONArray().putAll(input).toString(compactJSON);
}
public Resource findResourceForModule(String moduleName)
{
Resource resource = cache.get(moduleName);
if (resource == null)
{
resource = resolveModuleNameToResource(moduleName);
cache.put(moduleName, resource);
}
// We're treating classpathRoot as a placeholder for null.
return resource == classpathRoot ? null : resource;
}
private Resource resolveModuleNameToResource(String moduleName)
{
Resource resource = shimModuleNameToResource.get(moduleName);
if (resource != null)
{
return resource;
}
// Tack on a fake extension; otherwise modules whose name includes a '.' get mangled
// by Resource.withExtension().
String baseName = String.format("/META-INF/modules/%s.EXT", moduleName);
Resource baseResource = classpathRoot.forFile(baseName);
for (String extension : extensions)
{
resource = baseResource.withExtension(extension);
if (resource.exists())
{
return resource;
}
}
// Return placeholder for null:
return classpathRoot;
}
}