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; }