private static string CompressCSS(string path) { var rawcss = File.ReadAllText(path); var cssCompressor = new CssCompressor(); var compressed = cssCompressor.Compress(rawcss); return compressed; }
internal YuiMinifier(int columnWidth) { compressor = new CssCompressor { LineBreakPosition = columnWidth, }; }
public override void Process(BundleContext context, BundleResponse response) { var compressor = new CssCompressor(); response.Content = compressor.Compress(response.Content); response.ContentType = ContentTypes.Css; }
/// <inheritdoc cref="IResourceMinifier.Minify" /> public string Minify(Settings settings, ResourceSet resourceSet, string combinedContent) { var compressor = new CssCompressor(); compressor.LineBreakPosition = LineBreakPosition == null ? -1 : LineBreakPosition.Value; compressor.RemoveComments = RemoveComments == null ? true : RemoveComments.Value; return compressor.Compress(combinedContent); }
public ResourceCompressor(CssCompressor cssCompressor, JavaScriptCompressor jsCompressor) { Ensure.That(() => cssCompressor).IsNotNull(); Ensure.That(() => jsCompressor).IsNotNull(); this.cssCompressor = cssCompressor; this.jsCompressor = jsCompressor; }
internal YuiMinifier(int columnWidth, CompressionType compressionType) { compressor = new CssCompressor { CompressionType = compressionType, LineBreakPosition = columnWidth, }; }
public YuiCssTransformer(CompressionType compressionType = CompressionType.Standard, int lineBreakPosition = -1, bool removeComments = true) { _compressor = new CssCompressor { CompressionType = compressionType, LineBreakPosition = lineBreakPosition, RemoveComments = removeComments }; }
internal YuiMinifier(int columnWidth, CompressionType compressionType, bool removeComments) { compressor = new CssCompressor { CompressionType = compressionType, LineBreakPosition = columnWidth, RemoveComments = removeComments }; }
public string Minify(string content) { CssCompressor cssCompressor = new CssCompressor { CompressionType = CompressionType.Standard, RemoveComments = true, LineBreakPosition = -1 }; return cssCompressor.Compress(content); }
public static void cssInPlaceMinify(string dplUrl) { var files = FileSources.pathsFromDpl(dplUrl).ToArray(); var compr = new CssCompressor(); foreach (var fn in files) { var res = compr.Compress(File.ReadAllText(fn, Encoding.UTF8)); var destFn = fn.Replace(".css", ".min.css"); File.WriteAllText(destFn, res); Trace.TraceInformation("Minified CSS: " + destFn); } }
public override void Process(BundleContext context, BundleResponse response) { response.ContentType = ContentTypes.Css; if (context.HttpContext.IsDebuggingEnabled) { return; } var compressor = new CssCompressor(); response.Content = compressor.Compress(response.Content); }
public ResourceCompressor(CssCompressor cssCompressor, JavaScriptCompressor jsCompressor) { if (cssCompressor == null) { throw new ArgumentNullException("cssCompressor"); } if (jsCompressor == null) { throw new ArgumentNullException("jsCompressor"); } this.cssCompressor = cssCompressor; this.jsCompressor = jsCompressor; }
public CompileResults Compile(string inPath, string outPath) { using (StreamReader sr = new StreamReader(inPath)) { string content = sr.ReadToEnd(); var x = new CssCompressor(); string output = x.Compress(content); using (StreamWriter sw = new StreamWriter(outPath)) { sw.Write(output); } } return null; }
public static MvcHtmlString MinifyInlineCss(this HtmlHelper html, Func <object, object> markup) { string notMinifiedCss = (markup.Invoke(html.ViewContext)?.ToString() ?? "").TrimStart("<style>") .TrimStart("<text>").TrimEnd("</style>").TrimEnd("</text>"); var minifier = new Yahoo.Yui.Compressor.CssCompressor() { RemoveComments = true }; minifier.CompressionType = Yahoo.Yui.Compressor.CompressionType.Standard; var minifiedCss = minifier.Compress(notMinifiedCss); return(new MvcHtmlString("<style>" + minifiedCss + "</style>")); }
private static string CompressCss(string content) { string results = ""; try { var cssCompressor = new CssCompressor(); results = cssCompressor.Compress(content); } catch (Exception ex) { WriteLog(ex); } return results; }
/// <summary> /// Process the request /// </summary> public void ProcessRequest(HttpContext context) { DateTime mod = new FileInfo(Assembly.GetExecutingAssembly().Location).LastWriteTime ; var compressor = new CssCompressor() ; if (File.Exists(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css"))) { FileInfo file = new FileInfo(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css")) ; mod = file.LastWriteTime > mod ? file.LastWriteTime : mod ; } if (!ClientCache.HandleClientCache(context, resource, mod)) { StreamReader io = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(resource)) ; context.Response.ContentType = "text/css" ; #if DEBUG context.Response.Write(io.ReadToEnd()) ; #else context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ; #endif io.Close() ; // Now apply standard theme if (ConfigurationManager.AppSettings["disable_manager_theme"] != "1") { io = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(theme)) ; #if DEBUG context.Response.Write(io.ReadToEnd()) ; #else context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ; #endif io.Close() ; } // Now check for application specific styles if (File.Exists(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css"))) { io = new StreamReader(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css")) ; #if DEBUG context.Response.Write(io.ReadToEnd()) ; #else context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ; #endif io.Close() ; } } }
/// <summary> /// Filters the assets /// </summary> /// <param name="Assets">Assets to filter</param> /// <returns>The filtered assets</returns> public IList<IAsset> Filter(IList<IAsset> Assets) { if (Assets == null || Assets.Count == 0) return new List<IAsset>(); if (Assets.FirstOrDefault().Type != AssetType.CSS) return Assets; var Processable = Assets.Where(x => !x.Minified); if (Processable.FirstOrDefault() == null) return Assets; var Minifier = new CssCompressor { CompressionType = CompressionType.Standard, RemoveComments = true }; foreach (IAsset Asset in Processable.Where(x => x != null)) { try { Asset.Content = Minifier.Compress(Asset.Content); Asset.Minified = true; } catch { } } return Assets; }
static void Main(string[] args) { foreach (var arg in args) Console.WriteLine(arg); List<string> cssFiles = new List<string>(); List<string> jsFiles = new List<string>(); foreach (var file in args) { if (file.EndsWith(".css")) cssFiles.Add(file); else if (file.EndsWith(".js")) jsFiles.Add(file); } var cssCompressor = new CssCompressor(); var jsCompressor = new JavaScriptCompressor(); foreach(var jsFile in jsFiles){ var compress = jsCompressor.Compress(File.ReadAllText(jsFile)); var newPath = jsFile.Replace(".js", "") + ".min.js"; using (StreamWriter swr = new StreamWriter(newPath,false)) { swr.Write(compress); swr.Close(); } } foreach (var cssFile in cssFiles) { var compress = cssCompressor.Compress(File.ReadAllText(cssFile)); var newPath = cssFile.Replace(".css", "") + ".min.css"; using (StreamWriter swr = new StreamWriter(newPath, false)) { swr.Write(compress); swr.Close(); } } }
private string TransformContent(BundleResource bundleResource, HttpContext context) { var bundleType = bundleResource.Type; var content = bundleResource.Content; var serverpath = bundleResource.ServerPath; try { if (bundleType == BundleResourceType.EmbeddedScript || bundleType == BundleResourceType.ScriptFile) { var compressor = new JavaScriptCompressor { CompressionType = CompressionType.Standard, Encoding = Encoding.UTF8, ObfuscateJavascript = bundleResource.ObfuscateJs }; //Minimize var contentOut = compressor.Compress(content.Trim()) + ";"; //Return deffered execution if (ClientSettings.IsJavascriptDefferingEnabled) { return string.Format(ClientSettings.JavascriptDefferingScript, JsonConvert.SerializeObject(contentOut)); } return contentOut; } if (!string.IsNullOrEmpty(serverpath)) { string directoryName = Path.GetDirectoryName(serverpath); if (directoryName != null) serverpath = directoryName.Replace('\\', '/'); } if (bundleType == BundleResourceType.EmbeddedStyle || bundleType == BundleResourceType.StyleFile) { var compressor = new CssCompressor { CompressionType = CompressionType.Standard, RemoveComments = true }; return ReplaceUrls(compressor.Compress(content), serverpath, context); } if (bundleType == BundleResourceType.LessFile) { DotlessConfiguration cfg = DotlessConfiguration.GetDefaultWeb(); cfg.Web = true; cfg.MinifyOutput = true; cfg.MapPathsToWeb = true; cfg.CacheEnabled = false; //Prefilter content = ReplaceImportRegex.Replace(content, match => ReplaceImports(match, serverpath)); string processed = ReplaceUrls(LessWeb.Parse(content, cfg), serverpath, context); return processed; } } catch (EcmaScript.NET.EcmaScriptException e) { _log.ErrorFormat("EcmaScriptException: {0} in {1} at {2} ({3}, {4}) at ", e.Message, serverpath, e.LineSource, e.LineNumber, e.ColumnNumber, e.ScriptStackTrace); } catch (Exception e) { _log.Error(e); } return content; }
string YUI_CSS(string filesource, ConfigSettings.YUICompressionSettings.CSS CssSettings) { try { var csscompressor = new CssCompressor(); csscompressor.CompressionType = CssSettings.CompressionType; csscompressor.LineBreakPosition = CssSettings.LineBreakPosition; csscompressor.RemoveComments = CssSettings.RemoveComments; return csscompressor.Compress(filesource); } catch (Exception ex) { var msg = ex.Message; return filesource; } }
internal static string CSS(string css) { var cssCom = new CssCompressor(); return cssCom.Compress(css); }
private void Minify(FileInfo source, FileInfo file) { if (Options.IsDebugLoggingEnabled) Logger.Log("Generating minified css file."); try { var css = File.ReadAllText(source.FullName); string minified = ""; if (!string.IsNullOrEmpty(css)) { var compressor = new CssCompressor { RemoveComments = true }; minified = compressor.Compress(css); } InteropHelper.CheckOut(file.FullName); File.WriteAllText(file.FullName, minified, UTF8_ENCODING); // nest if (Options.IncludeCssInProject) AddFileToProject(source, file, Options); } catch (Exception ex) { Logger.Log(ex, "Failed to generate minified css file."); if (Options.ReplaceCssWithException) SaveExceptionToFile(ex, file); } }
static string RunYuiCompressorForCss(IList<string> pSourceFilePaths, string pOutputFilePath, bool pCompressFileContents = true, string pHeaderComment = null, bool pIncludeGenDateInHeaderComment = true) { var compressor = new CssCompressor(); compressor.RemoveComments = true; return RunYuiCompressor(compressor, pSourceFilePaths, pOutputFilePath, pCompressFileContents, pHeaderComment, pIncludeGenDateInHeaderComment); }
public CssMinifyCompiler() { _compiler = new CssCompressor(); }
/// <summary> /// Creates a instance of inline CSS-code compressor /// </summary> /// <returns>Inline CSS-code compressor</returns> private CssCompressor CreateInlineCssCompressorInstance() { var inlineCssCompressor = new CssCompressor(); ApplyCssSettingsToCssCompressor(inlineCssCompressor, _settings); inlineCssCompressor.LineBreakPosition = -1; return inlineCssCompressor; }
/// <summary> /// Applies a CSS settings to original CSS minifier /// </summary> /// <param name="originalMinifier">Original CSS minifier</param> /// <param name="settings">CSS minifier settings</param> private static void ApplyCssSettingsToOriginalCssMinifier(CssCompressor originalMinifier, YuiCssMinificationSettings settings) { ApplyCommonSettingsToOriginalMinifier(originalMinifier, settings); originalMinifier.RemoveComments = settings.RemoveComments; }
/// <summary> /// Creates a instance of original CSS minifier /// </summary> /// <param name="settings">CSS minifier settings</param> /// <param name="isInlineCode">Flag for whether to create a settings for inline code</param> /// <returns>Instance of original CSS minifier</returns> private static CssCompressor CreateOriginalCssMinifierInstance(YuiCssMinificationSettings settings, bool isInlineCode) { var originalMinifier = new CssCompressor(); ApplyCssSettingsToOriginalCssMinifier(originalMinifier, settings); if (isInlineCode) { originalMinifier.LineBreakPosition = -1; } return originalMinifier; }
public string Compress(string contents) { var cssCompressor = new CssCompressor(); return cssCompressor.Compress(contents); }
/// <summary> /// Constructs an instance of the YUI CSS Minifier /// </summary> /// <param name="settings">Settings of YUI CSS Minifier</param> public YuiCssMinifier(YuiCssMinificationSettings settings) { _originalEmbeddedCssMinifier = CreateOriginalCssMinifierInstance(settings, false); _originalInlineCssMinifier = CreateOriginalCssMinifierInstance(settings, true); }
/// <summary> /// OnItemProcessed event handler. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> public void OnItemProcessed(object sender, EventArgs args) { var context = ((ItemProcessedEventArgs)args).Context; string targetDataBase = context.PublishOptions.TargetDatabase.Name.ToLower(); Databases = Databases.ToLower(); if (Databases.Contains(targetDataBase)) { using (new Sitecore.SecurityModel.SecurityDisabler()) { // Get published item in target environment var item = context.PublishHelper.GetTargetItem(context.ItemId); // Check if item is published and it is a media item if (item != null && item.Paths.IsMediaItem) { MediaItem mediaItem = new MediaItem(item); string fileExtension = mediaItem.Extension.ToLower(); // Check if media item is css or js resource if (fileExtension != "css" && fileExtension != "js") { return; } try { // Get Stream object of the media item using (Stream mediaStream = mediaItem.GetMediaStream()) { using (StreamReader sr = new StreamReader(mediaStream)) { // Read contents of the media items into a String object string originalString = sr.ReadToEnd(); string newString = String.Empty; // If media item is CSS, then use CssCompressor for compression if (fileExtension == "css") { newString = new CssCompressor().Compress(originalString); } // If media item is JS, then use JavaScriptCompressor for compression else if (fileExtension == "js") { newString = new JavaScriptCompressor().Compress(originalString); } if (String.IsNullOrEmpty(newString)) { return; } byte[] byteArray = Encoding.ASCII.GetBytes(newString); using (MemoryStream stream = new MemoryStream(byteArray)) { // Edit mediaItem and upload minified version using (new EditContext((Item)mediaItem, SecurityCheck.Disable)) { Sitecore.Resources.Media.Media media = MediaManager.GetMedia(mediaItem); media.SetStream(new MediaStream(stream, fileExtension, mediaItem)); } } } } Sitecore.Diagnostics.Log.Info(String.Format("Media Items Minfier: Published item - '{0}' minified successfully.", item.Paths.FullPath), this); } catch (Exception ex) { Sitecore.Diagnostics.Log.Error(String.Format("Media Items Minfier: Published item - '{0}' not minified. Error: ", item.Paths.FullPath), ex, this); } } } } }
/// <summary> /// Minimizes the CSS code. /// </summary> /// <param name="inputCssFile">The input CSS file.</param> /// <returns></returns> public string MinimizeCssCode(string inputCssFile) { var cssContents = File.ReadAllText(this.RapContext.MapPath(inputCssFile)); var cssCompress = new CssCompressor(); return cssCompress.Compress(cssContents); }