/// <summary>
///
/// </summary>
/// <param name="contentType"></param>
/// <param name="assetGroup"></param>
/// <returns></returns>
private static MergedAsset CreateMergedAssetWith(string contentType, WebAssetItemGroup assetGroup)
{
Func <string, string> getDirectory = path => path.Substring(2, path.LastIndexOf("/", StringComparison.Ordinal) - 2);
Func <string, string> getFile = path => path.Substring(path.LastIndexOf("/", StringComparison.Ordinal) + 1);
MergedAsset asset = new MergedAsset
{
ContentType = contentType,
Version = assetGroup.Version,
Compress = assetGroup.Compress,
CacheDurationInDays = assetGroup.CacheDurationInDays
};
IEnumerable <string> directories = assetGroup.Items.Select(item => getDirectory(item.Source)).Distinct(StringComparer.OrdinalIgnoreCase);
directories.Each(directory => asset.Directories.Add(new MergedAssetDirectory {
Path = directory
}));
for (int i = 0; i < assetGroup.Items.Count; i++)
{
string item = assetGroup.Items[i].Source;
string directory = getDirectory(item);
string file = getFile(item);
MergedAssetDirectory assetDirectory = asset.Directories.Single(d => d.Path.IsCaseInsensitiveEqual(directory));
assetDirectory.Files.Add(new MergedAssetFile {
Order = i, Name = file
});
}
return(asset);
}
/// <summary>
///
/// </summary>
/// <param name="mergedAsset"></param>
/// <returns></returns>
private static string CreateIdFrom(MergedAsset mergedAsset)
{
string serialized = Serialize(mergedAsset);
string id = Encode(Compress(serialized));
return(id);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
private static MergedAsset CreateMergedAssetFromUrl(string id)
{
string decompressed = Decompress(Decode(id));
MergedAsset mergedAsset = Deserialize(decompressed);
return(mergedAsset);
}
/// <summary>
/// Retrieves the web asset by specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public WebAsset Retrieve(string id)
{
MergedAsset mergedAsset = CreateMergedAssetFromConfiguration(id) ?? CreateMergedAssetFromUrl(id);
WebAssetHolder assetHolder = EnsureAsset(mergedAsset, id);
return(new WebAsset(assetHolder.Asset.ContentType, assetHolder.Asset.Version, assetHolder.Asset.Compress, assetHolder.Asset.CacheDurationInDays, assetHolder.Content));
}
/// <summary>
///
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
private static MergedAsset Deserialize(string json)
{
JavaScriptSerializer serializer = CreateSerializer();
MergedAsset mergedAsset = serializer.Deserialize <MergedAsset>(json);
return(mergedAsset);
}
/// <summary>
///
/// </summary>
/// <param name="mergedAsset"></param>
/// <returns></returns>
private static string Serialize(MergedAsset mergedAsset)
{
JavaScriptSerializer serializer = CreateSerializer();
string json = serializer.Serialize(mergedAsset);
return(json);
}
/// <summary>
/// Stores the specified asset group.
/// </summary>
/// <param name="contentType">Type of the content.</param>
/// <param name="assetGroup">The asset group.</param>
/// <returns></returns>
public string Store(string contentType, WebAssetItemGroup assetGroup)
{
MergedAsset mergedAsset = CreateMergedAssetWith(contentType, assetGroup);
string id = assetGroup.IsShared ? assetGroup.Name : CreateIdFrom(mergedAsset);
EnsureAsset(mergedAsset, id);
return(id);
}
/// <summary>
///
/// </summary>
/// <param name="asset"></param>
/// <param name="id"></param>
/// <returns></returns>
private WebAssetHolder EnsureAsset(MergedAsset asset, string id)
{
string key = "{0}:{1}".FormatWith(GetType().AssemblyQualifiedName, id);
WebAssetHolder assetHolder;
using (syncLock.ReadAndWrite())
{
assetHolder = GetWebAssetHolder(key);
if (assetHolder == null)
{
using (syncLock.Write())
{
assetHolder = GetWebAssetHolder(key);
if (assetHolder == null)
{
List <string> physicalPaths = new List <string>();
StringBuilder contentBuilder = new StringBuilder();
var files = asset.Directories
.SelectMany(d => d.Files.Select(f => new { Directory = d, File = f }))
.OrderBy(f => f.File.Order);
foreach (var pair in files)
{
string path = "~/" + pair.Directory.Path + "/" + pair.File.Name;
string virtualPath = assetLocator.Locate(path, asset.Version);
string fileContent = virtualPathProvider.ReadAllText(virtualPath);
if (string.Compare(asset.ContentType, "text/css", StringComparison.OrdinalIgnoreCase) == 0)
{
string baseDiretory = virtualPathProvider.GetDirectory(virtualPath);
fileContent = ReplaceImagePath(baseDiretory, asset.Version, fileContent);
}
contentBuilder.AppendLine(fileContent);
physicalPaths.Add(pathResolver.Resolve(virtualPath));
}
assetHolder = new WebAssetHolder {
Asset = asset, Content = contentBuilder.ToString()
};
cacheManager.Insert(key, assetHolder, null, physicalPaths.ToArray());
}
}
}
}
return(assetHolder);
}
public void Should_Set_Content()
{
var assets = new AssetCollection()
{
new AssetBaseImpl("function(){}"),
new AssetBaseImpl("function(){}")
};
var asset = new MergedAsset(assets, ";");
Assert.AreEqual("function(){};function(){};", asset.OpenStream().ReadToEnd());
}
/// <summary>
///
/// </summary>
/// <param name="dictionary"></param>
/// <param name="type"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
MergedAsset mergedAsset = new MergedAsset
{
ContentType = serializer.ConvertToType <string>(dictionary["ct"]),
Version = serializer.ConvertToType <string>(dictionary["v"]),
Compress = serializer.ConvertToType <bool>(dictionary["c"]),
CacheDurationInDays = serializer.ConvertToType <float>(dictionary["cd"])
};
mergedAsset.Directories.AddRange(serializer.ConvertToType <IList <MergedAssetDirectory> >(dictionary["d"]));
return(mergedAsset);
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
{
MergedAsset mergedAsset = (MergedAsset)obj;
IDictionary <string, object> dictionary = new Dictionary <string, object>
{
{ "ct", mergedAsset.ContentType },
{ "v", mergedAsset.Version },
{ "c", mergedAsset.Compress },
{ "cd", mergedAsset.CacheDurationInDays },
{ "d", mergedAsset.Directories }
};
return(dictionary);
}
public void Should_Return_New_Stream_And_Full_Content()
{
var assets = new AssetCollection()
{
new AssetBaseImpl("function(){}"),
new AssetBaseImpl("function(){}")
};
var asset = new MergedAsset(assets, ";");
//will throw exception if we do not return new stream
var content = asset.OpenStream().ReadToEnd();
var content2 = asset.OpenStream().ReadToEnd();
Assert.AreEqual(content2, content);
}
private WebAssetHolder EnsureAsset(MergedAsset asset, string id)
{
string key = "{0}:{1}".FormatWith(GetType().AssemblyQualifiedName, id);
WebAssetHolder assetHolder;
using (syncLock.ReadAndWrite())
{
assetHolder = GetWebAssetHolder(key);
if (assetHolder == null)
{
using (syncLock.Write())
{
assetHolder = GetWebAssetHolder(key);
if (assetHolder == null)
{
List<string> physicalPaths = new List<string>();
StringBuilder contentBuilder = new StringBuilder();
var files = asset.Directories
.SelectMany(d => d.Files.Select(f => new { Directory = d, File = f }))
.OrderBy(f => f.File.Order);
foreach (var pair in files)
{
string path = "~/" + pair.Directory.Path + "/" + pair.File.Name;
string virtualPath = assetLocator.Locate(path, asset.Version);
string fileContent = virtualPathProvider.ReadAllText(virtualPath);
if (string.Compare(asset.ContentType, "text/css", StringComparison.OrdinalIgnoreCase) == 0)
{
string baseDiretory = virtualPathProvider.GetDirectory(virtualPath);
fileContent = ReplaceImagePath(baseDiretory, fileContent);
}
contentBuilder.AppendLine(fileContent);
physicalPaths.Add(pathResolver.Resolve(virtualPath));
}
assetHolder = new WebAssetHolder { Asset = asset, Content = contentBuilder.ToString() };
cacheManager.Insert(key, assetHolder, null, physicalPaths.ToArray());
}
}
}
}
return assetHolder;
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
MergedAsset mergedAsset = new MergedAsset
{
ContentType = serializer.ConvertToType<string>(dictionary["ct"]),
Version = serializer.ConvertToType<string>(dictionary["v"]),
Compress = serializer.ConvertToType<bool>(dictionary["c"]),
CacheDurationInDays = serializer.ConvertToType<float>(dictionary["cd"])
};
mergedAsset.Directories.AddRange(serializer.ConvertToType<IList<MergedAssetDirectory>>(dictionary["d"]));
return mergedAsset;
}
private WebAssetHolder EnsureAsset(MergedAsset asset, string id)
{
string key = CreateKey(id);
WebAssetHolder assetHolder;
using (syncLock.ReadAndWrite())
{
assetHolder = cacheManager.GetItem(key) as WebAssetHolder;
if (assetHolder == null)
{
using (syncLock.Write())
{
assetHolder = cacheManager.GetItem(key) as WebAssetHolder;
if (assetHolder == null)
{
IEnumerable<string> items = asset.Directories
.SelectMany(d => d.Files.Select(f => new { f.Order, path = "~/" + d.Path + "/" + f.Name }))
.OrderBy(f => f.Order)
.Select(f => f.path);
List<string> physicalPaths = new List<string>();
StringBuilder contentBuilder = new StringBuilder();
foreach (string item in items)
{
string virtualPath = assetLocator.Locate(item);
string physicalPath = pathResolver.Resolve(virtualPath);
string fileContent = fileSystem.ReadAllText(physicalPath);
contentBuilder.AppendLine(fileContent);
physicalPaths.Add(physicalPath);
}
assetHolder = new WebAssetHolder { Asset = asset, Content = contentBuilder.ToString() };
cacheManager.Insert(key, assetHolder, null, physicalPaths.ToArray());
}
}
}
}
return assetHolder;
}
private static string Serialize(MergedAsset mergedAsset)
{
JavaScriptSerializer serializer = CreateSerializer();
string json = serializer.Serialize(mergedAsset);
return json;
}
private static MergedAsset CreateMergedAssetWith(string contentType, string version, bool compress, float cacheDurationInDays, IList<string> items)
{
Func<string, string> getDirectory = path => path.Substring(2, path.LastIndexOf("/", StringComparison.Ordinal) - 2);
Func<string, string> getFile = path => path.Substring(path.LastIndexOf("/", StringComparison.Ordinal) + 1);
MergedAsset asset = new MergedAsset
{
ContentType = contentType,
Version = version,
Compress = compress,
CacheDurationInDays = cacheDurationInDays
};
IEnumerable<string> directories = items.Select(getDirectory).Distinct(StringComparer.OrdinalIgnoreCase);
directories.Each(directory => asset.Directories.Add(new MergedAssetDirectory { Path = directory }));
for (int i = 0; i < items.Count; i++)
{
string item = items[i];
string directory = getDirectory(item);
string file = getFile(item);
MergedAssetDirectory assetDirectory = asset.Directories.Single(d => d.Path.IsCaseInsensitiveEqual(directory));
assetDirectory.Files.Add(new MergedAssetFile { Order = i, Name = file });
}
return asset;
}
private static string CreateIdFrom(MergedAsset mergedAsset)
{
string serialized = Serialize(mergedAsset);
string id = Encode(Compress(serialized));
return id;
}
