/// <summary>
/// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento
/// </summary>
private MLNodesCollection Parse(string value, StructDocumentationModel structDoc)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Interpreta la cadena
while (!value.IsEmpty())
{
string first = value.Cut("{{", out value);
// Añade el nodo con la parte inicial de la cadena
if (!first.IsEmpty())
{
nodesML.Add(Document.MLBuilder.GetSpan(first));
}
// Si queda algo, recoge hasta el siguiente }}
if (!value.IsEmpty())
{
string name = value.Cut("}}", out value).TrimIgnoreNull();
// Procesa el valor
nodesML.Add(GetStructParameterValue(name, structDoc));
}
}
// Devuelve el valor
return(nodesML);
}
/// <summary>
/// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento
/// </summary>
private MLNodesCollection Parse(string strValue, StructDocumentationModel objStruct)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Interpreta la cadena
while (!strValue.IsEmpty())
{
string strFirst = strValue.Cut("{{", out strValue);
// Añade el nodo con la parte inicial de la cadena
if (!strFirst.IsEmpty())
{
objColMLNodes.Add(Document.MLBuilder.GetSpan(strFirst));
}
// Si queda algo, recoge hasta el siguiente }}
if (!strValue.IsEmpty())
{
string strName = strValue.Cut("}}", out strValue).TrimIgnoreNull();
// Procesa el valor
objColMLNodes.Add(GetStructParameterValue(strName, objStruct));
}
}
// Devuelve el valor
return(objColMLNodes);
}
/// <summary>
/// Interpreta un parámetro
/// </summary>
private MLNode GetStructParameterValue(string name, StructDocumentationModel structDoc)
{
bool isLink = false;
string format = string.Empty;
// Comprueba si es un vínculo
if (!name.IsEmpty())
{
string[] parts = name.Split('|');
// Asigna el nombre
name = parts[0];
// Asigna los parámetros
for (int index = 1; index < parts.Length; index++)
{
if (parts[index].EqualsIgnoreCase("Link"))
{
isLink = true;
}
else
{
format = format.AddWithSeparator(parts[index], "|", false);
}
}
}
// Devuelve el nodo
return(GetStructParameterValue(name, format, isLink, structDoc));
}
/// <summary>
/// Comprueba si existe un tipo de estructura hija
/// </summary>
private bool CheckIfExistsChild(StructDocumentationModel objStruct, string strStructType)
{
StructDocumentationModelCollection objColStructs = SelectItemsForGeneration(objStruct, strStructType);
// Devuelve el valor que indica si existe
return(objColStructs != null && objColStructs.Count > 0);
}
/// <summary>
/// Carga las estructuras de documentación de un archivo
/// </summary>
public StructDocumentationModel Load(string fileName)
{
StructDocumentationModel structDoc = new StructDocumentationModel(null, StructDocumentationModel.ScopeType.Global, "", "", 0);
// Carga el archivo XML
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagStruct)
{
// Interpreta el elemento
LoadStruct(nodeML, structDoc);
// Interpreta los hijos
LoadChilds(nodeML, structDoc);
// Interpreta los parámetros
LoadParameters(nodeML, structDoc);
}
}
}
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Carga los parámetros de una estructura
/// </summary>
private void LoadStruct(MLNode nodeML, StructDocumentationModel structDoc)
{
structDoc.Scope = (StructDocumentationModel.ScopeType)nodeML.Nodes[TagScope].Value.GetInt(0);
structDoc.Name = nodeML.Nodes[TagName].Value;
structDoc.Type = nodeML.Nodes[TagType].Value;
structDoc.Order = nodeML.Nodes[TagOrder].Value.GetInt(0);
}
/// <summary>
/// Busca el documento que se asocia a una estructura
/// </summary>
internal DocumentFileModel Search(StructDocumentationModel objStruct)
{
DocumentFileModel objSearch = null;
// Busca el elemento en la colección
foreach (DocumentFileModel objDocument in this)
{
if (objSearch == null)
{
if (objDocument.LanguageStruct != null &&
objDocument.LanguageStruct.Type.EqualsIgnoreCase(objStruct.Type) &&
objDocument.LanguageStruct.Name.EqualsIgnoreCase(objStruct.Name) &&
objDocument.Order == objStruct.Order)
{
objSearch = objDocument;
}
else
{
objSearch = objDocument.Childs.Search(objStruct);
}
}
}
// Devuelve el elemento localizado
return(objSearch);
}
/// <summary>
/// Busca el documento que se asocia a una estructura
/// </summary>
internal DocumentFileModel Search(StructDocumentationModel structDoc)
{
DocumentFileModel search = null;
// Busca el elemento en la colección
foreach (DocumentFileModel document in this)
{
if (search == null)
{
if (document.LanguageStruct != null &&
document.LanguageStruct.Type.EqualsIgnoreCase(structDoc.Type) &&
document.LanguageStruct.Name.EqualsIgnoreCase(structDoc.Name) &&
document.Order == structDoc.Order)
{
search = document;
}
else
{
search = document.Childs.Search(structDoc);
}
}
}
// Devuelve el elemento localizado
return(search);
}
/// <summary>
/// Carga los parámetros de una estructura
/// </summary>
private void LoadStruct(MLNode objMLNode, StructDocumentationModel objStruct)
{
objStruct.Scope = (StructDocumentationModel.ScopeType)objMLNode.Nodes[cnstStrTagScope].Value.GetInt(0);
objStruct.Name = objMLNode.Nodes[cnstStrTagName].Value;
objStruct.Type = objMLNode.Nodes[cnstStrTagType].Value;
objStruct.Order = objMLNode.Nodes[cnstStrTagOrder].Value.GetInt(0);
}
/// <summary>
/// Trata una serie de nodos
/// </summary>
private void TreatChilds(MLNodesCollection sourcesML, MLNode parentTargetML, StructDocumentationModel structDoc)
{
foreach (MLNode sourceML in sourcesML)
{
TreatNode(sourceML, parentTargetML, structDoc);
}
}
/// <summary>
/// Comprueba si se debe añadir una estructura al diccionario
/// </summary>
private bool MustAdd(StructDocumentationModel structDoc)
{
return(structDoc.Type.EqualsIgnoreCase("NameSpace") ||
structDoc.Type.EqualsIgnoreCase("Class") ||
structDoc.Type.EqualsIgnoreCase("Struct") ||
structDoc.Type.EqualsIgnoreCase("Enum") ||
structDoc.Type.EqualsIgnoreCase("Interface"));
}
/// <summary>
/// Comprueba si existe algún valor en una estructura
/// </summary>
private bool CheckIfExistsValue(StructDocumentationModel objStruct, string strName)
{
return(!GetStructParameterContent(strName, objStruct).IsEmpty());
//MLNode objMLNode = GetStructParameterValue(strName, objStruct);
// // Comprueba si existe algún valor
// return objMLNode != null && !objMLNode.Value.IsEmpty();
}
/// <summary>
/// Convierte un espacio de nombres en una estructura
/// </summary>
private StructDocumentationModel Convert(NameSpaceGroupModel objGroup)
{
StructDocumentationModel objStruct = Create(null, objGroup.NameSpace, "NameSpace");
// Añade los datos
objStruct.Childs.AddRange(Convert(objStruct, objGroup.NameSpace.Items));
// Devuelve la estructura
return(objStruct);
}
/// <summary>
/// Convierte un espacio de nombres en una estructura
/// </summary>
private StructDocumentationModel Convert(NameSpaceGroupModel group)
{
StructDocumentationModel structDoc = Create(null, group.NameSpace, "NameSpace");
// Añade los datos
structDoc.Childs.AddRange(Convert(structDoc, group.NameSpace.Items));
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Graba en un archivo XML una estructura de documentación
/// </summary>
public void Save(string fileName, StructDocumentationModel structDoc)
{
MLFile fileML = new MLFile();
// Añade el nodo de la structura
fileML.Nodes.Add(GetStructNode(structDoc));
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Convierte un enumerado
/// </summary>
private StructDocumentationModel ConvertEnum(StructDocumentationModel objParent, EnumModel objItem)
{
StructDocumentationModel objStruct = Create(objParent, objItem, "Enum");
// Crea los elementos hijo
objStruct.Childs.AddRange(Convert(objStruct, objItem.Items));
// Devuelve la estructura
return(objStruct);
}
/// <summary>
/// Convierte un enumerado
/// </summary>
private StructDocumentationModel ConvertEnum(StructDocumentationModel parent, EnumModel item)
{
StructDocumentationModel structDoc = Create(parent, item, "Enum");
// Crea los elementos hijo
structDoc.Childs.AddRange(Convert(structDoc, item.Items));
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Graba en un archivo XML una estructura de documentación
/// </summary>
public void Save(string strFileName, StructDocumentationModel objStruct)
{
MLFile objMLFile = new MLFile();
// Añade el nodo de la structura
objMLFile.Nodes.Add(GetStructNode(objStruct));
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(objMLFile, strFileName);
}
/// <summary>
/// Carga los parámetros de una estructura
/// </summary>
private void LoadParameters(MLNode nodeML, StructDocumentationModel structDoc)
{
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == TagParameter)
{
structDoc.Parameters.Add(childML.Attributes[TagKey].Value, childML.Value, childML.Attributes[TagReference].Value);
}
}
}
public DocumentFileModel(DocumentFileModel parent, StructDocumentationModel structDoc, int order)
{
Parent = parent;
LanguageStruct = structDoc;
if (structDoc != null)
{
Name = structDoc.Name;
}
Order = order;
}
public DocumentFileModel(DocumentFileModel objParent, StructDocumentationModel objStruct, int intOrder)
{
Parent = objParent;
LanguageStruct = objStruct;
if (objStruct != null)
{
Name = objStruct.Name;
}
Order = intOrder;
}
/// <summary>
/// Crea una estructura con el contenido de un nodo
/// </summary>
private StructParameterModel CreateParameter(StructDocumentationModel parent, string key, MLNode nodeML)
{
string value = new LibMarkupLanguage.Services.XML.XMLWriter().ConvertToString(nodeML.Nodes);
// Quita los caracteres de CDATA
value = value.ReplaceWithStringComparison("<![CDATA[", "", StringComparison.CurrentCultureIgnoreCase);
value = value.ReplaceWithStringComparison("]]>", "", StringComparison.CurrentCultureIgnoreCase);
// Devuelve el parámetro
return(new StructParameterModel(key, value, null));
}
/// <summary>
/// Convierte una estructura
/// </summary>
private StructDocumentationModel ConvertStruct(StructDocumentationModel objParent, StructModel objItem)
{
StructDocumentationModel objStruct = Create(objParent, objItem, "Struct");
// Añade los parámetros de la clase compleja base
AddParametersBaseComplex(objStruct, objItem);
// Crea los elementos hijo
objStruct.Childs.AddRange(Convert(objStruct, objItem.Items));
// Devuelve la estructura
return(objStruct);
}
/// <summary>
/// Interpreta un archivo
/// </summary>
public StructDocumentationModel Parse(ProgramModel objProgram)
{
StructDocumentationModel objStruct = new StructDocumentationModel(null, StructDocumentationModel.ScopeType.Global,
System.IO.Path.GetFileNameWithoutExtension(objProgram.FileName),
"Program", 0);
// Añade las estructuras de documentación
objStruct.Childs.AddRange(Generate(objProgram));
// Devuelve las estructuras de documentación
return(objStruct);
}
/// <summary>
/// Convierte un constructor
/// </summary>
private StructDocumentationModel ConvertConstructor(StructDocumentationModel objParent, ConstructorModel objItem)
{
StructDocumentationModel objStruct = Create(objParent, objItem, "Constructor");
// Añade los argumentos
objStruct.Parameters.Add(GetPrototype(objItem));
AddListArguments(objStruct, objItem, objItem.Arguments);
AddListTypeParameter(objStruct, objItem.TypeParameters);
// Devuelve la estructura
return(objStruct);
}
/// <summary>
/// Convierte una interface
/// </summary>
private StructDocumentationModel ConvertInterface(StructDocumentationModel parent, InterfaceModel interfaceDef)
{
StructDocumentationModel structDoc = Create(parent, interfaceDef, "Interface");
// Añade los parámetros de la clase compleja base
AddParametersBaseComplex(structDoc, interfaceDef);
// Crea los elementos hijo
structDoc.Childs.AddRange(Convert(structDoc, interfaceDef.Items));
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Convierte un constructor
/// </summary>
private StructDocumentationModel ConvertConstructor(StructDocumentationModel parent, ConstructorModel item)
{
StructDocumentationModel structDoc = Create(parent, item, "Constructor");
// Añade los argumentos
structDoc.Parameters.Add(GetPrototype(item));
AddListArguments(structDoc, item, item.Arguments);
AddListTypeParameter(structDoc, item.TypeParameters);
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Convierte una estructura
/// </summary>
private StructDocumentationModel ConvertStruct(StructDocumentationModel parent, StructModel item)
{
StructDocumentationModel structDoc = Create(parent, item, "Struct");
// Añade los parámetros de la clase compleja base
AddParametersBaseComplex(structDoc, item);
// Crea los elementos hijo
structDoc.Childs.AddRange(Convert(structDoc, item.Items));
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Convierte un método de una propiedad
/// </summary>
private void ConvertPropertyMethod(StructDocumentationModel parent, MethodModel method, string name)
{
if (method != null)
{
StructDocumentationModel structDoc = ConvertMethod(parent, method);
// Cambia el nombre
structDoc.Name = name;
// ... y se lo añade a la colección
parent.Childs.Add(structDoc);
}
}
/// <summary>
/// Obtiene el valor de retorno
/// </summary>
private StructDocumentationModel GetReturnValue(StructDocumentationModel parent, TypedModel objType, string strRemarks)
{
StructDocumentationModel structDoc = new StructDocumentationModel(parent, StructDocumentationModel.ScopeType.Global, "ReturnValue", "ReturnValue", 0);
// Añade el tipo
structDoc.Childs.Add(GetTypeStruct(structDoc, "ReturnValueStruct", objType));
structDoc.Parameters.Add(GetTypeStructShort("Type", objType));
// Añade los valores
structDoc.Parameters.Add("Summary", ConvertRemarks(strRemarks));
// Devuelve el parámetro
return(structDoc);
}
