JST array for templates

src/Cassette/Cassette.csproj

@@ -99,6 +99,10 @@
     <Compile Include="HostBase.cs" />
     <Compile Include="BundleCollection.cs" />
     <Compile Include="HtmlTemplates\AddHtmlTemplateToJavaScriptTransformers.cs" />
+    <Compile Include="HtmlTemplates\AddHtmlTemplateToJavaScriptArrayTransformers.cs" />
+    <Compile Include="HtmlTemplates\WrapJavaScriptArrayHtmlTemplatesTransformer.cs" />
+    <Compile Include="HtmlTemplates\WrapJavaScriptArrayHtmlTemplates.cs" />
+    <Compile Include="HtmlTemplates\JavaScriptArrayHtmlTemplatePipeline.cs" />
     <Compile Include="HtmlTemplates\HtmlTemplateBundleExtensions.cs" />
     <Compile Include="HtmlTemplates\WrapJavaScriptHtmlTemplates.cs" />
     <Compile Include="HtmlTemplates\IHtmlTemplateIdStrategy.cs" />

src/Cassette/HtmlTemplates/AddHtmlTemplateToJavaScriptArrayTransformers.cs

@@ -0,0 +1,35 @@
+using Cassette.BundleProcessing;
+
+namespace Cassette.HtmlTemplates
+{
+    public class AddHtmlTemplateToJavaScriptArrayTransformers : IBundleProcessor<HtmlTemplateBundle>
+    {
+        readonly HtmlTemplateToJavaScriptTransformer.Factory createTransformer;
+
+        /// <summary>
+        /// The name of the JavaScript variable to store compiled templates in.
+        /// For example, the default is "JST", so a template will be registered as <code>JST['my-template'] = ...;</code>.
+        /// </summary>
+        public string JavaScriptVariableName { get; set; }
+
+        public AddHtmlTemplateToJavaScriptArrayTransformers(HtmlTemplateToJavaScriptTransformer.Factory createTransformer)
+        {
+            this.createTransformer = createTransformer;
+        }
+
+        public void Process(HtmlTemplateBundle bundle)
+        {
+            var javaScriptVariableName = JavaScriptVariableName;
+            if(string.IsNullOrEmpty(javaScriptVariableName))
+            {
+                javaScriptVariableName = "JST";
+            }
+
+            var transformer = createTransformer(javaScriptVariableName + "[{0}]={1};", bundle);
+            foreach (var asset in bundle.Assets)
+            {
+                asset.AddAssetTransformer(transformer);
+            }
+        }
+    }
+}

src/Cassette/HtmlTemplates/JavaScriptArrayHtmlTemplatePipeline.cs

