/// <summary>
/// js文件下载
/// </summary>
/// <param name="filePaths">文件路径</param>
public static void DownJSFile(string filePaths)
{
try
{
string rootPath = Assembly.GetExecutingAssembly().CodeBase.Replace("/bin/Game.Common.DLL", "").Replace("file:///", "");
HttpResponse response = HttpContext.Current.Response;
response.ContentType = "text/javascript";
string[] filePathlist = filePaths.Split(',');
foreach (var filePath in filePathlist)
{
string path = rootPath + filePath;
if (FileHelper.Context().IsExistFile(path))
{
string content = File.ReadAllText(path, Encoding.UTF8);
if (Config.GetValue("JsCompressor") == "true")
{
content = javaScriptCompressor.Compress(content);
}
response.Write(content);
}
}
response.Flush();
response.Clear();
}
catch (Exception ex)
{
string msg = ex.Message;
throw;
}
}
/// <summary>
/// 读取js文件内容并压缩
/// </summary>
/// <param name="filePathlist"></param>
/// <returns></returns>
public static string ReadJSFile(string[] filePathlist)
{
StringBuilder jsStr = new StringBuilder();
try
{
string rootPath = Assembly.GetExecutingAssembly().CodeBase.Replace("/bin/Learun.Util.DLL", "").Replace("file:///", "");
foreach (var filePath in filePathlist)
{
string path = rootPath + filePath;
if (DirFileHelper.IsExistFile(path))
{
string content = File.ReadAllText(path, Encoding.UTF8);
if (Config.GetValue("JsCompressor") == "true")
{
content = javaScriptCompressor.Compress(content);
}
jsStr.Append(content);
}
}
return(jsStr.ToString());
}
catch (Exception)
{
return("");
}
}
/// <summary>
/// JavaScript 压缩
/// </summary>
/// <param name="filePath"></param>
public static void JavaScriptCompressor(FileInfo filePath)
{
String _file = filePath.FullName;
if (filePath.Name.ToLower().EndsWith(".min.js"))
{
return;
}
String SaveFile = Path.ChangeExtension(_file, ".min.js");
if (File.Exists(SaveFile))
{
File.Delete(SaveFile);
//String bakfile = SaveFile + "_" + DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss") + ".bak";
//File.Move(SaveFile, bakfile);
}
File.SetAttributes(_file, FileAttributes.Normal); //取消文件只读
if (filePath.Extension.ToLower() == ".js")
{
String strContent = File.ReadAllText(_file, Encoding.Default);
//初始化JS压缩类
var js = new JavaScriptCompressor();
js.CompressionType = CompressionType.Standard; //压缩类型
js.Encoding = Encoding.UTF8; //编码
js.IgnoreEval = false; //大小写转换
js.ThreadCulture = CultureInfo.CurrentCulture;
strContent = js.Compress(strContent);//压缩该js
File.WriteAllText(SaveFile, strContent, Encoding.UTF8);
}
}
/// <summary>
/// Builds the javascript package file specified in <paramref name="configPath"/>.
/// </summary>
/// <remarks>
/// If package file already exists it will be rebuilt according with files access time.
/// </remarks>
/// <param name="environment">The environment.</param>
/// <param name="packageName">Name of the package.</param>
/// <param name="javascriptPath">The javascript directory server path.</param>
/// <param name="configPath">Assets config path.</param>
/// <returns>Generated package file name.</returns>
public static String BuildJavascriptPack(Environment environment, String packageName, String javascriptPath, String configPath)
{
var packageFileName = String.Format(JavascriptPackageNameTemplate, packageName);
var packagePath = Path.Combine(javascriptPath, packageFileName);
var files = GetJavascriptPackFiles(environment, packageName, configPath);
if (!File.Exists(packagePath) || File.GetLastWriteTimeUtc(packagePath) < GetMaxLastModifyDate(javascriptPath, files))
{
var output = new StringBuilder();
foreach (var file in files)
{
using (var reader = new StreamReader(Path.Combine(javascriptPath, file)))
{
var temp = reader.ReadToEnd();
if (!String.IsNullOrEmpty(temp))
{
output.Append(JavaScriptCompressor.Compress(temp));
}
}
}
using (var writer = new StreamWriter(File.Create(packagePath)))
{
writer.Write(output.ToString());
}
}
return packageFileName;
}
public void Minify()
{
try
{
if (Resource.Type == (int)WebresourceType.Script)
{
var compressor = new JavaScriptCompressor {
ObfuscateJavascript = Settings.ObfuscateJavascript
};
Resource.UpdatedStringContent = compressor.Compress(Resource.UpdatedStringContent);
scintilla.Text = Resource.UpdatedStringContent;
}
else if (Resource.Type == (int)WebresourceType.Css)
{
var compressor = new CssCompressor {
RemoveComments = Settings.RemoveCssComments
};
Resource.UpdatedStringContent = compressor.Compress(Resource.UpdatedStringContent);
scintilla.Text = Resource.UpdatedStringContent;
}
}
catch (Exception error)
{
MessageBox.Show(this, $@"An error occured while minifying code: {error.Message}", @"Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private string DoMinifyJs()
{
try
{
if (innerType == Enumerations.WebResourceType.Script)
{
var compressor = new JavaScriptCompressor {
ObfuscateJavascript = options.ObfuscateJavascript
};
return(compressor.Compress(scintilla.Text));
}
if (innerType == Enumerations.WebResourceType.Css)
{
var compressor = new CssCompressor {
RemoveComments = options.RemoveCssComments
};
return(compressor.Compress(scintilla.Text));
}
return(scintilla.Text);
}
catch (Exception error)
{
MessageBox.Show(error.ToString());
return(originalContent);
}
}
public static long compress(String input, ref String filename)
{
long compressed = 0;
try
{
String output = string.Empty;
if (stringContainsItemFromList(filename, ".js"))
{
JavaScriptCompressor compressor = new JavaScriptCompressor();
output = compressor.Compress(input);
compressed = output.Length;
}
else
{
CssCompressor compressor = new CssCompressor();
output = compressor.Compress(input);
compressed = output.Length;
}
}
catch
{
compressed = input.Replace("\\n", "").Replace("\\t", "").Replace("\\r", "").Length;
}
return(compressed);
}
public static void Compressor(string ReadPath, string SavePath, string Filter)
{
string[] files = Directory.GetFiles(HttpContext.Current.Server.MapPath(ReadPath), Filter);
string[] array = files;
for (int i = 0; i < array.Length; i++)
{
string text = array[i];
FileInfo fileInfo = new FileInfo(text);
string text2 = File.ReadAllText(text, Encoding.UTF8);
if (!text.Contains(".min."))
{
File.SetAttributes(text, FileAttributes.Normal);
if (!Directory.Exists(HttpContext.Current.Server.MapPath(SavePath)))
{
Directory.CreateDirectory(HttpContext.Current.Server.MapPath(SavePath));
}
if (fileInfo.Extension.ToLower() == ".js")
{
JavaScriptCompressor javaScriptCompressor = new JavaScriptCompressor();
javaScriptCompressor.CompressionType = 0;
javaScriptCompressor.Encoding = Encoding.UTF8;
javaScriptCompressor.IgnoreEval = false;
javaScriptCompressor.ThreadCulture = CultureInfo.CurrentCulture;
text2 = javaScriptCompressor.Compress(text2);
File.WriteAllText(HttpContext.Current.Server.MapPath(SavePath) + "/" + fileInfo.Name, text2, Encoding.UTF8);
}
else if (fileInfo.Extension.ToLower() == ".css")
{
CssCompressor cssCompressor = new CssCompressor();
text2 = cssCompressor.Compress(text2);
File.WriteAllText(HttpContext.Current.Server.MapPath(SavePath) + "/" + fileInfo.Name, text2, Encoding.UTF8);
}
}
}
}
public void Process(BundleContext context, BundleResponse response)
{
var compiler = new HandlebarsCompiler();
var templates = new Dictionary <string, string>();
var server = context.HttpContext.Server;
foreach (var bundleFile in response.Files)
{
var filePath = server.MapPath(bundleFile.VirtualFile.VirtualPath);
var bundleRelativePath = GetRelativePath(server, bundleFile, filePath);
var templateName = namer.GenerateName(bundleRelativePath, bundleFile.VirtualFile.Name);
var template = File.ReadAllText(filePath);
var compiled = compiler.Precompile(template, false);
templates[templateName] = compiled;
}
StringBuilder javascript = new StringBuilder();
foreach (var templateName in templates.Keys)
{
javascript.AppendFormat("Ember.TEMPLATES['{0}']=", templateName);
javascript.AppendFormat("Ember.Handlebars.template({0});", templates[templateName]);
}
var Compressor = new JavaScriptCompressor();
var compressed = Compressor.Compress(javascript.ToString());
response.ContentType = "text/javascript";
response.Cacheability = HttpCacheability.Public;
response.Content = compressed;
}
public dynamic[] Call(IDictionary <string, dynamic> env)
{
var root = _root;
if (root.EndsWith("/"))
{
root = _root.Remove(_root.Length - 1);
}
var path = root + env["PATH_INFO"];
if (!path.EndsWith(".js"))
{
return(_app.Call(env));
}
var response = string.Format("Not found: {0}.", path);
var responseCode = 400;
if (System.IO.File.Exists(path))
{
var js = System.IO.File.ReadAllText(path);
response = JavaScriptCompressor.Compress(js);
responseCode = 200;
}
return(new dynamic[] { responseCode, new Hash {
{ "Content-Type", "text/plain" }
}, new[] { response } });
}
public static long compress(String input, String filename)
{
long compressed = 0;
String output = string.Empty;
try
{
StreamReader inputReader = new StreamReader(input);
StringWriter outputWriter = new StringWriter();
if (stringContainsItemFromList(filename, ".js"))
{
JavaScriptCompressor compressor = new JavaScriptCompressor();
output = compressor.Compress(input);
compressed = output.Length;
}
else
{
CssCompressor compressor = new CssCompressor();
output = compressor.Compress(input);
compressed = output.Length;
}
}
catch (Exception e)
{
log.Debug("Error Compressing CSS or Javascript {}", e);
log.Debug("Continuing with simple minifier");
compressed = input.Replace("\\n", "").Replace("\\t", "").Replace("\\r", "").Length;
//compressed = input.Replace("\\n| {2}|\\t|\\r", "").Length;
}
return(compressed);
}
private string DoMinifyJs(string originalContent)
{
try
{
if (item.Type == CodeItemType.JavaScript)
{
var compressor = new JavaScriptCompressor {
ObfuscateJavascript = mySettings.ObfuscateJavascript
};
return(compressor.Compress(scintilla.Text));
}
if (item.Type == CodeItemType.Style)
{
var compressor = new CssCompressor {
RemoveComments = mySettings.RemoveCssComments
};
return(compressor.Compress(scintilla.Text));
}
return(scintilla.Text);
}
catch (Exception error)
{
MessageBox.Show(error.ToString());
return(originalContent);
}
}
/// <summary>
/// Filters the assets
/// </summary>
/// <param name="Assets">Assets to filter</param>
/// <returns>The filtered assets</returns>
public IList <IAsset> Filter(IList <IAsset> Assets)
{
if (Assets == null || Assets.Count == 0)
{
return(new List <IAsset>());
}
if (Assets.FirstOrDefault().Type != AssetType.Javascript)
{
return(Assets);
}
var Processable = Assets.Where(x => !x.Minified);
if (Processable.FirstOrDefault() == null)
{
return(Assets);
}
var Minifier = new JavaScriptCompressor();
foreach (IAsset Asset in Processable.Where(x => x != null))
{
try
{
Asset.Content = Minifier.Compress(Asset.Content);
Asset.Minified = true;
}
catch { }
}
return(Assets);
}
public static string GetScript(ScriptIds ids, string token)
{
var script = @"(function (v, t) {
if (!t) t = 'hidden';
var chk = function () {
var elem = document.getElementById('" + ids.ScriptId + @"');
document.getElementById('" + ids.HoneyPotContainerId + @"').style.display = 'none';
if (elem) {
var newElem = document.createElement('div');
newElem.innerHTML = '<input type=""' + t + '"" name=""" + ids.TokenId + @""" value=""' + v + '"" />';
elem.parentNode.appendChild(newElem);
elem.parentNode.removeChild(elem);
} else {
window.setTimeout(chk, 500);
}
};
window.setTimeout(chk, 500);
document.getElementById('" + ids.HoneyPotContainerId + @"').style.display = 'none';
}('" + token + @"'));";
var compressor = new JavaScriptCompressor
{
Encoding = Encoding.UTF8,
DisableOptimizations = false,
ObfuscateJavascript = true,
PreserveAllSemicolons = true,
IgnoreEval = true,
ThreadCulture = System.Globalization.CultureInfo.InvariantCulture
};
var example = compressor.Compress(script);
return(example);
}
private void btnMinify_Click(object sender, EventArgs e)
{
foreach (string f in Directory.GetFiles(txtInput.Text))
{
string filename = f.Split('\\')[f.Split('\\').Length - 1];
string filetype = filename.Split('.')[filename.Split('.').Length - 1];
try
{
string listBox1 = string.Empty;
if (filetype.ToLower() == "js")
{
listBox1 = JavaScriptCompressor.Compress(File.ReadAllText(f));
}
else if (filetype.ToLower() == "css")
{
listBox1 = CssCompressor.Compress(File.ReadAllText(f));
}
string path = txtOutput.Text + "\\" + filename;
File.AppendAllLines(path, new[] { listBox1 });
}
catch (Exception)
{
string listBox1 = File.ReadAllText(f);
string path = txtOutput.Text + "\\" + filename;
File.AppendAllLines(path, new[] { listBox1 });
}
}
}
public override string ToString()
{
GetFreeFromSet();
if (FFrm == null || FFrm.FFContent.IsMissing())
{
return("未找到为本单据设计的自由表单，请先进行设计！");
}
if (_formStatus == FormStatus.View)
{
return(RenderHtmlElements());
}
else
{
// Create javascript
var script = new StringBuilder();
// Start script
script.AppendLine("<script type=\"text/javascript\">");
JavaScriptCompressor compressor = new JavaScriptCompressor();
compressor.Encoding = Encoding.UTF8;
script.Append(compressor.Compress(RenderJavascript()));
script.AppendLine("</script>");
// Insert grid id where needed (in columns)
script.Replace("##formid##", $"frm-{FormId}");
// Return script + required elements
return(script.ToString() + RenderHtmlElements());
}
}
/// <summary>
/// Loads all resource scripts in the namespace path of the specified type.
/// </summary>
/// <param name="type"></param>
public static void LoadScripts(Type type)
{
lock (scriptLock)
{
Assembly assembly = type.Assembly;
if (_loaded.Contains(assembly))
{
return;
}
_loaded.Add(assembly);
string namespacePath = string.Format("{0}.", type.Namespace);
foreach (string fullScriptPath in assembly.GetManifestResourceNames())
{
string scriptName = fullScriptPath.Substring(namespacePath.Length, fullScriptPath.Length - namespacePath.Length);
Stream resource = assembly.GetManifestResourceStream(fullScriptPath);
JavaScriptCompressor jsc = new JavaScriptCompressor();
using (StreamReader script = new StreamReader(resource))
{
string js = script.ReadToEnd();
_scripts.AddMissing(scriptName, js);
_scripts.AddMissing(
string.Format("{0}.min.js", scriptName.Substring(0, scriptName.Length - 3)),
jsc.Compress(js)
);
}
}
}
}
public ActionResult Javascript(string keys)
{
string result = _provider.GetFromCache("resources.javascript." + Request.Url.PathAndQuery, () =>
{
var scriptFiles = keys.Split('|').ToList();
var sb = new StringBuilder();
foreach (var s in scriptFiles)
{
var script = MothScriptHelper.GetFileContent(new List <string> {
s
}, HttpContext).ToString();
if (_provider.Enable.ScriptMinification)
{
script = JavaScriptCompressor.Compress(script, false, true, true, false, Int32.MaxValue, Encoding.UTF8, new CultureInfo("en-US"));
}
sb.AppendLine(script);
}
return(sb.ToString());
}, _provider.CacheDurations.ExternalScript);
return(new ContentResult()
{
Content = result,
ContentType = "text/javascript",
});
}
private void button2_Click(object sender, EventArgs e)
{
string formPath = Config.GetValue("FormPath") + "\\Learun.Application.Web\\"; //来源文件目录
string toPath = Config.GetValue("ToPathWeb"); //目标文件目录
textBox1.Clear();
textBox1.AppendText("开始复制文件\r\n");
string[] filePaths = DirFileHelper.GetFileNames(formPath, "*", true);
int num = 0;
foreach (string filePath in filePaths)
{
if (filePath.IndexOf("\\bin\\") == -1 && filePath.IndexOf("\\obj\\") == -1 && filePath.IndexOf("Learun.Application.Web.csproj") == -1)
{
textBox1.AppendText(num + ":" + filePath + "\r\n");
string path = toPath + filePath.Replace(formPath, "");
if (filePath.IndexOf("\\LR_Content\\") != -1)
{
string content = File.ReadAllText(filePath, Encoding.UTF8);
FileInfo fi = new FileInfo(path);
if (fi.Extension == ".js")
{
if (!string.IsNullOrEmpty(content))
{
content = javaScriptCompressor.Compress(content);
}
DirFileHelper.CreateFileContent(path, content);
}
else if (fi.Extension == ".css")
{
if (!string.IsNullOrEmpty(content))
{
content = cssCompressor.Compress(content);
}
DirFileHelper.CreateFileContent(path, content);
}
else
{
if (!Directory.Exists(fi.DirectoryName))
{
Directory.CreateDirectory(fi.DirectoryName);
}
System.IO.File.Copy(filePath, path, true);
}
}
else
{
FileInfo fi = new FileInfo(path);
if (!Directory.Exists(fi.DirectoryName))
{
Directory.CreateDirectory(fi.DirectoryName);
}
System.IO.File.Copy(filePath, path, true);
}
num++;
}
}
textBox1.AppendText("结束复制文件\r\n");
}
private string minify(IIncludeTypeSettings settings)
{
if (Content == "")
{
return("");
}
if (!settings.Minify)
{
return(Content);
}
switch (Type)
{
case IncludeType.Js:
var compressor = new JavaScriptCompressor(Content);
var jsSettings = (JsTypeElement)settings;
var minifiedJs = compressor.Compress(jsSettings.Obfuscate, jsSettings.PreserveSemiColons, jsSettings.DisableOptimizations, settings.LineBreakAt);
return(minifiedJs);
case IncludeType.Css:
var minifiedCss = CssCompressor.Compress(Content, settings.LineBreakAt, ((CssTypeElement)settings).CompressionType);
return(minifiedCss);
default:
throw new ArgumentOutOfRangeException();
}
}
private static string CompressJs(string path)
{
var rawjs = File.ReadAllText(path);
var jsCompressor = new JavaScriptCompressor();
var compressed = jsCompressor.Compress(rawjs);
return(compressed);
}
public string Compress(string contents)
{
var jsCompressor = new JavaScriptCompressor {
Encoding = Encoding.UTF8, ThreadCulture = CultureInfo.InvariantCulture
};
return(jsCompressor.Compress(contents));
}
public void TestJsFileA()
{
//a is too large for Google
//so should be the same as YUI compressor
string min = JavaScriptCompressor.Compress(a_chirp_js);
Assert.IsTrue(a_min_js.Contains(min));
}
private String processFile(String url)
{
String path = Server.MapPath(url);
String src = File.ReadAllText(path);
String compressedSrc = JavaScriptCompressor.Compress(src);
return("\n// " + url + "\n" + compressedSrc + "\n// end " + url + "\n\n");
}
private void InnerMinify(IAsset asset)
{
string content = asset.Content;
string newContent;
string assetUrl = asset.Url;
try
{
newContent = !string.IsNullOrEmpty(content) ? _jsCompressor.Compress(content) : string.Empty;
var errorReporter = _jsCompressor.ErrorReporter as CustomErrorReporter;
if (errorReporter != null && errorReporter.ErrorMessages.Count > 0)
{
var stringBuilderPool = StringBuilderPool.Shared;
StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
foreach (var errorDetail in errorReporter.ErrorMessages)
{
errorMessageBuilder.AppendLine(errorDetail);
errorMessageBuilder.AppendLine();
}
errorReporter.ErrorMessages.Clear();
string errorMessage = errorMessageBuilder.ToString();
stringBuilderPool.Return(errorMessageBuilder);
throw new YuiCompressingException(errorMessage);
}
}
catch (EcmaScriptRuntimeException e)
{
throw new AssetMinificationException(
string.Format(CoreStrings.Minifiers_MinificationSyntaxError,
CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message), e);
}
catch (EcmaScriptException e)
{
throw new AssetMinificationException(
string.Format(CoreStrings.Minifiers_MinificationSyntaxError,
CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message), e);
}
catch (YuiCompressingException e)
{
throw new AssetMinificationException(
string.Format(CoreStrings.Minifiers_MinificationSyntaxError,
CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message), e);
}
catch (Exception e)
{
throw new AssetMinificationException(
string.Format(CoreStrings.Minifiers_MinificationFailed,
CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message), e);
}
asset.Content = newContent;
asset.Minified = true;
}
public string FilterContent(string content, ContentFilterContext context)
{
if (context.Minify)
{
return(JavaScriptCompressor.Compress(content));
}
return(content);
}
/// <summary>
/// Compress javascript using Yahoo javascript compressor
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
string minify_javascript(string data)
{
try
{
return(JavaScriptCompressor.Compress(data, false));
}
catch { }
return(data);
}
public string Precompile(string template, bool compress)
{
var compiled = Engine.CallGlobalFunction <string>("precompile", template, false);
if (compress)
{
compiled = Compressor.Compress(compiled);
}
return(compiled);
}
public void Process(BundleResponse bundle)
{
if (bundle == null)
{
throw new ArgumentNullException("bundle");
}
bundle.Content = JavaScriptCompressor.Compress(bundle.Content);
bundle.ContentType = "text/javascript";
}
private string Compress(string input)
{
var compressor = new JavaScriptCompressor
{
CompressionType = CompressionType.Standard,
Encoding = Encoding.UTF8,
ObfuscateJavascript = true,
};
return(compressor.Compress(input));
}
public void CompressFull_CodePlex48610Test()
{
string javascript = File.ReadAllText("jquery-1.3.1.js");
var javaScriptCompressor = new JavaScriptCompressor(javascript);
string compressedJavascript = javaScriptCompressor.Compress();
Assert.IsTrue(!string.IsNullOrEmpty(compressedJavascript));
Assert.IsTrue(javascript.Length > compressedJavascript.Length);
// Now, check to see that we have some error logging stuff.
var customErrorReporter = javaScriptCompressor.ErrorReporter as CustomErrorReporter;
Assert.IsNotNull(customErrorReporter);
Assert.IsTrue(customErrorReporter.ErrorMessages.Count > 0);
}
public void CompressTest()
{
// First load up some simple javascript.
string javascript = File.ReadAllText("SampleJavaScript1.js");
// Now compress the small javascript.
string compressedJavascript = JavaScriptCompressor.Compress(javascript);
Assert.IsTrue(!string.IsNullOrEmpty(compressedJavascript));
Assert.IsTrue(javascript.Length > compressedJavascript.Length);
// Now lets try the big mother fraker.
javascript = File.ReadAllText("SampleJavaScript2.js");
// Now compress the small javascript.
compressedJavascript = JavaScriptCompressor.Compress(javascript);
Assert.IsTrue(!string.IsNullOrEmpty(compressedJavascript));
Assert.IsTrue(javascript.Length > compressedJavascript.Length);
// Special Ms AJAX test.
string original = File.ReadAllText("SampleJavaScript2.js");
int index = original.IndexOf("Sys.Serialization.JavaScriptSerializer._stringRegEx");
string test = original.Substring(index);
var compressor = new JavaScriptCompressor(original);
string minified = compressor.Compress(true, false, false, -1);
index = minified.IndexOf("Sys.Serialization.JavaScriptSerializer._stringRegEx");
test = minified.Substring(index);
// And now some weird \n test.
javascript = File.ReadAllText("SampleJavaScript3.js");
// Now compress the small javascript.
compressedJavascript = JavaScriptCompressor.Compress(javascript);
Assert.IsTrue(!string.IsNullOrEmpty(compressedJavascript));
Assert.IsTrue(javascript.Length > compressedJavascript.Length);
// Expected failure.
JavaScriptCompressor.Compress(null);
}
public void Accents_Should_Be_Retained_In_All_Cases(string threadCulture, string compressorCulture)
{
// Arrange
var originalThreadCulture = Thread.CurrentThread.CurrentCulture;
var originalThreadUICulture = Thread.CurrentThread.CurrentUICulture;
const string source = @"Strings = {
IncorrectLogin: '******'
}";
const string expected = @"Strings={IncorrectLogin:""Felaktigt användarnamn eller lösenord. Försök igen.""};";
try
{
if (threadCulture != null)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(threadCulture);
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(threadCulture);
}
var compressor = new JavaScriptCompressor();
compressor.Encoding = Encoding.UTF8;
if (compressorCulture != null)
{
compressor.ThreadCulture = CultureInfo.CreateSpecificCulture(compressorCulture);
}
// Act
var actual = compressor.Compress(source);
// Assert.
Assert.That(actual, Is.EqualTo(expected));
}
finally
{
Thread.CurrentThread.CurrentCulture = originalThreadCulture;
Thread.CurrentThread.CurrentUICulture = originalThreadUICulture;
}
}
