Beispiel #1
0
        /// <summary>
        ///		Procesa la generación de documentación de un programa
        /// </summary>
        internal DocumentFileModelCollection Process(ProgramModel objProgram)
        {
            NameSpaceGroupModelCollection objColGroups    = new Prepare.NameSpaceGroupGenerator().Generate(objProgram);
            DocumentFileModelCollection   objColDocuments = new DocumentFileModelCollection();

            // Carga las plantillas
            Templates = new Repository.Templates.TemplateRepository().Load(DocumentationProcessor.Parameters.TemplateFileName);
            // Crea los documentos
            foreach (NameSpaceGroupModel objGroup in objColGroups)
            {
                if (Templates.MustGenerateFile(objGroup, DocumentationProcessor.Parameters))
                {
                    DocumentFileModel objDocument = new DocumentFileModel(null, objGroup.NameSpace, 0);

                    // Procesa la estructura del lenguaje
                    if (objGroup.NameSpace != null)
                    {
                        Generate(objGroup.NameSpace, objDocument);
                    }
                    else
                    {
                        objDocument.Name = objGroup.Name;
                    }
                    // Añade el documento a la colección
                    objColDocuments.Add(objDocument);
                }
            }
            // Graba los documentos
            ProcessDocuments(objColDocuments);
            // Devuelve los documentos
            return(objColDocuments);
        }
Beispiel #2
0
        /// <summary>
        ///		Genera los archivos de contenido
        /// </summary>
        private void GenerateFilesContent(DocumentFileModelCollection allDocuments, DocumentFileModelCollection documents)
        {
            foreach (DocumentFileModel document in documents)
            {
                TemplateModel template = Templates.Search(document.StructType);

                // Genera la documentación del archivo
                if (template == null)
                {
                    AddError(document, "No se encuentra ninguna plantilla para este tipo de estructura");
                }
                else
                {
                    try
                    {
                        new Generators.TemplateDocumentGenerator(Project, this, template, document, UrlBaseDocuments, allDocuments).Process();
                    }
                    catch (Exception exception)
                    {
                        AddError(document, $"Error al generar el documento. {exception.Message}");
                    }
                }
                // Genera los documentos hijo
                GenerateFilesContent(allDocuments, document.Childs);
            }
        }
Beispiel #3
0
        /// <summary>
        ///		Genera los archivos de índice
        /// </summary>
        private DocumentFileModelCollection GenerateFilesIndex(DocumentFileModelCollection documents)
        {
            DocumentFileModelCollection filesIndex = new DocumentFileModelCollection();

            // Recorre las plantillas generando los archivos de índice
            foreach (TemplateModel template in Templates)
            {
                if (template.Type == TemplateModel.TemplateType.Index)
                {
                    try
                    {
                        DocumentFileModel fullDocument = documents.Compact(template.Name);

                        // Procesa el documento
                        new Generators.TemplateDocumentGenerator(Project, this, template, fullDocument, UrlBaseDocuments,
                                                                 documents).Process();
                        // ... y lo añade a la colección de índices
                        filesIndex.Add(fullDocument);
                    }
                    catch (Exception exception)
                    {
                        AddError($"Error al generar el documento de índice de la plantilla {template.RelativeFileName}. {exception.Message}");
                    }
                }
            }
            // Devuelve la colección de índices
            return(filesIndex);
        }
Beispiel #4
0
        /// <summary>
        ///		Genera los archivos de índice
        /// </summary>
        private DocumentFileModelCollection GenerateFilesIndex(DocumentFileModelCollection objColDocuments)
        {
            DocumentFileModelCollection objColFilesIndex = new DocumentFileModelCollection();

            // Recorre las plantillas generando los archivos de índice
            foreach (TemplateModel objTemplate in Templates)
            {
                if (objTemplate.IDType == TemplateModel.TemplateType.Index)
                {
                    try
                    { DocumentFileModel objFullDocument = objColDocuments.Compact(objTemplate.Name);
                      Generators.TemplateDocumentGenerator objGenerator = new Generators.TemplateDocumentGenerator(Project, this, objTemplate,
                                                                                                                   objFullDocument, UrlBaseDocuments,
                                                                                                                   objColDocuments);

                      // Procesa el documento
                      objGenerator.Process();
                      // ... y lo añade a la colección de índices
                      objColFilesIndex.Add(objFullDocument); }
                    catch (Exception objException)
                    { AddError($"Error al generar el documento de índice de la plantilla {objTemplate.RelativeFileName}. {objException.Message}"); }
                }
            }
            // Devuelve la colección de índices
            return(objColFilesIndex);
        }
