public static void ProcessBundle(string baseFolder, Bundle bundle)
{
StringBuilder sb = new StringBuilder();
List<string> inputFiles = new List<string>();
string ext = Path.GetExtension(bundle.OutputFileName);
// Support both directories and specific files
foreach (string input in bundle.InputFiles)
{
string fullPath = Path.Combine(baseFolder, input);
if (Directory.Exists(fullPath))
{
DirectoryInfo dir = new DirectoryInfo(fullPath);
var files = dir.GetFiles("*" + ext, SearchOption.TopDirectoryOnly);
inputFiles.AddRange(files.Select(f => f.FullName));
}
else
{
inputFiles.Add(fullPath);
}
}
foreach (string input in inputFiles)
{
string file = Path.Combine(baseFolder, input);
string content = File.ReadAllText(file);
sb.AppendLine(content);
}
bundle.Output = sb.ToString();
}
internal static string GetValue(Bundle bundle, string key)
{
if (bundle.Minify.ContainsKey(key))
return bundle.Minify[key].ToString();
return string.Empty;
}
public static MinificationResult MinifyBundle(Bundle bundle)
{
string file = bundle.OutputFileName;
string extension = Path.GetExtension(file).ToUpperInvariant();
MinificationResult result = null;
switch (extension)
{
case ".JS":
result = MinifyJavaScript(bundle);
break;
case ".CSS":
result = MinifyCss(bundle);
break;
case ".HTML":
case ".HTM":
result = MinifyHtml(bundle);
break;
}
if (result != null && result.HasErrors)
{
OnErrorMinifyingFile(result);
}
return result;
}
protected static void OnAfterWritingMinFile(string file, string minFile, Bundle bundle)
{
if (AfterWritingMinFile != null)
{
AfterWritingMinFile(null, new MinifyFileEventArgs(file, minFile, bundle));
}
}
protected void OnAfterBundling(Bundle bundle, string baseFolder, bool containsChanges)
{
if (AfterBundling != null)
{
AfterBundling(this, new BundleFileEventArgs(bundle.GetAbsoluteOutputFile(), bundle, baseFolder, containsChanges));
}
}
protected void OnAfterProcess(Bundle bundle, string baseFolder)
{
if (AfterProcess != null)
{
AfterProcess(this, new BundleFileEventArgs(bundle.GetAbsoluteOutputFile(), bundle, baseFolder));
}
}
protected static void OnBeforeWritingGzipFile(string minFile, string gzipFile, Bundle bundle)
{
if (BeforeWritingGzipFile != null)
{
BeforeWritingGzipFile(null, new MinifyFileEventArgs(minFile, gzipFile, bundle));
}
}
public static CodeSettings GetSettings(Bundle bundle)
{
CodeSettings settings = new CodeSettings();
settings.PreserveImportantComments = GetValue(bundle, "preserveImportantComments", true) == "True";
settings.TermSemicolons = GetValue(bundle, "termSemicolons", true) == "True";
if (GetValue(bundle, "renameLocals", true) == "False")
settings.LocalRenaming = LocalRenaming.KeepAll;
string evalTreatment = GetValue(bundle, "evalTreatment", "ignore");
if (evalTreatment == "ignore")
settings.EvalTreatment = EvalTreatment.Ignore;
else if (evalTreatment == "makeAllSafe")
settings.EvalTreatment = EvalTreatment.MakeAllSafe;
else if (evalTreatment == "makeImmediateSafe")
settings.EvalTreatment = EvalTreatment.MakeImmediateSafe;
string outputMode = GetValue(bundle, "outputMode", "singleLine");
if (outputMode == "multipleLines")
settings.OutputMode = OutputMode.MultipleLines;
else if (outputMode == "singleLine")
settings.OutputMode = OutputMode.SingleLine;
else if (outputMode == "none")
settings.OutputMode = OutputMode.None;
string indentSize = GetValue(bundle, "indentSize", 2);
int size;
if (int.TryParse(indentSize, out size))
settings.IndentSize = size;
return settings;
}
public static HtmlMinificationSettings GetSettings(Bundle bundle)
{
HtmlMinificationSettings settings = new HtmlMinificationSettings();
settings.RemoveOptionalEndTags = GetValue(bundle, "removeOptionalEndTags") == "True";
settings.RemoveRedundantAttributes = GetValue(bundle, "removeRedundantAttributes") == "True";
settings.CollapseBooleanAttributes = GetValue(bundle, "collapseBooleanAttributes") == "True";
settings.CustomAngularDirectiveList = GetValue(bundle, "customAngularDirectiveList");
settings.MinifyAngularBindingExpressions = GetValue(bundle, "minifyAngularBindingExpressions") == "True";
settings.MinifyEmbeddedCssCode = GetValue(bundle, "minifyEmbeddedCssCode") == "True";
settings.MinifyEmbeddedJsCode= GetValue(bundle, "minifyEmbeddedJsCode") == "True";
settings.MinifyInlineCssCode = GetValue(bundle, "minifyInlineCssCode") == "True";
settings.MinifyInlineJsCode = GetValue(bundle, "minifyInlineJsCode") == "True";
settings.MinifyKnockoutBindingExpressions = GetValue(bundle, "minifyKnockoutBindingExpressions") == "True";
settings.ProcessableScriptTypeList = GetValue(bundle, "processableScriptTypeList");
settings.RemoveHtmlComments = GetValue(bundle, "removeHtmlComments") == "True";
settings.RemoveTagsWithoutContent = GetValue(bundle, "removeTagsWithoutContent") == "True";
string quotes = GetValue(bundle, "attributeQuotesRemovalMode");
if (quotes == "html4")
settings.AttributeQuotesRemovalMode = HtmlAttributeQuotesRemovalMode.Html4;
else if (quotes == "html5")
settings.AttributeQuotesRemovalMode = HtmlAttributeQuotesRemovalMode.Html5;
else if (quotes == "keepQuotes")
settings.AttributeQuotesRemovalMode = HtmlAttributeQuotesRemovalMode.KeepQuotes;
return settings;
}
public BundleFileEventArgs(string outputFileName, Bundle bundle, string baseFolder, bool containsChanges)
{
ContainsChanges = containsChanges;
OutputFileName = outputFileName;
Bundle = bundle;
BaseFolder = baseFolder;
}
internal static string GetValue(Bundle bundle, string key, object defaultValue = null)
{
if (bundle.Minify.ContainsKey(key))
return bundle.Minify[key].ToString();
if (defaultValue != null)
return defaultValue.ToString();
return string.Empty;
}
private static Bundle CreateBundleFile(IEnumerable<string> files, string outputFile)
{
var bundle = new Bundle
{
IncludeInProject = true,
OutputFileName = outputFile
};
bundle.InputFiles.AddRange(files);
return bundle;
}
public void AddBundle(string configFile, Bundle bundle)
{
IEnumerable<Bundle> existing = GetBundles(configFile);
List<Bundle> bundles = new List<Bundle>();
bundles.AddRange(existing);
bundles.Add(bundle);
bundle.FileName = configFile;
string content = JsonConvert.SerializeObject(bundles, Formatting.Indented);
File.WriteAllText(configFile, content);
}
public static void RemoveBundle(string configFile, Bundle bundleToRemove)
{
IEnumerable<Bundle> bundles = GetBundles(configFile);
List<Bundle> newBundles = new List<Bundle>();
if (bundles.Contains(bundleToRemove))
{
newBundles.AddRange(bundles.Where(b => !b.Equals(bundleToRemove)));
string content = JsonConvert.SerializeObject(newBundles, Formatting.Indented);
File.WriteAllText(configFile, content);
}
}
public void AddBundles()
{
var bundle = new Bundle();
bundle.IncludeInProject = true;
bundle.OutputFileName = _guid + ".js";
bundle.InputFiles.AddRange(new[] { "file1.js", "file2.js" });
string filePath = "../../artifacts/" + _guid + ".json";
_bundler.AddBundle(filePath, bundle);
var bundles = BundleHandler.GetBundles(filePath);
Assert.AreEqual(1, bundles.Count());
}
internal static string GetValue(Bundle bundle, string key)
{
if (bundle.Minify.ContainsKey(key))
{
object value = bundle.Minify[key];
if (value is JArray)
{
return string.Join(",", ((JArray)value).Values<string>());
}
else
{
return value.ToString();
}
}
return string.Empty;
}
public static void AddBundle(string configFile, Bundle bundle)
{
IEnumerable<Bundle> existing = GetBundles(configFile);
List<Bundle> bundles = new List<Bundle>();
bundles.AddRange(existing);
bundles.Add(bundle);
bundle.FileName = configFile;
JsonSerializerSettings settings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
DefaultValueHandling = DefaultValueHandling.Ignore,
};
string content = JsonConvert.SerializeObject(bundles, settings);
File.WriteAllText(configFile, content);
}
public static CssSettings GetSettings(Bundle bundle)
{
CssSettings settings = new CssSettings();
settings.TermSemicolons = GetValue(bundle, "termSemicolons") == "true";
string cssComment = GetValue(bundle, "commentMode");
if (cssComment == "hacks")
settings.CommentMode = CssComment.Hacks;
else if (cssComment == "important")
settings.CommentMode = CssComment.Important;
else if (cssComment == "none")
settings.CommentMode = CssComment.None;
else if (cssComment == "all")
settings.CommentMode = CssComment.All;
string colorNames = GetValue(bundle, "colorNames");
if (colorNames == "hex")
settings.ColorNames = CssColor.Hex;
else if (colorNames == "major")
settings.ColorNames = CssColor.Major;
else if (colorNames == "noSwap")
settings.ColorNames = CssColor.NoSwap;
else if (colorNames == "strict")
settings.ColorNames = CssColor.Strict;
string outputMode = GetValue(bundle, "outputMode");
if (outputMode == "multipleLines")
settings.OutputMode = OutputMode.MultipleLines;
else if (outputMode == "singleLine")
settings.OutputMode = OutputMode.SingleLine;
else if (outputMode == "none")
settings.OutputMode = OutputMode.None;
string indentSize = GetValue(bundle, "indentSize");
int size;
if (int.TryParse(indentSize, out size))
settings.IndentSize = size;
return settings;
}
public static void ProcessBundle(string baseFolder, Bundle bundle)
{
StringBuilder sb = new StringBuilder();
List<string> inputFiles = bundle.GetAbsoluteInputFiles();
//string ext = Path.GetExtension(bundle.OutputFileName);
// Support both directories and specific files
//foreach (string input in bundle.InputFiles)
//{
// string fullPath = Path.Combine(baseFolder, input);
// if (Directory.Exists(fullPath))
// {
// DirectoryInfo dir = new DirectoryInfo(fullPath);
// SearchOption search = bundle.Recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
// var files = dir.GetFiles("*" + ext, search);
// inputFiles.AddRange(files.Select(f => f.FullName));
// }
//}
foreach (string input in inputFiles)
{
string file = Path.Combine(baseFolder, input);
string content;
if (input.EndsWith(".css", System.StringComparison.OrdinalIgnoreCase) && AdjustRelativePaths(bundle))
{
content = CssRelativePath.Adjust(file, bundle.GetAbsoluteOutputFile());
}
else
{
content = BundleMinifier.ReadAllText(file);
}
sb.AppendLine(content);
}
bundle.Output = sb.ToString().Trim();
}
public BundleFileEventArgs(string outputFileName, Bundle bundle, string baseFolder)
{
OutputFileName = outputFileName;
Bundle = bundle;
BaseFolder = baseFolder;
}
private void ProcessBundle(string baseFolder, Bundle bundle)
{
BundleHandler.ProcessBundle(baseFolder, bundle);
string outputFile = Path.Combine(baseFolder, bundle.OutputFileName);
OnBeforeProcess(bundle, baseFolder);
DirectoryInfo outputFileDirectory = Directory.GetParent(outputFile);
outputFileDirectory.Create();
File.WriteAllText(outputFile, bundle.Output, new UTF8Encoding(true));
OnAfterProcess(bundle, baseFolder);
if (bundle.Minify.ContainsKey("enabled") && bundle.Minify["enabled"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase))
{
var result = BundleMinifier.MinifyBundle(bundle);
if (result != null && bundle.SourceMaps && !string.IsNullOrEmpty(result.SourceMap))
{
string minFile = FileMinifier.GetMinFileName(bundle.GetAbsoluteOutputFile());
string mapFile = minFile + ".map";
OnBeforeWritingSourceMap(minFile, mapFile);
File.WriteAllText(mapFile, result.SourceMap, new UTF8Encoding(true));
OnAfterWritingSourceMap(minFile, mapFile);
}
}
}
private static bool AdjustRelativePaths(Bundle bundle)
{
if (!bundle.Minify.ContainsKey("adjustRelativePaths"))
return true;
return bundle.Minify["adjustRelativePaths"].ToString() == "True";
}
protected void OnProcessing(Bundle bundle, string baseFolder)
{
if (Processing != null)
{
Processing(this, new BundleFileEventArgs(bundle.GetAbsoluteOutputFile(), bundle, baseFolder, false));
}
}
private void ProcessBundle(string baseFolder, Bundle bundle)
{
OnProcessing(bundle, baseFolder);
if (bundle.GetAbsoluteInputFiles().Count > 1 || bundle.InputFiles.FirstOrDefault() != bundle.OutputFileName)
{
BundleHandler.ProcessBundle(baseFolder, bundle);
string outputFile = Path.Combine(baseFolder, bundle.OutputFileName);
bool containsChanges = FileHelpers.HasFileContentChanged(outputFile, bundle.Output);
if (containsChanges)
{
DirectoryInfo outputFileDirectory = Directory.GetParent(outputFile);
outputFileDirectory.Create();
File.WriteAllText(outputFile, bundle.Output, new UTF8Encoding(false));
}
OnAfterBundling(bundle, baseFolder, containsChanges);
}
if (bundle.Minify.ContainsKey("enabled") && bundle.Minify["enabled"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase))
{
var result = BundleMinifier.MinifyBundle(bundle);
if (result != null && bundle.SourceMap && !string.IsNullOrEmpty(result.SourceMap))
{
string minFile = GetMinFileName(bundle.GetAbsoluteOutputFile());
string mapFile = minFile + ".map";
bool smChanges = FileHelpers.HasFileContentChanged(mapFile, result.SourceMap);
OnBeforeWritingSourceMap(minFile, mapFile, smChanges);
if (smChanges)
{
File.WriteAllText(mapFile, result.SourceMap, new UTF8Encoding(false));
}
OnAfterWritingSourceMap(minFile, mapFile, smChanges);
}
}
}
private static MinificationResult MinifyJavaScript(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
var settings = JavaScriptOptions.GetSettings(bundle);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!bundle.SourceMaps)
{
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
minifier.FileName = file;
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
result.SourceMap = writer.ToString();
}
}
GzipFile(minFile, bundle);
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return result;
}
private static MinificationResult MinifyHtml(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = File.ReadAllText(file);
var settings = HtmlOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new HtmlMinifier(settings);
var minResult = new MinificationResult(file, null, null);
try
{
MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true);
minResult.MinifiedContent = result.MinifiedContent;
if (!result.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
GzipFile(minFile, bundle);
}
else
{
foreach (var error in result.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.LineNumber,
ColumnNumber = error.ColumnNumber
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return minResult;
}
private static MinificationResult MinifyCss(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = File.ReadAllText(file);
var settings = CssOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
try
{
result.MinifiedContent = minifier.MinifyStyleSheet(content, settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
GzipFile(minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return result;
}
private static void GzipFile(string sourceFile, Bundle bundle)
{
if (!bundle.Minify.ContainsKey("gzip") || !bundle.Minify["gzip"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase))
return;
var gzipFile = sourceFile + ".gz";
OnBeforeWritingGzipFile(sourceFile, gzipFile, bundle);
using (var sourceStream = File.OpenRead(sourceFile))
using (var targetStream = File.OpenWrite(gzipFile))
using (var gzipStream = new GZipStream(targetStream, CompressionMode.Compress))
sourceStream.CopyTo(gzipStream);
OnAfterWritingGzipFile(sourceFile, gzipFile, bundle);
}
private string GetBundle(string[] inputFiles, string type)
{
var bundleFileProcessor = new BundleFileProcessor();
var bundle = new BundlerMinifier.Bundle();
//we wil store the file names with date of modification to keep track whether a new bundle should be generated or not
//any minor modification will cause regeneration of the bundle
//we do this because it is a performance intensive operation and the we should only do it when needed
var distinctFiles = inputFiles.Distinct().ToList();
var fileNamesWithDates = new List <string>();
foreach (var inputFile in distinctFiles)
{
//the input file can either be 1. theme-css 2. plugin-css 3. admin-css 4. common-css
//check them one by one
var file = ServerHelper.MapPath("~/Content/Themes" + inputFile);
if (!_localFileProvider.FileExists(file))
{
//plugins
file = ServerHelper.MapPath("~/" + inputFile);
if (!_localFileProvider.FileExists(file))
{
//administration & common
file = ServerHelper.MapPath("~/" + inputFile, true);
if (!_localFileProvider.FileExists(file))
{
continue; //can't do anything...the file doesn't exist
}
}
}
bundle.InputFiles.Add(file);
var modDate = _localFileProvider.GetLastModifiedDateTime(file);
fileNamesWithDates.Add($"{file}:{modDate}");
}
var outputFilePart1 = GetOutputFileName(fileNamesWithDates);
var outputFilePart2 = GetOutputFileName(distinctFiles);
var outputFile = outputFilePart1 + "_" + outputFilePart2;
var bundlesDirectory = ServerHelper.MapPath(ApplicationConfig.BundlesDirectory, true);
var bundleFileName = bundlesDirectory + "/" + outputFile + $".min.{type}";
bundle.OutputFileName = bundleFileName;
//do we need to generate the bundle?
if (!_localFileProvider.FileExists(bundleFileName))
{
//delete the existing bundles of these files
try
{
_localFileProvider.DeleteFiles(bundlesDirectory, $"*_{outputFilePart2}.min.{type}*");
}
catch
{
//do nothing...the file must be locked...will try next time
}
bundle.FileName = bundleFileName + ".json";
BundleMinifier.ErrorMinifyingFile += BundleMinifier_ErrorMinifyingFile;
bundleFileProcessor.Process(bundle.FileName, new List <BundlerMinifier.Bundle>()
{
bundle
});
}
//if operation succeeded, return the url, else null
if (bundle.OutputFileName == null)
{
return(null);
}
//also create a gzipped version as well
using (var bundleFileStream = File.OpenRead(bundleFileName))
using (var compressedFileStream = File.Create(bundleFileName + ".gz"))
{
using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress))
{
bundleFileStream.CopyTo(compressionStream);
}
}
return(bundle.OutputFileName == null ? null : ApplicationEngine.MapUrl(bundleFileName));
}
public MinifyFileEventArgs(string originalFile, string resultFile, Bundle bundle, bool containsChanges)
: this(originalFile, resultFile, containsChanges)
{
Bundle = bundle;
}
