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;
 }
Example #2
0
        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);

            }
        }
Example #3
0
        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);
                    }
                }
            }
        }
Example #4
0
 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;
 }
Example #5
0
 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;
 }
Example #7
0
 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;
 }
Example #8
0
 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;
 }
Example #9
0
 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;
 }
Example #10
0
 public virtual ResourceDefinition FindResource(RequireSettings settings)
 {
     return FindResource(settings, true);
 }
Example #11
0
        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);
 }