private static void Execute(ModuleDefinition mainModule, ModuleDefinition l2MModule, ModuleDefinition coreModule) { var l2MOptimizeAttribute = l2MModule.GetType("LinqPatcher.Attributes", "OptimizeAttribute"); var typeSystem = mainModule.TypeSystem; var classAnalyzer = new ClassAnalyzer(mainModule, l2MOptimizeAttribute); var methodAnalyzer = new MethodAnalyzer(typeSystem); var methodBuilder = new MethodBuilder(mainModule, coreModule); var analyzedClass = classAnalyzer.Analyze(); foreach (var targetClass in analyzedClass.OptimizeTypes) { foreach (var method in classAnalyzer.AnalyzeMethod(targetClass)) { var analyzedMethod = methodAnalyzer.Analyze(method); var methodName = Guid.NewGuid().ToString("N"); methodBuilder.Create(targetClass, methodName, analyzedMethod.ParameterType, analyzedMethod.ReturnType); methodBuilder.Begin(); foreach (var linqOperator in analyzedMethod.Operators) { var linq = methodAnalyzer.OperatorFactory(linqOperator, methodBuilder); methodBuilder.AppendOperator(linq); } methodBuilder.BuildOperator(); methodBuilder.End(); methodBuilder.Replace(method); } } mainModule.Write("Main.dll"); }
private static void Execute(ModuleDefinition mainModule, ModuleDefinition l2MModule, ModuleDefinition coreModule) { var l2MOptimizeAttribute = l2MModule.GetType("LinqPatcher.Attributes", "OptimizeAttribute"); var classAnalyzer = new ClassAnalyzer(mainModule, l2MOptimizeAttribute); var methodAnalyzer = new MethodAnalyzer(coreModule); var methodBuilder = new MethodBuilder(mainModule, coreModule); var analyzedClass = classAnalyzer.Analyze(); foreach (var optimizeClass in analyzedClass.OptimizeTypes) { foreach (var method in classAnalyzer.AnalyzeMethod(optimizeClass)) { var analyzedMethod = methodAnalyzer.Analyze(method); var returnType = mainModule.ImportReference(analyzedMethod.ReturnType); methodBuilder.Create(optimizeClass, MethodHelper.CreateUniqueName, analyzedMethod.ParameterType, returnType); methodBuilder.Begin(); foreach (var linqOperator in analyzedMethod.Operators) { var linq = methodAnalyzer.OperatorFactory(linqOperator, methodBuilder); methodBuilder.AppendOperator(linq); } methodBuilder.BuildOperator(); methodBuilder.End(); methodBuilder.Replace(method); } } mainModule.Write($"{TargetModuleName}.dll"); }
public void HandleResponseRoutesWithNameSetToNullOrEmpty(Type subscriberType) { Assert.Throws <NetmqRouterException>(() => { var subscriber = Activator.CreateInstance(subscriberType); ClassAnalyzer.AnalyzeClass(subscriber); }); }
public void HandleRouteWithMoreThanOneArgument() { var subscriber = new ExampleSubscriberRouteWithMoreThanOneArgument(); Assert.Throws <ConfigurationException>(() => { ClassAnalyzer.AnalyzeClass(subscriber); }); }
public static IMessageRouter RegisterSubscriber <T>(this IMessageRouter router, T subscriber) { ClassAnalyzer .AnalyzeClass(subscriber) .ToList() .ForEach(x => router.RegisterSubscriber(x)); return(router); }
public string CorrectlyHandleRoutesWithoutRouteResponseAttribute(string incomingROuteName) { var subscriber = new ExampleSubscriberWithVariousResponseConfiguration(); return(ClassAnalyzer .AnalyzeClass(subscriber) .First(x => x.Incoming.Name == incomingROuteName) .Outcoming ?.Name); }
public Type CorrectlyDiscoverOutcomingDataType(string methodName) { var subscriber = new ExampleSubscriberWithOutcomingRoutes(); return(ClassAnalyzer .AnalyzeClass(subscriber) .First(x => x.Outcoming.Name == methodName) .Outcoming .DataType); }
public string Generate(string classAsAString) { var analyzer = new ClassAnalyzer(); var analysisResult = analyzer.Analyze(classAsAString); var modelCreator = new BuilderModelCreator(); var model = modelCreator.Create(analysisResult); var codeGenerator = new BuilderCodeGenerator(); return(codeGenerator.Generate(model)); }
public void HandleBaseRoute() { // arrange var subscriber = new ClassWithBaseRoute(); // act var result = ClassAnalyzer.AnalyzeClass(subscriber); // assert Assert.AreEqual(1, result.Count); Assert.AreEqual("BaseRoute/IncomingRoute", result[0].Incoming.Name); Assert.AreEqual("OutcomingRoute", result[0].Outcoming.Name); }
public void CorrectlyCallRoute(string routeName, string value) { // arrange var subscriber = new ExampleSubscriberWithCallHandler(); var routes = ClassAnalyzer.AnalyzeClass(subscriber); // act routes .First(x => x.Incoming.Name == routeName) .Method(value); // assert Assert.AreEqual(value, subscriber.PassedValue); }
public void Parse_NoErrorIfNoAttributeTestClass_Test() { const string filecontent = @" public class Sample { [TestMethod] public void FooMethod_Descr() { } }"; var target = new ClassAnalyzer(filecontent); target.Parse(); Assert.IsFalse(target.Error.Any()); }
public void Parse_NoErrorIfContaintPostfix_Test() { const string filecontent = @" [TestClass] public class Sample { [TestMethod] public void FooMethod_Descr_Test() { } }"; var target = new ClassAnalyzer(filecontent); target.Parse(); Assert.IsFalse(target.Error.Any()); }
public void DiscoverOnlyMethodsWithRouteAttribute() { var subscriber = new ExampleSubscriberWithIncommingRoutes(); var incomingRouteNames = ClassAnalyzer .AnalyzeClass(subscriber) .Select(x => x.Incoming.Name); var expected = new[] { "GetEvent", "GetRaw", "GetText", "GetObject" }; Assert.AreEqual(expected, incomingRouteNames); }
public void Parse_ErrorIfNotContaintPostfix_Test() { const string filecontent = @" [TestClass] public class Sample { [TestMethod] public void FooMethod() { } }"; const string expectedError = "FooMethod"; var target = new ClassAnalyzer(filecontent); target.Parse(); Assert.IsTrue(target.Error.Contains(expectedError)); }
public void Parse_ErrorIfContaintSymbolsAfterPostfix_Test() { const string filecontent = @" [TestClass] public class Sample { [TestMethod] public void FooMethod_Descr_Test2() { } }"; const string expected = "FooMethod_Descr_Test2"; var target = new ClassAnalyzer(filecontent); target.Parse(); Assert.IsTrue(target.Error.Contains(expected)); }
public void DiscoverOnlyMethodsWithRouteResponseAttribute() { var subscriber = new ExampleSubscriberWithOutcomingRoutes(); var outcomingRouteNames = ClassAnalyzer .AnalyzeClass(subscriber) .Select(x => x.Outcoming.Name) .ToList(); var expected = new[] { "ResponseEvent", "ResponseRaw", "ResponseText", "ResponseObject" }; Assert.AreEqual(expected, outcomingRouteNames); }
private AnalysisResult Execute() { var analyzer = new ClassAnalyzer(); return(analyzer.Analyze(classAsAString)); }
private ModInfo ReadFromClassFile(ZipFileInfo file) { if (file.IsVolumeLabel || file.IsFolder || !file.Name.ToLower().EndsWith(".class")) { return(null); } ClassAnalyzer analyzer = null; using (Stream stream = file.OpenStream()) analyzer = ClassAnalyzer.Read(stream); if (analyzer == null) { return(null); } ModInfo info = new ModInfo(); foreach (JavaAttribute attribute in analyzer.Attributes) { if (attribute == null) { continue; } if (attribute is JavaRuntimeAnnotations) { foreach (JavaAnnotation annotation in ((JavaRuntimeAnnotations)attribute).Annotations) { if (annotation.Name.EndsWith("/fml/common/Mod;")) { if (annotation.Elements.ContainsKey("modid")) { info.ID = (string)annotation.Elements["modid"]; } if (annotation.Elements.ContainsKey("name")) { info.Name = (string)annotation.Elements["name"]; } if (annotation.Elements.ContainsKey("version")) { info.Version = (string)annotation.Elements["version"]; } if (annotation.Elements.ContainsKey("acceptedMinecraftVersions")) { info.MinecraftVersion = VersionTools.ToVersion((string)annotation.Elements["acceptedMinecraftVersions"]); } if (annotation.Elements.ContainsKey("dependencies")) { info.Dependencies = VersionTools.ToVersion((string)annotation.Elements["dependencies"]); } } else if (annotation.Name.EndsWith("/fml/relauncher/IFMLLoadingPlugin$Name;")) { info.Name = (string)annotation.Elements["value"]; if (info.ID == null) { info.ID = info.Name; } } else if (annotation.Name.EndsWith("/fml/relauncher/IFMLLoadingPlugin$MCVersion;")) { info.MinecraftVersion = VersionTools.ToVersion((string)annotation.Elements["value"]); } } } } return(info); }
public void HandleMethodWithRouteResponseAttributeButwithoutBasicRoute() { var subscriber = new ExampleSubscriberWithOutcomingRouteButWithoutIcoming(); Assert.Throws <ConfigurationException>(() => { ClassAnalyzer.AnalyzeClass(subscriber); }); }