@@ -0,0 +1,86 @@
+using System;
+using Cassette.BundleProcessing;
+using Cassette.Scripts;
+using Cassette.TinyIoC;
+
+namespace Cassette.HtmlTemplates
+{
+    public class JavaScriptArrayHtmlTemplatePipeline : BundlePipeline<HtmlTemplateBundle>
+    {
+        readonly TinyIoCContainer container;
+        readonly CassetteSettings settings;
+        readonly string javaScriptVariableName;
+        readonly AddHtmlTemplateToJavaScriptArrayTransformers transformer;
+
+        public JavaScriptArrayHtmlTemplatePipeline(TinyIoCContainer container, CassetteSettings settings)
+            : this(container, settings, "JST")
+        {
+        }
+
+        public JavaScriptArrayHtmlTemplatePipeline(TinyIoCContainer container, CassetteSettings settings, string javascriptVariableName)
+            : base(container)
+        {
+            if (string.IsNullOrEmpty(javascriptVariableName))
+            {
+                throw new ArgumentNullException("javascriptVariableName");
+            }
+
+            this.container = container;
+            this.settings = settings;
+            this.javaScriptVariableName = javascriptVariableName;
+            this.transformer = container.Resolve<AddHtmlTemplateToJavaScriptArrayTransformers>();
+
+            BuildPipeline();
+        }
+
+        void BuildPipeline()
+        {
+            TransformHtmlTemplatesIntoJavaScript();
+            Concatenate();
+            WrapJavaScriptHtmlTemplates();
+            MinifyIfNotDebugging();
+            AssignContentType();
+            AssignHash();
+            AssignRenderer();
+        }
+
+        void TransformHtmlTemplatesIntoJavaScript()
+        {
+            transformer.JavaScriptVariableName = javaScriptVariableName;
+            Add(transformer);
+        }
+
+        void Concatenate()
+        {
+            Add(new ConcatenateAssets { Separator = Environment.NewLine });
+        }
+
+        void WrapJavaScriptHtmlTemplates()
+        {
+            Add(new WrapJavaScriptArrayHtmlTemplates(javaScriptVariableName));
+        }
+
+        void MinifyIfNotDebugging()
+        {
+            if (!settings.IsDebuggingEnabled)
+            {
+                Add(new MinifyAssets(container.Resolve<IJavaScriptMinifier>()));
+            }
+        }
+
+        void AssignContentType()
+        {
+            Add(new AssignContentType("text/javascript"));
+        }
+
+        void AssignHash()
+        {
+            Add(new AssignHash());
+        }
+
+        void AssignRenderer()
+        {
+            Add(new AssignHtmlTemplateRenderer(container.Resolve<RemoteHtmlTemplateBundleRenderer>()));
+        }
+    }
+}

src/Cassette/HtmlTemplates/WrapJavaScriptArrayHtmlTemplates.cs

@@ -0,0 +1,29 @@
+using System;
+using Cassette.BundleProcessing;
+
+namespace Cassette.HtmlTemplates
+{
+    public class WrapJavaScriptArrayHtmlTemplates : IBundleProcessor<HtmlTemplateBundle>
+    {
+        readonly string javaScriptVariableName;
+
+        public WrapJavaScriptArrayHtmlTemplates(string javaScriptVariableName)
+        {
+            if (string.IsNullOrEmpty(javaScriptVariableName))
+            {
+                javaScriptVariableName = "JST";
+            }
+
+            this.javaScriptVariableName = javaScriptVariableName;
+        }
+
+        public void Process(HtmlTemplateBundle bundle)
+        {
+            if (bundle.Assets.Count == 0) return;
+            if (bundle.Assets.Count > 1) throw new ArgumentException("WrapJavaScriptArrayHtmlTemplates should only process a bundle where the assets have been concatenated.", "bundle");
+
+            var transformer = new WrapJavaScriptArrayHtmlTemplatesTransformer(javaScriptVariableName);
+            bundle.Assets[0].AddAssetTransformer(transformer);
+        }
+    }
+}

src/Cassette/HtmlTemplates/WrapJavaScriptArrayHtmlTemplatesTransformer.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using System.Text;
+using Cassette.Utilities;
+
+namespace Cassette.HtmlTemplates
+{
+    public class WrapJavaScriptArrayHtmlTemplatesTransformer : IAssetTransformer
+    {
+        readonly string javascriptVariableName;
+
+        public WrapJavaScriptArrayHtmlTemplatesTransformer(string javascriptVariableName)
+        {
+            if (string.IsNullOrEmpty(javascriptVariableName))
+            {
+                javascriptVariableName = "JST";
+            }
+
+            this.javascriptVariableName = javascriptVariableName;
+        }
+
+        public Func<Stream> Transform(Func<Stream> openSourceStream, IAsset asset)
+        {
+            return () =>
+            {
+
+                var addTemplateCalls = openSourceStream().ReadToEnd();
+
+                var output = string.Format(@"window.{0}=window.{0} || {{}};
+{1}", javascriptVariableName, addTemplateCalls);
+
+                return new MemoryStream(Encoding.UTF8.GetBytes(output));
+            };
+        }
+    }
+}