public DynamicallyCompiledIndividualResourceHandler(string physicalPathToResource,
ResourceType resourceType,
ContentFilterPipeline contentFilterPipeline,
ContentFilterContext contentFilterContext)
: this(physicalPathToResource, resourceType, contentFilterPipeline, contentFilterContext, new FileAccessWrapper())
{
}
public string FilterContent(string content, ContentFilterContext context)
{
if (context.Group == null)
return content;
return _urlRegex.Replace(content, m => FixPath(m, context));
}
public string FilterContent(string content, ContentFilterContext context)
{
if (context.Group == null)
{
return(content);
}
return(_urlRegex.Replace(content, m => FixPath(m, context)));
}
public string FilterContent(string unfilteredContent, ContentFilterContext context)
{
foreach (var filter in _filters)
{
unfilteredContent = filter.FilterContent(unfilteredContent, context);
}
return(unfilteredContent);
}
public string FilterContent(string content, ContentFilterContext context)
{
if(context.Minify)
{
return CssCompressor.Compress(content);
}
return content;
}
public DynamicallyCompiledIndividualResource(IFileAccess fileAccess, ResourceType resourceType,
string physicalFilePath, ContentFilterPipeline contentFilterPipeline,
ContentFilterContext contentFilterContext)
{
_fileAccess = fileAccess;
_resourceType = resourceType;
_physicalFilePath = physicalFilePath;
_contentFilterPipeline = contentFilterPipeline;
_contentFilterContext = contentFilterContext;
}
public string FilterContent(string content, ContentFilterContext context)
{
if(context.Minify)
{
var culture = AssmanConfiguration.Current.Scripts.JsCompressionOverride.Culture;
return JavaScriptCompressor.Compress(content, true, true, false, false, -1, Encoding.Default, culture);
}
return content;
}
public string FilterContent(string content, ContentFilterContext context)
{
var config = new DotlessConfiguration
{
MinifyOutput = context.Minify,
Web = HttpContext.Current != null,
LessSource = typeof(VirtualPathFileReader),
CacheEnabled = false /* no need to cache as we let the Assman framework manage its own cache */
};
return dotless.Core.Less.Parse(content, config);
}
internal DynamicallyCompiledIndividualResourceHandler(string physicalPathToResource,
ResourceType resourceType,
ContentFilterPipeline contentFilterPipeline,
ContentFilterContext contentFilterContext,
IFileAccess fileAccess)
{
_physicalPathToResource = physicalPathToResource;
_resourceType = resourceType;
_contentFilterPipeline = contentFilterPipeline;
_contentFilterContext = contentFilterContext;
_fileAccess = fileAccess;
}
/// <summary>
/// Minifies javascript content using the JSMin library.
/// </summary>
/// <param name="content"></param>
/// <param name="context"></param>
public string FilterContent(string content, ContentFilterContext context)
{
if (!context.Minify)
return content;
using (var input = new StringReader(content))
{
using (var output = new StringWriter())
{
_minifier.Minify(input, output);
return output.ToString();
}
}
}
private string FixPath(Match match, ContentFilterContext context)
{
var url = match.Groups["url"].Value.Trim();
string quoteChar = String.Empty;
url = StripQuotesIfNecessary(url, ref quoteChar);
if (url.StartsWith("/") || url.StartsWith("http://", Comparisons.VirtualPath) || url.StartsWith("https://", Comparisons.VirtualPath))
return match.Value;
var consolidatedUri = CreateUri(context.Group.ConsolidatedUrl);
var uri = CreateUri(url.ToAppRelativePath(context.ResourceVirtualPath));
var fixedRelativePath = consolidatedUri.MakeRelativeUri(uri).ToString();
return String.Format("url({1}{0}{1})", fixedRelativePath, quoteChar);
}
/// <summary>
/// Minifies javascript content using the JSMin library.
/// </summary>
/// <param name="content"></param>
/// <param name="context"></param>
public string FilterContent(string content, ContentFilterContext context)
{
if (!context.Minify)
{
return(content);
}
using (var input = new StringReader(content))
{
using (var output = new StringWriter())
{
_minifier.Minify(input, output);
return(output.ToString());
}
}
}
public IHttpHandler GetHandlerUncached(string physicalPathToResource, string appRelativePathToResource)
{
var resourceType = ResourceType.FromPath(physicalPathToResource);
if (resourceType == null)
{
return null;
}
var resourceMode = GetResourceMode();
if (_assmanContext.PreCompiled)
{
return new PreCompiledResourceHandler(physicalPathToResource, resourceType, resourceMode)
{
EnableGZip = _assmanContext.GZip,
Mode = resourceMode
};
}
var groupTemplate = _assmanContext.FindGroupTemplate(appRelativePathToResource);
if (groupTemplate != null)
{
return new DynamicallyConsolidatedResourceHandler(appRelativePathToResource, _assmanContext.GetCompiler(),
groupTemplate)
{
MinLastModified = _assmanContext.ConfigurationLastModified,
Mode = resourceMode,
EnableGZip = _assmanContext.GZip
};
}
else
{
var fileExtension = Path.GetExtension(physicalPathToResource);
var contentFilterPipeline = _assmanContext.GetContentPipelineForExtension(fileExtension);
var contentFilterContext = new ContentFilterContext
{
Minify = resourceMode == ResourceMode.Release, //TODO: base this off of global minification setting
ResourceVirtualPath = appRelativePathToResource
};
return new DynamicallyCompiledIndividualResourceHandler(physicalPathToResource, resourceType, contentFilterPipeline, contentFilterContext)
{
Mode = resourceMode,
EnableGZip = _assmanContext.GZip
};
}
}
public string FilterContent(string content, ContentFilterContext context)
{
if (string.IsNullOrEmpty(content)) throw new ArgumentException("File content cannot be empty: " + context.ResourceVirtualPath);
if(context.Minify)
{
try
{
return CssCompressor.Compress(content);
}
catch (Exception ex)
{
throw new ArgumentException("Css Yui compressor was unable to compress the following file: " + context.ResourceVirtualPath, ex);
}
}
return content;
}
private string FixPath(Match match, ContentFilterContext context)
{
var url = match.Groups["url"].Value.Trim();
string quoteChar = String.Empty;
url = StripQuotesIfNecessary(url, ref quoteChar);
if (url.StartsWith("/") || url.StartsWith("http://", Comparisons.VirtualPath) || url.StartsWith("https://", Comparisons.VirtualPath))
{
return(match.Value);
}
var consolidatedUri = CreateUri(context.Group.ConsolidatedUrl);
var uri = CreateUri(url.ToAppRelativePath(context.ResourceVirtualPath));
var fixedRelativePath = consolidatedUri.MakeRelativeUri(uri).ToString();
return(String.Format("url({1}{0}{1})", fixedRelativePath, quoteChar));
}
public ICompiledResource CompileGroup(IResourceGroup group)
{
Func<IResource, string> getResourceContent = resource =>
{
var contentFilterPipeline = _contentFilterPipelineMap.GetPipelineForExtension(resource.FileExtension);
var contentFilterContext = new ContentFilterContext
{
Group = group,
Minify = group.Minify,
ResourceVirtualPath = resource.VirtualPath
};
return contentFilterPipeline.FilterContent(resource.GetContent(), contentFilterContext);
};
return group.GetResources()
.SortByDependencies(_dependencyManager)
.Consolidate(group, getResourceContent, group.ResourceType.Separator);
}
public ICompiledResource CompileResource(IResource resource)
{
var contentFilterPipeline = _contentFilterPipelineMap.GetPipelineForExtension(resource.FileExtension);
var contentFilterContext = new ContentFilterContext
{
Minify = _resourceMode == ResourceMode.Release, //TODO: obey global Minify settings
ResourceVirtualPath = resource.VirtualPath
};
var compiledContent = contentFilterPipeline.FilterContent(resource.GetContent(), contentFilterContext);
return new IndividuallyCompiledResource
{
Resource = resource,
Mode = _resourceMode,
CompiledContent = compiledContent
};
}
public void SetupContext()
{
_filter = new CssRelativePathFilter();
_context = new ContentFilterContext
{
ResourceVirtualPath = "~/Styles/AStylesheet.css",
Group = new StubResourceGroup("~/Styles/Consolidated/OneStylesheet.css")
};
}
public string FilterContent(string content, ContentFilterContext context)
{
return(content);
}
public string FilterContent(string content, ContentFilterContext context)
{
return content;
}
