/// <summary>
 /// Adds a class declaration to the namespace.
 /// </summary>
 /// <param name="name">Name of the class.</param>
 /// <param name="typeParameters">List of type parameters if the class is generic.</param>
 /// <returns>The class declaration instance that was added the namespace.</returns>
 public ClassDeclaration AddClass(string name, params string[] typeParameters)
 {
     ClassDeclaration result = new ClassDeclaration(this, name, typeParameters);
     result.IsPartial = false;
     _classes.Add(result);
     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>
 /// Adds a class declaration to the namespace.
 /// </summary>
 /// <param name="name">Name of the class.</param>
 /// <param name="isPartialClass">Indicates whether the class is partial or not.</param>
 /// <returns>The class declaration instance that was added to the namespace.</returns>
 public ClassDeclaration AddClass(string name, bool isPartialClass)
 {
     ClassDeclaration result = new ClassDeclaration(this, name);
     result.IsPartial = isPartialClass;
     _classes.Add(result);
     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)
 {
     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;
 }
        public void CanCreateInterfaceWithTypeArgs()
        {
            InterfaceDeclaration iface = new InterfaceDeclaration("ITrackPropertyChanges", new CodeDomTypeReference("Awish.Common.Models.Core.Company"));

            ClassDeclaration cdecl = new ClassDeclaration("Company");
            cdecl.Implements(iface);
            new CodeBuilder().GenerateCode(Console.Out, "Poops.McGee", cdecl);
        }
 /// <summary>
 /// Creates a plain ol' property representing any column that is not a foreign key or primary key.
 /// </summary>
 /// <param name="classDeclaration">The class to which the property is added.</param>
 /// <param name="column">The column the property represents.</param>
 protected override void CreateNonKeyProperty(ClassDeclaration classDeclaration, ColumnSchema column)
 {
     string propertyName = this.NameProvider.GetPropertyName(column);
     string fieldName = this.NameProvider.GetFieldName(column);
     classDeclaration.AddProperty(propertyName, fieldName, column.DataType, column.Nullable)
             .AddAttribute("Castle.ActiveRecord.PropertyAttribute")
             .AddQuotedArgument(column.Name);
 }
 protected override ClassDeclaration AddMethods(ClassDeclaration classDecl, TableSchema table)
 {
     AddToDataMethod(classDecl, table);
     AddFromDataMethod(classDecl, table);
     AddPropertyChangedPlumbing(classDecl);
     AddCopyToMethod(classDecl, table);
     return classDecl;
 }
Example #8
0
        private static bool HasDependencies(ClassDeclaration classDecl)
        {
            if (classDecl.Definition.BaseClass != null)
            {
                return classDecl.Definition.BaseClass.Symbol.SpecialType != SpecialType.System_Object;
            }

            return false;
        }
 public void BasicClass()
 {
     var test = new ClassDeclaration("TestClass");
     var expected =
     @"class TestClass
     {
     };";
     Assert.AreEqual(expected, test.CreateSource());
 }
 /// <summary>
 /// Creates a property that is a foreign key within the current table that points to a primary key in another table.  These typically have BelongsTo attributes.
 /// </summary>
 /// <param name="classDeclaration">The class to which the property is added.</param>
 /// <param name="foreignKey">The foreign key the property represents.</param>
 /// <returns>The foreign key property that was added.</returns>
 protected override PropertyDeclaration CreateForeignKey(ClassDeclaration classDeclaration, ForeignKeyColumnSchema foreignKey)
 {
     string fkname = this.NameProvider.GetPropertyName(foreignKey);
     string fkfieldname = this.NameProvider.GetFieldName(foreignKey);
     string fkdatatype = this.NameProvider.GetClassName(foreignKey.PrimaryKeyTable);
     PropertyDeclaration result = classDeclaration.AddProperty(fkname, fkfieldname, fkdatatype);
     result.AddAttribute("Castle.ActiveRecord.BelongsToAttribute").AddQuotedArgument(foreignKey.Name);
     return result;
 }
        /// <summary>
        /// Creates a property that has a HasManyAttribute.
        /// </summary>
        /// <param name="classDecl">The class containing the property.</param>
        /// <param name="foreignkey">The foreign key to use.</param>
        /// <returns>A prpoerty with a hasmany attribute.</returns>
        protected override PropertyDeclaration CreateForeignKeyReference(ClassDeclaration classDecl, ForeignKeyColumnSchema foreignkey)
        {
            PropertyDeclaration fk = base.CreateForeignKeyReference(classDecl, foreignkey);
            if (fk == null)
                return null;

            AttributeDeclaration hasmany = fk.Attributes.Find(delegate(AttributeDeclaration attr) { return attr.TypeReference.IsTypeOf("Castle.ActiveRecord.HasManyAttribute"); });
            if (hasmany != null)
                hasmany.AddArgument("Lazy=true, Inverse=false");
            return fk;
        }
 /// <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;
        }
        /// <summary>
        /// Generates the specified writer.
        /// </summary>
        /// <param name="tableName">Name of the table.</param>
        /// <param name="nameField">The name field.</param>
        /// <param name="valueField">The value field.</param>
        public virtual ICodeDom<CodeTypeDeclaration> Generate(string tableName, string nameField, string valueField)
        {
            if (String.IsNullOrEmpty(tableName))
            {
                throw new ArgumentException("tableName is null or empty.", "tableName");
            }

            var tableSchema = _dbProvider.GetTableSchema(tableName);
            if (tableSchema == null)
            {
                throw new HyperActiveException("Table {0} was not found in the database.  Check your spelling and make sure that's the table you wanted.", tableName);
            }
            string internalNameField = GetNameField(nameField, tableSchema);
            if (String.IsNullOrEmpty(internalNameField))
            {
                return null;
            }

            string internalValueField = GetValueField(valueField, tableSchema);
            if (String.IsNullOrEmpty(internalValueField))
            {
                return null;
            }

            var data = _dbProvider.GetTableEnumData(tableName, internalNameField, internalValueField);
            if (data.Count == 0)
            {
                return null;
            }
            var @enum = new ClassDeclaration(_nameProvider.GetEnumName(tableName)).InheritsFrom(typeof(Enumeration).FullName);
            var fieldType = new CodeTypeReference(typeof(EnumerationField));
            foreach (var kvp in data)
            {
                var f1 = new CodeMemberField(fieldType, "_" + _nameProvider.GetEnumFieldName(kvp.Key));
                f1.Attributes = MemberAttributes.Private | MemberAttributes.Static;
                f1.InitExpression =
                    new CodeObjectCreateExpression(fieldType,
                        new CodeSnippetExpression(kvp.Value.ToString()),
                        new CodeSnippetExpression("\"" + _nameProvider.GetEnumFieldName(kvp.Key) + "\""));
                @enum.Members.Add(f1);

                var p1 = new CodeMemberProperty();
                p1.Type = fieldType;
                p1.Name = _nameProvider.GetEnumFieldName(kvp.Key);
                p1.Attributes = MemberAttributes.Public | MemberAttributes.Static;
                p1.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, "_" + _nameProvider.GetEnumFieldName(kvp.Key))));
                @enum.Members.Add(p1);

            }
            return @enum;
        }
        public void MemberField()
        {
            var test = new ClassDeclaration("TestClass");
            test.Fields.Add(new FieldDeclaration("m_someInt", Primitive.Int, AccessLevel.Private));

            var expected =
            @"class TestClass
            {
            private:
            int m_someInt;
            };";

            Assert.AreEqual(expected, test.CreateSource());
        }
        public void MemberFunction()
        {
            var test = new ClassDeclaration("TestClass");
            test.Functions.Add(new FunctionDeclaration("DoSomething", Primitive.Char.MakePointer().MakeConst(), AccessLevel.Public));

            var expected =
            @"class TestClass
            {
            public:
            const char *DoSomething();
            };";

            Assert.AreEqual(expected, test.CreateSource());
        }
        private void ValidateBaseClass(ClassDeclaration originalDecl, ClassDefinition classDef)
        {
            if (classDef.Constructors.Any(c => !c.Symbol.IsImplicitlyDeclared) ||
                classDef.Methods.Any(m => !m.Symbol.IsImplicitlyDeclared) ||
                classDef.Properties.Any(p => p.MemberKind != MemberDefinitionKind.Field) ||
                classDef.Fields.Any(f => f.MemberKind != MemberDefinitionKind.Field))
            {
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot inherit from class " + classDef.Symbol.GetFullName() +
                    ", because it contains one or more declarations that are not compatible with object literal notations.", originalDecl);
            }

            if (classDef.BaseClass != null && classDef.BaseClass.Symbol.SpecialType != Roslyn.Compilers.SpecialType.System_Object)
                ValidateBaseClass(originalDecl, classDef.BaseClass);
        }
        public void Test()
        {
            ClassDeclaration cdecl = new ClassDeclaration("ResultSet");
            MethodDeclaration mdecl = cdecl.AddMethod("GetData", typeof(DataTable))
                .Public()
                .AddParameter(typeof(string), "name");
            mdecl.Declare("result").New(new CodeDomTypeReference(typeof(DataTable)));

            mdecl.Declare("columns")
                .As(typeof(DataColumnCollection))
                .Assign("result", "Columns");

            mdecl.Call("columns", "Add").With("typeof(string)", "\"name\"");
            new CodeBuilder().GenerateCode(Console.Out, "My.Data", cdecl);
        }
        public void CSharpCodeGenerator_Constructor()
        {
            var type = new ClassDeclaration("Sample");
            var ctor = type.AddMember(new ConstructorDeclaration());

            ctor.Modifiers = Modifiers.Internal;
            var generator = new CSharpCodeGenerator();
            var result    = generator.Write(type);

            Assert.That.StringEquals(@"class Sample
{
    internal Sample()
    {
    }
}
", result);
        }
        private static MethodDeclaration GenerateExplicitImplementationMethod(ClassDeclaration clientClass, InterfaceDeclaration clientInterface, Method method, TypeReference requestType)
        {
            var m = clientClass.AddMember(new MethodDeclaration(GetMethodName(method)));

            m.PrivateImplementationType = clientInterface;
            GenerateMethodSignature(method, m, requestType, out _, out _, out _);
            foreach (var arg in m.Arguments)
            {
                arg.DefaultValue = null;
            }

            m.Statements = new ReturnStatement(
                new MethodInvokeExpression(
                    new MemberReferenceExpression(new ThisExpression(), method.MethodGroup.Name + '_' + m.Name),
                    m.Arguments.Select(arg => new ArgumentReferenceExpression(arg)).ToArray()));
            return(m);
        }
Example #21
0
        private static void ProcessAttributeUsage(this AttributeUsage attributeUsage)
        {
            ClassDeclaration classDeclaration = attributeUsage.Scope.GlobalClassSearch(attributeUsage.Name.Name);

            if (classDeclaration == null)
            {
                throw new ScopeException($"Attribute {attributeUsage.Name.Name} was not found");
            }
            if (!classDeclaration.IsAttribute)
            {
                throw new ScopeException($"Class {attributeUsage.Name.Name} is not an attribute");
            }
            AttributeDeclaration attributeDeclarationClass = classDeclaration.CastTo <AttributeDeclaration>();

            CheckCallParameters(attributeUsage, attributeUsage.FunctionCallParameters,
                                attributeDeclarationClass.ParameterNodes);
        }
        /// <summary>
        /// Creates a property that has many children that point to the primary key contained within this class.  Typically these will have HasMany attributes.
        /// </summary>
        /// <param name="classDeclaration">The class to which the property is added.</param>
        /// <param name="foreignKey">The foreign key in the table that references the primary key in this class.</param>
        /// <returns>The property that was added.</returns>
        protected override PropertyDeclaration CreateForeignKeyReference(ClassDeclaration classDeclaration, ForeignKeyColumnSchema foreignKey)
        {
            if (foreignKey.Table.PrimaryKey == null)
                return null;

            string propertyName = this.NameProvider.GetListPropertyName(foreignKey);
            string fieldName = this.NameProvider.GetListFieldName(foreignKey);
            string typeParam = this.NameProvider.GetClassName(foreignKey.Table);
            CodeDomTypeReference genericList = new CodeDomTypeReference("System.Collections.Generic.List").AddTypeParameters(typeParam);
            PropertyDeclaration result = classDeclaration.AddProperty(propertyName, fieldName, "System.Collections.Generic.IList");
            result.InitializeField(genericList)
                .AddTypeParameter(typeParam)
                .AddAttribute("Castle.ActiveRecord.HasManyAttribute")
                .AddArgument("typeof(" + this.NameProvider.GetClassName(foreignKey.Table) + ")");

            return result;
        }
Example #23
0
        protected override async Task <ClassDeclaration> AssignUpsertedReferences(ClassDeclaration record)
        {
            record.AttributeListCollection = await _attributeLists.UpsertAsync(record.AttributeListCollection);

            record.AttributeListCollectionId = record.AttributeListCollection?.AttributeListCollectionId ?? record.AttributeListCollectionId;
            record.BaseList = await _baseLists.UpsertAsync(record.BaseList);

            record.BaseListId           = record.BaseList?.BaseListId ?? record.BaseListId;
            record.ConstraintClauseList = await _constraintClauseLists.UpsertAsync(record.ConstraintClauseList);

            record.ConstraintClauseListId = record.ConstraintClauseList?.ConstraintClauseListId ?? record.ConstraintClauseListId;
            record.ConstructorList        = await _constuctorLists.UpsertAsync(record.ConstructorList);

            record.ConstructorListId        = record.ConstructorList?.ConstructorListId ?? record.ConstructorListId;
            record.DocumentationCommentList = await _documentationCommentLists.UpsertAsync(record.DocumentationCommentList);

            record.DocumentationCommentListId = record.DocumentationCommentList?.DocumentationCommentListId ?? record.DocumentationCommentListId;
            record.FieldList = await _fieldLists.UpsertAsync(record.FieldList);

            record.FieldListId = record.FieldList?.FieldListId ?? record.FieldListId;
            record.Finalizer   = await _finalizers.UpsertAsync(record.Finalizer);

            record.FinalizerId = record.Finalizer?.FinalizerId ?? record.FinalizerId;
            record.Identifier  = await _identifiers.UpsertAsync(record.Identifier);

            record.IdentifierId = record.Identifier?.IdentifierId ?? record.IdentifierId;
            record.MethodList   = await _methodLists.UpsertAsync(record.MethodList);

            record.MethodListId = record.MethodList?.MethodListId ?? record.MethodListId;
            record.ModifierList = await _modifierLists.UpsertAsync(record.ModifierList);

            record.ModifierListId = record.ModifierList?.ModifierListId ?? record.ModifierListId;
            record.Namespace      = await _namespaces.UpsertAsync(record.Namespace);

            record.NamespaceId  = record.Namespace?.NamespaceId ?? record.NamespaceId;
            record.PropertyList = await _propertyLists.UpsertAsync(record.PropertyList);

            record.PropertyListId    = record.PropertyList?.PropertyListId ?? record.PropertyListId;
            record.TypeParameterList = await _typeParameterLists.UpsertAsync(record.TypeParameterList);

            record.TypeParameterListId = record.TypeParameterList?.TypeParameterListId ?? record.TypeParameterListId;
            record.UsingDirectiveList  = await _usingDirectiveLists.UpsertAsync(record.UsingDirectiveList);

            record.UsingDirectiveListId = record.UsingDirectiveList?.UsingDirectiveListId ?? record.UsingDirectiveListId;
            return(record);
        }
Example #24
0
        private IList <Mutant> GetMethodMutants(string method)
        {
            var methodSyntax = _class
                               .DescendantNodes <MethodDeclarationSyntax>()
                               .FirstOrDefault(x => x.MethodName() == method);

            if (methodSyntax != null)
            {
                var mutantOrchestrator        = new MutantOrchestrator();
                var syntaxNodeAnalysisFactory = new SyntaxNodeAnalysisFactory();
                var classDeclaration          = new ClassDeclaration(_class);
                var syntaxNodeAnalysis        = syntaxNodeAnalysisFactory.Create(methodSyntax, classDeclaration);
                mutantOrchestrator.Mutate(syntaxNodeAnalysis);
                return(mutantOrchestrator.GetLatestMutantBatch().ToList());
            }

            return(new List <Mutant>());
        }
        public void TestRootedAndUnrooted()
        {
            ModuleDeclaration module   = ReflectToModules("public class Foo { } ", "SomeModule").Find(m => m.Name == "SomeModule");
            ClassDeclaration  fooClass = module.AllClasses.Where(cl => cl.Name == "Foo").FirstOrDefault();

            Assert.IsNotNull(fooClass);
            Assert.IsFalse(fooClass.IsUnrooted);
            ClassDeclaration unrootedFoo = fooClass.MakeUnrooted() as ClassDeclaration;

            Assert.IsNotNull(unrootedFoo);
            Assert.IsTrue(unrootedFoo != fooClass);
            Assert.AreEqual(unrootedFoo.Name, fooClass.Name);
            Assert.AreEqual(unrootedFoo.Access, fooClass.Access);
            ClassDeclaration doubleUnrootedFoo = unrootedFoo.MakeUnrooted() as ClassDeclaration;

            Assert.IsNotNull(doubleUnrootedFoo);
            Assert.IsTrue(doubleUnrootedFoo == unrootedFoo);
        }
Example #26
0
        private static void PreProcess(this ClassDeclaration classDeclaration)
        {
            var scope = classDeclaration.Scope;

            var duplicatedModifiers = classDeclaration.ModifiersList
                                      .GetDuplicatedItems().ToList();

            if (duplicatedModifiers.Any())
            {
                throw new ScopeException($"Modifier {duplicatedModifiers.First()} was specified more than once");
            }

            classDeclaration.ModifiersList.ForEach(modifier =>
            {
                if (modifier == Modifier.Static)
                {
                    classDeclaration.IsStatic = true;
                }
                if (modifier == Modifier.Extern)
                {
                    classDeclaration.IsExtern = true;
                }
            });

            if (!classDeclaration.IsStatic && !classDeclaration.IsAttribute)
            {
                throw new ScopeException(
                          $"Only static classes are supported at the moment ({classDeclaration.Name})");
            }
            classDeclaration.FunctionDeclarationNodes
            .ForEach(functionDeclaration =>
            {
                functionDeclaration.CheckName(scope);
                scope.AddFunction(functionDeclaration);
                functionDeclaration.PreProcess();
            });

            classDeclaration.VarDeclarationNodes
            .ForEach(declaration =>
            {
                declaration.CheckName(scope);
                scope.AddVariable(declaration);
            });
        }
        protected override PropertyDeclaration CreateForeignKey(ClassDeclaration classDeclaration, ForeignKeyColumnSchema foreignKey)
        {
            string columnName = foreignKey.PrimaryKeyTable.Name;

            string fkname = this.NameProvider.GetPropertyName(columnName);
            string fkfieldname = this.NameProvider.GetFieldName(columnName);
            string fkdatatype = this.NameProvider.GetClassName(foreignKey.PrimaryKeyTable);

            //add the field
            var field = new CodeMemberField(fkdatatype, fkfieldname);
            classDeclaration.Members.Add(field);

            //add the prop
            var prop = new CodeMemberProperty();
            prop.Name = fkname;
            prop.Type = new CodeTypeReference(fkdatatype);
            prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            prop.GetStatements.Add(
                new CodeMethodReturnStatement(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fkfieldname)));

            //if (value == null || this._stateCode == null || (value.ID != this._stateCode.ID))
            var ifValueNull = new CodeBinaryOperatorExpression(new CodeSnippetExpression("value"), CodeBinaryOperatorType.IdentityEquality, new CodeSnippetExpression("null"));
            var ifFieldNull = new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fkfieldname), CodeBinaryOperatorType.IdentityEquality, new CodeSnippetExpression("null"));
            var valueIdExpression = new CodePropertyReferenceExpression(new CodeSnippetExpression("value"), "ID");
            var fieldIdExpression = new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fkfieldname), "ID");
            var ifValueIdDoesNotEqualFieldId = new CodeBinaryOperatorExpression(valueIdExpression, CodeBinaryOperatorType.IdentityInequality, fieldIdExpression);

            prop.SetStatements.Add(
                new CodeConditionStatement(
                    new CodeBinaryOperatorExpression(
                        new CodeBinaryOperatorExpression(ifValueNull, CodeBinaryOperatorType.BooleanOr, ifFieldNull),
                        CodeBinaryOperatorType.BooleanOr,
                        ifValueIdDoesNotEqualFieldId),
                    new CodeSnippetStatement(String.Format("{1}((EightyProofSolutions.BlogEngine.Core.Models.ITrackPropertyChanges)this).OnPropertyChanged(\"{0}\", this.{2}, value);", fkname, new String('\t', 5), fkfieldname)),
                    new CodeAssignStatement(
                        new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fkfieldname),
                        new CodeSnippetExpression("value"))));
            classDeclaration.Members.Add(prop);
            return null;
            //PropertyDeclaration result = classDeclaration.AddProperty(fkname, fkfieldname, fkdatatype);
            //return result;
        }
