Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Extensions/ui/ScriptResourceAttribute.cs

@@ -0,0 +1,365 @@
+//------------------------------------------------------------------------------
+// <copyright file="ScriptResourceAttribute.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+ 
+namespace System.Web.UI {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Reflection;
+    using System.Resources;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using System.Web;
+    using System.Web.Handlers;
+    using System.Web.Resources;
+    using System.Web.Script.Serialization;
+    using System.Web.Util;
+
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+    public sealed class ScriptResourceAttribute : Attribute {
+        private string _scriptName;
+        private string _stringResourceName;
+        private string _stringResourceClientTypeName;
+        private static readonly Regex _webResourceRegEx = new Regex(
+            @"<%\s*=\s*(?<resourceType>WebResource|ScriptResource)\(""(?<resourceName>[^""]*)""\)\s*%>",
+            RegexOptions.Singleline | RegexOptions.Multiline);
+
+        public ScriptResourceAttribute(string scriptName)
+            : this(scriptName, null, null) {
+        }
+
+        [SuppressMessage("Microsoft.Naming","CA1720:IdentifiersShouldNotContainTypeNames", MessageId="string", Justification="Refers to 'string resource', not string the type.")]
+        public ScriptResourceAttribute(string scriptName, string stringResourceName, string stringResourceClientTypeName) {
+            if (String.IsNullOrEmpty(scriptName)) {
+                throw new ArgumentException(AtlasWeb.Common_NullOrEmpty, "scriptName");
+            }
+            _scriptName = scriptName;
+            _stringResourceName = stringResourceName;
+            _stringResourceClientTypeName = stringResourceClientTypeName;
+        }
+
+        public string ScriptName {
+            get {
+                return _scriptName;
+            }
+        }
+
+        [Obsolete("This property is obsolete. Use StringResourceName instead.")]
+        public string ScriptResourceName {
+            get {
+                return StringResourceName;
+            }
+        }
+
+        public string StringResourceClientTypeName {
+            get {
+                return _stringResourceClientTypeName;
+            }
+        }
+
+        public string StringResourceName {
+            get {
+                return _stringResourceName;
+            }
+        }
+
+        [Obsolete("This property is obsolete. Use StringResourceClientTypeName instead.")]
+        public string TypeName {
+            get {
+                return StringResourceClientTypeName;
+            }
+        }
+
+        private static void AddResources(Dictionary<String, String> resources,
+            ResourceManager resourceManager, ResourceSet neutralSet) {
+            foreach (DictionaryEntry res in neutralSet) {
+                string key = (string)res.Key;
+                string value = resourceManager.GetObject(key) as string;
+                if (value != null) {
+                    resources[key] = value;
+                }
+            }
+        }
+
+        private static Dictionary<String, String> CombineResources(
+            ResourceManager resourceManager, ResourceSet neutralSet,
+            ResourceManager releaseResourceManager, ResourceSet releaseNeutralSet) {
+            Dictionary<String, String> resources = new Dictionary<String, String>(StringComparer.Ordinal);
+            // add release resources first
+            AddResources(resources, releaseResourceManager, releaseNeutralSet);
+            // then debug, overwriting any existing release resources
+            AddResources(resources, resourceManager, neutralSet);
+            return resources;
+        }
+
+        private static void CopyScriptToStringBuilderWithSubstitution(
+            string content, Assembly assembly, bool zip, StringBuilder output) {
+
+            // Looking for something of the form: WebResource("resourcename")
+            MatchCollection matches = _webResourceRegEx.Matches(content);
+            int startIndex = 0;
+            foreach (Match match in matches) {
+                output.Append(content.Substring(startIndex, match.Index - startIndex));
+
+                Group group = match.Groups["resourceName"];
+                string embeddedResourceName = group.Value;
+                bool isScriptResource = String.Equals(
+                    match.Groups["resourceType"].Value, "ScriptResource", StringComparison.Ordinal);
+                try {
+                    if (isScriptResource) {
+                        output.Append(ScriptResourceHandler.GetScriptResourceUrl(
+                            assembly, embeddedResourceName, CultureInfo.CurrentUICulture, zip));
+                    }
+                    else {
+                        output.Append(AssemblyResourceLoader.GetWebResourceUrlInternal(
+                            assembly, embeddedResourceName, htmlEncoded: false, forSubstitution: true, scriptManager: null));
+                    }
+                }
+                catch (HttpException e) {
+                    throw new HttpException(String.Format(CultureInfo.CurrentCulture,
+                        AtlasWeb.ScriptResourceHandler_UnknownResource,
+                        embeddedResourceName), e);
+                }
+
+                startIndex = match.Index + match.Length;
+            }
+
+            output.Append(content.Substring(startIndex, content.Length - startIndex));
+        }
+
+        internal static ResourceManager GetResourceManager(string resourceName, Assembly assembly) {
+            if (String.IsNullOrEmpty(resourceName)) {
+                return null;
+            }
+            return new ResourceManager(GetResourceName(resourceName), assembly);
+        }
+
+        private static string GetResourceName(string rawResourceName) {
+            if (rawResourceName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase)) {
+                return rawResourceName.Substring(0, rawResourceName.Length - 10);
+            }
+            return rawResourceName;
+        }
+
+        internal static string GetScriptFromWebResourceInternal(
+            Assembly assembly, string resourceName, CultureInfo culture, 
+            bool zip, out string contentType) {
+
+            ScriptResourceInfo resourceInfo = ScriptResourceInfo.GetInstance(assembly, resourceName);
+            ScriptResourceInfo releaseResourceInfo = null;
+            if (resourceName.EndsWith(".debug.js", StringComparison.OrdinalIgnoreCase)) {
+                // This is a debug script, we'll need to merge the debug resource
+                // with the release one.
+                string releaseResourceName = resourceName.Substring(0, resourceName.Length - 9) + ".js";
+                releaseResourceInfo = ScriptResourceInfo.GetInstance(assembly, releaseResourceName);
+            }
+            if ((resourceInfo == ScriptResourceInfo.Empty) &&
+                ((releaseResourceInfo == null) || (releaseResourceInfo == ScriptResourceInfo.Empty))) {
+
+                throw new HttpException(AtlasWeb.ScriptResourceHandler_InvalidRequest);
+            }
+
+            ResourceManager resourceManager = null;
+            ResourceSet neutralSet = null;
+            ResourceManager releaseResourceManager = null;
+            ResourceSet releaseNeutralSet = null;
+            CultureInfo previousCulture = Thread.CurrentThread.CurrentUICulture;
+
+            try {
+                Thread.CurrentThread.CurrentUICulture = culture;
+
+                if (!String.IsNullOrEmpty(resourceInfo.ScriptResourceName)) {
+                    resourceManager = GetResourceManager(resourceInfo.ScriptResourceName, assembly);
+                    // The following may throw MissingManifestResourceException
+                    neutralSet = resourceManager.GetResourceSet(CultureInfo.InvariantCulture, true, true);
+                }
+                if ((releaseResourceInfo != null) &&
+                    !String.IsNullOrEmpty(releaseResourceInfo.ScriptResourceName)) {
+
+                    releaseResourceManager = GetResourceManager(releaseResourceInfo.ScriptResourceName, assembly);
+                    releaseNeutralSet = releaseResourceManager.GetResourceSet(CultureInfo.InvariantCulture, true, true);
+                }
+                if ((releaseResourceInfo != null) &&
+                    !String.IsNullOrEmpty(releaseResourceInfo.ScriptResourceName) &&
+                    !String.IsNullOrEmpty(resourceInfo.ScriptResourceName) &&
+                    (releaseResourceInfo.TypeName != resourceInfo.TypeName)) {
+                    throw new HttpException(String.Format(
+                        CultureInfo.CurrentCulture,
+                        AtlasWeb.ScriptResourceHandler_TypeNameMismatch,
+                        releaseResourceInfo.ScriptResourceName));
+                }
+
+                StringBuilder builder = new StringBuilder();
+                WriteScript(assembly,
+                    resourceInfo, releaseResourceInfo,
+                    resourceManager, neutralSet,
+                    releaseResourceManager, releaseNeutralSet,
+                    zip, builder);
+                contentType = resourceInfo.ContentType;
+                return builder.ToString();
+            }
+            finally {
+                Thread.CurrentThread.CurrentUICulture = previousCulture;
+
+                if (releaseNeutralSet != null) {
+                    releaseNeutralSet.Dispose();
+                }
+                if (neutralSet != null) {
+                    neutralSet.Dispose();
+                }
+            }
+        }
+
+        private static void RegisterNamespace(StringBuilder builder, string typeName, bool isDebug) {
+            int lastDot = typeName.LastIndexOf('.');
+            if (lastDot != -1) {
+                builder.Append("Type.registerNamespace('");
+                builder.Append(typeName.Substring(0, lastDot));
+                builder.Append("');");
+                if (isDebug) builder.AppendLine();
+            }
+        }
+
+        private static void WriteResource(StringBuilder builder,
+            Dictionary<String, String> resources,
+            bool isDebug) {
+            bool first = true;
+            foreach (KeyValuePair<String,String> res in resources) {
+                if (first) {
+                    first = false;
+                }
+                else {
+                    builder.Append(',');
+                }
+                if (isDebug) {
+                    builder.AppendLine();
+                }
+                builder.Append('"');
+                builder.Append(HttpUtility.JavaScriptStringEncode(res.Key));
+                builder.Append("\":\"");
+                builder.Append(HttpUtility.JavaScriptStringEncode(res.Value));
+                builder.Append('"');
+            }
+        }
+
+        private static void WriteResource(
+            StringBuilder builder,
+            ResourceManager resourceManager,
+            ResourceSet neutralSet,
+            bool isDebug) {
+
+            bool first = true;
+            foreach (DictionaryEntry res in neutralSet) {
+                string key = (string)res.Key;
+                string value = resourceManager.GetObject(key) as string;
+                if (value != null) {
+                    if (first) {
+                        first = false;
+                    }
+                    else {
+                        builder.Append(',');
+                    }
+                    if (isDebug) builder.AppendLine();
+                    builder.Append('"');
+                    builder.Append(HttpUtility.JavaScriptStringEncode(key));
+                    builder.Append("\":\"");
+                    builder.Append(HttpUtility.JavaScriptStringEncode(value));
+                    builder.Append('"');
+                }
+            }
+        }
+
+        private static void WriteResourceToStringBuilder(
+            ScriptResourceInfo resourceInfo, 
+            ScriptResourceInfo releaseResourceInfo, 
+            ResourceManager resourceManager, 
+            ResourceSet neutralSet, 
+            ResourceManager releaseResourceManager, 
+            ResourceSet releaseNeutralSet, 
+            StringBuilder builder) {
+
+            if ((resourceManager != null) || (releaseResourceManager != null)) {
+                string typeName = resourceInfo.TypeName;
+                if (String.IsNullOrEmpty(typeName)) {
+                    typeName = releaseResourceInfo.TypeName;
+                }
+                WriteResources(builder, typeName, resourceManager, neutralSet,
+                    releaseResourceManager, releaseNeutralSet, resourceInfo.IsDebug);
+            }
+        }
+
+        private static void WriteResources(StringBuilder builder, string typeName,
+            ResourceManager resourceManager, ResourceSet neutralSet,
+            ResourceManager releaseResourceManager, ResourceSet releaseNeutralSet,
+            bool isDebug) {
+
+            // DevDiv Bugs 131109: Resources and notification should go on a new line even in release mode
+            // because main script may not end in a semi-colon or may end in a javascript comment.
+            builder.AppendLine();
+            RegisterNamespace(builder, typeName, isDebug);
+            builder.Append(typeName);
+            builder.Append("={");
+            if ((resourceManager != null) && (releaseResourceManager != null)) {
+                WriteResource(builder, CombineResources(resourceManager, neutralSet, releaseResourceManager, releaseNeutralSet), isDebug);
+            }
+            else {
+                if (resourceManager != null) {
+                    WriteResource(builder, resourceManager, neutralSet, isDebug);
+                }
+                else if (releaseResourceManager != null) {
+                    WriteResource(builder, releaseResourceManager, releaseNeutralSet, isDebug);
+                }
+            }
+            if (isDebug) {
+                builder.AppendLine();
+                builder.AppendLine("};");
+            }
+            else{
+                builder.Append("};");
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2106:SecureAsserts", Justification="Violation is no longer relevant due to 4.0 CAS model")]
+        [FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
+        [SecuritySafeCritical]
+        private static void WriteScript(Assembly assembly,
+            ScriptResourceInfo resourceInfo, ScriptResourceInfo releaseResourceInfo,
+            ResourceManager resourceManager, ResourceSet neutralSet,
+            ResourceManager releaseResourceManager, ResourceSet releaseNeutralSet,
+            bool zip, StringBuilder output) {
+
+            using (StreamReader reader = new StreamReader(
+                assembly.GetManifestResourceStream(resourceInfo.ScriptName), true)) {
+
+                if (resourceInfo.IsDebug) {
+                    // Output version information
+                    AssemblyName assemblyName = assembly.GetName();
+                    output.AppendLine("// Name:        " + resourceInfo.ScriptName);
+                    output.AppendLine("// Assembly:    " + assemblyName.Name);
+                    output.AppendLine("// Version:     " + assemblyName.Version.ToString());
+                    output.AppendLine("// FileVersion: " + AssemblyUtil.GetAssemblyFileVersion(assembly));
+                }
+                if (resourceInfo.PerformSubstitution) {
+                    CopyScriptToStringBuilderWithSubstitution(
+                        reader.ReadToEnd(), assembly, zip, output);
+                }
+                else {
+                    output.Append(reader.ReadToEnd());
+                }
+                WriteResourceToStringBuilder(resourceInfo, releaseResourceInfo, 
+                    resourceManager, neutralSet, 
+                    releaseResourceManager, releaseNeutralSet, 
+                    output);
+            }
+        }
+    }
+}