/// <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;
}
/// <summary>
/// Initializes a new instance of the NamespaceDeclaration class.
/// </summary>
/// <param name="nsdecl">The namespace being compiled.</param>
public DomTester(NamespaceDeclaration nsdecl)
{
_nsdecl = nsdecl;
_appDomain = AppDomain.CreateDomain("testdomain");
this.Compile();
_appDomain.Load("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
_appDomain.Load(_compiled.GetName());
}
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 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;
}
/// <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 Can_generate_associations()
{
string connString = "integrated security=SSPI;server=(local);database=Lars";
var dbprovider = new SqlServerProvider(new DbHelper(connString));
var configOptions = new DefaultConfigurationOptions();
var generator = new AwishModelGenerator(); //new ConfigurableActiveRecordGenerator(configOptions);
generator.ConfigOptions = configOptions;
//foreach (var tbl in dbprovider.GetTableSchemas().Where(tbl => { return tbl.PrimaryKey != null; }))
//{
var tbl = dbprovider.GetTableSchema("LeasePaymentDescriptorLease");
//var fkrefs = tbl.PrimaryKey.ForeignKeyReferences;
//foreach (var fkref in fkrefs)
//{
//
//}
var theNs = new NamespaceDeclaration("Awish.Lars.Data");
var cdecl = generator.Generate(theNs, tbl);
new CodeBuilder().GenerateCode(Console.Out, "Awish.Lars.Data", cdecl);
//}
}
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);
}
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> /// 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 abstract ClassDeclaration CreateClass(NamespaceDeclaration namespaceDeclaration, TableSchema table);
/// <summary>
/// Creates a CodeCompileUnit from a NamespaceDeclaration.
/// </summary>
/// <param name="nsdecl"></param>
/// <returns></returns>
public CodeCompileUnit CreateCodeCompileUnit(NamespaceDeclaration nsdecl)
{
CodeCompileUnit result = new CodeCompileUnit();
result.Namespaces.Add(nsdecl.ToCodeDom());
return result;
}
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);
}
/// <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);
}
/// <summary>
/// Generates code from a NamespaceDeclaration instance.
/// </summary>
/// <param name="writer"></param>
/// <param name="nsdecl"></param>
public void GenerateCode(TextWriter writer, NamespaceDeclaration nsdecl)
{
CodeCompileUnit compunit = new CodeCompileUnit();
compunit.Namespaces.Add(nsdecl.ToCodeDom());
CodeGeneratorOptions options = new CodeGeneratorOptions();
this.DomProvider.GenerateCodeFromCompileUnit(compunit, writer, options);
}
private void GenerateTables()
{
TableSchemaList tableSchemas = GetTableSchemas();
foreach (var tableSchema in tableSchemas.OrderBy(tbl => { return tbl.Name; }))
{
if (tableSchema.PrimaryKey == null)
{
WriteLine("Skipping table {0} because it does not have a primary key.", tableSchema.Name);
continue;
}
if (_options.SkipTablesWithPrefix.Count > 0 && _options.SkipTablesWithPrefix.Contains(tableSchema.Name))
{
WriteLine("Skipping table {0} because it's in the skiptableswithprefix list.", tableSchema.Name);
continue;
}
if (_options.SkipTables.Count > 0 && _options.SkipTables.Contains(tableSchema.Name))
{
WriteLine("Skipping table {0} because it's in the skiptables list.", tableSchema.Name);
continue;
}
var ns = new NamespaceDeclaration(_options.Namespace);
var classDecl = _codeRunnerConfig.Generator.Generate(ns, tableSchema);
string outputFileName = Path.Combine(_options.OutputPath, _codeRunnerConfig.NameProvider.GetClassName(tableSchema) + ".cs");
using (TextWriter writer = _codeRunnerConfig.Writer(outputFileName))
{
Write("Generating {0} ... ", tableSchema.Name);
if (_codeRunnerConfig.Options.UseMicrosoftsHeader)
{
new CodeBuilder().GenerateCode(writer, ns);
}
else
{
writer.Write(UseHyperActiveHeader(ns));
}
WriteLine("Done");
}
}
}
private string UseHyperActiveHeader(NamespaceDeclaration ns)
{
string source = "";
// Generate source to a string for post parsing.
string tempSource = String.Empty;
using (StringWriter tempWriter = new StringWriter())
{
new CodeBuilder().GenerateCode(tempWriter, ns);
tempSource = tempWriter.ToString();
}
// Now while walking through each line of the file, intercept where
// there is Microsoft header s***e and put in HyperActive header s***e.
using (StringReader reader = new StringReader(tempSource))
using (StringWriter tempWriter = new StringWriter())
{
bool insideHeader = false;
bool hyperActiveMessageWritten = false;
string line;
while ((line = reader.ReadLine()) != null)
{
if (line == "// </auto-generated>")
{
insideHeader = false;
}
if (!insideHeader)
{
tempWriter.WriteLine(line);
}
else if (!hyperActiveMessageWritten)
{
tempWriter.WriteLine("// HyperActive {0} generated this file.", Assembly.GetExecutingAssembly().GetName().Version.ToString());
hyperActiveMessageWritten = true;
}
if (line.Trim() == "// <auto-generated>")
{
insideHeader = true;
}
}
source = tempWriter.ToString();
}
return source;
}
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.");
}
}
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);
}
/// <summary>
/// Generates the specified namespace declaration.
/// </summary>
/// <param name="namespaceDeclaration">The namespace declaration.</param>
/// <param name="table">The table.</param>
/// <returns></returns>
public ClassDeclaration Generate(NamespaceDeclaration namespaceDeclaration, TableSchema table)
{
ClassDeclaration classDecl = this.CreateClass(namespaceDeclaration, table);
this.AddClassAttributes(classDecl, table);
this.CreatePrimaryKeyProperty(classDecl, table);
foreach (ForeignKeyColumnSchema fk in table.ForeignKeys)
{
this.CreateForeignKey(classDecl, fk);
}
if (table.PrimaryKey != null && table.PrimaryKey.ForeignKeyReferences != null)
{
foreach (ForeignKeyColumnSchema foreignkey in table.PrimaryKey.ForeignKeyReferences)
{
this.CreateForeignKeyReference(classDecl, foreignkey);
}
}
if (table.NonKeyColumns != null)
{
foreach (ColumnSchema column in table.NonKeyColumns)
{
this.CreateNonKeyProperty(classDecl, column);
}
}
if (_configOptions.GenerateColumnList)
{
CreateColumnList(table, classDecl);
}
this.CreateConstructors(classDecl, table);
this.CreateAssociationProperties(classDecl, table);
this.AddMethods(classDecl, table);
return classDecl;
}
/// <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 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);
}