Example #28
0
        public void NoDatabaseSchemaWhileClassDeclarationTest()
        {
            Mock <IStorage> storage = new Mock <IStorage>();

            storage.Setup(s => s.SaveSchema(It.IsAny <IDatabaseSchema>())).Verifiable();

            Mock <Action <String, MessageLevel> > log = new Mock <Action <String, MessageLevel> >();

            ClassDeclaration classDeclarationStatement = new ClassDeclaration();

            QueryParameters parameters = new QueryParameters {
                Storage = storage.Object, Log = log.Object
            };
            var result = classDeclarationStatement.Execute(parameters);

            storage.Verify(s => s.SaveSchema(It.IsAny <IDatabaseSchema>()), Times.Never);
            Assert.AreEqual(ResultType.StringResult, result.Result.QueryResultType);
            Assert.AreEqual("Error ocured while class creation", result.Result.StringOutput);
        }
Example #29
0
        private void convertClassDeclaration(ClassDeclarationSyntax classDeclarationSyntax, ModuleDeclaration module)
        {
            var classDeclaration = new ClassDeclaration();

            module.Clases.Add(classDeclaration);

            foreach (var memberDeclarationSyntax in classDeclarationSyntax.Members)
            {
                if (memberDeclarationSyntax is PropertyDeclarationSyntax propertyDeclaration)
                {
                    convertPropertyDeclaration(propertyDeclaration, classDeclaration);
                }

                if (memberDeclarationSyntax is MethodDeclarationSyntax method)
                {
                    convertMethodDeclaration(method, classDeclaration);
                }
            }
        }
