private void WriteDocuments( ContentTypeConfiguration contentTypeConfiguration, IEnumerable<XDocument> documents, string path, string baseClass ) { var contentTypeName = contentTypeConfiguration.ContentTypeName; var docsAtLevel = documents.Where(doc => doc.Element(contentTypeName).Element("Info").Element("Master").Value == baseClass); foreach (var doc in docsAtLevel) { var alias = doc.Element(contentTypeName).Element("Info").Element("Alias").Value; var directoryPath = Path.Combine(path, alias); if (!Directory.Exists(directoryPath)) Directory.CreateDirectory(directoryPath); var defPath = Path.Combine(directoryPath, "def.config"); if (configuration.OverwriteReadOnly && File.Exists(defPath)) File.SetAttributes(defPath, File.GetAttributes(defPath) & ~FileAttributes.ReadOnly); doc.Save(defPath); WriteDocuments(contentTypeConfiguration, documents, directoryPath, alias); } }
public PropertyInfoGenerator( ContentTypeConfiguration config, IList <DataTypeDefinition> dataTypes ) : base(config) { this.dataTypes = dataTypes; }
private static CodeGeneratorBase CreateGenerators( ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes ) { return(new NamespaceGenerator( configuration, new ImportsGenerator(configuration), new ClassGenerator(configuration, new CompositeCodeGenerator( configuration, new EntityNameGenerator(configuration) ), new CtorGenerator(configuration), new PropertiesGenerator( configuration, new PublicPropertyDeclarationGenerator( configuration, dataTypes.ToList(), new EntityNameGenerator(configuration), new PropertyBodyGenerator(configuration) ) ) ) )); }
public CompositeCodeGenerator( ContentTypeConfiguration config, params CodeGeneratorBase[] generators ) : base(config) { this.generators = generators; }
private void WriteDocuments( ContentTypeConfiguration contentTypeConfiguration, IEnumerable <XDocument> documents, string path, string baseClass ) { var contentTypeName = contentTypeConfiguration.ContentTypeName; var docsAtLevel = documents.Where(doc => doc.Element(contentTypeName).Element("Info").Element("Master").Value == baseClass); foreach (var doc in docsAtLevel) { var alias = doc.Element(contentTypeName).Element("Info").Element("Alias").Value; var directoryPath = Path.Combine(path, alias); if (!Directory.Exists(directoryPath)) { Directory.CreateDirectory(directoryPath); } var defPath = Path.Combine(directoryPath, "def.config"); if (configuration.OverwriteReadOnly && File.Exists(defPath)) { File.SetAttributes(defPath, File.GetAttributes(defPath) & ~FileAttributes.ReadOnly); } doc.Save(defPath); WriteDocuments(contentTypeConfiguration, documents, directoryPath, alias); } }
public PropertyInfoGenerator( ContentTypeConfiguration config, IList <DataTypeDefinition> dataTypes, params CodeGeneratorBase[] memberGenerators ) : base(config, dataTypes, memberGenerators) { }
public NamespaceGenerator( ContentTypeConfiguration config, params CodeGeneratorBase[] memberGenerators ) : base(config) { this.memberGenerators = memberGenerators; }
public ClassGenerator( ContentTypeConfiguration config, params CodeGeneratorBase[] memberGenerators ) : base(config, memberGenerators) { }
public PropertiesParser( ContentTypeConfiguration configuration, ContentTypeCodeParserBase propertyParser ) : base(configuration) { this.propertyParser = propertyParser; }
public CodeGeneratorBase CreateMediaTypeGenerator(ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes) { return(CreateGenerators( configuration, dataTypes )); }
public PropertiesGenerator( ContentTypeConfiguration config, params CodeGeneratorBase[] propertyGenerators ) : base(config) { this.propertyGenerators = propertyGenerators; }
public override CodeGeneratorBase Create(ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes) { if (configuration.ContentTypeName == "DocumentType") { return(CreateDocTypeGenerator(configuration, dataTypes)); } return(CreateMediaTypeGenerator(configuration, dataTypes)); }
protected ContentTypeCodeParser( ContentTypeConfiguration configuration, params ContentTypeCodeParserBase[] memberParsers ) : base(configuration) { this.memberParsers = memberParsers; }
public CodeGeneratorBase CreateDocTypeGenerator(ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes) { return(CreateGenerators( configuration, dataTypes, "DocumentType", new DocumentTypeInfoGenerator(configuration) )); }
protected PropertyDeclarationGenerator( ContentTypeConfiguration config, IList <DataTypeDefinition> dataTypes, params CodeGeneratorBase[] memberGenerators ) : base(config) { this.DataTypes = dataTypes; this.MemberGenerators = memberGenerators; }
public AttributeCodeGenerator( string attributeName, ContentTypeConfiguration config, params CodeGeneratorBase[] memberGenerators ) : base(config) { this.attributeName = attributeName; this.memberGenerators = memberGenerators; }
public CodeGenerator( ContentTypeConfiguration contentTypeConfiguration, IDataTypeProvider dataTypeProvider, CodeGeneratorFactory factory) { this.contentTypeConfiguration = contentTypeConfiguration; this.dataTypeProvider = dataTypeProvider; this.factory = factory; }
public void Create_DelegatesConfiguration() { var factory = new DefaultParserFactory(); var configuration = new ContentTypeConfiguration(CodeGeneratorConfiguration.Create(), "DocumentType"); var dataTypeDefinitions = new List <DataTypeDefinition>(); var parser = factory.Create(configuration, dataTypeDefinitions); Assert.IsInstanceOf <DocumentTypeCodeParser>(parser); }
public DocumentTypeCodeParser( ContentTypeConfiguration configuration, params ContentTypeCodeParserBase[] memberParsers ) : base( configuration, memberParsers ) { }
private string EnsureModelPath(ContentTypeConfiguration typeConfig) { var modelPath = paths[typeConfig.ContentTypeName]; if (!Directory.Exists(modelPath)) { Directory.CreateDirectory(modelPath); } return(modelPath); }
protected static string FindMaster(TypeDeclaration type, ContentTypeConfiguration configuration) { var baseType = type.BaseTypes.FirstOrDefault() as SimpleType; if (baseType == null || baseType.Identifier == configuration.BaseClass) { return(null); } return(baseType.Identifier); }
public CodeParser( ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes, ParserFactory parserFactory ) { this.configuration = configuration; this.dataTypes = dataTypes; this.parserFactory = parserFactory; }
public CodeParser( ContentTypeConfiguration configuration, IEnumerable<DataTypeDefinition> dataTypes, ParserFactory parserFactory ) { this.configuration = configuration; this.dataTypes = dataTypes; this.parserFactory = parserFactory; }
public ContentTypeCodeParser Create( ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes ) { Configuration = configuration; DataTypes = dataTypes as List <DataTypeDefinition> ?? dataTypes.ToList(); var typedParser = configuration.ContentTypeName == "DocumentType" ? CreateDocumentTypeParser() : CreateMediaTypeParser(); return(typedParser); }
private CodeGeneratorBase CreateGenerators(ContentTypeConfiguration c, CodeGeneratorBase infoGenerator, IEnumerable <DataTypeDefinition> dataTypes) { return(new NamespaceGenerator(c, new ImportsGenerator(c), new ClassGenerator(c, new EntityDescriptionGenerator(c), new CtorGenerator(c), infoGenerator, new StructureGenerator(c), new PropertiesGenerator(c, new PropertyInfoGenerator(c, dataTypes.ToList(), new EntityDescriptionGenerator(c)), new PropertyBodyGenerator(c) ) ) )); }
private void GenerateXml(ContentTypeConfiguration contentTypeConfiguration) { var xmlGenerator = new DocumentTypeXmlGenerator(contentTypeConfiguration, dataTypes); var modelPath = HttpContext.Current.Server.MapPath(contentTypeConfiguration.ModelPath); if (!Directory.Exists(modelPath)) Directory.CreateDirectory(modelPath); var files = Directory.GetFiles(modelPath, "*.cs"); var documents = new List<XDocument>(); foreach(var file in files) { using (var reader = File.OpenText(file)) { documents.AddRange(xmlGenerator.Generate(reader)); } } var documentTypeRoot = Path.Combine(uSyncConfiguration.USyncFolder, contentTypeConfiguration.ContentTypeName); if (!Directory.Exists(documentTypeRoot)) Directory.CreateDirectory(documentTypeRoot); WriteDocuments(contentTypeConfiguration, documents, documentTypeRoot, ""); }
private static CodeGeneratorBase CreateGenerators( ContentTypeConfiguration configuration, IEnumerable <DataTypeDefinition> dataTypes, string attributeName, CodeGeneratorBase infoGenerator) { return(new NamespaceGenerator( configuration, new ImportsGenerator(configuration), new ClassGenerator(configuration, new CompositeCodeGenerator( configuration, new EntityNameGenerator(configuration), new AttributeCodeGenerator( attributeName, configuration, infoGenerator, new StructureGenerator(configuration) ) ), new BaseSupportedAnnotated.CtorGenerator(configuration), new PropertiesGenerator( configuration, new PublicPropertyDeclarationGenerator( configuration, dataTypes.ToList(), new EntityNameGenerator(configuration), new AttributeCodeGenerator( "GenericProperty", configuration, new PropertyInfoGenerator(configuration, dataTypes.ToList()) ), new BaseSupportedAnnotated.PropertyBodyGenerator(configuration) ) ) ) )); }
private void GenerateXml(ContentTypeConfiguration contentTypeConfiguration) { var parser = new CodeParser(contentTypeConfiguration, dataTypes, parserFactory); var modelPath = HttpContext.Current.Server.MapPath(contentTypeConfiguration.ModelPath); if (!Directory.Exists(modelPath)) { Directory.CreateDirectory(modelPath); } var files = Directory.GetFiles(modelPath, "*.cs"); var documents = new List <XDocument>(); foreach (var file in files) { itemStart = DateTime.Now; LogHelper.Debug <CodeGenerator>(() => String.Format("Parsing file {0}", file)); using (var reader = File.OpenText(file)) { var contentType = parser.Parse(reader).FirstOrDefault(); if (contentType != null) { documents.Add(XDocument.Parse(serializer.Serialize(contentType))); } } LogHelper.Debug <CodeGenerator>(() => String.Format("Parsing file {0} done. Took {1:MM\\:ss}", file, DateTime.Now - itemStart)); } var documentTypeRoot = Path.Combine(uSyncConfiguration.USyncFolder, contentTypeConfiguration.ContentTypeName); if (!Directory.Exists(documentTypeRoot)) { Directory.CreateDirectory(documentTypeRoot); } itemStart = DateTime.Now; LogHelper.Info <CodeGenerator>(() => "Writing uSync definitions"); WriteDocuments(contentTypeConfiguration, documents, documentTypeRoot, ""); LogHelper.Info <CodeGenerator>(() => String.Format("Writing uSync definitions done. Took {0:MM\\:ss}", DateTime.Now - itemStart)); }
private static void TestBuildCode(string fileName, string contentTypeName) { var xml = ""; var expectedOutput = ""; using (var inputReader = File.OpenText(@"..\..\TestFiles\" + fileName + ".xml")) { xml = inputReader.ReadToEnd(); } using (var goldReader = File.OpenText(@"..\..\TestFiles\" + fileName + ".cs")) { expectedOutput = goldReader.ReadToEnd(); } var configuration = new CodeGeneratorConfiguration { TypeMappings = new Dictionary<string, string> { {"1413afcb-d19a-4173-8e9a-68288d2a73b8", "Int32"} }, DefaultTypeMapping = "String", }; var typeConfig = new ContentTypeConfiguration(configuration) { ContentTypeName = contentTypeName, BaseClass = "DocumentTypeBase", Namespace = "Umbraco.CodeGen.Models" }; var sb = new StringBuilder(); var writer = new StringWriter(sb); var generator = new ContentTypeCodeGenerator(typeConfig, XDocument.Parse(xml), new CSharpCodeProvider()); generator.BuildCode(writer); writer.Flush(); Console.WriteLine(sb.ToString()); Assert.AreEqual(expectedOutput, sb.ToString()); }
public ImportsGenerator(ContentTypeConfiguration config) : base(config) { }
public EntityDescriptionGenerator(ContentTypeConfiguration config) : base(config) { }
public StructureGenerator(ContentTypeConfiguration config) : base(config) { }
public EntityNameGenerator(ContentTypeConfiguration config) : base(config) { }
public PropertyBodyGenerator(ContentTypeConfiguration config) : base(config) { }