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);
}
public static BundlingConfigurer UseNUglify(this BundlingConfigurer @this, CssSettings cssSettings = null, CodeSettings jsSettings = null)
{
@this.Services.Replace(ServiceDescriptor.Singleton <ICssMinifier>(sp => new CssMinifier(cssSettings, sp.GetRequiredService <ILoggerFactory>())));
@this.Services.Replace(ServiceDescriptor.Singleton <IJsMinifier>(sp => new JsMinifier(jsSettings, sp.GetRequiredService <ILoggerFactory>())));
return(@this);
}
CssSettings ConfigureSettings(CssSettings cssSettings)
{
cssSettings.CommentMode = CssComment.None;
cssSettings.OutputMode = OutputMode.SingleLine;
cssSettings.TermSemicolons = true;
return(cssSettings);
}
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);
}
/// <summary>
/// Builds the required CssSettings class needed for the Ajax Minifier.
/// </summary>
/// <returns>The required CssSettings class needed for the Ajax Minifier.</returns>
private CssSettings CreateCssSettings()
{
CssSettings cssSettings = new CssSettings
{
OutputMode = this.RemoveWhiteSpace ? OutputMode.SingleLine : OutputMode.MultipleLines
};
if (this.ShouldMinify)
{
switch (this.ColorNamesRange)
{
case ColorNamesRange.W3CStrict:
cssSettings.ColorNames = CssColor.Strict;
break;
case ColorNamesRange.HexadecimalOnly:
cssSettings.ColorNames = CssColor.Hex;
break;
case ColorNamesRange.AllMajorColors:
cssSettings.ColorNames = CssColor.Major;
break;
}
}
return(cssSettings);
}
public static void Minify(CompilerOptions options)
{
if (!options.Minify || !File.Exists(options.OutputFilePath))
{
return;
}
string cssContent = File.ReadAllText(options.OutputFilePath);
var settings = new CssSettings
{
ColorNames = CssColor.Strict,
CommentMode = CssComment.Important
};
NUglify.UglifyResult result = Uglify.Css(cssContent, settings);
if (result.HasErrors)
{
return;
}
string minFilePath = Path.ChangeExtension(options.OutputFilePath, ".min.css");
VsHelpers.CheckFileOutOfSourceControl(minFilePath);
File.WriteAllText(minFilePath, result.Code, new UTF8Encoding(true));
VsHelpers.AddNestedFile(options.OutputFilePath, minFilePath);
}
/// <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);
}
/// <summary>
/// Runs the CSS minifier on the content.
/// </summary>
public static IAsset MinifyCss(this IAsset asset, CssSettings settings)
{
var minifier = new CssMinifier(settings);
asset.Processors.Add(minifier);
return(asset);
}
private void minifyButton_Click(object sender, EventArgs e)
{
this.ccsb.SetMessage("Minify in progress...");
this.Refresh();
foreach (var item in webResourceListView.CheckedItems)
{
var entity = (Entity)((ListViewItem)item).Tag;
if (entity.GetAttributeValue <OptionSetValue>("webresourcetype").Value == 3)
{
CodeSettings cs = new CodeSettings()
{
//common
AllowEmbeddedAspNetBlocks = aspnetCheckBox.Checked,
BlocksStartOnSameLine = (BlockStart)((ComboBoxItem)bracesComboBox.SelectedItem).Value,
IgnoreAllErrors = IgnoreAllErrorsCheckBox.Checked,
//js specific
AlwaysEscapeNonAscii = asciiCheckBox.Checked,
CollapseToLiteral = collapseCheckBox.Checked,
ConstStatementsMozilla = ConstStatementsMozillaCheckBox.Checked,
ErrorIfNotInlineSafe = ErrorIfNotInlineSafeCheckBox.Checked,
EvalLiteralExpressions = EvalLiteralExpressionsCheckBox.Checked,
EvalTreatment = (EvalTreatment)((ComboBoxItem)EvalTreatmentComboBox.SelectedItem).Value,
Format = (JavaScriptFormat)((ComboBoxItem)FormatComboBox.SelectedItem).Value,
LocalRenaming = (LocalRenaming)((ComboBoxItem)LocalRenamingComboBox.SelectedItem).Value,
MacSafariQuirks = MacSafariQuirksCheckBox.Checked,
PreserveFunctionNames = PreserveFunctionNamesCheckBox.Checked,
PreserveImportantComments = PreserveImportantCommentsCheckBox.Checked,
QuoteObjectLiteralProperties = QuoteObjectLiteralPropertiesCheckBox.Checked,
RemoveFunctionExpressionNames = RemoveFunctionExpressionNamesCheckBox.Checked,
StripDebugStatements = StripDebugStatementsCheckBox.Checked
};
minifyJS(entity, cs);
}
else if (entity.GetAttributeValue <OptionSetValue>("webresourcetype").Value == 2)
{
CssSettings settings = new CssSettings()
{
//common
AllowEmbeddedAspNetBlocks = aspnetCheckBox.Checked,
BlocksStartOnSameLine = (BlockStart)((ComboBoxItem)bracesComboBox.SelectedItem).Value,
IgnoreAllErrors = IgnoreAllErrorsCheckBox.Checked,
//css specific
ColorNames = (CssColor)((ComboBoxItem)ColorNamesComboBox.SelectedItem).Value,
CommentMode = (CssComment)((ComboBoxItem)CommentModeComboBox.SelectedItem).Value,
CssType = (CssType)((ComboBoxItem)CssTypeComboBox.SelectedItem).Value,
MinifyExpressions = MinifyExpressionsCheckBox.Checked
};
minifyCSS(entity, settings);
}
}
this.ccsb.SetMessage("Minify complete.");
this.Refresh();
}
/// <summary>
/// Gets a embedded CSS-code parser settings
/// </summary>
/// <returns>Embedded CSS-code parser settings</returns>
private CssSettings GetEmbeddedCssParserSettings()
{
var embeddedCssParserSettings = new CssSettings();
MapCssSettings(embeddedCssParserSettings, _settings);
embeddedCssParserSettings.CssType = CssType.FullStyleSheet;
return(embeddedCssParserSettings);
}
/// <summary>
/// Gets a inline CSS-code parser settings
/// </summary>
/// <returns>Inline CSS-code parser settings</returns>
private CssSettings GetInlineCssParserSettings()
{
var inlineCssParserSettings = new CssSettings();
MapCssSettings(inlineCssParserSettings, _settings);
inlineCssParserSettings.CssType = CssType.DeclarationList;
return(inlineCssParserSettings);
}
/// <summary>
/// Creates a original CSS minifier settings
/// </summary>
/// <param name="settings">CSS minifier settings</param>
/// <param name="isInlineCode">Flag for whether to create a settings for inline code</param>
/// <returns>Original CSS minifier settings</returns>
private static CssSettings CreateOriginalCssMinifierSettings(MsAjaxCssMinificationSettings settings,
bool isInlineCode)
{
var originalSettings = new CssSettings();
MapCssSettings(originalSettings, settings);
originalSettings.CssType = isInlineCode ? CssType.DeclarationList : CssType.FullStyleSheet;
return(originalSettings);
}
public CssMinifier(CssSettings settings, ILoggerFactory loggerFactory)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_settings = settings;
_logger = loggerFactory.CreateLogger <CssMinifier>();
}
public void AddCssBundle_CustomSettings_Success()
{
var settings = new CssSettings();
var pipeline = new AssetPipeline();
var asset = pipeline.AddCssBundle("/foo.css", settings, "file1.css", "file2.css");
Assert.Equal("/foo.css", asset.Route);
Assert.Equal("text/css; charset=UTF-8", asset.ContentType);
Assert.Equal(2, asset.SourceFiles.Count());
Assert.Equal(5, asset.Processors.Count);
}
/// <summary>
/// Maps a CSS minifier settings
/// </summary>
/// <param name="originalSettings">Original CSS minifier settings</param>
/// <param name="settings">CSS minifier settings</param>
private static void MapCssSettings(CssSettings originalSettings, MsAjaxCssMinificationSettings settings)
{
MapCommonSettings(originalSettings, settings);
originalSettings.ColorNames = Utils.GetEnumFromOtherEnum <WmmCssColor, MsCssColor>(
settings.ColorNames);
originalSettings.CommentMode = Utils.GetEnumFromOtherEnum <WmmCssComment, MsCssComment>(
settings.CommentMode);
originalSettings.MinifyExpressions = settings.MinifyExpressions;
originalSettings.RemoveEmptyBlocks = settings.RemoveEmptyBlocks;
}
/// <inheritdoc cref="IResourceMinifier.Minify" />
public string Minify(Settings settings, ResourceSet resourceSet, string combinedContent)
{
var outputMode = (OutputMode)OutputMode.ConvertToType(
typeof(OutputMode), Microsoft.Ajax.Utilities.OutputMode.SingleLine);
var codeSettings = new CssSettings()
{
OutputMode = outputMode,
MinifyExpressions = MinifyExpressions == null ? true : MinifyExpressions.Value,
};
return(new Minifier().MinifyStyleSheet(combinedContent, codeSettings));
}
/// <summary>
/// Maps a CSS settings
/// </summary>
/// <param name="cssParserSettings">CSS-code parser settings</param>
/// <param name="cssMinifierSettings">Microsoft CSS Minifier settings</param>
private static void MapCssSettings(CssSettings cssParserSettings,
MsAjaxCssMinificationSettings cssMinifierSettings)
{
MapCommonSettings(cssParserSettings, cssMinifierSettings);
cssParserSettings.ColorNames = Utils.GetEnumFromOtherEnum <WmmCssColor, MsCssColor>(
cssMinifierSettings.ColorNames);
cssParserSettings.CommentMode = Utils.GetEnumFromOtherEnum <WmmCssComment, MsCssComment>(
cssMinifierSettings.CommentMode);
cssParserSettings.MinifyExpressions = cssMinifierSettings.MinifyExpressions;
cssParserSettings.RemoveEmptyBlocks = cssMinifierSettings.RemoveEmptyBlocks;
}
/// <summary>
/// Constructs a instance of Microsoft Ajax CSS minifier
/// </summary>
/// <param name="microsoftAjaxConfig">Configuration settings of Microsoft Ajax Minifier</param>
public MicrosoftAjaxCssMinifier(MicrosoftAjaxSettings microsoftAjaxConfig)
{
_cssParserConfiguration = new CssSettings();
CssMinifierSettings cssMinifierConfig = microsoftAjaxConfig.CssMinifier;
MapCommonSettings(this, cssMinifierConfig);
ColorNames = cssMinifierConfig.ColorNames;
CommentMode = cssMinifierConfig.CommentMode;
MinifyExpressions = cssMinifierConfig.MinifyExpressions;
RemoveEmptyBlocks = cssMinifierConfig.RemoveEmptyBlocks;
}
public override void Invoke()
{
string separator = CssSettings.Get(_span.TextBuffer).FormatterBlockBracePosition == BracePosition.Compact ? " " : Environment.NewLine;
//string separator = CssSettings.FormatterBlockBracePosition == BracePosition.Compact ? " " : Environment.NewLine;
string insert = _lastVendor.Text + separator + _standard.Text;
using (EditorExtensionsPackage.UndoContext((DisplayText)))
{
_span.TextBuffer.Replace(new Span(_lastVendor.Start, _lastVendor.Length), insert);
_span.TextBuffer.Delete(new Span(_standard.Start, _standard.Length));
EditorExtensionsPackage.ExecuteCommand("Edit.FormatSelection");
}
}
/// <summary>
/// Constructs a instance of NUglify CSS minifier
/// </summary>
/// <param name="nuglifyConfig">Configuration settings of NUglify Minifier</param>
public NUglifyCssMinifier(NUglifySettings nuglifyConfig)
{
_cssParserConfiguration = new CssSettings();
CssMinifierSettings cssMinifierConfig = nuglifyConfig.CssMinifier;
MapCommonSettings(this, cssMinifierConfig);
ColorNames = cssMinifierConfig.ColorNames;
CommentMode = cssMinifierConfig.CommentMode;
FixIE8Fonts = cssMinifierConfig.FixIE8Fonts;
MinifyExpressions = cssMinifierConfig.MinifyExpressions;
RemoveEmptyBlocks = cssMinifierConfig.RemoveEmptyBlocks;
}
/// <summary>
/// Produces a code minifiction of CSS content by using the NUglify CSS Minifier
/// </summary>
/// <param name="content">CSS content</param>
/// <param name="isInlineCode">Flag whether the content is inline code</param>
/// <param name="encoding">Text encoding</param>
/// <returns>Minification result</returns>
public CodeMinificationResult Minify(string content, bool isInlineCode, Encoding encoding)
{
if (string.IsNullOrWhiteSpace(content))
{
return(new CodeMinificationResult(string.Empty));
}
CssSettings originalCssSettings = isInlineCode ?
_originalInlineCssSettings : _originalEmbeddedCssSettings;
UgliflyResult originalResult = Uglify.Css(content, originalCssSettings, _originalJsSettings);
CodeMinificationResult result = GetCodeMinificationResult(originalResult);
return(result);
}
/// <summary>
/// Minifies the CSS stylesheet passes to it using the given settings, returning the minified results
/// The ErrorList property will be set with any errors found during the minification process.
/// </summary>
/// <param name="source">CSS Source</param>
/// <param name="fileName">File name to use in error reporting. Default is <c>input</c></param>
/// <param name="settings">CSS minification settings</param>
/// <param name="scriptSettings">JS minification settings to use for expression-minification</param>
/// <returns>Minified StyleSheet</returns>
public static UglifyResult Css(string source, string fileName, CssSettings settings = null, CodeSettings scriptSettings = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
fileName = fileName ?? "input";
settings = settings ?? new CssSettings();
scriptSettings = scriptSettings ?? new CodeSettings();
// initialize some values, including the error list (which shoudl start off empty)
string minifiedResults;
var errorList = new List <UglifyError>();
// create the parser object and if we specified some settings,
// use it to set the Parser's settings object
var parser = new CssParser
{
FileContext = fileName,
Settings = settings,
JSSettings = scriptSettings
};
// hook the error handler
parser.CssError += (sender, e) =>
{
var error = e.Error;
if (error.Severity <= settings.WarningLevel)
{
errorList.Add(error);
}
};
// try parsing the source and return the results
try
{
minifiedResults = parser.Parse(source);
}
catch (Exception e)
{
errorList.Add(new UglifyError()
{
Severity = 0,
File = fileName,
Message = e.Message,
});
throw;
}
return(new UglifyResult(minifiedResults, errorList));
}
public HtmlMinifier(HtmlDocument html, HtmlSettings settings = null)
{
if (html == null)
{
throw new ArgumentNullException(nameof(html));
}
this.settings = settings ?? new HtmlSettings();
attributeCssSettings = this.settings.CssSettings.Clone();
attributeCssSettings.CssType = CssType.DeclarationList;
this.html = html;
pendingTexts = new List <HtmlText>();
Errors = new List <UglifyError>();
}
private static void Minify(HttpResponse response, string file, string ext)
{
string content = File.ReadAllText(file);
Minifier minifier = new Minifier();
if (ext == ".css")
{
CssSettings settings = new CssSettings() { CommentMode = CssComment.None };
response.Write(minifier.MinifyStyleSheet(content, settings));
}
else if (ext == ".js")
{
CodeSettings settings = new CodeSettings() { PreserveImportantComments = false };
response.Write(minifier.MinifyJavaScript(content, settings));
}
}
private void minifyCSS(Entity entity, CssSettings settings)
{
Microsoft.Ajax.Utilities.Minifier minifier = new Microsoft.Ajax.Utilities.Minifier();
string name = entity.GetAttributeValue <string>("displayname");
byte[] cssFileBytes = Convert.FromBase64String(entity.GetAttributeValue <string>("content"));
string originalCss = UnicodeEncoding.UTF8.GetString(cssFileBytes);
string minifiedCss = minifier.MinifyStyleSheet(originalCss, settings);
byte[] minifiedCssBytes = UnicodeEncoding.UTF8.GetBytes(minifiedCss);
string minifiedCssBytesString = Convert.ToBase64String(minifiedCssBytes);
Entity updatedWebResource = new Entity(entity.LogicalName);
updatedWebResource.Attributes.Add("content", minifiedCssBytesString);
updatedWebResource.Id = entity.Id;
this.service.Update(updatedWebResource);
}
private static MinificationResult MinifyCss(string file, bool produceGzipFile)
{
string content = File.ReadAllText(file);
string minFile = GetMinFileName(file);
var settings = new CssSettings()
{
CommentMode = CssComment.Hacks
};
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);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
if (produceGzipFile)
{
GzipFile(minFile);
}
}
else
{
AddAjaxminErrors(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(result);
}
public virtual string BuildBundleContent(Bundle bundle, BundleContext context, IEnumerable <BundleFile> files)
{
var content = new StringBuilder();
foreach (var file in files)
{
FileInfo f = new FileInfo(HttpContext.Current.Server.MapPath(file.VirtualFile.VirtualPath));
CssSettings settings = new CssSettings();
settings.IgnoreAllErrors = true; //this is what you want
settings.CommentMode = Microsoft.Ajax.Utilities.CssComment.Important;
var minifier = new Microsoft.Ajax.Utilities.Minifier();
string readFile = Read(f);
string res = minifier.MinifyStyleSheet(readFile, settings);
content.Append(res);
}
return(content.ToString());
}
public async Task MinifyCss_CustomSettings_Success()
{
var settings = new CssSettings {
TermSemicolons = true, ColorNames = CssColor.NoSwap
};
var minifier = new CssMinifier(settings);
var context = new Mock <IAssetContext>().SetupAllProperties();
context.Object.Content = new Dictionary <string, byte[]> {
{ "", "body { color: yellow; }".AsByteArray() }
};
var options = new Mock <WebOptimizerOptions>();
await minifier.ExecuteAsync(context.Object);
Assert.Equal("body{color:yellow;}", context.Object.Content.First().Value.AsString());
Assert.Equal("", minifier.CacheKey(new DefaultHttpContext()));
}
public virtual string BuildBundleContent(Bundle bundle, BundleContext context, IEnumerable <BundleFile> files)
{
CssSettings settings = new CssSettings();
settings.IgnoreAllErrors = true;
settings.CommentMode = CssComment.None;
var minifier = new Minifier();
var content = new StringBuilder(100000);
foreach (var file in files)
{
FileInfo f = new FileInfo(HttpContext.Current.Server.MapPath(file.VirtualFile.VirtualPath));
string readFile = Read(f);
content.Append(minifier.MinifyStyleSheet(readFile, settings));
content.AppendLine();
}
return(content.ToString());
}
public override async Task <IEnumerable <Asset> > TransformAsync(string extension, params Asset[] assets)
{
CssSettings cssSettings = new CssSettings()
{
CommentMode = CssComment.None
};
if (0 < this.MinificationOptions.Substitutions.Count)
{
cssSettings.ReplacementTokensApplyDefaults(this.MinificationOptions.Substitutions);
}
CodeSettings codeSettings = new CodeSettings()
{
AmdSupport = true,
ScriptVersion = ScriptVersion.None,
PreserveImportantComments = false
};
List <Asset> outputs = new List <Asset>();
foreach (var asset in assets)
{
string code = await asset.ReadContentAsStringAsync();
UglifyResult uglifyResult = Uglify.Css(code, cssSettings, codeSettings);
if (uglifyResult.HasErrors)
{
throw new AggregateException(uglifyResult.Errors.Select(x => new Exception(x.Message)));
}
Asset outputAsset = await asset.CloneWithContentAsync(uglifyResult.Code);
outputs.Add(outputAsset);
}
return(outputs.AsEnumerable());
}
/// <summary>
/// Creates a original CSS minifier settings
/// </summary>
/// <param name="settings">CSS minifier settings</param>
/// <param name="isInlineCode">Flag for whether to create a settings for inline code</param>
/// <returns>Original CSS minifier settings</returns>
private static CssSettings CreateOriginalCssMinifierSettings(NUglifyCssMinificationSettings settings,
bool isInlineCode)
{
var originalSettings = new CssSettings();
MapCssSettings(originalSettings, settings);
originalSettings.CssType = isInlineCode ? CssType.DeclarationList : CssType.FullStyleSheet;
return originalSettings;
}
/// <summary>
/// Maps a CSS minifier settings
/// </summary>
/// <param name="originalSettings">Original CSS minifier settings</param>
/// <param name="settings">CSS minifier settings</param>
private static void MapCssSettings(CssSettings originalSettings, NUglifyCssMinificationSettings settings)
{
MapCommonSettings(originalSettings, settings);
originalSettings.ColorNames = Utils.GetEnumFromOtherEnum<WmmCssColor, NuCssColor>(
settings.ColorNames);
originalSettings.CommentMode = Utils.GetEnumFromOtherEnum<WmmCssComment, NuCssComment>(
settings.CommentMode);
originalSettings.MinifyExpressions = settings.MinifyExpressions;
originalSettings.RemoveEmptyBlocks = settings.RemoveEmptyBlocks;
}
/// <summary>
/// Constructs an instance of the NUglify CSS Minifier
/// </summary>
/// <param name="settings">NUglify CSS Minifier settings</param>
public NUglifyCssMinifier(NUglifyCssMinificationSettings settings)
{
_originalEmbeddedCssSettings = CreateOriginalCssMinifierSettings(settings, false);
_originalInlineCssSettings = CreateOriginalCssMinifierSettings(settings, true);
_originalJsSettings = new CodeSettings();
}