Example #30
0
        /// <summary>
        /// Génére le code d'une classe.
        /// </summary>
        /// <param name="declaration"></param>
        /// <returns></returns>
        string GenerateClass(ClassDeclaration declaration)
        {
            StringBuilder builder     = new StringBuilder();
            string        inheritance = declaration.InheritsFrom == null ? "" : "(" + declaration.InheritsFrom + ")";

            builder.Append("class " + declaration.Name);

            // Héritage
            builder.AppendLine(inheritance + ":\n");

            // Instructions
            foreach (Instruction instruction in declaration.Instructions)
            {
                builder.Append(Tools.StringUtils.Indent(GenerateInstruction(instruction), 1));
                builder.Append("\n");
            }

            return(builder.ToString());
        }
 /// <summary>
 /// Adds compiler feature abstraction to all attribute annotations of or nested within a class declaration.
 /// </summary>
 /// <param name="class">The class declaration</param>
 private static void AddCompilerAbstractionToAttributes(ClassDeclaration @class)
 {
     foreach (ConditionalAttributeAnnotation annotation in @class.AttributeAnnotations)
     {
         AddCompilerAbstraction(annotation);
     }
     foreach (ClassDeclarationNestedDeclaration declaration in @class.NestedDeclarations)
     {
         if (declaration.DeclarationCase == ClassDeclarationNestedDeclaration.DeclarationOneofCase.NestedTypeDeclaration &&
             declaration.NestedTypeDeclaration.DeclarationCase == NestedTypeDeclaration.DeclarationOneofCase.ClassDeclaration)
         {
             AddCompilerAbstractionToAttributes(declaration.NestedTypeDeclaration.ClassDeclaration);
         }
         if (declaration.DeclarationCase == ClassDeclarationNestedDeclaration.DeclarationOneofCase.Member)
         {
             AddCompilerAbstractionToAttributes(declaration.Member);
         }
     }
 }
