public TagBuilder GetTagBuilder(RequireSettings baseSettings, string appPath) { var tagBuilder = new TagBuilder(Resource.TagName); tagBuilder.MergeAttributes(Resource.TagBuilder.Attributes); if (!String.IsNullOrEmpty(Resource.FilePathAttributeName)) { var resolvedUrl = GetResourceUrl(baseSettings, appPath); if (!String.IsNullOrEmpty(resolvedUrl)) { tagBuilder.MergeAttribute(Resource.FilePathAttributeName, resolvedUrl, true); } } return tagBuilder; }
public void WriteResources(TextWriter Output, string resourceType, string resourceName) { bool debugMode = workContext.IsDebug; var settings = new RequireSettings { DebugMode = debugMode, Culture = CultureInfo.CurrentUICulture.Name, Type = resourceType, Name = resourceName }; var appPath = httpContext.Request.ApplicationPath; var requiredResources = resourceManager.FindRequiredResources(settings); if (debugMode == true) { foreach (var context in requiredResources) { var path = context.GetResourceUrl(settings, appPath); var condition = context.Settings.Condition; var attributes = context.Settings.HasAttributes ? context.Settings.Attributes : null; ResourceManager.WriteResource(Output, context.Resource, path, condition, attributes); } } else { var disableCompressResources = requiredResources.Where(o => o.Resource.EnableCompress == false).ToArray(); if (disableCompressResources != null) { foreach (var context in disableCompressResources) { var path = context.GetResourceUrl(settings, appPath); var condition = context.Settings.Condition; var attributes = context.Settings.HasAttributes ? context.Settings.Attributes : null; ResourceManager.WriteResource(Output, context.Resource, path, condition, attributes); } } BundleCollection bundles = BundleTable.Bundles; string virtualPath = string.Format("~/{0}/{1}", resourceType, resourceName); if (!BundleResolver.Current.IsBundleVirtualPath(virtualPath)) { Bundle bundle = null; if (resourceType == "stylesheet") { bundle = new StyleBundle(virtualPath); } else { bundle = new ScriptBundle(virtualPath); } foreach (var context in requiredResources) { if (context.Resource.EnableCompress) { var bundlePath = "~" + context.GetResourceUrl(settings, appPath); bundle.Include(bundlePath); } } bundles.Add(bundle); } ResourceManager.WriteResource(Output, requiredResources[0].Resource, bundles.ResolveBundleUrl(virtualPath), null, null); } }
private void WriteResources(TextWriter Output, string resourceType, ResourceLocation? includeLocation, ResourceLocation? excludeLocation) { bool debugMode = workContext.IsDebug; var defaultSettings = new RequireSettings { DebugMode = debugMode, Culture = CultureInfo.CurrentUICulture.Name, }; var appPath = httpContext.Request.ApplicationPath; if (debugMode == true) { #region debugMode var requiredResources = resourceManager.BuildRequiredResources(resourceType); foreach (var context in requiredResources.Where(r => (includeLocation.HasValue ? r.Settings.Location == includeLocation.Value : true) && (excludeLocation.HasValue ? r.Settings.Location != excludeLocation.Value : true))) { var path = context.GetResourceUrl(defaultSettings, appPath); var condition = context.Settings.Condition; var attributes = context.Settings.HasAttributes ? context.Settings.Attributes : null; //IHtmlString result; //if (resourceType == "stylesheet") //{ // result = Style(Url: path, Condition: condition, Resource: context.Resource, TagAttributes: attributes); //} //else //{ // result = Resource(Url: path, Condition: condition, Resource: context.Resource, TagAttributes: attributes); //} ResourceManager.WriteResource(Output, context.Resource, path, condition, attributes); // Output.Write(result); } #endregion } else { BundleCollection bundles = BundleTable.Bundles; var requiredGroupResources = resourceManager.BuildRequiredGroupResources(resourceType, includeLocation); foreach (var requiredGroupResource in requiredGroupResources) { var disableCompressResources = requiredGroupResource.Value.Where(o => o.Resource.EnableCompress == false).ToArray(); if (disableCompressResources != null) { foreach (var context in disableCompressResources) { var path = context.GetResourceUrl(defaultSettings, appPath); var condition = context.Settings.Condition; var attributes = context.Settings.HasAttributes ? context.Settings.Attributes : null; ResourceManager.WriteResource(Output, context.Resource, path, condition, attributes); } } string virtualPath = string.Format("~/{0}/{1}", resourceType, requiredGroupResource.Key); bool hasValue = BundleResolver.Current.IsBundleVirtualPath(virtualPath); if (!hasValue) { Bundle bundle = null; if (resourceType == "stylesheet") { bundle = new StyleBundle(virtualPath); } else { bundle = new ScriptBundle(virtualPath); } foreach (var context in requiredGroupResource.Value) { if (context.Resource.EnableCompress) { var bundlePath = "~" + context.GetResourceUrl(defaultSettings, appPath); bundle.Include(bundlePath); hasValue = true; } } if (hasValue) bundles.Add(bundle); } if (hasValue) { ResourceManager.WriteResource(Output, requiredGroupResource.Value[0].Resource, bundles.ResolveBundleUrl(virtualPath), null, null); } } } }
private Dictionary<string, string> MergeAttributes(RequireSettings other) { // efficiently merge the two dictionaries, taking into account that one or both may not exist // and that attributes in 'other' should overridde attributes in this, even if the value is null. if (_attributes == null) { return other._attributes == null ? null : new Dictionary<string, string>(other._attributes); } if (other._attributes == null) { return new Dictionary<string, string>(_attributes); } var mergedAttributes = new Dictionary<string, string>(_attributes); foreach (var pair in other._attributes) { mergedAttributes[pair.Key] = pair.Value; } return mergedAttributes; }
public RequireSettings Combine(RequireSettings other) { var settings = (new RequireSettings { Name = Name, Type = Type }).AtLocation(Location).AtLocation(other.Location) .WithBasePath(BasePath).WithBasePath(other.BasePath) .UseCdn(CdnMode).UseCdn(other.CdnMode) .UseDebugMode(DebugMode).UseDebugMode(other.DebugMode) .UseCulture(Culture).UseCulture(other.Culture) .UseCondition(Condition).UseCondition(other.Condition) .Define(InlineDefinition).Define(other.InlineDefinition); settings._attributes = MergeAttributes(other); return settings; }
public string ResolveUrl(RequireSettings settings, string applicationPath) { string url; if (_urlResolveCache.TryGetValue(settings, out url)) { return url; } // Url priority: if (settings.DebugMode) { url = settings.CdnMode ? Coalesce(UrlCdnDebug, UrlDebug, UrlCdn, Url) : Coalesce(UrlDebug, Url, UrlCdnDebug, UrlCdn); } else { url = settings.CdnMode ? Coalesce(UrlCdn, Url, UrlCdnDebug, UrlDebug) : Coalesce(Url, UrlDebug, UrlCdn, UrlCdnDebug); } if (String.IsNullOrEmpty(url)) { return null; } if (!String.IsNullOrEmpty(settings.Culture)) { string nearestCulture = FindNearestCulture(settings.Culture); if (!String.IsNullOrEmpty(nearestCulture)) { url = Path.ChangeExtension(url, nearestCulture + Path.GetExtension(url)); } } if (!Uri.IsWellFormedUriString(url, UriKind.Absolute) && !VirtualPathUtility.IsAbsolute(url) && !VirtualPathUtility.IsAppRelative(url) && !String.IsNullOrEmpty(BasePath)) { // relative urls are relative to the base path of the module that defined the manifest url = VirtualPathUtility.Combine(BasePath, url); } if (VirtualPathUtility.IsAppRelative(url)) { url = VirtualPathUtility.ToAbsolute(url, applicationPath); } _urlResolveCache[settings] = url; return url; }
private ResourceDefinition FindResource(RequireSettings settings, bool resolveInlineDefinitions) { // find the resource with the given type and name // that has at least the given version number. If multiple, // return the resource with the greatest version number. // If not found and an inlineDefinition is given, define the resource on the fly // using the action. var name = settings.Name ?? ""; var type = settings.Type; var resource = (from p in ResourceProviders from r in p.GetResources(type) where name.Equals(r.Key, StringComparison.OrdinalIgnoreCase) orderby r.Value.Version descending select r.Value).FirstOrDefault(); if (resource == null && _dynamicManifest != null) { resource = (from r in _dynamicManifest.GetResources(type) where name.Equals(r.Key, StringComparison.OrdinalIgnoreCase) orderby r.Value.Version descending select r.Value).FirstOrDefault(); } if (resolveInlineDefinitions && resource == null) { // Does not seem to exist, but it's possible it is being // defined by a Define() from a RequireSettings somewhere. if (ResolveInlineDefinitions(settings.Type)) { // if any were defined, now try to find it resource = FindResource(settings, false); } } return resource; }
protected virtual void ExpandDependencies(ResourceDefinition resource, RequireSettings settings, OrderedDictionary allResources) { if (resource == null) { return; } // Settings is given so they can cascade down into dependencies. For example, if Foo depends on Bar, and Foo's required // location is Head, so too should Bar's location. // forge the effective require settings for this resource // (1) If a require exists for the resource, combine with it. Last settings in gets preference for its specified values. // (2) If no require already exists, form a new settings object based on the given one but with its own type/name. settings = allResources.Contains(resource) ? ((RequireSettings)allResources[resource]).Combine(settings) : new RequireSettings { Type = resource.Type, Name = resource.Name }.Combine(settings); if (resource.Dependencies != null) { var dependencies = from d in resource.Dependencies select FindResource(new RequireSettings { Type = resource.Type, Name = d }); foreach (var dependency in dependencies) { if (dependency == null) { continue; } ExpandDependencies(dependency, settings, allResources); } } allResources[resource] = settings; }
public virtual RequireSettings Require(string resourceType, string resourceName, int group) { if (resourceType == null) { throw new ArgumentNullException("resourceType"); } if (resourceName == null) { throw new ArgumentNullException("resourceName"); } RequireSettings settings; var key = new Tuple<string, string>(resourceType, resourceName); if (!_required.TryGetValue(key, out settings)) { settings = new RequireSettings { Type = resourceType, Name = resourceName, Group = group }; _required[key] = settings; } _builtResources[resourceType] = null; return settings; }
public virtual ResourceDefinition FindResource(RequireSettings settings) { return FindResource(settings, true); }
public virtual IList<ResourceRequiredContext> FindRequiredResources(RequireSettings settings) { IList<ResourceRequiredContext> requiredResources; string key = settings.Type + settings.Name; if (_builtResources.TryGetValue(key, out requiredResources) && requiredResources != null) { return requiredResources; } var allResources = new OrderedDictionary(); var resource = FindResource(settings); if (resource == null) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "A '{1}' named '{0}' could not be found.", settings.Name, settings.Type)); } ExpandDependencies(resource, settings, allResources); requiredResources = (from DictionaryEntry entry in allResources select new ResourceRequiredContext { Resource = (ResourceDefinition)entry.Key, Settings = (RequireSettings)entry.Value }).ToList(); _builtResources[key] = requiredResources; return requiredResources; }
public string GetResourceUrl(RequireSettings baseSettings, string appPath) { return Resource.ResolveUrl(baseSettings == null ? Settings : baseSettings.Combine(Settings), appPath); }