Beispiel #5
0
        /// <summary>
        ///		Añade una lista de clases
        /// </summary>
        private void AddListChildClasses(MLNode objMLRoot, DocumentFileModelCollection objColDocuments)
        {
            if (objColDocuments.ExistsItems(LanguageStructModel.StructType.Class) ||
                objColDocuments.ExistsItems(LanguageStructModel.StructType.Interface))
            {
                MLNode objMLList = objMLRoot.Nodes.Add("ul");

                // Añade las clases
                foreach (DocumentFileModel objDocument in objColDocuments)
                {
                    if (objDocument.StructType == LanguageStructModel.StructType.Class)
                    {
                        objMLList.Nodes.Add(MLBuilder.GetListItem(MLBuilder.GetSpan("Clase:", true),
                                                                  MLBuilderHelper.GetLink(objDocument)));
                    }
                }
                // Añade las interfaces
                foreach (DocumentFileModel objDocument in objColDocuments)
                {
                    if (objDocument.StructType == LanguageStructModel.StructType.Interface)
                    {
                        objMLList.Nodes.Add(MLBuilder.GetListItem(MLBuilder.GetSpan("Interface:", true),
                                                                  MLBuilderHelper.GetLink(objDocument)));
                    }
                }
            }
        }
Beispiel #6
0
 /// <summary>
 ///		Crea el índice
 /// </summary>
 internal Writers.MLIntermedialBuilder CreateIndex(DocumentFileModelCollection objColDocuments, string strUrlBase)
 {               // Limpia el generador
     objMLBuilder.Clear();
     // Crea el índice
     CreateIndex(objMLBuilder.Root, objColDocuments, strUrlBase);
     // Devuelve el generador
     return(objMLBuilder);
 }
Beispiel #7
0
        /// <summary>
        ///		Muestra los documentos en el árbol
        /// </summary>
        private void ShowDocumentNodes(DocumentFileModelCollection objColDocuments, TreeNode trnParent)
        {
            foreach (DocumentFileModel objDocument in objColDocuments)
            {
                TreeNode trnNode = trvNodes.AddNode(trnParent, 0, 0, objDocument.Name, false);

                // Añade los documentos hijo
                ShowDocumentNodes(objDocument.Childs, trnNode);
            }
        }
Beispiel #8
0
 /// <summary>
 ///		Graba los documentos
 /// </summary>
 private void SaveDocuments(DocumentFileModelCollection objColDocuments)
 {
     foreach (DocumentFileModel objDocument in objColDocuments)
     {                     // Graba el documento
         DocumentationProcessor.Writer.Save(objDocument, objDocument.MLBuilder,
                                            Templates.Search(objDocument.StructType)?.FullFileNameRootTemplate,
                                            DocumentationProcessor.OutputPath);
         // Graba los documentos hijo
         SaveDocuments(objDocument.Childs);
     }
 }
Beispiel #9
0
 internal TemplateDocumentGenerator(ProjectDocumentationModel project,
                                    DocumentationGenerator documentationGenerator,
                                    TemplateModel template, DocumentFileModel document,
                                    string urlBase, DocumentFileModelCollection allDocuments)
 {
     Project            = project;
     Generator          = documentationGenerator;
     Template           = template;
     Document           = document;
     UrlBase            = urlBase;
     DocumentsGenerated = allDocuments;
 }
Beispiel #10
0
 /// <summary>
 ///		Genera la documentación
 /// </summary>
 private void ProcessDocuments(DocumentFileModelCollection objColDocuments)
 {         // Ordena los archivos por nombres
     objColDocuments.SortByName();
     // Genera los archivos de contenido
     GenerateFilesContent(objColDocuments, objColDocuments);
     // Genera los archivos de índice
     objColDocuments.AddRange(GenerateFilesIndex(objColDocuments));
     // Transforma los hipervínculos
     objColDocuments.TransformSearchLinks(UrlBaseDocuments);
     // Graba los documentos
     SaveDocuments(objColDocuments);
 }
 internal TemplateDocumentGenerator(Models.Projects.ProjectDocumentationModel objProject,
                                    DocumentationGenerator objDocumentationGenerator,
                                    TemplateModel objTemplate, DocumentFileModel objDocument,
                                    string strUrlBase,
                                    DocumentFileModelCollection objColAllDocuments)
 {
     Project            = objProject;
     Generator          = objDocumentationGenerator;
     Template           = objTemplate;
     Document           = objDocument;
     UrlBase            = strUrlBase;
     DocumentsGenerated = objColAllDocuments;
 }
