public ActionResult Index() { IOptimizedResult sample = ResourceHandler.Create <IOptimizedResult>(HomeController.SamplePath); IOptimizedResult support = ResourceHandler.Create <IOptimizedResult>(JbstController.SupportScriptPath); // populate data to be used in view return(this.View(new HomeViewModel(sample.Source, support))); }
/// <summary> /// Ctor /// </summary> /// <param name="source"></param> /// <param name="support"></param> public HomeViewModel(string source, IOptimizedResult support) { this.SampleSource = HttpUtility.HtmlEncode(source).Trim(); this.CompactSize = FormatFileSize(support.Compacted.Length); this.FullSize = FormatFileSize(support.PrettyPrinted.Length); this.GzipSize = FormatFileSize(support.Gzipped.Length); this.DeflateSize = FormatFileSize(support.Deflated.Length); }
/// <summary> /// Ctor /// </summary> /// <param name="source"></param> /// <param name="support"></param> public HomeViewModel(string source, IOptimizedResult support) { this.SampleSource = HttpUtility.HtmlEncode(source).Trim(); this.CompactSize = FormatFileSize(support.Compacted.Length); this.FullSize = FormatFileSize(support.PrettyPrinted.Length); this.GzipSize = FormatFileSize(support.Gzipped.Length); this.DeflateSize = FormatFileSize(support.Deflated.Length); }
void IHttpHandler.ProcessRequest(HttpContext context) { HttpResponse response = context.Response; try { response.ClearHeaders(); response.ClearContent(); } catch { } response.TrySkipIisCustomErrors = true; response.BufferOutput = true; // specifying "DEBUG" in the query string gets the non-compacted form IOptimizedResult info = this.GetResourceInfo(context, this.IsDebug); if (info == null) { // either eTag 304 was sent or no resource found return; } bool isCached = StringComparer.OrdinalIgnoreCase.Equals(info.Hash, this.CacheKey); if (isCached) { // if the content changes then so will the hash // so we can effectively cache this forever response.ExpiresAbsolute = DateTime.UtcNow.AddYears(1); } response.ContentType = info.ContentType; string filename = Path.GetFileNameWithoutExtension(context.Request.FilePath) + '.' + info.FileExtension; // this helps IE determine the Content-Type // http://tools.ietf.org/html/rfc2183#section-2.3 ContentDisposition disposition = new ContentDisposition { Inline = true, FileName = filename }; response.AddHeader("Content-Disposition", disposition.ToString()); ResourceHandler.WriteResponse(context, info, this.IsDebug); }
private IOptimizedResult ProcessPrecompiled(IResourceBuildHelper helper, string file) { IOptimizedResult result = ResourceHandler.Create <IOptimizedResult>(file); if (result != null) { if (!this.isMimeSet && !String.IsNullOrEmpty(result.ContentType) && !String.IsNullOrEmpty(result.FileExtension)) { this.contentType = result.ContentType; this.fileExtension = result.FileExtension; this.isMimeSet = true; } if (result is IGlobalizedBuildResult) { this.GlobalizationKeys.AddRange(((IGlobalizedBuildResult)result).GlobalizationKeys); } helper.AddVirtualPathDependency(file); ICollection dependencies = BuildManager.GetVirtualPathDependencies(file); if (dependencies != null) { foreach (string dependency in dependencies) { helper.AddVirtualPathDependency(dependency); } } if (result is IDependentResult) { foreach (string dependency in ((IDependentResult)result).VirtualPathDependencies) { helper.AddVirtualPathDependency(dependency); } } } return(result); }
/// <summary> /// Determines the appropriate source for the incomming request /// </summary> /// <param name="context"></param> /// <param name="isDebug"></param> /// <returns>CompiledBuildResult</returns> protected virtual IOptimizedResult GetResourceInfo(HttpContext context, bool isDebug) { string virtualPath = context.Request.AppRelativeCurrentExecutionFilePath; IOptimizedResult info = ResourceHandler.Create <IOptimizedResult>(virtualPath); if (info == null) { throw new HttpException(404, "Resource not found: " + virtualPath); } // check if client has cached copy ETag etag = new HashETag(info.Hash); if (etag.HandleETag(context, HttpCacheability.ServerAndPrivate, isDebug)) { return(null); } return(info); }
/// <summary> /// Determines the most compact Content-Encoding supported by request. /// </summary> /// <param name="acceptEncoding"></param> /// <param name="isDebug"></param> /// <returns>optimal format</returns> private static BuildResultType GetOutputEncoding(IOptimizedResult result, HttpContext context, bool isDebug) { if (isDebug) { // short cut all debug builds return(BuildResultType.PrettyPrint); } string acceptEncoding = context.Request.Headers[ResourceHandler.HeaderAcceptEncoding]; if (String.IsNullOrEmpty(acceptEncoding)) { // not compressed but fully compacted return(BuildResultType.Compact); } acceptEncoding = acceptEncoding.ToLowerInvariant(); if (result.Deflated != null && result.Deflated.Length > 0 && acceptEncoding.Contains(ResourceHandler.DeflateContentEncoding)) { // compressed with Deflate return(BuildResultType.Deflate); } if (result.Gzipped != null && result.Gzipped.Length > 0 && acceptEncoding.Contains(ResourceHandler.GzipContentEncoding)) { // compressed with Gzip return(BuildResultType.Gzip); } // not compressed but fully compacted return(BuildResultType.Compact); }
/// <summary> /// Writes the infor object to the HttpResult stream /// </summary> /// <param name="context"></param> /// <param name="info"></param> /// <param name="isDebug"></param> public static void WriteResponse(HttpContext context, IOptimizedResult info, bool isDebug) { HttpResponse response = context.Response; switch (ResourceHandler.GetOutputEncoding(info, context, isDebug)) { case BuildResultType.PrettyPrint: { response.ContentEncoding = Encoding.UTF8; response.Output.Write(info.PrettyPrinted); break; } case BuildResultType.Gzip: { response.AppendHeader(ResourceHandler.HeaderContentEncoding, ResourceHandler.GzipContentEncoding); response.OutputStream.Write(info.Gzipped, 0, info.Gzipped.Length); break; } case BuildResultType.Deflate: { response.AppendHeader(ResourceHandler.HeaderContentEncoding, ResourceHandler.DeflateContentEncoding); response.OutputStream.Write(info.Deflated, 0, info.Deflated.Length); break; } case BuildResultType.Compact: default: { response.ContentEncoding = Encoding.UTF8; response.Output.Write(info.Compacted); break; } } }
/// <summary> /// Ctor /// </summary> /// <param name="path"></param> public ResourceResult(string resourcePath) { this.ResourcePath = resourcePath; this.Resource = ResourceHandler.Create <IOptimizedResult>(resourcePath); this.IsDebug = HttpContext.Current.IsDebuggingEnabled; }
/// <summary> /// Ctor /// </summary> /// <param name="path"></param> public ResourceResult(string resourcePath) { this.ResourcePath = resourcePath; this.Resource = ResourceHandler.Create<IOptimizedResult>(resourcePath); this.IsDebug = HttpContext.Current.IsDebuggingEnabled; }
protected internal override void ProcessResource( IResourceBuildHelper helper, string virtualPath, string sourceText, out string resource, out string compacted, List <ParseException> errors) { if (String.IsNullOrEmpty(sourceText)) { resource = null; compacted = null; return; } StringBuilder resources = new StringBuilder(); StringBuilder compacts = new StringBuilder(); string[] files = sourceText.Split(LineDelims, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < files.Length; i++) { try { string file = files[i], compactAlt = null; if (file != null) { file = file.Trim(); } // skip blank and comment lines if (String.IsNullOrEmpty(file) || file.StartsWith("//") || file.StartsWith("#")) { continue; } MergeResourceCodeProvider.SplitAlternates(file, out file, out compactAlt); if (file.IndexOf("://") >= 0) { string preProcessed, compact; this.ProcessExternalResource(helper, file, out preProcessed, out compact, errors); if (!String.IsNullOrEmpty(compactAlt)) { this.ProcessExternalResource(helper, compactAlt, out compactAlt, out compact, errors); } compacts.Append(compact); resources.Append(preProcessed); continue; } // process embedded resource if (file.IndexOf(',') >= 0) { string preProcessed, compact; this.ProcessEmbeddedResource(helper, file, out preProcessed, out compact, errors); if (!String.IsNullOrEmpty(compactAlt)) { this.ProcessEmbeddedResource(helper, compactAlt, out compactAlt, out compact, errors); } compacts.Append(compact); resources.Append(preProcessed); continue; } file = ResourceHandler.EnsureAppRelative(file); if (!String.IsNullOrEmpty(compactAlt)) { compactAlt = ResourceHandler.EnsureAppRelative(compactAlt); } // try to get as a IOptimizedResult IOptimizedResult result = this.ProcessPrecompiled(helper, file); if (result != null) { resources.Append(result.PrettyPrinted); if (String.IsNullOrEmpty(compactAlt)) { compacts.Append(result.Compacted); } else { IOptimizedResult result2 = this.ProcessPrecompiled(helper, compactAlt); if (result2 != null) { compacts.Append(result2.Compacted); } } continue; } // ask BuildManager if compiles down to a string string text = BuildManager.GetCompiledCustomString(file); if (String.IsNullOrEmpty(text)) { // use the raw contents of the virtual path text = helper.OpenReader(file).ReadToEnd(); } if (!String.IsNullOrEmpty(text)) { helper.AddVirtualPathDependency(file); resources.Append(text); if (String.IsNullOrEmpty(compactAlt)) { compacts.Append(text); } else { helper.AddVirtualPathDependency(compactAlt); string text2 = BuildManager.GetCompiledCustomString(compactAlt); compacts.Append(text2); } continue; } } catch (ParseException ex) { errors.Add(ex); } catch (Exception ex) { errors.Add(new ParseError(ex.Message, virtualPath, i + 1, 1, ex)); } } resources.AppendLine(); resources.AppendFormat("/* JsonFx v{0} */", JsonFx.About.Fx.Version); resource = resources.ToString(); compacted = compacts.ToString(); }