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)
                           .UseVersion(Version).UseVersion(other.Version)
                           .Define(InlineDefinition).Define(other.InlineDefinition);

            settings._attributes = MergeAttributes(other);
            return(settings);
        }
        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);
        }
Beispiel #3
0
        public TagBuilder GetTagBuilder(RequireSettings settings, string applicationPath)
        {
            string 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))
            {
                url = null;
            }
            if (!String.IsNullOrEmpty(settings.Culture))
            {
                string nearestCulture = FindNearestCulture(settings.Culture);
                if (!String.IsNullOrEmpty(nearestCulture))
                {
                    url = Path.ChangeExtension(url, nearestCulture + Path.GetExtension(url));
                }
            }

            if (url.StartsWith("~/", StringComparison.Ordinal))
            {
                if (!String.IsNullOrEmpty(_basePath))
                {
                    url = _basePath + url.Substring(1);
                }
                else
                {
                    url = applicationPath + url.Substring(1);
                }
            }

            var tagBuilder = new TagBuilder(TagName)
            {
                TagRenderMode = TagRenderMode
            };

            if (!String.IsNullOrEmpty(CdnIntegrity) && url != null && url == UrlCdn)
            {
                tagBuilder.Attributes["integrity"]   = CdnIntegrity;
                tagBuilder.Attributes["crossorigin"] = "anonymous";
            }
            else if (!String.IsNullOrEmpty(CdnDebugIntegrity) && url != null && url == UrlCdnDebug)
            {
                tagBuilder.Attributes["integrity"]   = CdnDebugIntegrity;
                tagBuilder.Attributes["crossorigin"] = "anonymous";
            }

            if (_resourceAttributes.ContainsKey(Type))
            {
                tagBuilder.MergeAttributes(_resourceAttributes[Type]);
            }

            if (Attributes != null)
            {
                tagBuilder.MergeAttributes(Attributes);
            }

            if (settings.HasAttributes)
            {
                tagBuilder.MergeAttributes(settings.Attributes);
            }

            if (!String.IsNullOrEmpty(FilePathAttributeName))
            {
                if (!String.IsNullOrEmpty(url))
                {
                    tagBuilder.MergeAttribute(FilePathAttributeName, url, true);
                }
            }

            return(tagBuilder);
        }