Example #32
0
        public void ClassAlreadyExistsTest()
        {
            var existingClass = new Class
            {
                ClassId = new ClassId {
                    Id = 1, Name = "Test1"
                },
                Name = "Test1"
            };

            var classes = new ConcurrentDictionary <ClassId, Class>();

            classes.TryAdd(existingClass.ClassId, existingClass);

            Mock <IDatabaseParameters> database = new Mock <IDatabaseParameters>();

            database.Setup(d => d.Schema.Classes).Returns(classes);

            Mock <IStorage> storage = new Mock <IStorage>();

            storage.Setup(s => s.SaveSchema(It.IsAny <IDatabaseSchema>())).Verifiable();

            Mock <Action <String, MessageLevel> > log = new Mock <Action <String, MessageLevel> >();

            ClassDeclaration classDeclarationStatement = new ClassDeclaration();

            Mock <ClassName> className = new Mock <ClassName>();

            className.Setup(cn => cn.Execute(It.IsAny <QueryParameters>())).Returns(new QueryDTO {
                QueryClass = existingClass
            });
            classDeclarationStatement.Add(className.Object);

            QueryParameters parameters = new QueryParameters {
                Database = database.Object, Storage = storage.Object, Log = log.Object
            };
            var result = classDeclarationStatement.Execute(parameters);

            storage.Verify(s => s.SaveSchema(It.IsAny <IDatabaseSchema>()), Times.Never);
            Assert.AreEqual(ResultType.StringResult, result.Result.QueryResultType);
            Assert.AreEqual("Class or interface with name: " + existingClass.Name + " arleady exists!", result.Result.StringOutput);
        }
