public ICompileResult CreateModules(Snowflake id, string code)
{
Logger.LogInformation("Compiling module code...");
var sw = Stopwatch.StartNew();
var result = CompileUtils.CompileCommandModule(id.ToString(), code);
sw.Stop();
Logger.LogInformation("Finished compiling module code in {0}ms.", sw.ElapsedMilliseconds);
if (result is SuccessfulCompileResult successfulResult)
{
var context = successfulResult.AssemblyLoadContext;
if (context.Assemblies.Count() != 1)
{
throw new Exception("Assemblies loaded in load context is not equal to 1. This should not happen.");
}
var assembly = context.Assemblies.First();
var modules = _commandService.AddModules(assembly);
Logger.LogInformation("Added {0} module(s).", modules.Count);
_loadedModules.Add(id, new CommandModuleLoadContext(context, modules));
}
return(result);
}
public void ShouldProperlyConvertEnumWithoutInitializersToInt()
{
var minifier = new RoslynMinifier();
var minified = minifier.MinifyFromString(Samples["EnumToIntConversion"]);
Assert.IsTrue(CompileUtils.CanCompile(minified));
Assert.AreEqual(
"using System.Collections.Generic;class c{static int a=5;static Dictionary<int,Dictionary<char,int>>b=new Dictionary<int,Dictionary<char,int>>{{5,new Dictionary<char,int>{{' ',8}}},{6,new Dictionary<char,int>{{' ',24}}}};}",
minified);
}
public void Init()
{
Samples = new Dictionary <string, string>();
var sampleFiles = Directory.GetFiles($"{System.AppDomain.CurrentDomain.BaseDirectory}..\\..\\Samples");
foreach (var file in sampleFiles)
{
var code = File.ReadAllText(file);
Samples.Add(Path.GetFileNameWithoutExtension(file), code);
if (!CompileUtils.CanCompile(code))
{
Assert.Inconclusive("All input code should be compilied");
}
}
}
public void CompressIdentifiers()
{
var minifierOptions = new MinifierOptions(false)
{
LocalVarsCompressing = true,
MembersCompressing = true,
TypesCompressing = true
};
var minifier = new RoslynMinifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
}
}
public void LineLengthConstraint()
{
var minifierOptions = new MinifierOptions
{
SpacesRemoving = false,
CommentsRemoving = true,
LineLength = 80,
RegionsRemoving = true
};
var minifier = new RoslynMinifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
}
}
private void btnMinify_Click(object sender, EventArgs e)
{
var minifierOptions = new MinifierOptions
{
LocalVarsCompressing = cbCompressLocalVars.Checked,
MembersCompressing = cbCompressMemebers.Checked,
TypesCompressing = cbCompressTypes.Checked,
SpacesRemoving = cbRemoveSpaces.Checked,
RegionsRemoving = cbRemoveRegions.Checked,
CommentsRemoving = cbRemoveComments.Checked,
MiscCompressing = cbCompressMisc.Checked,
ConsoleApp = cbConsoleApp.Checked,
NamespacesRemoving = cbRemoveNamespaces.Checked,
LineLength = int.Parse(tbLineLength.Text),
ToStringMethodsRemoving = cbRemoveToStringMethods.Checked,
PublicCompressing = cbCompressPublic.Checked,
EnumToIntConversion = cbEnumToIntConversion.Checked,
Unsafe = cbUnsafe.Checked
};
Minifier minifier = new Minifier(minifierOptions);
tbOutput.Text = !cbMinifyFiles.Checked ? minifier.MinifyFromString(tbInput.Text) : minifier.MinifyFiles(Sources.Select(source => source.Value).ToArray());
tbInputLength.Text = tbInput.Text.Length.ToString();
tbOutputLength.Text = tbOutput.Text.Length.ToString();
tbOutputInputRatio.Text = ((double)tbOutput.Text.Length / tbInput.Text.Length).ToString("0.000000");
var compileResult = CompileUtils.Compile(tbOutput.Text);
dgvErrors.Rows.Clear();
if (!compileResult.Errors.HasErrors)
{
pbOutputCompilied.Image = Resources.Ok;
lblOutputCompilied.Text = "Compilied";
}
else
{
pbOutputCompilied.Image = Resources.Error;
lblOutputCompilied.Text = "Not compilied";
for (int i = 0; i < compileResult.Errors.Count; i++)
{
var error = compileResult.Errors[i];
dgvErrors.Rows.Add(error.Line.ToString(), error.Column.ToString(),
error.ErrorText, "output");
}
}
}
public void RemoveSpaces()
{
var minifierOptions = new MinifierOptions(false)
{
SpacesRemoving = true
};
var minifier = new RoslynMinifier(minifierOptions);
foreach (var sample in Samples)
{
var minified = minifier.MinifyFromString(sample.Value);
Assert.IsTrue(CompileUtils.CanCompile(minified));
if (sample.Key == "Test1")
{
Assert.IsFalse(minified.Contains(" /*"));
}
}
}
public void RemoveRegions()
{
var minifierOptions = new MinifierOptions
{
SpacesRemoving = true,
RegionsRemoving = true
};
var minifier = new RoslynMinifier(minifierOptions);
var test = Samples["Test1"];
if (!test.Contains("#region") || !test.Contains("#endregion"))
{
Assert.Inconclusive("Invalid test sample for RemoveRegions test");
}
var minified = minifier.MinifyFromString(test);
Assert.IsTrue(CompileUtils.CanCompile(minified));
Assert.IsFalse(minified.Contains("#region"));
Assert.IsFalse(minified.Contains("#endregion"));
}
public void RemoveComments()
{
var minifierOptions = new MinifierOptions(false)
{
SpacesRemoving = true,
CommentsRemoving = true
};
var minifier = new Minifier(minifierOptions);
var test = Samples["Test1"];
if (!test.Contains("//") || !test.Contains("/*") || !test.Contains("*/"))
{
Assert.Inconclusive("Invalid test sample for RemoveComments test");
}
var minified = minifier.MinifyFromString(test);
Assert.IsTrue(CompileUtils.CanCompile(minified));
Assert.IsFalse(minified.Contains("//"));
Assert.IsFalse(minified.Contains("/*"));
Assert.IsFalse(minified.Contains("*/"));
}
