Question

I was experimenting with Bundle and Minification in MVC4 and came across an interesting problem.
I am using Coffeescript and I would like a Render helper that works a bit like the @Scripts.Render() method.

For example, let’s say I have this bundle config:

new ScriptBundle("~/bundle/appfiles").Include(
    "~/Scripts/app/sample.js",
    "~/Scripts/app/myApp.js");

In the cshtml, when I do @Scripts.Render() I get different results based on the debug setting in the web.config. If debug is true I get one script tag per file, otherwise I get a single script tag that returns the bundled and minified js. This is fine.

Let-s assume now that I want to do the same with my Coffeescripts. I create a bundle like this:

new Bundle("~/bundle/appfiles", new CoffeeBundler(), new JsMinify()).Include(
    "~/Scripts/app/sample.coffee",
    "~/Scripts/app/myApp.coffee");

The problem now is that if I use @Scripts.Render() I get, while in debug, one script per file but this is not transformed at all. The only use I could do is this:

<script type="text/javascript" src="@(BundleTable.Bundles.ResolveBundleUrl("~/bundle/appfiles"))"></script>

But this will, even in debug mode, bundle everything together and then minify, which of course is not what I want.

I have tried to create a Coffee.Render() helper similar to the Scripts one but it uses the AssetManager class which is internal to the System.Web.Optimization assembly.

I was wondering if you have an idea on how to do this in a clean way (i.e: using the available public classes, not copying and pasting the whole AssetManager code, not doing fancy Directory.EnumerateFiles when creating the bundle).

Thanks!

PS: I know that a quicker solution would be to use Mindscape Workbench and bundle the generated js files, I am looking for something that uses what the framework has, maybe also avoiding to have to tell the team to install a tool that people may not like…

Answer 1

In the end I went for a HtmlHelper solution for this. Still in early stage but working as I would like. It is detailed in a blog post for the time being.

Here is the full Helper code in case the blog goes lost…

public static class HtmlHelperExtensions
{
    public static MvcHtmlString RenderCoffeeBundle(this HtmlHelper htmlHelper, string virtualPath)
    {
        if (String.IsNullOrEmpty(virtualPath))
            throw new ArgumentException("virtualPath must be defined", "virtualPath");

        var list = GetPathsList(virtualPath);

        //TODO: Nice and cleaner EliminateDuplicatesAndResolveUrls(list);

        var stringBuilder = new StringBuilder();
        foreach (string path in list)
        {
            stringBuilder.Append(RenderScriptTag(path));
            stringBuilder.Append(Environment.NewLine);
        }
        return MvcHtmlString.Create(stringBuilder.ToString());
    }

    private static IEnumerable<string> GetPathsList(string virtualPath)
    {
        var list = new List<string>();

        if (BundleResolver.Current.IsBundleVirtualPath(virtualPath))
        {
            if (!BundleTable.EnableOptimizations)
            {
                foreach (var path in BundleResolver.Current.GetBundleContents(virtualPath))
                {
                    var bundlePath = "~/autoBundle" + ResolveVirtualPath(path.Replace("coffee", "js"));
                    BundleTable.Bundles.Add(new Bundle(bundlePath, new CoffeeBundler()).Include(path));
                    // TODO: Get the actual CustomTransform used in the Bundle
                    // rather than forcing "new CoffeeBundler()" like here
                    list.Add(bundlePath);
                }
            }
            else
                list.Add(BundleResolver.Current.GetBundleUrl(virtualPath));
        }
        else
            list.Add(virtualPath);
        return list.Select(ResolveVirtualPath).ToList();
    }

    private static string RenderScriptTag(string path)
    {
        return "<script src=\"" + HttpUtility.UrlPathEncode(path) + "\"></script>";
    }

    private static string ResolveVirtualPath(string virtualPath)
    {
        return VirtualPathUtility.ToAbsolute(virtualPath);;
    }
}