public BundleResult Bundle(IBundlerContext context)
{
Logger.LogInformation($"Bundling {context.BundleRelativePath} ({context.ContentFiles.Count} files)");
var sb = new StringBuilder();
Logger.LogDebug("Bundle files:");
foreach (var file in context.ContentFiles)
{
var fileContent = GetFileContent(context, file);
Logger.LogDebug($"- {file} ({fileContent.Length} bytes)");
sb.AppendLine(fileContent);
}
var bundleContent = sb.ToString();
if (context.IsMinificationEnabled)
{
Logger.LogInformation($"Minifying {context.BundleRelativePath} ({bundleContent.Length} bytes)");
bundleContent = Minifier.Minify(bundleContent, context.BundleRelativePath);
}
Logger.LogInformation($"Bundled {context.BundleRelativePath} ({bundleContent.Length} bytes)");
return(new BundleResult(bundleContent));
}
public virtual void Process()
{
if (!File.Exists(_file_name))
{
Console.WriteLine("文件:{0}不存在", _file_name);
}
Minifier minifier = new Minifier();
CodeSettings settings = new CodeSettings();
settings.EvalTreatment = EvalTreatment.MakeAllSafe;
settings.PreserveImportantComments = false;
string content = File.ReadAllText(_file_name);
string str = minifier.MinifyJavaScript(content, settings);
if (minifier.ErrorList != null && minifier.ErrorList.Count > 0)
{
str = GenerateErrorResponse(content, minifier.ErrorList);
}
string new_file_name = _file_name.Substring(0, _file_name.LastIndexOf('.')) + ".min.js";
File.WriteAllText(new_file_name, str);
Console.WriteLine("成功将文件:{0}进行压缩,输出文件为:{1}", _file_name, new_file_name);
}
public static IHtmlString CssMinify(this HtmlHelper helper, Func <ViewContext, HelperResult> markup)
{
if (helper == null)
{
throw new ArgumentNullException("helper");
}
if (markup == null)
{
return(MvcHtmlString.Empty);
}
var result = markup.Invoke(helper.ViewContext);
if (!BundleTable.EnableOptimizations)
{
return(result);
}
var sourceCss = result.ToString();
var minifier = new Minifier();
var minifiedCss = minifier.MinifyStyleSheet(sourceCss, new CssSettings
{
CommentMode = CssComment.None
});
return(new MvcHtmlString(minifiedCss));
}
private static void OutputHubs(string path, string url, string outputPath, bool minify)
{
path = path ?? Directory.GetCurrentDirectory();
url = url ?? "/signalr";
var assemblies = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
var tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Console.WriteLine("Creating temp directory {0}", tempPath);
Directory.CreateDirectory(tempPath);
// Copy all assemblies to temp
foreach (var assemblyPath in assemblies)
{
Copy(assemblyPath, tempPath);
}
Copy(typeof(Program).Assembly.Location, tempPath);
var setup = new AppDomainSetup
{
ApplicationBase = tempPath
};
var domain = AppDomain.CreateDomain("hubs", AppDomain.CurrentDomain.Evidence, setup);
var minifier = new Minifier();
var generator = (JavascriptGenerator)domain.CreateInstanceAndUnwrap(typeof(Program).Assembly.FullName,
typeof(JavascriptGenerator).FullName);
var js = generator.GenerateProxy(path, url);
Generate(outputPath, minify, minifier, js);
}
public static IHtmlString JsMinify(this HtmlHelper helper, Func <ViewContext, HelperResult> markup)
{
if (helper == null)
{
throw new ArgumentNullException("helper");
}
if (markup == null)
{
return(MvcHtmlString.Empty);
}
var result = markup.Invoke(helper.ViewContext);
if (!BundleTable.EnableOptimizations)
{
return(result);
}
string sourceJs = result.ToString();
var minifier = new Minifier();
var minifiedJs = minifier.MinifyJavaScript(sourceJs, new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
});
return(new MvcHtmlString(minifiedJs));
}
/// <summary>
/// Minifies the specified CSS.
/// </summary>
/// <param name="resource">The CSS to minify.</param>
/// <returns>The minified CSS, if minification was successful; otherwise, the original CSS with minification errors appended at the end.</returns>
public string Minify(string resource)
{
if (String.IsNullOrEmpty(resource))
{
return(resource);
}
var settings = new CssSettings
{
AllowEmbeddedAspNetBlocks = false
};
var minifier = new Minifier();
try
{
resource = minifier.MinifyStyleSheet(resource, settings);
}
catch
{
var minificationErrors = String.Join(Environment.NewLine, minifier.Errors);
resource = AppendMinificationErrors(resource, minificationErrors);
if (mLogErrors)
{
CoreServices.EventLog.LogEvent("W", "Resource minification", "CssMinificationFailed", minificationErrors);
}
}
return(resource);
}
public MinifierManager(CommandLineOptions cmdLineOptions)
: base(cmdLineOptions)
{
_minifier = new Minifier();
SetupDependencies();
StartListener();
}
public void Process(BundleContext context, BundleResponse response)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
if (!context.EnableInstrumentation)
{
Minifier minifier = new Minifier();
CodeSettings codeSettings = new CodeSettings
{
EvalTreatment = EvalTreatment.Ignore,
PreserveImportantComments = false
};
string str = minifier.MinifyJavaScript(response.Content, codeSettings);
if (minifier.ErrorList.Count == 0)
{
response.Content = str;
}
}
response.ContentType = "text/javascript";
}
public static string RequireScriptBlock(this HtmlHelper htmlHelper, string source, int priority = 1)
{
var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as List <PartialScriptInclude>;
if (requiredScripts == null)
{
HttpContext.Current.Items["RequiredScripts"] = requiredScripts = new List <PartialScriptInclude>();
}
Minifier minifier = new Minifier();
string minified = minifier.MinifyJavaScript(source);
if (minifier.Errors.Count > 0)
{
return(null);
}
if (requiredScripts.All(i => i.Source != minified))
{
requiredScripts.Add(new PartialScriptInclude()
{
Source = minified, Priority = priority
});
}
return(null);
}
public void IncrementPlus()
{
var minifier = new Minifier(new MinifierOptions {
LocalVarsCompressing = false
});
var testCode =
@"public class Test
{
public void Main()
{
int x = 1;
int y = 2;
int z1 = y + ++x;
int z2 = y + --x;
int z3 = y - ++x;
int z4 = y - --x;
}
}";
var minified = minifier.MinifyFromString(testCode);
Assert.IsTrue(minified.Contains("int z1=y+ ++x"));
Assert.IsTrue(minified.Contains("int z2=y+--x"));
Assert.IsTrue(minified.Contains("int z3=y-++x"));
Assert.IsTrue(minified.Contains("int z4=y- --x"));
}
private static void MinifyFile(string file, string minFile, CodeSettings settings, bool isBundle)
{
Minifier minifier = new Minifier();
if (!isBundle)
{
minifier.FileName = Path.GetFileName(file);
}
string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps))
{
content += Environment.NewLine + "//@ sourceMappingURL=" + Path.GetFileName(minFile) + ".map";
}
ProjectHelpers.CheckOutFileFromSourceControl(minFile);
using (StreamWriter writer = new StreamWriter(minFile, false, new UTF8Encoding(true)))
{
writer.Write(content);
}
if (WESettings.GetBoolean(WESettings.Keys.JavaScriptEnableGzipping))
{
CssSaveListener.GzipFile(file, minFile, content);
}
}
/// <summary>
/// Minifies the supplied CSS bundle and sets the Http content-type header to 'text/css'
/// </summary>
/// <param name="context">The <see cref="BundleContext"/> object that contains state for both the framework configuration and the HTTP request.</param>
/// <param name="response">A <see cref="BundleResponse"/> object containing the bundle contents.</param>
public virtual void Process(BundleContext context, BundleResponse response)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
// Don't minify in Instrumentation mode
if (!context.EnableInstrumentation)
{
Minifier min = new Minifier();
string minifiedCss = min.MinifyStyleSheet(response.Content, new CssSettings()
{
CommentMode = CssComment.None
});
if (min.ErrorList.Count > 0)
{
JsMinify.GenerateErrorResponse(response, min.ErrorList);
}
else
{
response.Content = minifiedCss;
}
}
response.ContentType = CssContentType;
}
private static MinificationResult MinifyCss(Config config, string file)
{
string content = File.ReadAllText(file);
var settings = CssOptions.GetSettings(config);
if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
var minifier = new Minifier();
// Remove control characters which AjaxMin can't handle
content = Regex.Replace(content, @"[\u0000-\u0009\u000B-\u000C\u000E-\u001F]", string.Empty);
string result = minifier.MinifyStyleSheet(content, settings);
string minFile = GetMinFileName(file);
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result);
OnBeforeWritingMinFile(file, minFile, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, result, new UTF8Encoding(true));
}
OnAfterWritingMinFile(file, minFile, containsChanges);
GzipFile(config, minFile, containsChanges);
return(new MinificationResult(result, null));
}
public static string MinifyString(string extension, string content)
{
if (extension == ".css")
{
Minifier minifier = new Minifier();
CssSettings settings = new CssSettings();
settings.CommentMode = CssComment.None;
if (WESettings.GetBoolean(WESettings.Keys.KeepImportantComments))
{
settings.CommentMode = CssComment.Important;
}
return(minifier.MinifyStyleSheet(content, settings));
}
else if (extension == ".js")
{
Minifier minifier = new Minifier();
CodeSettings settings = new CodeSettings()
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = WESettings.GetBoolean(WESettings.Keys.KeepImportantComments)
};
return(minifier.MinifyJavaScript(content, settings));
}
return(null);
}
protected override sealed void OnFileChanged(FileSystemEventArgs e)
{
if (Path.GetExtension(e.FullPath) == ".js")
{
Console.WriteLine($"ts watcher changed: {e.FullPath}");
}
if (!Path.GetFileNameWithoutExtension(e.FullPath).EndsWith(".vue"))
{
var originalFile = GetOriginalFilePath(e.FullPath);
if (!File.Exists(originalFile))
{
return;
}
builder.WriteInfo($"[{Name}] {Path.GetFileName(originalFile)} changed.");
var content = File.ReadAllText(e.FullPath);
cache.AddCache(originalFile);
cache.SaveCache();
var minFile = ResourceMinifier.GetMinimizedFileName(e.FullPath);
File.WriteAllText(minFile, Minifier.Minify(PostBuild(content)));
builder.UpdateCachedMinFile(minFile);
if (e.Name.Contains("dark-slice"))
{
builder.BuildDarkStyles();
}
}
}
private static MinificationResult MinifyJavaScript(Config config, string file)
{
string content = File.ReadAllText(file);
var settings = JavaScriptOptions.GetSettings(config);
if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
var minifier = new Minifier();
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
string result = minifier.MinifyJavaScript(content, settings);
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result);
if (!string.IsNullOrEmpty(result))
{
OnBeforeWritingMinFile(file, minFile, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, result, new UTF8Encoding(true));
}
OnAfterWritingMinFile(file, minFile, containsChanges);
GzipFile(config, minFile, containsChanges);
}
return(new MinificationResult(result, null));
}
public virtual void Process()
{
if (!File.Exists(_file_name))
{
Console.WriteLine("文件:{0}不存在", _file_name);
}
Minifier minifier = new Minifier();
CssSettings settings = new CssSettings();
settings.CommentMode = CssComment.None;
string content = File.ReadAllText(_file_name);
string str = minifier.MinifyStyleSheet(content, settings);
if (minifier.ErrorList.Count > 0)
{
this.GenerateErrorResponse(content, minifier.ErrorList);
}
string new_file_name = _file_name.Substring(0, _file_name.LastIndexOf('.')) + ".min.css";
File.WriteAllText(new_file_name, str);
Console.WriteLine("成功将文件:{0}进行压缩,输出文件为:{1}", _file_name, new_file_name);
}
public void ReplacementTokensCSS()
{
var source = ReadFile(s_inputFolder, "replacements.css");
var settings = new CssSettings();
settings.ReplacementTokensApplyDefaults(new Dictionary <string, string> {
{ "MediaQueries.SnapMax", "600px" },
{ "bing-orange", "#930" },
{ "MetroSdk.Resolution", "24x" },
{ "Global.Right", "right" },
{ "dim-gray", "#cccccc" },
{ "theme_name", "green" },
{ "Module-ID", "weather" },
});
settings.ReplacementFallbacks.Add("full", "100%");
settings.ReplacementFallbacks.Add("1x", "1x");
settings.ReplacementFallbacks.Add("color", "#ff0000");
var minifier = new Minifier();
var actual = minifier.MinifyStyleSheet(source, settings);
var expected = ReadFile(s_expectedFolder, "replacements.css");
Assert.AreEqual(expected, actual);
}
private void AddFileToBundle(IBundlerContext context, StringBuilder bundleContentBuilder, string fileName)
{
string fileContent = null;
if (context.IsMinificationEnabled && !IsMinFile(fileName))
{
var minFileInfo = GetMinFileInfoOrNull(fileName);
if (minFileInfo != null)
{
Logger.LogDebug($"- {fileName} ({minFileInfo.Length} bytes) - already minified");
fileContent = minFileInfo.ReadAsString();
}
}
if (fileContent == null)
{
fileContent = GetFileContent(context, fileName);
Logger.LogDebug($"- {fileName} ({fileContent.Length} bytes) - non minified");
if (context.IsMinificationEnabled)
{
var nonMinifiedSize = fileContent.Length;
fileContent = Minifier.Minify(fileContent, context.BundleRelativePath);
Logger.LogInformation($" > Minified {fileName} ({nonMinifiedSize} bytes -> {fileContent.Length} bytes)");
}
}
fileContent = ProcessBeforeAddingToTheBundle(context, fileName, fileContent);
bundleContentBuilder.Append(fileContent);
}
/// <summary>
/// Transforms the bundle contents by applying javascript minification
/// </summary>
/// <param name="context">The <see cref="BundleContext"/> object that contains state for both the framework configuration and the HTTP request.</param>
/// <param name="response">A <see cref="BundleResponse"/> object containing the bundle contents.</param>
public virtual void Process(BundleContext context, BundleResponse response)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
// Don't minify in Instrumentation mode
if (!context.EnableInstrumentation)
{
Minifier min = new Minifier();
// NOTE: Eval immediate treatment is needed for WebUIValidation.js to work properly after minification
// NOTE: CssMinify does not support important comments, so we are going to strip them in JS minification as well
string minifiedJs = min.MinifyJavaScript(response.Content, new CodeSettings()
{
EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = false
});
if (min.ErrorList.Count > 0)
{
GenerateErrorResponse(response, min.ErrorList);
}
else
{
response.Content = minifiedJs;
}
}
response.ContentType = JsContentType;
}
private async static Task <bool> MinifyFile(string file, string minFile, CodeSettings settings)
{
Minifier minifier = new Minifier();
// If the source file is not itself mapped, add the filename for mapping
// TODO: Make sure this works for compiled output too. (check for .map?)
if (!((await FileHelpers.ReadAllLinesRetry(file))
.SkipWhile(string.IsNullOrWhiteSpace)
.FirstOrDefault() ?? "")
.Trim()
.StartsWith("///#source", StringComparison.CurrentCulture))
{
minifier.FileName = file;
}
string content = minifier.MinifyJavaScript(await FileHelpers.ReadAllTextRetry(file), settings);
if (File.Exists(minFile) && content == await FileHelpers.ReadAllTextRetry(minFile))
{
return(false);
}
ProjectHelpers.CheckOutFileFromSourceControl(minFile);
await FileHelpers.WriteAllTextRetry(minFile, content);
ProjectHelpers.AddFileToProject(file, minFile);
return(true);
}
public static void UnCompressFile()
{
Methods.OnClipboardFile(f => {
var min = new Minifier();
var r = min.MinifyJavaScript(f.ReadAllText(), PrettyPrintOptions());
f.AppendFileName("_prettyprint").WriteAllText(r);
});
/*
* var settings = new CodeSettings();
* MinifyCode = settings.MinifyCode;
* OutputMode = settings.OutputMode;
* CollapseToLiteral = settings.CollapseToLiteral;
* CombineDuplicateLiterals = settings.CombineDuplicateLiterals;
* EvalTreatment = settings.EvalTreatment;
* IndentSize = settings.IndentSize;
* InlineSafeStrings = settings.InlineSafeStrings;
* LocalRenaming = settings.LocalRenaming;
* MacSafariQuirks = settings.MacSafariQuirks;
* PreserveFunctionNames = settings.PreserveFunctionNames;
* RemoveFunctionExpressionNames = settings.RemoveFunctionExpressionNames;
* RemoveUnneededCode = settings.RemoveUnneededCode;
* StripDebugStatements = settings.StripDebugStatements;
*/
}
private static string MinifyJavaScript(string s)
{
var min = new Minifier();
var r = min.MinifyJavaScript(s, PrettyPrintOptions());
return(r);
}
public string Process(string includedVirtualPath, string input)
{
if (includedVirtualPath.EndsWith("min.js", StringComparison.OrdinalIgnoreCase))
{
return(input);
}
var minifier = new Minifier();
var codeSettings = new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false,
Format = JavaScriptFormat.Normal,
MinifyCode = true
};
var str = minifier.MinifyJavaScript(input, codeSettings);
if (minifier.ErrorList.Count > 0)
{
return("/* " + string.Concat(minifier.Errors) + " */");
}
return(str);
}
public virtual void Process(BundleContext context, BundleResponse response)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
if (!context.EnableInstrumentation)
{
var minifier = new Minifier();
FixCustomCssErrors(response);
string str = minifier.MinifyStyleSheet(response.Content, new CssSettings()
{
CommentMode = CssComment.None
});
if (minifier.ErrorList.Count > 0)
{
GenerateErrorResponse(response, minifier.ErrorList);
}
else
{
response.Content = str;
}
}
response.ContentType = CssContentType;
}
private string GetAndMinifyFileContent(IBundlerContext context, string fileName)
{
var fileContent = GetFileInfo(context, fileName).ReadAsString();
var nonMinifiedSize = fileContent.Length;
Logger.LogDebug($"- {fileName} ({nonMinifiedSize} bytes) - non minified, minifying...");
try
{
fileContent = Minifier.Minify(
fileContent,
context.BundleRelativePath,
fileName
);
Logger.LogInformation($" > Minified {fileName} ({nonMinifiedSize} bytes -> {fileContent.Length} bytes)");
return(fileContent);
}
catch (Exception ex)
{
Logger.LogWarning($"Unable to minify the file: {fileName}. Return file content without minification.", ex);
}
return(fileContent);
}
public override string ToString()
{
string html = ViewRenderer.ConvertirVueString("~/HtmlHelpers/Datatables/RazorExtension/views/DtJs.cshtml", this);
html = html.Replace("<script>", "").Replace("</script>", "");
string jsMified = new Minifier().MinifyJavaScript(html);
//return html;
// return $"<div id='div__dt__{TableName}'><script>{html}</script></div>";
//var result= $"<div id='div__dt__{TableName}'><script>{jsMified}</script></div>";
//return $"<script>{jsMified}</script>";
//create a script file on the server and Return an script tag
string jsPath = $"Scripts/{TableName}.js";
FileInfo jsFileInfo = new FileInfo(HttpContext.Current.Server.MapPath($"~/{jsPath}"));
using (StreamWriter sw = new StreamWriter(jsFileInfo.FullName))
{
//sw.WriteLine(html); // Write the file.
sw.WriteLine(jsMified); // Write the file.
}
//TODO: think of reusing same file if not modified
var result = $"<div id='div__dt__{TableName}'><script src='{jsPath}?v={DateTime.Now.Ticks}'></script></div>";//Use ?v toget latest version
return(result);
}
/// <summary>
/// Minifies the specified JavaScript.
/// </summary>
/// <param name="resource">The JavaScript to minify.</param>
/// <returns>The minified JavaScript, if minification was successful; otherwise, the original JavaScript with minification errors appended at the end.</returns>
public static string MinifyJavascript(string resource)
{
if (String.IsNullOrEmpty(resource))
{
return(resource);
}
var settings = new CodeSettings
{
AllowEmbeddedAspNetBlocks = false,
EvalTreatment = EvalTreatment.MakeAllSafe
};
var minifier = new Minifier();
try
{
resource = minifier.MinifyJavaScript(resource, settings);
}
catch
{
var minificationErrors = String.Join(Environment.NewLine, minifier.Errors);
resource = AppendMinificationErrors(resource, minificationErrors);
}
return(resource);
}
private static bool MinifyFile(string file, string minFile, CodeSettings settings)
{
Minifier minifier = new Minifier();
// If the source file is not itself mapped, add the filename for mapping
// TODO: Make sure this works for compiled output too. (check for .map?)
if (!(File.ReadLines(file)
.SkipWhile(string.IsNullOrWhiteSpace)
.FirstOrDefault() ?? "")
.Trim()
.StartsWith("///#source", StringComparison.CurrentCulture))
{
minifier.FileName = Path.GetFileName(file);
}
string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
content += "\r\n/*\r\n//# sourceMappingURL=" + Path.GetFileName(minFile) + ".map\r\n*/";
if (File.Exists(minFile) && content == File.ReadAllText(minFile))
{
return(false);
}
ProjectHelpers.CheckOutFileFromSourceControl(minFile);
File.WriteAllText(minFile, content, Encoding.UTF8);
ProjectHelpers.AddFileToProject(file, minFile);
return(true);
}
// [BindMenuItem(Name = "压缩 JavaScripts", SplitButton = "javaScriptButton", Toolbar = "toolStrip1", AddSeparatorBefore = true)]
// public static void CompressProjectsJavaScripts()
// {
// Helper.CompressScripts(@"C:\Users\psycho\go\src\psycho\static\javascripts"
// , @"C:\Users\psycho\go\src\psycho\static"
// , @"C:\Users\psycho\go\src\psycho\templates\_footer.html");
//
// }
// [BindMenuItem(Name = "压缩 SheetStyles", SplitButton = "javaScriptButton", Toolbar = "toolStrip1")]
// public static void CompressProjectsSheetStyles()
// {
// Helper.CompressScripts(@"C:\Users\psycho\go\src\psycho\static\styles"
// , @"C:\Users\psycho\go\src\psycho\static"
// , @"C:\Users\psycho\go\src\psycho\templates\_header.html", false);
// }
public static void CompressSheetStyles()
{
var minifier = new Minifier();
const string javaScriptSourceDirectory = @"C:\Users\psycho\go\src\psycho\static\styles";
const string javaScriptDestinationDirectory = @"C:\Users\psycho\go\src\psycho\static";
var files = Directory.GetFiles(javaScriptSourceDirectory, "*.css")
.Where(i => !i.GetFileName().StartsWith(".") && !i.GetFileName().StartsWith("$"))
.OrderBy(i => i.GetFileName()).ToArray();
var sb = new StringBuilder();
foreach (var element in files)
{
sb.AppendLine(element.ReadAllText());
}
Path.Combine(javaScriptDestinationDirectory, "app.min.css").WriteAllText(minifier.MinifyStyleSheet(sb.ToString()));
var javaScripts = Directory.GetFiles(javaScriptSourceDirectory, "*.css")
.Where(i => i.GetFileName().StartsWith("."));
foreach (var element in javaScripts)
{
var m = minifier.MinifyStyleSheet(element.ReadAllText());
Path.Combine(javaScriptDestinationDirectory, Path.GetFileNameWithoutExtension(element).TrimStart('.') + ".min.css").WriteAllText(m);
}
}
public void IgnoredIdAndComments()
{
var minifier = new Minifier(null, new string[] { "unminifiedId" }, new string[] { "unremovableComment", "/*unremovableComment1*/" });
var test = Samples["Test1"];
if (!test.Contains("unminifiedId") || !test.Contains("unremovableComment") || !test.Contains("/*unremovableComment1*/"))
Assert.Inconclusive("Invalid test sample for IgnoredIdAndComments test");
var minified = minifier.MinifyFromString(test);
Assert.IsTrue(minified.Contains("unminifiedId"));
Assert.IsTrue(minified.Contains("unremovableComment"));
Assert.IsTrue(minified.Contains("/*unremovableComment1*/"));
}
public void CompressMisc()
{
var minifierOptions = new MinifierOptions(false)
{
MiscCompressing = true
};
var minifier = new Minifier(minifierOptions);
var minified = minifier.MinifyFromString(Samples["MiscCompression"]);
Assert.IsTrue(minified.Contains("255"));
Assert.IsTrue(minified.Contains("0x7048860F9180"));
Assert.IsFalse(minified.Contains("private"));
Assert.AreEqual(2, minified.Count(c => c == '{'));
Assert.AreEqual(2, minified.Count(c => c == '}'));
}
public void CompressIdentifiers()
{
var minifierOptions = new MinifierOptions(false)
{
LocalVarsCompressing = true,
MembersCompressing = true,
TypesCompressing = true
};
var minifier = new Minifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
}
}
/// <summary>
/// Excute the request and response the needes content
/// <para>Save the response in the Output cach for next requests</para>
/// </summary>
/// <param name="context"></param>
/// <param name="absoluteFiles"></param>
/// <param name="minify"></param>
/// <param name="versionHash"></param>
/// <param name="encodingMgr"></param>
public void Excute(HttpContext context, string[] absoluteFiles, Minifier minify, int versionHash, EncodingManager encodingMgr)
{
context.Response.Write(SR.GetString(SR.CREDIT_STRING));
List<string> exsitingFiles = new List<string>();
for (int i = 0; i < absoluteFiles.Length; i++)
{
WriteContent(context, GetFileContent(absoluteFiles[i], minify, exsitingFiles));
}
SetResponseCacheSettings(context, exsitingFiles.ToArray());
if (encodingMgr.IsEncodingEnabled)
{
encodingMgr.CompressResponse();
encodingMgr.SetResponseEncodingType();
}
}
/// <summary>
/// Get the content of the specified file
/// </summary>
/// <param name="fileName"></param>
/// <param name="minify"></param>
/// <param name="exsitingFiles"></param>
/// <returns></returns>
private string GetFileContent(string fileName, Minifier minify, List<string> exsitingFiles)
{
string content = string.Empty;
if (fileName.StartsWith("NOT_FOUND", StringComparison.Ordinal))
{
content = string.Format(SR.File_FileNotFound, Path.GetFileName(fileName.Split('|')[1]));
}
else
{
using (StreamReader reader = new StreamReader(fileName))
{
content = minify(reader);
}
exsitingFiles.Add(fileName);
}
return content;
}
private void btnMinify_Click(object sender, EventArgs e)
{
var minifierOptions = new MinifierOptions
{
LocalVarsCompressing = cbCompressLocalVars.Checked,
MembersCompressing = cbCompressMemebers.Checked,
TypesCompressing = cbCompressTypes.Checked,
SpacesRemoving = cbRemoveSpaces.Checked,
RegionsRemoving = cbRemoveRegions.Checked,
CommentsRemoving = cbRemoveComments.Checked,
MiscCompressing = cbCompressMisc.Checked,
ConsoleApp = cbConsoleApp.Checked,
NamespacesRemoving = cbRemoveNamespaces.Checked,
LineLength = int.Parse(tbLineLength.Text),
ToStringMethodsRemoving = cbRemoveToStringMethods.Checked,
PublicCompressing = cbCompressPublic.Checked,
EnumToIntConversion = cbEnumToIntConversion.Checked
};
Minifier minifier = new Minifier(minifierOptions);
tbOutput.Text = !cbMinifyFiles.Checked ? minifier.MinifyFromString(tbInput.Text) : minifier.MinifyFiles(Sources.Select(source => source.Value).ToArray());
tbInputLength.Text = tbInput.Text.Length.ToString();
tbOutputLength.Text = tbOutput.Text.Length.ToString();
tbOutputInputRatio.Text = ((double)tbOutput.Text.Length / tbInput.Text.Length).ToString("0.000000");
var compileResult = CompileUtils.Compile(tbOutput.Text);
dgvErrors.Rows.Clear();
if (!compileResult.Errors.HasErrors)
{
pbOutputCompilied.Image = Resources.Ok;
lblOutputCompilied.Text = "Compilied";
}
else
{
pbOutputCompilied.Image = Resources.Error;
lblOutputCompilied.Text = "Not compilied";
for (int i = 0; i < compileResult.Errors.Count; i++)
{
var error = compileResult.Errors[i];
dgvErrors.Rows.Add(error.Line.ToString(), error.Column.ToString(),
error.ErrorText, "output");
}
}
}
/// <summary>
/// Process the request
/// </summary>
/// <param name="context"></param>
public virtual void ProcessRequest(HttpContext context)
{
int versionHash;
DateTime lastUpdate;
string[] relativeFiles = context.Request.QueryString["d"].Split(',');
string[] absoluteFiles = GetFilesInfo(relativeFiles,context, out versionHash,out lastUpdate);
context.Response.Clear();
SetHeaders(context, lastUpdate, versionHash);
CheckETag(context, versionHash);
Minifier currentMinifier = new Minifier(Minify);
EncodingManager encodingMgr = new EncodingManager(context);
if (!IsCompressContent())
{
encodingMgr.PreferredEncodingType = EncodingManager.EncodingType.None;
}
Settings.Instance.CurrentStorage.Excute(context, absoluteFiles, currentMinifier, versionHash, encodingMgr);
}
public void IncrementPlus()
{
var minifier = new Minifier(new MinifierOptions { LocalVarsCompressing = false });
var testCode =
@"public class Test
{
public void Main()
{
int x = 1;
int y = 2;
int z1 = y + ++x;
int z2 = y + --x;
int z3 = y - ++x;
int z4 = y - --x;
}
}";
var minified = minifier.MinifyFromString(testCode);
Assert.IsTrue(minified.Contains("int z1=y+ ++x"));
Assert.IsTrue(minified.Contains("int z2=y+--x"));
Assert.IsTrue(minified.Contains("int z3=y-++x"));
Assert.IsTrue(minified.Contains("int z4=y- --x"));
}
/// <summary>
/// Get the content of the specified file
/// </summary>
/// <param name="fileName"></param>
/// <param name="minify"></param>
/// <param name="exsitingFiles"></param>
/// <returns></returns>
private static string GetFileContent(string fileName, Minifier minify, ICollection<string> exsitingFiles)
{
string content;
if (fileName.StartsWith("NOT_FOUND", StringComparison.Ordinal))
{
content = string.Format(CultureInfo.CurrentCulture, SR.File_FileNotFound, Path.GetFileName(fileName.Split('|')[1]));
}
else
{
using (StreamReader reader = new StreamReader(fileName))
{
if (Settings.Instance.IsValidPathForMinify(fileName))
{
content = minify(reader);
}
else
{
content = reader.ReadToEnd();
}
}
exsitingFiles.Add(fileName);
}
return content;
}
public void LineLengthConstraint()
{
var minifierOptions = new MinifierOptions
{
SpacesRemoving = true,
CommentsRemoving = true,
LineLength = 80,
RegionsRemoving = true
};
var minifier = new Minifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
}
}
private static string GenerateMinifierErrorsContent(string contentConcatedString, Minifier minifier)
{
var sbContent = new StringBuilder();
sbContent.Append("/* ");
sbContent.Append("An error occurred during minification, see errors below - returning concatenated content unminified.").Append("\r\n");
foreach (var error in minifier.ErrorList)
{
sbContent.Append(error).Append("\r\n");
}
sbContent.Append(" */\r\n");
sbContent.Append(contentConcatedString);
return sbContent.ToString();
}
public string BuildBundleContent(Bundle bundle, BundleContext context, IEnumerable<BundleFile> files)
{
if (files == null)
{
return string.Empty;
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (bundle == null)
{
throw new ArgumentNullException("bundle");
}
// Generates source map using an approach documented here: http://ajaxmin.codeplex.com/discussions/446616
var sourcePath = VirtualPathUtility.ToAbsolute(bundle.Path);
var mapVirtualPath = string.Concat(bundle.Path, "map"); // don't use .map so it's picked up by the bundle module
var mapPath = VirtualPathUtility.ToAbsolute(mapVirtualPath);
// Concatenate file contents to be minified, including the sourcemap hints
var contentConcatedString = GetContentConcated(context, files);
// Try minify (+ source map) using AjaxMin dll
try
{
var contentBuilder = new StringBuilder();
var mapBuilder = new StringBuilder();
using (var contentWriter = new StringWriter(contentBuilder))
using (var mapWriter = new StringWriter(mapBuilder))
using (var sourceMap = new V3SourceMap(mapWriter))
{
var settings = new CodeSettings()
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false,
SymbolsMap = sourceMap,
TermSemicolons = true
};
sourceMap.StartPackage(sourcePath, mapPath);
var minifier = new Minifier();
string contentMinified = minifier.MinifyJavaScript(contentConcatedString, settings);
if (minifier.ErrorList.Count > 0)
{
return GenerateMinifierErrorsContent(contentConcatedString, minifier);
}
contentWriter.Write(contentMinified);
}
// Write the SourceMap to another Bundle
AddContentToAdHocBundle(context, mapVirtualPath, mapBuilder.ToString());
// Note: A current bug in AjaxMin reported by @LodewijkSioen here https://ajaxmin.codeplex.com/workitem/21834,
// causes the MinifyJavascript method call to hang when debugger is attached if the following line is included.
// To avoid more harm than good, don't support source mapping in this scenario until AjaxMin fixes it's bug.
if (System.Diagnostics.Debugger.IsAttached)
{
contentBuilder.Insert(0, sourceMappingDisabledMsg + "\r\n\r\n\r\n");
}
return contentBuilder.ToString();
}
catch (Exception ex)
{
Trace.TraceWarning("An exception occurred trying to build bundle contents for bundle with virtual path: " + bundle.Path + ". See Exception details.", ex, typeof(ScriptWithSourceMapBundleBuilder));
return GenerateGenericErrorsContent(contentConcatedString);
}
}
/// <summary>
/// Occurs when the content was just reloaded. This occurs lazily
/// when <see cref="Content"/> property is touched.
/// </summary>
protected override void OnContentChange()
{
// Call the base
base.OnContentChange();
// Each view is dependant on the code-behind script, with the same name
this.Dependancies.Clear();
this.Dependancies.AddCodeBehind(this.CodeBehind);
// Read the stream and write a string
using (var stream = new MemoryStream(this.Content))
using (var reader = new StreamReader(stream))
using (var code = new StringWriter())
using (var body = new StringWriter())
{
// Read line by line and render the body which is not dependancy
string line;
while ((line = reader.ReadLine()) != null)
{
if(!this.Dependancies.TryAddParsed(line))
body.WriteLine(line);
}
// Resolve all dependancies for the view
var dependancies = this.Dependancies.Resolve();
// Render all dependancies
foreach (var link in dependancies)
{
// Get the dependant and the dependancy
var dependant = link.Dependant;
var dependancy = link.Dependancy;
// We should render an element (component) which actually
// generates javascript angularjs directive.
if (dependancy is MetaElement)
code.WriteLine((dependancy as MetaElement).Script);
// We should render a script, being a code-behind script
// or any other script that should be included
if (dependancy is MetaScript)
{
// If the dependant is a view, we should write the
// appropriate view script.
if(dependant is MetaView)
code.WriteLine((dependancy as MetaScript).View);
// If the dependant is a view, we should write the
// appropriate element script.
if (dependant is MetaElement)
code.WriteLine((dependancy as MetaScript).Element);
}
}
// Minify the embedded javascript
var minify = new Minifier();
var script = "<script type='application/javascript'>" +
minify.MinifyJavaScript(code.ToString()) +
"</script>";
// Minify the HTML template
var htmlBody = body.ToString();
htmlBody = Regex.Replace(htmlBody, @"\n|\t", " ");
htmlBody = Regex.Replace(htmlBody, @">\s+<", "><").Trim();
// Create a final text version
this.Text = script + htmlBody;
}
}
private void FileSetCache(StringBuilder lFilesContent, string cacheKey, MediaType media)
{
Minifier m = new Minifier();
if (media == MediaType.javascript)
{
CodeSettings c = new CodeSettings();
this._objCacheManager.Add(cacheKey,
ApplicationConfiguration.IsDebugMode ? lFilesContent.ToString() : m.MinifyJavaScript(lFilesContent.ToString(), c)
, _objCachePolicy);
}
else
{
this._objCacheManager.Add(cacheKey,
ApplicationConfiguration.IsDebugMode ? lFilesContent.ToString() : m.MinifyStyleSheet(lFilesContent.ToString())
, _objCachePolicy);
}
}
/// <summary>
/// Excute the request and response the needes content
/// <para>Save the response in the file system for next requests</para>
/// </summary>
/// <param name="context"></param>
/// <param name="filesInfo"></param>
/// <param name="minify"></param>
/// <param name="versionHash"></param>
/// <param name="encodingMgr"></param>
public void Excute(HttpContext context, string[] filesInfo, Minifier minify, int versionHash, EncodingManager encodingMgr)
{
string phisicalRoot = context.Server.MapPath("~/") + cReferencesCache;
string fullPath;
if (encodingMgr.IsEncodingEnabled)
{
fullPath = phisicalRoot + "comp_" + encodingMgr.PreferredEncoding + "_" + versionHash + (minify.Target is JavaScriptCompressionHandler ? ".js" : ".css");
encodingMgr.SetResponseEncodingType();
}
else
{
fullPath = phisicalRoot + versionHash + (minify.Target is JavaScriptCompressionHandler ? ".js" : ".css");
}
SetResponseCacheSettings(context, null);
if (!File.Exists(fullPath))
{
lock (_syncObject)
{
if (!File.Exists(fullPath))
{
if (!Directory.Exists(phisicalRoot))
{
Directory.CreateDirectory(phisicalRoot);
}
if (encodingMgr.IsEncodingEnabled)
{
StringBuilder contentSb = new StringBuilder(SR.GetString(SR.CREDIT_STRING));
foreach (string fileName in filesInfo)
{
if (fileName.StartsWith("NOT_FOUND", StringComparison.Ordinal))
{
contentSb.AppendFormat(SR.File_FileNotFound + Environment.NewLine, Path.GetFileName(fileName.Split('|')[1]));
}
else
{
using (StreamReader reader = new StreamReader(fileName, context.Response.ContentEncoding))
{
if (Settings.Instance.IsValidPathForMinify(fileName))
{
contentSb.AppendLine(minify(reader));
}
else
{
contentSb.AppendLine(reader.ReadToEnd());
}
}
}
}
using (FileStream fs = new FileStream(fullPath, FileMode.Create))
{
byte[] compressedContent = encodingMgr.CompressString(contentSb.ToString());
fs.Write(compressedContent, 0, compressedContent.Length);
}
// Release the StringBuilder
contentSb.Length = 0;
}
else
{
using (FileStream fs = new FileStream(fullPath, FileMode.Create))
using (StreamWriter sw = new StreamWriter(fs,context.Response.ContentEncoding))
{
string content = SR.GetString(SR.CREDIT_STRING);
sw.WriteLine(content);
foreach (string fileName in filesInfo)
{
if (fileName.Length == 0)
{
content = string.Format(CultureInfo.CurrentCulture, SR.File_FileNotFound, Path.GetFileName(fileName));
}
else
{
using (StreamReader reader = new StreamReader(fileName, context.Response.ContentEncoding))
{
if (Settings.Instance.IsValidPathForMinify(fileName))
{
content = minify(reader);
}
else
{
content = reader.ReadToEnd();
}
}
}
sw.WriteLine(content);
}
}
}
}
}
}
context.Response.TransmitFile(fullPath);
}
public void RemoveRegions()
{
var minifierOptions = new MinifierOptions
{
SpacesRemoving = true,
RegionsRemoving = true
};
var minifier = new Minifier(minifierOptions);
var test = Samples["Test1"];
if (!test.Contains("#region") || !test.Contains("#endregion"))
Assert.Inconclusive("Invalid test sample for RemoveRegions test");
var minified = minifier.MinifyFromString(test);
Assert.IsTrue(CompileUtils.CanCompile(minified));
Assert.IsFalse(minified.Contains("#region"));
Assert.IsFalse(minified.Contains("#endregion"));
}
public void RemoveSpaces()
{
var minifierOptions = new MinifierOptions(false)
{
SpacesRemoving = true
};
var minifier = new Minifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
if (sample.Key == "Test1")
Assert.IsFalse(minified.Contains(" /*"));
}
}