Example #33
0
        private void AddField(ClassDeclaration c, FieldInfo f)
        {
            if (c == null)
            {
                throw new ArgumentNullException("c");
            }
            if (f == null)
            {
                throw new ArgumentNullException("f");
            }

            FieldDeclaration    fd = c.AddField(MapType(f.FieldType), f.Name);
            PropertyDeclaration p  = c.AddProperty(fd, f.Name, true, true, false);

            // adding attributes
            if (TypeHelper.HasCustomAttribute(f, typeof(XmlAttributeAttribute)))
            {
                XmlAttributeAttribute att  = (XmlAttributeAttribute)TypeHelper.GetFirstCustomAttribute(f, typeof(XmlAttributeAttribute));
                AttributeDeclaration  attr = p.CustomAttributes.Add(typeof(XmlAttributeAttribute));
                string attrName            = att.AttributeName;
                if (att.AttributeName.Length == 0)
                {
                    attrName = f.Name;
                }
                AttributeArgument arg = attr.Arguments.Add(
                    "AttributeName",
                    Expr.Prim(attrName)
                    );
            }
            else
            {
                if (TypeHelper.HasCustomAttribute(f, typeof(XmlElementAttribute)))
                {
                    AttachXmlElementAttributes(p, f);
                }
                else
                {
                    AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlElementAttribute));
                    attr.Arguments.Add("ElementName", Expr.Prim(f.Name));
                }
            }
        }
        public static bool IsClassAndSuperclassesContainsLoop(this ClassDeclaration classDecl, HashSet <MofProduction> mof)
        {
            Func <MofProduction, bool> func = null;

            while (classDecl != null && classDecl.SuperclassName != null)
            {
                HashSet <MofProduction> mofProductions = mof;
                if (func == null)
                {
                    func = (MofProduction item) => item.GetFullClassName() == classDecl.SuperclassName.FullName;
                }
                var temp = mofProductions.First <MofProduction>(func) as ClassDeclaration;
                if (classDecl != temp)
                {
                    continue;
                }
                return(true);
            }
            return(false);
        }
Example #35
0
        CSProperty ImportProperty(PropertyDefinition property, ClassDeclaration typeDeclaration, bool isProtocol)
        {
            var hasGetter = property.GetMethod != null;
            var hasSetter = property.SetMethod != null;

            if (!hasGetter && !hasGetter)
            {
                return(null);
            }
            // if there's a getter, it's the return value's type
            // if there's a setter, it's the 0th argument (value)
            var gettervisibility = ToVisibility(property.GetMethod ?? property.SetMethod);
            var settervisibility = ToVisibility(property.SetMethod ?? property.GetMethod);
            var propType         = property.GetMethod != null?MapType(property.GetMethod.ReturnType) :
                                       MapType(property.SetMethod.Parameters [0].ParameterType);

            return(new CSProperty(propType, ToMethodKind(property.GetMethod ?? property.SetMethod), new CSIdentifier(property.Name),
                                  gettervisibility, hasGetter ? new CSCodeBlock() : null,
                                  settervisibility, hasSetter ? new CSCodeBlock() : null));
        }
        public void CSharpCodeGenerator_Constructor_ThisWithArgs()
        {
            var type = new ClassDeclaration("Sample");
            var ctor = type.AddMember(new ConstructorDeclaration());

            ctor.Initializer = new ConstructorThisInitializer(new LiteralExpression("arg"));
            ctor.Modifiers   = Modifiers.Public;

            var generator = new CSharpCodeGenerator();
            var result    = generator.Write(type);

            Assert.That.StringEquals(@"class Sample
{
    public Sample()
        : this(""arg"")
    {
    }
}
", result);
        }
Example #37
0
        private void ValidateBaseClass(ClassDeclaration originalDecl, ClassDefinition classDef)
        {
            var extensionFactory = new ExtensionFactory();
            var extensions       = extensionFactory.GetExtensions(classDef.Symbol);

            if (!extensions.Any(e => e.GetType() == typeof(ScriptObjectLiteralExtension)) &&
                (classDef.Constructors.Any(c => !c.Symbol.IsImplicitlyDeclared) ||
                 classDef.Methods.Any(m => !m.Symbol.IsImplicitlyDeclared) ||
                 classDef.Properties.Any(p => p.MemberKind != MemberDefinitionKind.Field) ||
                 classDef.Fields.Any(f => f.MemberKind != MemberDefinitionKind.Field)))
            {
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot inherit from class " + classDef.Symbol.GetFullName() +
                                               ", because it contains one or more declarations that are not compatible with object literal notations.", originalDecl);
            }

            if (classDef.BaseClass != null && classDef.BaseClass.Symbol.SpecialType != Roslyn.Compilers.SpecialType.System_Object)
            {
                ValidateBaseClass(originalDecl, classDef.BaseClass);
            }
        }
