001// Licensed under the Apache License, Version 2.0 (the "License");
002// you may not use this file except in compliance with the License.
003// You may obtain a copy of the License at
004//
005// http://www.apache.org/licenses/LICENSE-2.0
006//
007// Unless required by applicable law or agreed to in writing, software
008// distributed under the License is distributed on an "AS IS" BASIS,
009// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
010// See the License for the specific language governing permissions and
011// limitations under the License.
012
013package org.apache.tapestry5.internal.services.assets;
014
015import org.apache.tapestry5.Asset;
016import org.apache.tapestry5.ContentType;
017import org.apache.tapestry5.SymbolConstants;
018import org.apache.tapestry5.ioc.Resource;
019import org.apache.tapestry5.ioc.annotations.Symbol;
020import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
021import org.apache.tapestry5.ioc.services.ThreadLocale;
022import org.apache.tapestry5.services.assets.*;
023import org.apache.tapestry5.services.javascript.JavaScriptStack;
024import org.apache.tapestry5.services.javascript.JavaScriptStackSource;
025import org.apache.tapestry5.services.javascript.JavaScriptAggregationStrategy;
026import org.apache.tapestry5.services.javascript.ModuleManager;
027
028import java.io.*;
029import java.util.Collections;
030import java.util.List;
031import java.util.Locale;
032import java.util.Map;
033import java.util.regex.Pattern;
034
035public class JavaScriptStackAssemblerImpl implements JavaScriptStackAssembler
036{
037    private static final ContentType JAVASCRIPT_CONTENT_TYPE = new ContentType("text/javascript;charset=utf-8");
038
039    private final ThreadLocale threadLocale;
040
041    private final ResourceChangeTracker resourceChangeTracker;
042
043    private final StreamableResourceSource streamableResourceSource;
044
045    private final JavaScriptStackSource stackSource;
046
047    private final AssetChecksumGenerator checksumGenerator;
048
049    private final ModuleManager moduleManager;
050
051    private final ResourceMinimizer resourceMinimizer;
052
053    private final boolean minificationEnabled;
054
055    private final Map<String, StreamableResource> cache = Collections.synchronizedMap(CollectionFactory.<StreamableResource>newCaseInsensitiveMap());
056
057    private class Parameters
058    {
059        final Locale locale;
060
061        final String stackName;
062
063        final boolean compress;
064
065        final JavaScriptAggregationStrategy javascriptAggregationStrategy;
066
067        private Parameters(Locale locale, String stackName, boolean compress, JavaScriptAggregationStrategy javascriptAggregationStrategy)
068        {
069            this.locale = locale;
070            this.stackName = stackName;
071            this.compress = compress;
072            this.javascriptAggregationStrategy = javascriptAggregationStrategy;
073        }
074
075        Parameters disableCompress()
076        {
077            return new Parameters(locale, stackName, false, javascriptAggregationStrategy);
078        }
079    }
080
081    // TODO: Support for aggregated CSS as well as aggregated JavaScript
082
083    public JavaScriptStackAssemblerImpl(ThreadLocale threadLocale, ResourceChangeTracker resourceChangeTracker, StreamableResourceSource streamableResourceSource,
084                                        JavaScriptStackSource stackSource, AssetChecksumGenerator checksumGenerator, ModuleManager moduleManager,
085                                        ResourceMinimizer resourceMinimizer,
086                                        @Symbol(SymbolConstants.MINIFICATION_ENABLED)
087                                        boolean minificationEnabled)
088    {
089        this.threadLocale = threadLocale;
090        this.resourceChangeTracker = resourceChangeTracker;
091        this.streamableResourceSource = streamableResourceSource;
092        this.stackSource = stackSource;
093        this.checksumGenerator = checksumGenerator;
094        this.moduleManager = moduleManager;
095        this.resourceMinimizer = resourceMinimizer;
096        this.minificationEnabled = minificationEnabled;
097
098        resourceChangeTracker.clearOnInvalidation(cache);
099    }
100
101    public StreamableResource assembleJavaScriptResourceForStack(String stackName, boolean compress, JavaScriptAggregationStrategy javascriptAggregationStrategy) throws IOException
102    {
103        Locale locale = threadLocale.getLocale();
104
105        return assembleJavascriptResourceForStack(new Parameters(locale, stackName, compress, javascriptAggregationStrategy));
106    }
107
108    private StreamableResource assembleJavascriptResourceForStack(Parameters parameters) throws IOException
109    {
110        String key =
111                String.format("%s[%s] %s",
112                        parameters.stackName,
113                        parameters.compress ? "COMPRESS" : "UNCOMPRESSED",
114                        parameters.locale.toString());
115
116        StreamableResource result = cache.get(key);
117
118        if (result == null)
119        {
120            result = assemble(parameters);
121            cache.put(key, result);
122        }
123
124        return result;
125    }
126
127    private StreamableResource assemble(Parameters parameters) throws IOException
128    {
129        if (parameters.compress)
130        {
131            StreamableResource uncompressed = assembleJavascriptResourceForStack(parameters.disableCompress());
132
133            return new CompressedStreamableResource(uncompressed, checksumGenerator);
134        }
135
136        JavaScriptStack stack = stackSource.getStack(parameters.stackName);
137
138        return assembleStreamableForStack(parameters.locale.toString(), parameters, stack.getJavaScriptLibraries(), stack.getModules());
139    }
140
141    interface StreamableReader
142    {
143        /**
144         * Reads the content of a StreamableResource as a UTF-8 string, and optionally transforms it in some way.
145         */
146        String read(StreamableResource resource) throws IOException;
147    }
148
149    static String getContent(StreamableResource resource) throws IOException
150    {
151        final ByteArrayOutputStream bos = new ByteArrayOutputStream(resource.getSize());
152        resource.streamTo(bos);
153
154        return new String(bos.toByteArray(), "UTF-8");
155    }
156
157
158    final StreamableReader libraryReader = new StreamableReader()
159    {
160        public String read(StreamableResource resource) throws IOException
161        {
162            return getContent(resource);
163        }
164    };
165
166    private final static Pattern DEFINE = Pattern.compile("\\bdefine\\s*\\((?!\\s*['\"])");
167
168    private static class ModuleReader implements StreamableReader
169    {
170        final String moduleName;
171
172        private ModuleReader(String moduleName)
173        {
174            this.moduleName = moduleName;
175        }
176
177        public String read(StreamableResource resource) throws IOException
178        {
179            String content = getContent(resource);
180
181            return transform(content);
182        }
183
184        public String transform(String moduleContent)
185        {
186            return DEFINE.matcher(moduleContent).replaceFirst("define(\"" + moduleName + "\",");
187        }
188    }
189
190
191    private class Assembly
192    {
193        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(2000);
194        final PrintWriter writer;
195        long lastModified = 0;
196        final StringBuilder description;
197        private String sep = "";
198
199        private Assembly(String description) throws UnsupportedEncodingException
200        {
201            writer = new PrintWriter(new OutputStreamWriter(outputStream, "UTF-8"));
202
203            this.description = new StringBuilder(description);
204        }
205
206        void add(Resource resource, StreamableReader reader) throws IOException
207        {
208            writer.format("\n/* %s */;\n", resource.toString());
209
210            description.append(sep).append(resource.toString());
211            sep = ", ";
212
213            StreamableResource streamable = streamableResourceSource.getStreamableResource(resource,
214                    StreamableResourceProcessing.FOR_AGGREGATION, resourceChangeTracker);
215
216            writer.print(reader.read(streamable));
217
218            lastModified = Math.max(lastModified, streamable.getLastModified());
219        }
220
221        StreamableResource finish()
222        {
223            writer.close();
224
225            return new StreamableResourceImpl(
226                    description.toString(),
227                    JAVASCRIPT_CONTENT_TYPE, CompressionStatus.COMPRESSABLE, lastModified,
228                    new BytestreamCache(outputStream), checksumGenerator, null);
229        }
230    }
231
232    private StreamableResource assembleStreamableForStack(String localeName, Parameters parameters,
233                                                          List<Asset> libraries, List<String> moduleNames) throws IOException
234    {
235        Assembly assembly = new Assembly(String.format("'%s' JavaScript stack, for locale %s, resources=", parameters.stackName, localeName));
236
237        for (Asset library : libraries)
238        {
239            Resource resource = library.getResource();
240
241            assembly.add(resource, libraryReader);
242        }
243
244        for (String moduleName : moduleNames)
245        {
246            Resource resource = moduleManager.findResourceForModule(moduleName);
247
248            if (resource == null)
249            {
250                throw new IllegalArgumentException(String.format("Could not identify a resource for module name '%s'.", moduleName));
251            }
252
253            assembly.add(resource, new ModuleReader(moduleName));
254        }
255
256        StreamableResource streamable = assembly.finish();
257
258        if (minificationEnabled && parameters.javascriptAggregationStrategy.enablesMinimize())
259        {
260            return resourceMinimizer.minimize(streamable);
261        }
262
263        return streamable;
264    }
265}