Beispiel #12
0
 /// <summary>
 ///		Genera la documentación
 /// </summary>
 private void ProcessDocuments(DocumentFileModelCollection objColDocuments)
 {         // Ordena los archivos por nombres
     objColDocuments.SortByName();
     // Genera el archivo de índice
     DocumentationProcessor.Writer.Save("Indice", "Indice de la documentación",
                                        new Generators.IndexFileGenerator().CreateIndex(objColDocuments, UrlBaseDocuments),
                                        null, DocumentationProcessor.OutputPath);
     // Genera los archivos de contenido
     GenerateFilesContent(objColDocuments);
     // Transforma los hipervínculos
     objColDocuments.TransformSearchLinks(UrlBaseDocuments);
     // Graba los documentos
     SaveDocuments(objColDocuments);
 }
Beispiel #13
0
        /// <summary>
        ///		Crea el índice de una colección de documentos
        /// </summary>
        private void CreateIndex(MLNode objMLParent, DocumentFileModelCollection objColDocuments, string strUrlBase)
        {
            bool blnIsAddedUl = false;

            // Crea los elementos de la lista
            foreach (DocumentFileModel objDocument in objColDocuments)
            {                                     // Si es un espacio de nombres, añade el elemento de la lista
                if (objDocument.IsRealNameSpace)
                {                                 // Añade la etiqueta ul
                    if (!blnIsAddedUl)
                    {                             // Añade la etiqueta
                        objMLParent = objMLParent.Nodes.Add("ul");
                        // Indica que se ha añadido
                        blnIsAddedUl = true;
                    }
                    // Crea el elemento de la lista
                    objMLParent.Nodes.Add("li").Nodes.Add(objMLBuilder.GetLink(objDocument.Name, objDocument.GetUrl(strUrlBase)));
                }
                // En cualquier caso, crea los elementos hijo
                CreateIndex(objMLParent, objDocument.Childs, strUrlBase);
            }
        }
Beispiel #14
0
        /// <summary>
        ///		Procesa la generación de documentos
        /// </summary>
        internal void Process(StructDocumentationModelCollection structDocs)
        {
            DocumentFileModelCollection documents = new DocumentFileModelCollection();

            // Carga las plantillas
            Templates = new Repository.Templates.TemplateRepository().Load(Project.TemplatePath);
            // Crea los documentos
            foreach (StructDocumentationModel structDoc in structDocs)
            {
                if (Templates.MustGenerateFile(structDoc, Project.GenerationParameters))
                {
                    DocumentFileModel document = new DocumentFileModel(null, structDoc, 0);

                    // Procesa la estructura del lenguaje
                    Generate(structDoc, document);
                    // Añade el documento a la colección
                    documents.Add(document);
                }
            }
            // Graba los documentos
            ProcessDocuments(documents);
        }
Beispiel #15
0
        /// <summary>
        ///		Genera los archivos de contenido
        /// </summary>
        private void GenerateFilesContent(DocumentFileModelCollection objColDocuments)
        {
            foreach (DocumentFileModel objDocument in objColDocuments)
            {
                TemplateModel objTemplate = Templates.Search(objDocument.StructType);

                // Genera la documentación del archivo
                if (objTemplate == null)
                {
                    AddError(objDocument, "No se encuentra ninguna plantilla para este tipo de estructura");
                }
                else
                {
                    try
                    { Generators.TemplateDocumentGenerator objGenerator = new Generators.TemplateDocumentGenerator(this, objTemplate, objDocument, UrlBaseDocuments);

                      objGenerator.Process(); }
                    catch (Exception objException)
                    { AddError(objDocument, "Error al generar el documento. " + objException.Message); }
                }
                // Genera los documentos hijo
                GenerateFilesContent(objDocument.Childs);
            }
        }