Example #38
0
        private void AddPropertyInitStatements(Constructor ctorNode)
        {
            ClassDeclaration classNode = ctorNode.Parent as ClassDeclaration;

            if (classNode == null)
            {
                return;
            }

            Block ctorBlock = ctorNode.Body as Block;
            List <PropertyDeclaration> props = this.GetInitProperties(classNode);

            props.Reverse();
            foreach (PropertyDeclaration prop in props)
            {
                ExpressionStatement statement = (ExpressionStatement)NodeHelper.CreateNode(this.BuildPropertyStatementString(prop.Name.Text));
                (statement.Expression as BinaryExpression).SetRight(prop.Initializer, false);
                ctorBlock.InsertStatement(0, statement);
            }
        }
Example #39
0
        public void Generate(System.Extensions.CodeDom.NamespaceDeclaration ns)
        {
            if (this.Name == null)
            {
                throw new InvalidOperationException("name not set");
            }

            // create class
            ClassDeclaration c = ns.AddClass(DecorateName(this.Name));

            this.Properties = new Hashtable();
            // add fields and properties
            foreach (DictionaryEntry de in this.Fields)
            {
                FieldDeclaration f = c.AddField(de.Value.ToString(), de.Key.ToString());

                PropertyDeclaration p = c.AddProperty(f, true, !ReadOnly, false);
                this.Properties.Add(de, p);
            }
        }
        private void GenerateClassType(Type t)
        {
            ClassDeclaration c = this.ns.Classes[this.conformer.ToCapitalized(t.Name)];

            // generate fields and properties
            foreach (FieldInfo f in t.GetFields())
            {
                if (f.FieldType.IsArray)
                {
                    AddArrayField(c, f);
                }
                else
                {
                    AddField(c, f);
                }
            }

            // add constructors
            GenerateDefaultConstructor(c);
        }
Example #41
0
        private static void TestRetrieveBaseClassName(ClassDeclarationSyntax classDeclarationNode, SemanticModel semanticModel, string expected)
        {
            Assert.IsNotNull(classDeclarationNode, "Found node should be of type `{0}`!",
                             typeof(ClassDeclarationSyntax).Name);

            ClassDeclaration  classDeclaration = new ClassDeclaration(classDeclarationNode, semanticModel);
            BaseTypeReference baseClass        = classDeclaration.BaseClass;

            if (expected == null)
            {
                Assert.IsNull(baseClass, "Class name should be null!");
                return;
            }

            string name = classDeclaration.BaseClass.Name;

            Assert.IsNotNull(name, "Class name should not be null!");
            Assert.AreNotEqual(string.Empty, name, "Class name should not be empty!");
            Assert.AreEqual(expected, name, "Base class name is not the one in source!");
        }
        private void ValidateClass(ClassDeclaration classDecl)
        {
            if (classDecl.IsStatic)
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot be declaraed static.", classDecl);

            if (classDecl.Constructors.Count > 0)
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot contain constructors.", classDecl);

            if (classDecl.Methods.Count > 0)
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot contain methods.", classDecl);

            if (classDecl.Events.Count > 0)
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute cannot contain events.", classDecl);

            if (classDecl.Properties.Any(p => !p.IsAutoProperty))
                throw new CompilationException("A class using the [ScriptObjectLiteral] attribute can only contain auto properties.", classDecl);

            if (classDecl.IsDerived)
                ValidateBaseClass(classDecl, classDecl.Definition.BaseClass);
        }
Example #43
0
        /// <summary>
        /// Génère un constructeur initialisant tous les champs bien comme il faut.
        /// </summary>
        /// <param name="decl"></param>
        /// <returns></returns>
        public string GenerateConstructor(ClassDeclaration decl)
        {
            StringBuilder b = new StringBuilder();

            b.AppendLine(decl.Name + "::" + decl.Name + "() {");

            /*var varDecls = decl.Instructions.Where(inst => inst is VariableDeclarationInstruction).ToList();
             *
             * foreach (var vdecl in varDecls)
             * {
             *  var d = vdecl as VariableDeclarationInstruction;
             *  if (d.Var.Type.BaseType.JType == JSONType.Array || d.Var.Type.BaseType.JType == JSONType.Object)
             *  {
             *      b.AppendLine("\t" + d.Var.Name + " = " + GenerateTypeInstanceName(d.Var.Type) + "();");
             *  }
             * }*/

            b.AppendLine("}");
            return(b.ToString());
        }
Example #44
0
        private void AddLostConstructor(ClassDeclaration classNode)
        {
            Constructor             constructor = classNode.GetConstructor();
            List <ClassDeclaration> baseClasses = classNode.Project.GetInheritClasses(classNode);

            if (constructor == null)
            {
                if (baseClasses.Count > 0)
                {
                    var baseClass = baseClasses.Find(c =>
                    {
                        var ctor = c.GetConstructor();
                        return(ctor != null && ctor.Parameters.Count > 0);
                    });

                    if (baseClass != null)
                    {
                        Constructor baseCtor = baseClass.GetConstructor();
                        Constructor newCtor  = (Constructor)NodeHelper.CreateNode((JObject)baseCtor.TsNode.DeepClone());

                        CallExpression baseNode = (CallExpression)NodeHelper.CreateNode(NodeKind.CallExpression);
                        baseNode.SetExpression(NodeHelper.CreateNode(NodeKind.SuperKeyword));
                        foreach (Parameter parameter in baseCtor.Parameters)
                        {
                            baseNode.AddArgument(NodeHelper.CreateNode(NodeKind.Identifier, parameter.Name.Text));
                        }

                        newCtor.SetBase(baseNode);
                        newCtor.Body.ClearStatements();
                        ModifierNormalizer.NormalizeModify(newCtor);
                        classNode.InsertMember(0, newCtor);
                    }
                }
                else if (this.GetInitProperties(classNode).Count > 0)
                {
                    Constructor newCtor = (Constructor)NodeHelper.CreateNode(BuildConstructorString());
                    ModifierNormalizer.NormalizeModify(newCtor);
                    classNode.InsertMember(0, newCtor);
                }
            }
        }
