/// <summary> /// Creates a ClassDeclaration. /// </summary> /// <param name="namespaceDeclaration">The NamespaceDeclaration instance the class is added to.</param> /// <param name="table">The database table the ClassDeclaration represents.</param> /// <returns>A reference to the ClassDeclaration instance that was created.</returns> protected override ClassDeclaration CreateClass(NamespaceDeclaration namespaceDeclaration, TableSchema table) { ClassDeclaration result = namespaceDeclaration.AddClass(this.NameProvider.GetClassName(table), true); ClassDeclaration baseType = new ClassDeclaration(this.ConfigOptions.BaseTypeName, new CodeDomTypeReference(result.FullName)); result.InheritsFrom(baseType); return result; }
protected override ClassDeclaration CreateClass(NamespaceDeclaration namespaceDeclaration, TableSchema table) { ClassDeclaration result = new ClassDeclaration(this.NameProvider.GetClassName(table.Name)); result.IsPartial = true; namespaceDeclaration.AddClass(result); return result; }
public void VerifyAddAttribute() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("Test"); ClassDeclaration cdecl = nsdecl.AddClass("Customer"); cdecl.AddAttribute(typeof(SerializableAttribute)); ClassDeclaration attrib1 = nsdecl.AddClass("SuperAttribute").InheritsFrom("System.Attribute"); cdecl.AddAttribute(new CodeDomTypeReference("Test.SuperAttribute")); ClassDeclaration attrib2 = nsdecl.AddClass("Crattribute").InheritsFrom("System.Attribute"); cdecl.AddAttribute("Test.Crattribute"); using (DomTester dom = new DomTester(nsdecl)) { Assert.IsTrue(dom.Type("Customer").HasAttribute("System.SerializableAttribute")); Assert.IsTrue(dom.Type("Customer").HasAttribute("Test.SuperAttribute")); Assert.IsTrue(dom.Type("Customer").HasAttribute("Test.Crattribute")); } new CodeBuilder().GenerateCode(Console.Out, nsdecl); }
/// <summary> /// Creates a ClassDeclaration shell. /// </summary> /// <param name="nsdecl">NamespaceDeclaration the class is added.</param> /// <param name="table">Database table that the generated class will interact with.</param> /// <returns>The ClassDeclaration shell that was created.</returns> protected override ClassDeclaration CreateClass(NamespaceDeclaration nsdecl, TableSchema table) { ClassDeclaration result = nsdecl.AddClass(this.NameProvider.GetClassName(table), true); ClassDeclaration baseType = null; if (!String.IsNullOrEmpty(this.ConfigOptions.AbstractBaseName)) baseType = new ClassDeclaration(this.ConfigOptions.AbstractBaseName, new CodeDomTypeReference(result.FullName)); else baseType = new ClassDeclaration(this.ConfigOptions.BaseTypeName, new CodeDomTypeReference(result.FullName)); result.InheritsFrom(baseType); return result; }
public void CanCreateActiveRecordClass2() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("My.Data").Imports("Castle.ActiveRecord"); ClassDeclaration cdecl = nsdecl.AddClass("Customer").IsAbstract().InheritsFrom("ActiveRecordBase", "My.Data.Customer"); using (DomTester tester = new DomTester(nsdecl)) { Assert.IsTrue(tester.IsCompiled, "should have compiled"); Assert.IsTrue(tester.ContainsType("My.Data.Customer")); Assert.IsTrue(tester.Type("My.Data.Customer").InheritsFrom("ActiveRecordBase`1", "Customer")); } }
/// <summary> /// Creates a ClassDeclaration. /// </summary> /// <param name="namespaceDeclaration">The NamespaceDeclaration instance the class is added to.</param> /// <param name="table">The database table the ClassDeclaration represents.</param> /// <returns> /// A reference to the ClassDeclaration instance that was created. /// </returns> protected override ClassDeclaration CreateClass(NamespaceDeclaration namespaceDeclaration, TableSchema table) { var result = namespaceDeclaration.AddClass(this.NameProvider.GetClassName(table), true); string baseTypeName = String.IsNullOrEmpty(ConfigOptions.AbstractBaseName) ? ConfigOptions.BaseTypeName : ConfigOptions.AbstractBaseName; var baseType = new ClassDeclaration(baseTypeName, new CodeDomTypeReference(result.FullName)); result.InheritsFrom(baseType); return result; }
public void CanCreateActiveRecordClass() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("My.Data").Imports("Castle.ActiveRecord"); ClassDeclaration cdecl = nsdecl.AddClass("Customer").IsAbstract().InheritsFrom("ActiveRecordBase", "My.Data.Customer"); //compile to assembly CodeBuilder builder = new CodeBuilder(); CodeCompileUnit compunit = builder.CreateCodeCompileUnit(nsdecl); CodeDomProvider compiler = new CSharpCodeProvider(); CompilerParameters options = new CompilerParameters(); options.GenerateInMemory = true; options.WarningLevel = 4; options.TreatWarningsAsErrors = true; options.IncludeDebugInformation = true; options.ReferencedAssemblies.Add(@"C:\lib\Castle\bin\Castle.ActiveRecord.dll"); CompilerResults results = compiler.CompileAssemblyFromDom(options, compunit); foreach (CompilerError error in results.Errors) { Console.WriteLine(error.ErrorText); } Assembly compiled = results.CompiledAssembly; //load assembly in it's own app domain AppDomain testdomain = AppDomain.CreateDomain("testdomain"); testdomain.Load("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); testdomain.Load(compiled.GetName()); //test the assembly Type testtype = compiled.GetType("My.Data.Customer"); Assert.IsNotNull(testtype); Assert.AreEqual("ActiveRecordBase`1", testtype.BaseType.Name); Assert.AreEqual("Customer", testtype.BaseType.GetGenericArguments()[0].Name); AppDomain.Unload(testdomain); }
public void AddProperties() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("Test"); ClassDeclaration cdecl = nsdecl.AddClass("Customer"); FieldDeclaration lastName = new FieldDeclaration("_lastName", "System.String"); PropertyDeclaration propdecl = new PropertyDeclaration("LastName", lastName, typeof(string)); cdecl.AddProperty(propdecl); PropertyDeclaration firstName = cdecl.AddProperty("FirstName", "_firstName", typeof(string)); PropertyDeclaration duplicateFirstName = cdecl.AddProperty("FirstName", "_firstName", typeof(string)); Assert.AreEqual(firstName, duplicateFirstName); cdecl.AddProperty("DateOfBirth", "_dateOfBirth", typeof(DateTime), true); cdecl.AddProperty("Age", "_age", new CodeDomTypeReference(typeof(int))); cdecl.AddProperty("Items", "_items", "System.Collections.Generic.List", "System.String"); using (DomTester dom = new DomTester(nsdecl)) { Assert.IsTrue(dom.ContainsType("Test.Customer")); Assert.IsTrue(dom.ContainsProperty("Test.Customer", "FirstName")); Assert.IsTrue(dom.ContainsProperty("Test.Customer", "LastName")); Assert.IsTrue(dom.ContainsProperty("Test.Customer", "DateOfBirth")); Assert.IsTrue(dom.ContainsProperty("Test.Customer", "Age")); Assert.IsTrue(dom.ContainsProperty("Test.Customer", "Items")); } new CodeBuilder().GenerateCode(Console.Out, nsdecl); }
/// <summary> /// Generates the test class for a table. /// </summary> /// <param name="writer">The writer to which the code is written.</param> /// <param name="namespaceName">The namespace containing the test class.</param> /// <param name="table">The table being tested.</param> public void Generate(TextWriter writer, string namespaceName, TableSchema table) { if (table == null) throw new ArgumentNullException("table"); NamespaceDeclaration nstest = new NamespaceDeclaration(namespaceName + ".Tests"); //declare the test class string typeName = this.NameProvider.GetClassName(table.Name); ClassDeclaration testclass = nstest.AddClass(typeName + "Tests", true); string targetTypeName = namespaceName + "." + typeName; testclass.InheritsFrom(new ClassDeclaration("ActiveRecordBaseTest", new CodeDomTypeReference(targetTypeName))); //create the test method MethodDeclaration testmeth = testclass.AddMethod(String.Format("Verify{0}", typeName)).Public(); testmeth.AddAttribute("NUnit.Framework.TestAttribute"); string fullName = namespaceName + "." + typeName; string fieldName = this.NameProvider.GetClassName(table.Name).Substring(0, 1).ToLower() + this.NameProvider.GetClassName(table.Name).Substring(1); testmeth.Declare(fieldName).New(new CodeDomTypeReference(fullName));//generates: Customer customer = new Customer(); foreach (ColumnSchema column in table.NonKeyColumns) { string propertyName = this.NameProvider.GetPropertyName(column); string propertyValue = this.ValueProvider.GetValue(column); testmeth.Assign(fieldName).Property(propertyName).To(propertyValue); } testmeth.Call(fieldName, "Save"); nstest.Imports("System"); CodeBuilder builder = new CodeBuilder(); builder.GenerateCode(writer, nstest); }
public void VerifyAddClassTypeParameters() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("Test"); nsdecl.AddClass("Customer"); nsdecl.AddClass("CustomerList") .InheritsFrom("System.Collections.Generic.List", "Test.Customer"); using (DomTester dom = new DomTester(nsdecl)) { Assert.IsTrue(dom.Type("CustomerList") .InheritsFrom("List`1", "Customer")); } //new CodeBuilder().GenerateCode(Console.Out, nsdecl); }
public void VerifyInheritsFrom() { NamespaceDeclaration nsdecl = new NamespaceDeclaration("TestContainer"); nsdecl.AddClass("Manager") .InheritsFrom(nsdecl.AddClass("Employee")); using (DomTester dom = new DomTester(nsdecl)) { Assert.IsTrue(dom.Type("Manager").InheritsFrom("Employee")); } //new CodeBuilder().GenerateCode(Console.Out, nsdecl); }
public void CanCreateClass() { //create dom NamespaceDeclaration nsdecl = new NamespaceDeclaration("My.Data"); ClassDeclaration cdecl = nsdecl.AddClass("Customer"); cdecl.AddProperty("ID", "_id", "System.Int32"); //compile to assembly CodeBuilder builder = new CodeBuilder(); CodeCompileUnit compunit = builder.CreateCodeCompileUnit(nsdecl); CodeDomProvider compiler = new CSharpCodeProvider(); CompilerParameters options = new CompilerParameters(); options.GenerateInMemory = true; options.WarningLevel = 4; options.TreatWarningsAsErrors = true; options.IncludeDebugInformation = true; CompilerResults results = compiler.CompileAssemblyFromDom(options, compunit); Assembly compiled = results.CompiledAssembly; //load assembly in it's own app domain AppDomain testdomain = AppDomain.CreateDomain("testdomain"); testdomain.Load("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); testdomain.Load(compiled.GetName()); //test the assembly Type testtype = compiled.GetType("My.Data.Customer"); Assert.IsNotNull(testtype); PropertyInfo id = testtype.GetProperty("ID"); Assert.AreEqual(typeof(int), id.PropertyType); AppDomain.Unload(testdomain); }
private void GenerateEnums() { if (_options.Enums == null || _options.Enums.Count() == 0) { return; } var generator = new EnumGenerator(_codeRunnerConfig.DbProvider, _codeRunnerConfig.Options, _codeRunnerConfig.NameProvider); foreach (var enumDescriptor in _options.Enums) { Write("Generating enum {0} ... ", enumDescriptor.TableName); var @enum = generator.Generate(enumDescriptor.TableName, enumDescriptor.NameField, enumDescriptor.ValueField); if (@enum == null) { WriteLine("Failed. Make sure {0} is spelled correctly and exists in the database.", enumDescriptor.TableName); continue; } var ns = new NamespaceDeclaration(_options.EnumNamespace); ns.AddClass(@enum); string fileName = Inflector.Pluralize(_codeRunnerConfig.NameProvider.GetClassName(enumDescriptor.TableName)) + ".cs"; string outputFilePath = Path.Combine(_options.EnumOutputPath, fileName); using (TextWriter writer = _codeRunnerConfig.Writer(outputFilePath)) { if (_options.UseMicrosoftsHeader) { new CodeBuilder().GenerateCode(writer, ns); } else { writer.Write(UseHyperActiveHeader(ns)); } } WriteLine("Done."); } }
/// <summary> /// Generates code from a codeTypeDeclaration. /// </summary> /// <param name="writer">The textwriter the code is written to.</param> /// <param name="namespaceName">The namespace that will contain the class.</param> /// <param name="codeTypeDeclaration">The CodeDom definition to generate.</param> public void GenerateCode(TextWriter writer, string namespaceName, ICodeDom<System.CodeDom.CodeTypeDeclaration> codeTypeDeclaration) { NamespaceDeclaration nsdecl = new NamespaceDeclaration(namespaceName); nsdecl.AddClass(codeTypeDeclaration); this.GenerateCode(writer, nsdecl); }