/// <summary>
/// Replace some tag with the content of other section
/// </summary>
/// <param name="tagName">Tag Name, doesn't need the {} brackets</param>
/// <param name="section">Section to replace</param>
/// <param name="isLocalVariable">if set to <c>true</c> [is local variable].</param>
public void ReplaceTag(string tagName, TemplateSection section, bool isLocalVariable = true)
{
if (section._isValidSection)
{
_contentBuilder.Replace(GetReplaceTag(tagName, isLocalVariable), section.Content);
}
}
/// <summary>
/// Replace some tag with a list of sections
/// </summary>
/// <param name="sectionName">Name of the section.</param>
/// <param name="sectionList">The section list.</param>
/// <param name="separator">The separator.</param>
public void ReplaceSection(string sectionName, TemplateSectionCollection sectionList, string separator = "")
{
// Extraigo la sección que quiero reemplazar
TemplateSection subSection = ExtractSection(sectionName);
// Remuevo el content de la sección excepto el tag de inicio.
_contentBuilder.Remove(subSection.FromContentIndex, subSection.ContentLength + subSection.EndTag.Length);
// Reemplazo el tag de inicio por el content nuevo
_contentBuilder.Replace(subSection.BeginTag, sectionList.GetAllContent(separator));
}
/// <summary>
/// Replace a section using the child reference
/// </summary>
/// <param name="section">The section.</param>
/// <exception cref="NotDaughterSectionException">When the section to replace isn't child of the section</exception>
public void ReplaceSection(TemplateSection section)
{
if (section._parent != this)
{
throw new NotDaughterSectionException(section.SectionName, SectionName);
}
if (section._isValidSection)
{
// Remuevo el content de la sección excepto el tag de inicio.
_contentBuilder.Remove(section.FromContentIndex, section.ContentLength + section.EndTag.Length);
// Reemplazo el tag de inicio por el content nuevo
_contentBuilder.Replace(section.BeginTag, section.Content);
}
}
/// <summary>
/// Removes the section.
/// </summary>
/// <param name="section">The section.</param>
internal void RemoveSection(TemplateSection section)
{
_sections.Remove(section);
}
/// <summary>
/// Adds the section.
/// </summary>
/// <param name="section">The section.</param>
public void AddSection(TemplateSection section)
{
_sections.Add(section);
}
/// <summary>
/// Extrae una sección contenida dentro de esta sección de manera recursiva
/// </summary>
/// <param name="sectionName">Nombre de la Sección</param>
/// <returns></returns>
public TemplateSection ExtractSection(string sectionName)
{
// Creo la clase para expresiones regulares, el tipo de patron depende del tipo de sección (se hereda el tipo de la sección padre)
Regex regexPatternSection;
switch (SectionType)
{
case TemplateType.ASPX: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplateAspxSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
case TemplateType.HTML: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplateHtmlSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
case TemplateType.CS: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplateCsSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
case TemplateType.SQL: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplateSqlSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
case TemplateType.CPP: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplateCppSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
case TemplateType.PHP: { regexPatternSection = new Regex(string.Format(RegularExpressionsPatterns.TemplatePhpSection, sectionName), RegexOptions.Compiled | RegexOptions.IgnoreCase); break; }
default: { throw new NotSupportedTemplateTypeException(SectionType); }
}
// Busco todas las coincidencias del patron en el content de la sección
MatchCollection matches = regexPatternSection.Matches(Content);
int tagsNumber = 0;
string beginTag = string.Empty;
string endTag = string.Empty;
string sectionVariable = string.Empty;
// Recorro todas las coincidencias, las cuales sólo deberían ser dos (inicio y término)
foreach (Match match in matches)
{
// si es un tag de inicio
if (match.Value.ToLower().Contains(TemplateTags.SectionBegin))
{
beginTag = match.Value;
tagsNumber += 1;
int i = 0;
// reviso todos los grupos de la coincidencia, usualmente sería algo asi
// 0= <!-- o /*--
// 1= begin
// 2= section
// 3= NOMBRE_SECCION
// 4= as
// 5= NOMBRE_VARIABLE
// 6= --> o */
foreach (Group group in match.Groups)
{
// recupero el nombre de la variable, el cual debe venir
// despés del 'as'
if (group.Value.ToLower().Equals(TemplateTags.SectionAlias))
{
sectionVariable = match.Groups[i + 1].Value;
break;
}
i += 1;
}
}
// o si es un tag de termino
else if (match.Value.ToLower().Contains(TemplateTags.SectionEnd))
{
endTag = match.Value;
tagsNumber += 1;
}
}
// Verifico que hayan sido dos sectionList las que encontré
if (tagsNumber != 2)
{
throw new SectionNotFoundException(SectionName, sectionName);
}
// IndexOf retorna la ubicación del primer caracter respecto al Content
int beginTagIndex = Content.IndexOf(beginTag, StringComparison.Ordinal);
int endTagIndex = Content.IndexOf(endTag, 0, StringComparison.Ordinal);
// Verifico que el tag de inicio sea predecesor del tag de término
if (beginTagIndex > endTagIndex)
{
throw new InvalidFormatTagsException(sectionName);
}
int fromContentIndex = beginTagIndex + beginTag.Length;
int daughterContentLength = endTagIndex - fromContentIndex;
// Creo la nueva sección y le asigno todas las variables calculadas
TemplateSection seccion = new TemplateSection
{
_parent = this,
_contentBuilder = new StringBuilder(Content, fromContentIndex, daughterContentLength, Content.Length),
SectionName = sectionName,
SectionType = SectionType,
SectionVariable = sectionVariable,
BeginTag = beginTag,
EndTag = endTag,
BeginTagIndex = beginTagIndex,
EndTagIndex = endTagIndex,
FromContentIndex = fromContentIndex,
ContentLength = daughterContentLength,
_isValidSection = true
};
return(seccion);
}
/// <summary>
/// Remove all template tags (with their respective contents).
/// </summary>
/// <remarks>
/// Only calls this methods after all replaces
/// </remarks>
public void RemoveInnerSections()
{
// Creo la clase para expresiones regulares, el tipo de patron depende del tipo de sección
Regex regexPatternSection;
switch (SectionType)
{
case TemplateType.ASPX: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericAspxSection; break; }
case TemplateType.HTML: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericHtmlSection; break; }
case TemplateType.CS: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericCsSection; break; }
case TemplateType.SQL: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericSqlSection; break; }
case TemplateType.CPP: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericCppSection; break; }
case TemplateType.PHP: { regexPatternSection = RegularExpressionsPatterns.RegexTemplateGenericPhpSection; break; }
default: { throw new NotSupportedTemplateTypeException(SectionType); }
}
// Busco todas las coincidencias del patron en el content de la sección
MatchCollection matches = regexPatternSection.Matches(Content);
// Inicializo una lista con las sectionList que contiene el content
TemplateSectionCollection sectionList = new TemplateSectionCollection();
foreach (Match match in matches)
{
// si es un tag de inicio
if (match.Value.ToLower().Contains(TemplateTags.SectionBegin))
{
string beginTag = match.Value;
string sectionName = string.Empty;
string variableName = string.Empty;
// reviso todos los grupos de la coincidencia, usualmente sería algo asi
// 0= <!-- o /*--
// 1= begin
// 2= section
// 3= NOMBRE_SECCION
// 4= as
// 5= NOMBRE_VARIABLE
// 6= --> o */
for (int i = 0; i < match.Groups.Count; i++)
{
Group group = match.Groups[i];
// recupero el nombre de la sección, el cual debe venir
// después del 'section'
if (group.Value.ToLower().Equals(TemplateTags.SectionTag))
{
sectionName = match.Groups[i + 1].Value;
}
// recupero el nombre de la variable, el cual debe venir
// despés del 'as'
else if (group.Value.ToLower().Equals(TemplateTags.SectionAlias))
{
variableName = match.Groups[i + 1].Value;
break;
}
}
// Se encontró una nueva sección, la guardo en la lista
TemplateSection seccion = new TemplateSection
{
BeginTag = beginTag,
SectionVariable = variableName,
SectionName = sectionName
};
sectionList.AddSection(seccion);
}
// o si es un tag de termino
else if (match.Value.ToLower().Contains(TemplateTags.SectionEnd))
{
string tagFin = match.Value;
string sectionName = string.Empty;
// reviso todos los grupos de la coincidencia, debería ser asi
// 0= <!-- o /*--
// 1= end
// 2= section
// 3= NOMBRE_SECCION
// 4= --> o */
for (int i = 0; i < match.Groups.Count; i++)
{
Group group = match.Groups[i];
// recupero el nombre de la sección, el cual debe venir
// después del 'section'
if (group.Value.ToLower().Equals(TemplateTags.SectionTag))
{
sectionName = match.Groups[i + 1].Value;
break;
}
}
// busco el tag de inicio el cual debería estar en la lista. El tag de inicio debería
// haberse ingresado en la lista antes de encontrar el de término. En el caso de que
// la encuentre, actualizo la entrada con los datos que faltan.
TemplateSection section = sectionList.FindSection(sectionName);
if (section != null)
{
section.EndTag = tagFin;
}
else
{
throw new InvalidFormatTagsException(sectionName);
}
}
}
// Recorro todas las sectionList que encontré
foreach (TemplateSection section in sectionList.Sections)
{
string cleanText = _contentBuilder.ToString();
// Verifico que los tags de inicio y término se encuentren en el Content. Esta verificación es para
// las sectionList que estan contenidas dentro de otras las cuales son eliminadas recursivamente
if (cleanText.Contains(section.BeginTag) && cleanText.Contains(section.EndTag))
{
// Calculo los indices de inicio y término de los tags (los indices van cambiando a medida que limpio el content)
section.BeginTagIndex = cleanText.IndexOf(section.BeginTag, StringComparison.Ordinal);
section.EndTagIndex = cleanText.IndexOf(section.EndTag, section.BeginTagIndex, StringComparison.Ordinal);
section.FromContentIndex = section.BeginTagIndex + section.BeginTag.Length;
section.ContentLength = section.EndTagIndex - section.FromContentIndex;
// Remuevo la sección del content, desde el primer caracter del tag de inicio hasta el último caracter del tag de término
_contentBuilder.Remove(section.BeginTagIndex, section.BeginTag.Length + section.ContentLength + section.EndTag.Length);
}
}
}