Example #45
0
        public void DeclareClass(ClassDeclaration classNode, ModuleBuilder module)
        {
            if (classNode.IsAttribute)
            {
                return;
            }

            TypeBuilder typeBuilder = null;

            if (!classNode.IsExtern)
            {
                // create public static class
                typeBuilder = module.DefineType(classNode.Name, TypeAttributes.Public |
                                                TypeAttributes.Class | TypeAttributes.Sealed |
                                                TypeAttributes.Abstract);

                classTypeBuilders.Add(classNode.Name, typeBuilder);


                if (classNode.VarDeclarationNodes.Count > 0)
                {
                    ConstructorBuilder constructor = typeBuilder.DefineConstructor(
                        MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig |
                        MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard,
                        new Type[0]);

                    ILGenerator ilGenerator = constructor.GetILGenerator();

                    foreach (var declarationNode in classNode.VarDeclarationNodes)
                    {
                        DeclareField(declarationNode, typeBuilder, ilGenerator);
                    }

                    ilGenerator.Emit(OpCodes.Ret);
                }
            }
            foreach (var funcNode in classNode.FunctionDeclarationNodes)
            {
                DeclareFunc(funcNode, typeBuilder);
            }
        }
        public override void Generate()
        {
            if (this.Name == null)
            {
                throw new InvalidOperationException("name not set");
            }

            // create class
            ClassDeclaration c = this.NamespaceDeclaration.AddClass(this.DataName);

            this.Properties = new Hashtable();
            // add fields and properties
            foreach (DictionaryEntry de in this.Fields)
            {
                FieldDeclaration f = c.AddField(de.Value.ToString(), de.Key.ToString());

                PropertyDeclaration p = c.AddProperty(f, true, !ReadOnly, false);
                this.Properties.Add(de, p);
            }
            this.Compile();
        }
        public void CSharpCodeGenerator_FieldDeclaration()
        {
            var type = new ClassDeclaration("Sample");

            type.AddMember(new FieldDeclaration("_a", typeof(int)));
            type.AddMember(new FieldDeclaration("_b", typeof(Type), Modifiers.Private));
            type.AddMember(new FieldDeclaration("_c", typeof(int), Modifiers.Protected, 10));

            var generator = new CSharpCodeGenerator();
            var result    = generator.Write(type);

            Assert.That.StringEquals(@"class Sample
{
    int _a;

    private System.Type _b;

    protected int _c = 10;
}
", result);
        }
Example #48
0
        /// <summary>
        /// Génére le code d'une classe.
        /// </summary>
        /// <param name="declaration"></param>
        /// <returns></returns>
        string GenerateClass(ClassDeclaration declaration)
        {
            StringBuilder builder     = new StringBuilder();
            string        inheritance = declaration.InheritsFrom == null ? "" : " : " + declaration.InheritsFrom;

            if (declaration.Modifiers.Contains("public"))
            {
                builder.Append("public ");
            }
            builder.Append("class " + declaration.Name);

            // Paramètres génériques
            if (declaration.GenericParameters.Count > 0)
            {
                builder.Append("<");
                foreach (string tupe in declaration.GenericParameters)
                {
                    builder.Append(tupe);
                    if (tupe != declaration.GenericParameters.Last())
                    {
                        builder.Append(",");
                    }
                }
                builder.Append(">");
            }
            // Héritage
            builder.AppendLine(inheritance + "\n{\n");

            // Instructions
            foreach (Instruction instruction in declaration.Instructions)
            {
                builder.Append(Tools.StringUtils.Indent(GenerateInstruction(instruction), 1));
                builder.Append("\n");
            }

            builder.AppendLine(Tools.StringUtils.Indent(GenerateDeserializer(declaration)));

            builder.Append("}");
            return(builder.ToString());
        }
Example #49
0
        private void CreateClass(Type t)
        {
            ClassDeclaration c = this.ns.AddClass(this.conformer.ToCapitalized(t.Name));

            // check if XmlType present
            if (TypeHelper.HasCustomAttribute(t, typeof(XmlTypeAttribute)))
            {
                XmlTypeAttribute typeAttr =
                    (XmlTypeAttribute)TypeHelper.GetFirstCustomAttribute(t, typeof(XmlTypeAttribute));
                AttributeDeclaration type = c.CustomAttributes.Add(typeof(XmlTypeAttribute));
                type.Arguments.Add("IncludeInSchema", Expr.Prim(typeAttr.IncludeInSchema));
                if (this.Config.KeepNamespaces)
                {
                    type.Arguments.Add("Namespace", Expr.Prim(typeAttr.Namespace));
                }
                type.Arguments.Add("TypeName", Expr.Prim(typeAttr.TypeName));
            }

            // check if XmlRoot present
            if (TypeHelper.HasCustomAttribute(t, typeof(XmlRootAttribute)))
            {
                XmlRootAttribute rootAttr =
                    (XmlRootAttribute)TypeHelper.GetFirstCustomAttribute(t, typeof(XmlRootAttribute));
                AttributeDeclaration root = c.CustomAttributes.Add(typeof(XmlRootAttribute));

                root.Arguments.Add("ElementName", Expr.Prim(rootAttr.ElementName));
                root.Arguments.Add("IsNullable", Expr.Prim(rootAttr.IsNullable));
                if (this.Config.KeepNamespaces)
                {
                    root.Arguments.Add("Namespace", Expr.Prim(rootAttr.Namespace));
                }
                root.Arguments.Add("DataType", Expr.Prim(rootAttr.DataType));
            }
            else
            {
                AttributeDeclaration root = c.CustomAttributes.Add(typeof(XmlRootAttribute));
                root.Arguments.Add("ElementName", Expr.Prim(t.Name));
            }
            this.types.Add(t, c);
        }
Example #50
0
        public override IQueryElement VisitClass_delcaration([NotNull] QueryGrammarParser.Class_delcarationContext context)
        {
            ClassDeclaration classDeclaration = new ClassDeclaration();

            IQueryElement className = Visit(context.class_name());

            classDeclaration.Add(className);

            if (context.parent_type() != null)
            {
                IQueryElement parentClasses = Visit(context.parent_type());
                classDeclaration.Add(parentClasses);
            }

            foreach (var attribute in context.cls_attribute_dec_stm())
            {
                IQueryElement attributeDeclaration = Visit(attribute);
                classDeclaration.Add(attributeDeclaration);
            }

            return(classDeclaration);
        }
Example #51
0
 private static void __Execute(atom.Trace context, int level, ClassDeclaration data, string file, bool isShowPrivate)
 {
     if (__IsEnabled(data, isShowPrivate))
     {
         context.
         SetComment(__GetType(data, "class"), "[[[Data Type]]]").
         SetUrl(file, __GetLine(data, data.Name.Pos.Value), __GetPosition(data, data.Name.Pos.Value)).
         Send(NAME.SOURCE.PREVIEW, NAME.TYPE.CLASS, level, __GetName(data.Name, true));
         foreach (var a_Context in data.Members.OfType <MethodDeclaration>())
         {
             __Execute(context, level + 1, a_Context, file, false, isShowPrivate);
         }
         foreach (var a_Context in data.Members.OfType <PropertyDeclaration>())
         {
             __Execute(context, level + 1, a_Context, file, isShowPrivate);
         }
         foreach (var a_Context in data.Members.OfType <VariableDeclaration>())
         {
             __Execute(context, level + 1, a_Context, file, isShowPrivate);
         }
     }
 }
        protected override void CreateAssociationProperties(ClassDeclaration classDeclaration, TableSchema table)
        {
            if (classDeclaration == null || table == null || table.Associations.Count == 0)
                return;

            foreach (var assocTable in table.Associations)
            {
                Console.WriteLine("assocTable.Name=" + assocTable.Name);
                var otherTable = assocTable.ForeignKeys.Single(fk => { return fk.PrimaryKeyTable.Name != table.Name; }).PrimaryKeyTable;

                string propName = Inflector.Pluralize(this.NameProvider.GetPropertyName(otherTable.Name));
                string fieldName = Inflector.Pluralize(this.NameProvider.GetFieldName(otherTable.Name));
                var typeRef = new CodeDomTypeReference(typeof(IList<>).FullName, this.NameProvider.GetClassName(otherTable));
                var prop = classDeclaration.AddProperty(propName, fieldName, typeRef);
                prop.AddAttribute("Castle.ActiveRecord.HasAndBelongsToMany")
                    .AddArgument("typeof(" + this.NameProvider.GetClassName(otherTable) + ")")
                    .AddQuotedArgument("Table", assocTable.Name)
                    .AddQuotedArgument("ColumnKey", assocTable.ForeignKeys.Single(fk => { return fk.PrimaryKeyTable.Name == table.Name; }).Name)
                    .AddQuotedArgument("ColumnRef", assocTable.ForeignKeys.Single(fk => { return fk.PrimaryKeyTable.Name != table.Name; }).Name)
                    .AddArgument("Lazy = true");

            }
        }
 protected override void CreateAssociationProperties(ClassDeclaration classDeclaration, TableSchema table)
 {
     //throw new NotImplementedException();
 }
 public void CanInheritFromInterface()
 {
     ClassDeclaration cdecl = new ClassDeclaration("F**k").Implements(new InterfaceDeclaration("You"));
     new CodeBuilder().GenerateCode(Console.Out, "Blah", cdecl);
 }
 /// <summary>
 /// Creates a plain ol' property representing any column that is not a foreign key or primary key.
 /// </summary>
 /// <param name="classDeclaration">The class to which the property is added.</param>
 /// <param name="column">The column the property represents.</param>
 protected override void CreateNonKeyProperty(ClassDeclaration classDeclaration, ColumnSchema column)
 {
     string propertyName = this.NameProvider.GetPropertyName(column);
     string fieldName = this.NameProvider.GetFieldName(column);
     AttributeDeclaration attrib = classDeclaration.AddProperty(propertyName, fieldName, column.DataType, column.Nullable)
             .AddAttribute("Castle.ActiveRecord.PropertyAttribute")
             .AddQuotedArgument(column.Name);
     if (column.SqlType == System.Data.SqlDbType.Image)
         attrib.AddArgument("ColumnType=\"BinaryBlob\"");
     if (column.SqlType == System.Data.SqlDbType.Xml)
         attrib.AddArgument("ColumnType=\"StringClob\"");
 }
 /**
  * Call back method that must be called as soon as the given <code>
  * ClassDeclaration</code> object has been traversed.
  *
  * @param pClassDeclaration  The <code>ClassDeclaration</code> object that
  *                           has just been traversed.
  */
 public void actionPerformed(
      ClassDeclaration pClassDeclaration)
 {
     // Nothing to do.
 }
 /**
  * Call back method that must be called when the given <code>
  * ClassDeclaration</code> will become the next <i>traverse candidate</i>.
  *
  * @param pClassDeclaration  The <code>ClassDeclaration</code> object that
  *                           will become the next <i>traverse candidate</i>.
  */
 public void performAction(
      ClassDeclaration pClassDeclaration)
 {
     // Nothing to do.
 }
Example #58
0
 public void Test()
 {
     var @class = new ClassDeclaration("Customer");
     new CodeBuilder().GenerateCode(Console.Out, "My.Models", @class);
 }
Example #59
0
 public FullClassDeclaration(string FullName, ClassDeclaration ClassDeclaration, NamespaceDeclaration NamespaceDeclaration)
 {
     fullName = FullName;
     classDeclaration = ClassDeclaration;
     namespaceDeclaration = NamespaceDeclaration;
 }
 /// <summary>
 /// Add some class attributes.
 /// </summary>
 /// <param name="classDecl">The ClassDeclaration instance we're adding an attribute to.</param>
 /// <param name="table">The database table that the ClassDeclaration represents.</param>
 protected override void AddClassAttributes(ClassDeclaration classDecl, TableSchema table)
 {
     classDecl.AddAttribute("Castle.ActiveRecord.ActiveRecordAttribute").AddQuotedArgument(this.NameProvider.Escape(table.Name));
 }