petrohs/extraerDocuFinalDeScript.bash

## extraerDocuFinalDeScript.bash
#!/bin/bash
ayuda() { echo '
                      * extraerDocuFinalDeScript.bash *
 DESCRIPCION:  Obtiene la documentación descrita al pie del script.
               La convierte a man y a html con txt2tags

         USO:  extraerDocuFinalDeScript.bash scriptParaExtraerDocu
               extraerDocuFinalDeScript.bash [-h|-?|--help|--ayuda] [-v]
               extraerDocuFinalDeScript.bash --docu
    OPCIONES:  -h       Ayuda
               -v       Version
               --docu   Leer la documentacion incluida.t2t
DEPENDENCIAS:  txt2tags, mermaid
        BUGS:  ---
       NOTAS:  Los scripts requieren un formato especial.
   VERSIONES:  20210227 1.0.1 petrohs/  Diagramas.
               20191230 1.0.0 petrohs/  Documentacion.
               20191227 0.0.2 petrohs/  Ajustes mayores.
               20191226 0.0.1 petrohs/  Creacion.
         URL:  https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
';}

#ayuda y version
 if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} | cut -d: -f1) + 1)),$(cat ${0}|wc -l)p ${0} | less; exit 1;
 elif [[ "$1" = "-v" ]] || [[ "$1" = "--version" ]]; then ayuda | grep VERSIONES | cut -d: -f2 | cut -d/ -f1; exit 1; fi;

#argumentos
 elScript="$1";
 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} | cut -d: -f1);
 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f1);
 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f2);
 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f3);
 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f4);

#creando temporales
 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} | cat -n | sed -e "s/\"/ð=comillaDoble=ð/g" -e "s/'/ð=comillaSimple=ð/g" -e "s/\\\/ð=diagonalInvertida=ð/g" -e "s/&/ð=ampersand=ð/g" -e "s/Łinea/ð=linea=ð/g" -e "s/т/ð=graficador=ð/g" >${elScript}.numerado;
 echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^<CODE>	<br /><CODE>" >${elScript}.t2t;
 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}|wc -l)p ${elScript} >>${elScript}.t2t;
 echo -e '\n\n== Código ==\n```' >>${elScript}.t2t;
 cat ${elScript}.numerado  >>${elScript}.t2t;
 echo '```' >>${elScript}.t2t;

#ciclo si existe sustitucion de Łineas
 pasoI=0;
 for eLe in $(grep -n Łinea ${elScript}.t2t | cut -d: -f1)
   do
     eLe=$((${eLe}+${pasoI}));
     laLinea=$(sed -n ${eLe}p ${elScript}.t2t | sed -e "s/.*Łinea//" -e "s/ .*//");
     laNueva=$(sed -n ${laLinea}p ${elScript}.numerado | sed -e "s/^ *//" -e "s/	/:/");
     sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
     pasoI=$((${pasoI}+1));
   done

#Ciclo para grafico
 for gra in $( grep -n '^%т' ${elScript}.t2t | cut -d: -f1)
   do
     graficador=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f1 | cut -c4-);
     graLi=$((${gra}+2));
     graL=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f2);
     graLf=$((${graLi}+${graL}-1));
     graNombre=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f3);
     sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
     ${graficador} ${graNombre}.${graficador};
     sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
   done

#quitando remplazos
 sed -i -e "s/ð=comillaDoble=ð/\"/g" -e "s/ð=comillaSimple=ð/'/g" -e "s/ð=diagonalInvertida=ð/\\\/g" -e "s/ð=ampersand=ð/\\&/g" -e "s/Łinea/Linea/g" -e "s/ð=linea=ð/Łinea/g" -e "s/ð=graficador=ð/т/g" ${elScript}.t2t;

#ejecutando conversion con txt2tags
 ${formateador} -t html ${elScript}.t2t
 ${formateador} -t man  ${elScript}.t2t
 rm ${elScript}.numerado

#Ser cultos para ser libres
 exit 0;

--------------------------------------------------------------------------------ðtxt2tags,20210227,doc v1.00 de script v1.0.1,petrohs
%ejecutar utileria «extraerDocuFinalDeScript.bash»

= extraerDocuFinalDeScript =
Este proceso esta pensado para documentar en el mismo script un pequeño
**manual técnico** con un //marcado ligero// y que se pueda extraer para
convertirlo en //.man y .html//


== proceso ==
La idea es que cualquier cosa despues del ``exit`` final ya no se interpreta,
por lo que se puede emplear para documentar y no tener un archivo separado el
seudocódigo.

La documentación inicia con el bloque de ochenta guiones.
Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
con txt2tags) para describir los procesos.

Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
donde se llama al construir el .man y el .html.

Al final tambien agregara la sección «código» el cual incluira el fuente
numerado.

Con la opcion ``--docu`` se puede ver esta documentacion en texto plano.

== Usando graficos ==
Probando con ``mermaid``
%тmermaid,5,grafica01
```
graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;
```

== formato especial ==
- Inicia con un bloque de ochenta guiones linea 64
- Despues de los guiones el separador ð indica el interprete de marcado, la
  fecha, el comentario de versiones.
- El bloque de documentación debe estar en formato de marcado ligero.
- La v1.00 usa el formato txt2tags
  https://txt2tags.org/doc/Spanish/userguide-es.pdf
- Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
  seguido del numero. Ejemplo Łinea24
- Para el grafico debe iniciar la linea con %т seguda del nombre de la
  herramienta para graficar, separado por comas (,) el segundo campo son la
  cantidad de lineas correspondientes al codigo del grafico, el tercer campo
  es el nombre del archivo que va a generar.


== to-do ==
- Probar con markdown a la par que txt2tags.
- Agregar hoja de estilo.
- Probar graphviz en lugar de mermaid

## extraerDocuFinalDeScript.bash.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Documentación técnica de extraerDocuFinalDeScript.bash</title>
<meta name="generator" content="http://txt2tags.org">
<link rel="stylesheet" href="fancy.css">
<style>
body{background-color:#fff;color:#000;}
hr{background-color:#000;border:0;color:#000;}
hr.heavy{height:5px;}
hr.light{height:1px;}
img{border:0;display:block;}
img.right{margin:0 0 0 auto;}
img.center{border:0;margin:0 auto;}
table th,table td{padding:4px;}
.center,header{text-align:center;}
table.center {margin-left:auto; margin-right:auto;}
.right{text-align:right;}
.left{text-align:left;}
.tableborder,.tableborder td,.tableborder th{border:1px solid #000;}
.underline{text-decoration:underline;}
</style>
</head>
<body>
<header>
<hgroup>
<h1>Documentación técnica de extraerDocuFinalDeScript.bash</h1>
<h2>petrohs</h2>
<h3>20210227, doc v1.00 de script v1.0.1</h3>
</hgroup>
</header>
<article>

<nav>
<div class="body" id="body">

  <ul>
  <li><a href="#toc1">extraerDocuFinalDeScript</a>
    <ul>
    <li><a href="#toc2">proceso</a>
    </li>
    <li><a href="#toc3">Usando graficos</a>
    </li>
    <li><a href="#toc4">formato especial</a>
    </li>
    <li><a href="#toc5">to-do</a>
    </li>
    <li><a href="#toc6">Código</a>
    </li>
    </ul>
  </li>
  </ul>

</div>
</nav>
<div class="body" id="body">

<section id="toc1">
<h1>extraerDocuFinalDeScript</h1>

<p>
Este proceso esta pensado para documentar en el mismo script un pequeño
<strong>manual técnico</strong> con un <em>marcado ligero</em> y que se pueda extraer para
convertirlo en <em>.man y .html</em>
</p>

<section id="toc2">
<h2>proceso</h2>

<p>
La idea es que cualquier cosa despues del <code>exit</code> final ya no se interpreta,
por lo que se puede emplear para documentar y no tener un archivo separado el
seudocódigo.
</p>
<p>
La documentación inicia con el bloque de ochenta guiones.
Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
con txt2tags) para describir los procesos.
</p>
<p>
Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
donde se llama al construir el .man y el .html.
</p>
<p>
Al final tambien agregara la sección «código» el cual incluira el fuente
numerado.
</p>
<p>
Con la opcion <code>--docu</code> se puede ver esta documentacion en texto plano.
</p>

</section>
<section id="toc3">
<h2>Usando graficos</h2>

<p>
Probando con <code>mermaid</code>
<img class="center" src="grafica01.mermaid.png" alt="">
</p>

<pre>
graph TD;
    A--&gt;B;
    A--&gt;C;
    B--&gt;D;
    C--&gt;D;
</pre>

</section>
<section id="toc4">
<h2>formato especial</h2>

<ul>
<li>Inicia con un bloque de ochenta guiones linea 64
</li>
<li>Despues de los guiones el separador ð indica el interprete de marcado, la
  fecha, el comentario de versiones.
</li>
<li>El bloque de documentación debe estar en formato de marcado ligero.
</li>
<li>La v1.00 usa el formato txt2tags
  <a href="https://txt2tags.org/doc/Spanish/userguide-es.pdf">https://txt2tags.org/doc/Spanish/userguide-es.pdf</a>
</li>
<li>Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
  seguido del numero. Ejemplo Linea24
<code>24: if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;</code>
</li>
<li>Para el grafico debe iniciar la linea con %т seguda del nombre de la
  herramienta para graficar, separado por comas (,) el segundo campo son la
  cantidad de lineas correspondientes al codigo del grafico, el tercer campo
  es el nombre del archivo que va a generar.
</li>
</ul>

</section>
<section id="toc5">
<h2>to-do</h2>

<ul>
<li>Probar con markdown a la par que txt2tags.
</li>
<li>Agregar hoja de estilo.
</li>
<li>Probar graphviz en lugar de mermaid
</li>
</ul>

</section>
<section id="toc6">
<h2>Código</h2>

<pre>
     1	#!/bin/bash
     2	ayuda() { echo '
     3	                      * extraerDocuFinalDeScript.bash *
     4	 DESCRIPCION:  Obtiene la documentación descrita al pie del script.
     5	               La convierte a man y a html con txt2tags
     6
     7	         USO:  extraerDocuFinalDeScript.bash scriptParaExtraerDocu
     8	               extraerDocuFinalDeScript.bash [-h|-?|--help|--ayuda] [-v]
     9	               extraerDocuFinalDeScript.bash --docu
    10	    OPCIONES:  -h       Ayuda
    11	               -v       Version
    12	               --docu   Leer la documentacion incluida.t2t
    13	DEPENDENCIAS:  txt2tags, mermaid
    14	        BUGS:  ---
    15	       NOTAS:  Los scripts requieren un formato especial.
    16	   VERSIONES:  20210227 1.0.1 petrohs/  Diagramas.
    17	               20191230 1.0.0 petrohs/  Documentacion.
    18	               20191227 0.0.2 petrohs/  Ajustes mayores.
    19	               20191226 0.0.1 petrohs/  Creacion.
    20	         URL:  https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
    21	';}
    22
    23	#ayuda y version
    24	 if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
    25	 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} | cut -d: -f1) + 1)),$(cat ${0}|wc -l)p ${0} | less; exit 1;
    26	 elif [[ "$1" = "-v" ]] || [[ "$1" = "--version" ]]; then ayuda | grep VERSIONES | cut -d: -f2 | cut -d/ -f1; exit 1; fi;
    27
    28	#argumentos
    29	 elScript="$1";
    30	 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} | cut -d: -f1);
    31	 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f1);
    32	 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f2);
    33	 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f3);
    34	 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f4);
    35
    36	#creando temporales
    37	 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} | cat -n | sed -e "s/\"/"/g" -e "s/'/'/g" -e "s/\\\/\/g" -e "s/&amp;/&amp;/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" &gt;${elScript}.numerado;
    38	 echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^&lt;CODE&gt;	&lt;br /&gt;&lt;CODE&gt;" &gt;${elScript}.t2t;
    39	 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}|wc -l)p ${elScript} &gt;&gt;${elScript}.t2t;
    40	 echo -e '\n\n== Código ==\n```' &gt;&gt;${elScript}.t2t;
    41	 cat ${elScript}.numerado  &gt;&gt;${elScript}.t2t;
    42	 echo '```' &gt;&gt;${elScript}.t2t;
    43
    44	#ciclo si existe sustitucion de Łineas
    45	 pasoI=0;
    46	 for eLe in $(grep -n Łinea ${elScript}.t2t | cut -d: -f1)
    47	   do
    48	     eLe=$((${eLe}+${pasoI}));
    49	     laLinea=$(sed -n ${eLe}p ${elScript}.t2t | sed -e "s/.*Łinea//" -e "s/ .*//");
    50	     laNueva=$(sed -n ${laLinea}p ${elScript}.numerado | sed -e "s/^ *//" -e "s/	/:/");
    51	     sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&amp;\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
    52	     pasoI=$((${pasoI}+1));
    53	   done
    54
    55	#Ciclo para grafico
    56	 for gra in $( grep -n '^%т' ${elScript}.t2t | cut -d: -f1)
    57	   do
    58	     graficador=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f1 | cut -c4-);
    59	     graLi=$((${gra}+2));
    60	     graL=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f2);
    61	     graLf=$((${graLi}+${graL}-1));
    62	     graNombre=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f3);
    63	     sed -n ${graLi},${graLf}p ${elScript}.t2t &gt; ${graNombre}.${graficador};
    64	     ${graficador} ${graNombre}.${graficador};
    65	     sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
    66	   done
    67
    68	#quitando remplazos
    69	 sed -i -e "s/"/\"/g" -e "s/'/'/g" -e "s/\/\\\/g" -e "s/&amp;/\\&amp;/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
    70
    71	#ejecutando conversion con txt2tags
    72	 ${formateador} -t html ${elScript}.t2t
    73	 ${formateador} -t man  ${elScript}.t2t
    74	 rm ${elScript}.numerado
    75
    76	#Ser cultos para ser libres
    77	 exit 0;
    78
</pre>

</section>
</section>
</div>
<!-- html code generated by txt2tags 3.4 (http://txt2tags.org) -->
<!-- cmdline: txt2tags -t html extraerDocuFinalDeScript.bash.t2t -->
</article></body></html>

## extraerDocuFinalDeScript.bash.man
.TH "Documentación técnica de extraerDocuFinalDeScript.bash" 1 "20210227, doc v1.00 de script v1.0.1" "petrohs"

.P
  extraerDocuFinalDeScript
    proceso
    Usando graficos
    formato especial
    to\-do
    Código
.SH extraerDocuFinalDeScript
.P
Este proceso esta pensado para documentar en el mismo script un pequeño
\fBmanual técnico\fR con un \fImarcado ligero\fR y que se pueda extraer para
convertirlo en \fI.man y .html\fR
.SS proceso
.P
La idea es que cualquier cosa despues del exit final ya no se interpreta,
por lo que se puede emplear para documentar y no tener un archivo separado el
seudocódigo.
.P
La documentación inicia con el bloque de ochenta guiones.
Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
con txt2tags) para describir los procesos.
.P
Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
donde se llama al construir el .man y el .html.
.P
Al final tambien agregara la sección «código» el cual incluira el fuente
numerado.
.P
Con la opcion \-\-docu se puede ver esta documentacion en texto plano.
.SS Usando graficos
.P
Probando con mermaid
grafica01.mermaid.png

.nf
graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;
.fi


.SS formato especial

.RS
.IP \(bu 3
Inicia con un bloque de ochenta guiones linea 64
.IP \(bu 3
Despues de los guiones el separador ð indica el interprete de marcado, la
fecha, el comentario de versiones.
.IP \(bu 3
El bloque de documentación debe estar en formato de marcado ligero.
.IP \(bu 3
La v1.00 usa el formato txt2tags
https://txt2tags.org/doc/Spanish/userguide\-es.pdf
.IP \(bu 3
Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
seguido del numero. Ejemplo Linea24
24: if [[ "$1" = "" ]] || [[ "$1" = "\-h" ]] || [[ "$1" = "\-\-help" ]] || [[ "$1" = "\-?" ]] || [[ "$1" = "\-\-ayuda" ]]; then ayuda; exit 1;
.IP \(bu 3
Para el grafico debe iniciar la linea con %т seguda del nombre de la
herramienta para graficar, separado por comas (,) el segundo campo son la
cantidad de lineas correspondientes al codigo del grafico, el tercer campo
es el nombre del archivo que va a generar.
.RE
.IP

.SS to-do

.RS
.IP \(bu 3
Probar con markdown a la par que txt2tags.
.IP \(bu 3
Agregar hoja de estilo.
.IP \(bu 3
Probar graphviz en lugar de mermaid
.RE
.IP

.SS Código

.nf
     1	#!/bin/bash
     2	ayuda() { echo '
     3	                      * extraerDocuFinalDeScript.bash *
     4	 DESCRIPCION:  Obtiene la documentación descrita al pie del script.
     5	               La convierte a man y a html con txt2tags
     6
     7	         USO:  extraerDocuFinalDeScript.bash scriptParaExtraerDocu
     8	               extraerDocuFinalDeScript.bash [-h|-?|--help|--ayuda] [-v]
     9	               extraerDocuFinalDeScript.bash --docu
    10	    OPCIONES:  -h       Ayuda
    11	               -v       Version
    12	               --docu   Leer la documentacion incluida.t2t
    13	DEPENDENCIAS:  txt2tags, mermaid
    14	        BUGS:  ---
    15	       NOTAS:  Los scripts requieren un formato especial.
    16	   VERSIONES:  20210227 1.0.1 petrohs/  Diagramas.
    17	               20191230 1.0.0 petrohs/  Documentacion.
    18	               20191227 0.0.2 petrohs/  Ajustes mayores.
    19	               20191226 0.0.1 petrohs/  Creacion.
    20	         URL:  https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
    21	';}
    22
    23	#ayuda y version
    24	 if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
    25	 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} | cut -d: -f1) + 1)),$(cat ${0}|wc -l)p ${0} | less; exit 1;
    26	 elif [[ "$1" = "-v" ]] || [[ "$1" = "--version" ]]; then ayuda | grep VERSIONES | cut -d: -f2 | cut -d/ -f1; exit 1; fi;
    27
    28	#argumentos
    29	 elScript="$1";
    30	 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} | cut -d: -f1);
    31	 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f1);
    32	 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f2);
    33	 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f3);
    34	 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f4);
    35
    36	#creando temporales
    37	 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} | cat -n | sed -e "s/\e"/"/g" -e "s/'/'/g" -e "s/\e\e\e/\e/g" -e "s/&/&/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" >${elScript}.numerado;
    38	 echo -e "Documentación técnica de ${elScript}\en${elAut}\en${laFec}, ${laVer}\en\en%!encoding: UTF-8\en%!style: fancy.css\en%!options: --toc\en%!postproc: ^<CODE>	<br /><CODE>" >${elScript}.t2t;
    39	 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}|wc -l)p ${elScript} >>${elScript}.t2t;
    40	 echo -e '\en\en== Código ==\en```' >>${elScript}.t2t;
    41	 cat ${elScript}.numerado  >>${elScript}.t2t;
    42	 echo '```' >>${elScript}.t2t;
    43
    44	#ciclo si existe sustitucion de Łineas
    45	 pasoI=0;
    46	 for eLe in $(grep -n Łinea ${elScript}.t2t | cut -d: -f1)
    47	   do
    48	     eLe=$((${eLe}+${pasoI}));
    49	     laLinea=$(sed -n ${eLe}p ${elScript}.t2t | sed -e "s/.*Łinea//" -e "s/ .*//");
    50	     laNueva=$(sed -n ${laLinea}p ${elScript}.numerado | sed -e "s/^ *//" -e "s/	/:/");
    51	     sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\en\e`\e`${laNueva}\e`\e`%" ${elScript}.t2t;
    52	     pasoI=$((${pasoI}+1));
    53	   done
    54
    55	#Ciclo para grafico
    56	 for gra in $( grep -n '^%т' ${elScript}.t2t | cut -d: -f1)
    57	   do
    58	     graficador=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f1 | cut -c4-);
    59	     graLi=$((${gra}+2));
    60	     graL=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f2);
    61	     graLf=$((${graLi}+${graL}-1));
    62	     graNombre=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f3);
    63	     sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
    64	     ${graficador} ${graNombre}.${graficador};
    65	     sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
    66	   done
    67
    68	#quitando remplazos
    69	 sed -i -e "s/"/\e"/g" -e "s/'/'/g" -e "s/\e/\e\e\e/g" -e "s/&/\e\e&/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
    70
    71	#ejecutando conversion con txt2tags
    72	 ${formateador} -t html ${elScript}.t2t
    73	 ${formateador} -t man  ${elScript}.t2t
    74	 rm ${elScript}.numerado
    75
    76	#Ser cultos para ser libres
    77	 exit 0;
    78
.fi


.\" man code generated by txt2tags 3.4 (http://txt2tags.org)
.\" cmdline: txt2tags -t man extraerDocuFinalDeScript.bash.t2t

## extraerDocuFinalDeScript.bash.t2t
Documentación técnica de extraerDocuFinalDeScript.bash
petrohs
20210227, doc v1.00 de script v1.0.1

%!encoding: UTF-8
%!style: fancy.css
%!options: --toc
%!postproc: ^<CODE>	<br /><CODE>
%ejecutar utileria «extraerDocuFinalDeScript.bash»

= extraerDocuFinalDeScript =
Este proceso esta pensado para documentar en el mismo script un pequeño
**manual técnico** con un //marcado ligero// y que se pueda extraer para
convertirlo en //.man y .html//


== proceso ==
La idea es que cualquier cosa despues del ``exit`` final ya no se interpreta,
por lo que se puede emplear para documentar y no tener un archivo separado el
seudocódigo.

La documentación inicia con el bloque de ochenta guiones.
Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
con txt2tags) para describir los procesos.

Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
donde se llama al construir el .man y el .html.

Al final tambien agregara la sección «código» el cual incluira el fuente
numerado.

Con la opcion ``--docu`` se puede ver esta documentacion en texto plano.

== Usando graficos ==
Probando con ``mermaid``
[grafica01.mermaid.png]
```
graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;
```

== formato especial ==
- Inicia con un bloque de ochenta guiones linea 64
- Despues de los guiones el separador ð indica el interprete de marcado, la
  fecha, el comentario de versiones.
- El bloque de documentación debe estar en formato de marcado ligero.
- La v1.00 usa el formato txt2tags
  https://txt2tags.org/doc/Spanish/userguide-es.pdf
- Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
  seguido del numero. Ejemplo Linea24
``24: if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;``
- Para el grafico debe iniciar la linea con %т seguda del nombre de la
  herramienta para graficar, separado por comas (,) el segundo campo son la
  cantidad de lineas correspondientes al codigo del grafico, el tercer campo
  es el nombre del archivo que va a generar.


== to-do ==
- Probar con markdown a la par que txt2tags.
- Agregar hoja de estilo.
- Probar graphviz en lugar de mermaid


== Código ==
```
     1	#!/bin/bash
     2	ayuda() { echo '
     3	                      * extraerDocuFinalDeScript.bash *
     4	 DESCRIPCION:  Obtiene la documentación descrita al pie del script.
     5	               La convierte a man y a html con txt2tags
     6
     7	         USO:  extraerDocuFinalDeScript.bash scriptParaExtraerDocu
     8	               extraerDocuFinalDeScript.bash [-h|-?|--help|--ayuda] [-v]
     9	               extraerDocuFinalDeScript.bash --docu
    10	    OPCIONES:  -h       Ayuda
    11	               -v       Version
    12	               --docu   Leer la documentacion incluida.t2t
    13	DEPENDENCIAS:  txt2tags, mermaid
    14	        BUGS:  ---
    15	       NOTAS:  Los scripts requieren un formato especial.
    16	   VERSIONES:  20210227 1.0.1 petrohs/  Diagramas.
    17	               20191230 1.0.0 petrohs/  Documentacion.
    18	               20191227 0.0.2 petrohs/  Ajustes mayores.
    19	               20191226 0.0.1 petrohs/  Creacion.
    20	         URL:  https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
    21	';}
    22
    23	#ayuda y version
    24	 if [[ "$1" = "" ]] || [[ "$1" = "-h" ]] || [[ "$1" = "--help" ]] || [[ "$1" = "-?" ]] || [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
    25	 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} | cut -d: -f1) + 1)),$(cat ${0}|wc -l)p ${0} | less; exit 1;
    26	 elif [[ "$1" = "-v" ]] || [[ "$1" = "--version" ]]; then ayuda | grep VERSIONES | cut -d: -f2 | cut -d/ -f1; exit 1; fi;
    27
    28	#argumentos
    29	 elScript="$1";
    30	 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} | cut -d: -f1);
    31	 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f1);
    32	 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f2);
    33	 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f3);
    34	 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} | sed -e "s/^-.*ð//" | cut -d, -f4);
    35
    36	#creando temporales
    37	 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} | cat -n | sed -e "s/\"/"/g" -e "s/'/'/g" -e "s/\\\/\/g" -e "s/&/&/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" >${elScript}.numerado;
    38	 echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^<CODE>	<br /><CODE>" >${elScript}.t2t;
    39	 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}|wc -l)p ${elScript} >>${elScript}.t2t;
    40	 echo -e '\n\n== Código ==\n```' >>${elScript}.t2t;
    41	 cat ${elScript}.numerado  >>${elScript}.t2t;
    42	 echo '```' >>${elScript}.t2t;
    43
    44	#ciclo si existe sustitucion de Łineas
    45	 pasoI=0;
    46	 for eLe in $(grep -n Łinea ${elScript}.t2t | cut -d: -f1)
    47	   do
    48	     eLe=$((${eLe}+${pasoI}));
    49	     laLinea=$(sed -n ${eLe}p ${elScript}.t2t | sed -e "s/.*Łinea//" -e "s/ .*//");
    50	     laNueva=$(sed -n ${laLinea}p ${elScript}.numerado | sed -e "s/^ *//" -e "s/	/:/");
    51	     sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
    52	     pasoI=$((${pasoI}+1));
    53	   done
    54
    55	#Ciclo para grafico
    56	 for gra in $( grep -n '^%т' ${elScript}.t2t | cut -d: -f1)
    57	   do
    58	     graficador=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f1 | cut -c4-);
    59	     graLi=$((${gra}+2));
    60	     graL=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f2);
    61	     graLf=$((${graLi}+${graL}-1));
    62	     graNombre=$(sed -n ${gra}p ${elScript}.t2t | cut -d, -f3);
    63	     sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
    64	     ${graficador} ${graNombre}.${graficador};
    65	     sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
    66	   done
    67
    68	#quitando remplazos
    69	 sed -i -e "s/"/\"/g" -e "s/'/'/g" -e "s/\/\\\/g" -e "s/&/\\&/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
    70
    71	#ejecutando conversion con txt2tags
    72	 ${formateador} -t html ${elScript}.t2t
    73	 ${formateador} -t man  ${elScript}.t2t
    74	 rm ${elScript}.numerado
    75
    76	#Ser cultos para ser libres
    77	 exit 0;
    78
```

## grafica01.mermaid

      
    Raw
  

              grafica01.mermaid
            
          
        Loading

      Sorry, something went wrong. Reload?
      Sorry, we cannot display this file.
      Sorry, this file is invalid so it cannot be displayed.
      
          Viewer requires iframe.
	#!/bin/bash
	ayuda() { echo '
	* extraerDocuFinalDeScript.bash *
	DESCRIPCION: Obtiene la documentación descrita al pie del script.
	La convierte a man y a html con txt2tags

	USO: extraerDocuFinalDeScript.bash scriptParaExtraerDocu
	extraerDocuFinalDeScript.bash [-h\|-?\|--help\|--ayuda] [-v]
	extraerDocuFinalDeScript.bash --docu
	OPCIONES: -h Ayuda
	-v Version
	--docu Leer la documentacion incluida.t2t
	DEPENDENCIAS: txt2tags, mermaid
	BUGS: ---
	NOTAS: Los scripts requieren un formato especial.
	VERSIONES: 20210227 1.0.1 petrohs/ Diagramas.
	20191230 1.0.0 petrohs/ Documentacion.
	20191227 0.0.2 petrohs/ Ajustes mayores.
	20191226 0.0.1 petrohs/ Creacion.
	URL: https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
	';}

	#ayuda y version
	if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
	elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} \| cut -d: -f1) + 1)),$(cat ${0}\|wc -l)p ${0} \| less; exit 1;
	elif [[ "$1" = "-v" ]] \|\| [[ "$1" = "--version" ]]; then ayuda \| grep VERSIONES \| cut -d: -f2 \| cut -d/ -f1; exit 1; fi;

	#argumentos
	elScript="$1";
	separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} \| cut -d: -f1);
	formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f1);
	laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f2);
	laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f3);
	elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f4);

	#creando temporales
	sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} \| cat -n \| sed -e "s/\"/ð=comillaDoble=ð/g" -e "s/'/ð=comillaSimple=ð/g" -e "s/\\\/ð=diagonalInvertida=ð/g" -e "s/&/ð=ampersand=ð/g" -e "s/Łinea/ð=linea=ð/g" -e "s/т/ð=graficador=ð/g" >${elScript}.numerado;
	echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^<CODE> <br /><CODE>" >${elScript}.t2t;
	sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}\|wc -l)p ${elScript} >>${elScript}.t2t;
	echo -e '\n\n== Código ==\n```' >>${elScript}.t2t;
	cat ${elScript}.numerado >>${elScript}.t2t;
	echo '```' >>${elScript}.t2t;

	#ciclo si existe sustitucion de Łineas
	pasoI=0;
	for eLe in $(grep -n Łinea ${elScript}.t2t \| cut -d: -f1)
	do
	eLe=$((${eLe}+${pasoI}));
	laLinea=$(sed -n ${eLe}p ${elScript}.t2t \| sed -e "s/.Łinea//" -e "s/ .//");
	laNueva=$(sed -n ${laLinea}p ${elScript}.numerado \| sed -e "s/^ *//" -e "s/ /:/");
	sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
	pasoI=$((${pasoI}+1));
	done

	#Ciclo para grafico
	for gra in $( grep -n '^%т' ${elScript}.t2t \| cut -d: -f1)
	do
	graficador=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f1 \| cut -c4-);
	graLi=$((${gra}+2));
	graL=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f2);
	graLf=$((${graLi}+${graL}-1));
	graNombre=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f3);
	sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
	${graficador} ${graNombre}.${graficador};
	sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
	done

	#quitando remplazos
	sed -i -e "s/ð=comillaDoble=ð/\"/g" -e "s/ð=comillaSimple=ð/'/g" -e "s/ð=diagonalInvertida=ð/\\\/g" -e "s/ð=ampersand=ð/\\&/g" -e "s/Łinea/Linea/g" -e "s/ð=linea=ð/Łinea/g" -e "s/ð=graficador=ð/т/g" ${elScript}.t2t;

	#ejecutando conversion con txt2tags
	${formateador} -t html ${elScript}.t2t
	${formateador} -t man ${elScript}.t2t
	rm ${elScript}.numerado

	#Ser cultos para ser libres
	exit 0;

	--------------------------------------------------------------------------------ðtxt2tags,20210227,doc v1.00 de script v1.0.1,petrohs
	%ejecutar utileria «extraerDocuFinalDeScript.bash»

	= extraerDocuFinalDeScript =
	Este proceso esta pensado para documentar en el mismo script un pequeño
	manual técnico con un //marcado ligero// y que se pueda extraer para
	convertirlo en //.man y .html//


	== proceso ==
	La idea es que cualquier cosa despues del ``exit`` final ya no se interpreta,
	por lo que se puede emplear para documentar y no tener un archivo separado el
	seudocódigo.

	La documentación inicia con el bloque de ochenta guiones.
	Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
	con txt2tags) para describir los procesos.

	Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
	donde se llama al construir el .man y el .html.

	Al final tambien agregara la sección «código» el cual incluira el fuente
	numerado.

	Con la opcion ``--docu`` se puede ver esta documentacion en texto plano.

	== Usando graficos ==
	Probando con ``mermaid``
	%тmermaid,5,grafica01
	```
	graph TD;
	A-->B;
	A-->C;
	B-->D;
	C-->D;
	```

	== formato especial ==
	- Inicia con un bloque de ochenta guiones linea 64
	- Despues de los guiones el separador ð indica el interprete de marcado, la
	fecha, el comentario de versiones.
	- El bloque de documentación debe estar en formato de marcado ligero.
	- La v1.00 usa el formato txt2tags
	https://txt2tags.org/doc/Spanish/userguide-es.pdf
	- Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
	seguido del numero. Ejemplo Łinea24
	- Para el grafico debe iniciar la linea con %т seguda del nombre de la
	herramienta para graficar, separado por comas (,) el segundo campo son la
	cantidad de lineas correspondientes al codigo del grafico, el tercer campo
	es el nombre del archivo que va a generar.


	== to-do ==
	- Probar con markdown a la par que txt2tags.
	- Agregar hoja de estilo.
	- Probar graphviz en lugar de mermaid
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="UTF-8">
	<title>Documentación técnica de extraerDocuFinalDeScript.bash</title>
	<meta name="generator" content="http://txt2tags.org">
	<link rel="stylesheet" href="fancy.css">
	<style>
	body{background-color:#fff;color:#000;}
	hr{background-color:#000;border:0;color:#000;}
	hr.heavy{height:5px;}
	hr.light{height:1px;}
	img{border:0;display:block;}
	img.right{margin:0 0 0 auto;}
	img.center{border:0;margin:0 auto;}
	table th,table td{padding:4px;}
	.center,header{text-align:center;}
	table.center {margin-left:auto; margin-right:auto;}
	.right{text-align:right;}
	.left{text-align:left;}
	.tableborder,.tableborder td,.tableborder th{border:1px solid #000;}
	.underline{text-decoration:underline;}
	</style>
	</head>
	<body>
	<header>
	<hgroup>
	<h1>Documentación técnica de extraerDocuFinalDeScript.bash</h1>
	<h2>petrohs</h2>
	<h3>20210227, doc v1.00 de script v1.0.1</h3>
	</hgroup>
	</header>
	<article>

	<nav>
	<div class="body" id="body">

	<ul>
	<li><a href="#toc1">extraerDocuFinalDeScript</a>
	<ul>
	<li><a href="#toc2">proceso</a>
	</li>
	<li><a href="#toc3">Usando graficos</a>
	</li>
	<li><a href="#toc4">formato especial</a>
	</li>
	<li><a href="#toc5">to-do</a>
	</li>
	<li><a href="#toc6">Código</a>
	</li>
	</ul>
	</li>
	</ul>

	</div>
	</nav>
	<div class="body" id="body">

	<section id="toc1">
	<h1>extraerDocuFinalDeScript</h1>

	<p>
	Este proceso esta pensado para documentar en el mismo script un pequeño
	<strong>manual técnico</strong> con un <em>marcado ligero</em> y que se pueda extraer para
	convertirlo en <em>.man y .html</em>
	</p>

	<section id="toc2">
	<h2>proceso</h2>

	<p>
	La idea es que cualquier cosa despues del <code>exit</code> final ya no se interpreta,
	por lo que se puede emplear para documentar y no tener un archivo separado el
	seudocódigo.
	</p>
	<p>
	La documentación inicia con el bloque de ochenta guiones.
	Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
	con txt2tags) para describir los procesos.
	</p>
	<p>
	Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
	donde se llama al construir el .man y el .html.
	</p>
	<p>
	Al final tambien agregara la sección «código» el cual incluira el fuente
	numerado.
	</p>
	<p>
	Con la opcion <code>--docu</code> se puede ver esta documentacion en texto plano.
	</p>

	</section>
	<section id="toc3">
	<h2>Usando graficos</h2>

	<p>
	Probando con <code>mermaid</code>
	<img class="center" src="grafica01.mermaid.png" alt="">
	</p>

	<pre>
	graph TD;
	A-->B;
	A-->C;
	B-->D;
	C-->D;
	</pre>

	</section>
	<section id="toc4">
	<h2>formato especial</h2>

	<ul>
	<li>Inicia con un bloque de ochenta guiones linea 64
	</li>
	<li>Despues de los guiones el separador ð indica el interprete de marcado, la
	fecha, el comentario de versiones.
	</li>
	<li>El bloque de documentación debe estar en formato de marcado ligero.
	</li>
	<li>La v1.00 usa el formato txt2tags
	<a href="https://txt2tags.org/doc/Spanish/userguide-es.pdf">https://txt2tags.org/doc/Spanish/userguide-es.pdf</a>
	</li>
	<li>Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
	seguido del numero. Ejemplo Linea24
	<code>24: if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;</code>
	</li>
	<li>Para el grafico debe iniciar la linea con %т seguda del nombre de la
	herramienta para graficar, separado por comas (,) el segundo campo son la
	cantidad de lineas correspondientes al codigo del grafico, el tercer campo
	es el nombre del archivo que va a generar.
	</li>
	</ul>

	</section>
	<section id="toc5">
	<h2>to-do</h2>

	<ul>
	<li>Probar con markdown a la par que txt2tags.
	</li>
	<li>Agregar hoja de estilo.
	</li>
	<li>Probar graphviz en lugar de mermaid
	</li>
	</ul>

	</section>
	<section id="toc6">
	<h2>Código</h2>

	<pre>
	1 #!/bin/bash
	2 ayuda() { echo '
	3 * extraerDocuFinalDeScript.bash *
	4 DESCRIPCION: Obtiene la documentación descrita al pie del script.
	5 La convierte a man y a html con txt2tags
	6
	7 USO: extraerDocuFinalDeScript.bash scriptParaExtraerDocu
	8 extraerDocuFinalDeScript.bash [-h\|-?\|--help\|--ayuda] [-v]
	9 extraerDocuFinalDeScript.bash --docu
	10 OPCIONES: -h Ayuda
	11 -v Version
	12 --docu Leer la documentacion incluida.t2t
	13 DEPENDENCIAS: txt2tags, mermaid
	14 BUGS: ---
	15 NOTAS: Los scripts requieren un formato especial.
	16 VERSIONES: 20210227 1.0.1 petrohs/ Diagramas.
	17 20191230 1.0.0 petrohs/ Documentacion.
	18 20191227 0.0.2 petrohs/ Ajustes mayores.
	19 20191226 0.0.1 petrohs/ Creacion.
	20 URL: https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
	21 ';}
	22
	23 #ayuda y version
	24 if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
	25 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} \| cut -d: -f1) + 1)),$(cat ${0}\|wc -l)p ${0} \| less; exit 1;
	26 elif [[ "$1" = "-v" ]] \|\| [[ "$1" = "--version" ]]; then ayuda \| grep VERSIONES \| cut -d: -f2 \| cut -d/ -f1; exit 1; fi;
	27
	28 #argumentos
	29 elScript="$1";
	30 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} \| cut -d: -f1);
	31 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f1);
	32 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f2);
	33 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f3);
	34 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f4);
	35
	36 #creando temporales
	37 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} \| cat -n \| sed -e "s/\"/"/g" -e "s/'/'/g" -e "s/\\\/\/g" -e "s/&/&/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" >${elScript}.numerado;
	38 echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^<CODE> <br /><CODE>" >${elScript}.t2t;
	39 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}\|wc -l)p ${elScript} >>${elScript}.t2t;
	40 echo -e '\n\n== Código ==\n```' >>${elScript}.t2t;
	41 cat ${elScript}.numerado >>${elScript}.t2t;
	42 echo '```' >>${elScript}.t2t;
	43
	44 #ciclo si existe sustitucion de Łineas
	45 pasoI=0;
	46 for eLe in $(grep -n Łinea ${elScript}.t2t \| cut -d: -f1)
	47 do
	48 eLe=$((${eLe}+${pasoI}));
	49 laLinea=$(sed -n ${eLe}p ${elScript}.t2t \| sed -e "s/.Łinea//" -e "s/ .//");
	50 laNueva=$(sed -n ${laLinea}p ${elScript}.numerado \| sed -e "s/^ *//" -e "s/ /:/");
	51 sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
	52 pasoI=$((${pasoI}+1));
	53 done
	54
	55 #Ciclo para grafico
	56 for gra in $( grep -n '^%т' ${elScript}.t2t \| cut -d: -f1)
	57 do
	58 graficador=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f1 \| cut -c4-);
	59 graLi=$((${gra}+2));
	60 graL=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f2);
	61 graLf=$((${graLi}+${graL}-1));
	62 graNombre=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f3);
	63 sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
	64 ${graficador} ${graNombre}.${graficador};
	65 sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
	66 done
	67
	68 #quitando remplazos
	69 sed -i -e "s/"/\"/g" -e "s/'/'/g" -e "s/\/\\\/g" -e "s/&/\\&/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
	70
	71 #ejecutando conversion con txt2tags
	72 ${formateador} -t html ${elScript}.t2t
	73 ${formateador} -t man ${elScript}.t2t
	74 rm ${elScript}.numerado
	75
	76 #Ser cultos para ser libres
	77 exit 0;
	78
	</pre>

	</section>
	</section>
	</div>
	<!-- html code generated by txt2tags 3.4 (http://txt2tags.org) -->
	<!-- cmdline: txt2tags -t html extraerDocuFinalDeScript.bash.t2t -->
	</article></body></html>
	.TH "Documentación técnica de extraerDocuFinalDeScript.bash" 1 "20210227, doc v1.00 de script v1.0.1" "petrohs"

	.P
	extraerDocuFinalDeScript
	proceso
	Usando graficos
	formato especial
	to\-do
	Código
	.SH extraerDocuFinalDeScript
	.P
	Este proceso esta pensado para documentar en el mismo script un pequeño
	\fBmanual técnico\fR con un \fImarcado ligero\fR y que se pueda extraer para
	convertirlo en \fI.man y .html\fR
	.SS proceso
	.P
	La idea es que cualquier cosa despues del exit final ya no se interpreta,
	por lo que se puede emplear para documentar y no tener un archivo separado el
	seudocódigo.
	.P
	La documentación inicia con el bloque de ochenta guiones.
	Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
	con txt2tags) para describir los procesos.
	.P
	Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
	donde se llama al construir el .man y el .html.
	.P
	Al final tambien agregara la sección «código» el cual incluira el fuente
	numerado.
	.P
	Con la opcion \-\-docu se puede ver esta documentacion en texto plano.
	.SS Usando graficos
	.P
	Probando con mermaid
	grafica01.mermaid.png

	.nf
	graph TD;
	A-->B;
	A-->C;
	B-->D;
	C-->D;
	.fi


	.SS formato especial

	.RS
	.IP \(bu 3
	Inicia con un bloque de ochenta guiones linea 64
	.IP \(bu 3
	Despues de los guiones el separador ð indica el interprete de marcado, la
	fecha, el comentario de versiones.
	.IP \(bu 3
	El bloque de documentación debe estar en formato de marcado ligero.
	.IP \(bu 3
	La v1.00 usa el formato txt2tags
	https://txt2tags.org/doc/Spanish/userguide\-es.pdf
	.IP \(bu 3
	Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
	seguido del numero. Ejemplo Linea24
	24: if [[ "$1" = "" ]] \|\| [[ "$1" = "\-h" ]] \|\| [[ "$1" = "\-\-help" ]] \|\| [[ "$1" = "\-?" ]] \|\| [[ "$1" = "\-\-ayuda" ]]; then ayuda; exit 1;
	.IP \(bu 3
	Para el grafico debe iniciar la linea con %т seguda del nombre de la
	herramienta para graficar, separado por comas (,) el segundo campo son la
	cantidad de lineas correspondientes al codigo del grafico, el tercer campo
	es el nombre del archivo que va a generar.
	.RE
	.IP

	.SS to-do

	.RS
	.IP \(bu 3
	Probar con markdown a la par que txt2tags.
	.IP \(bu 3
	Agregar hoja de estilo.
	.IP \(bu 3
	Probar graphviz en lugar de mermaid
	.RE
	.IP

	.SS Código

	.nf
	1 #!/bin/bash
	2 ayuda() { echo '
	3 * extraerDocuFinalDeScript.bash *
	4 DESCRIPCION: Obtiene la documentación descrita al pie del script.
	5 La convierte a man y a html con txt2tags
	6
	7 USO: extraerDocuFinalDeScript.bash scriptParaExtraerDocu
	8 extraerDocuFinalDeScript.bash [-h\|-?\|--help\|--ayuda] [-v]
	9 extraerDocuFinalDeScript.bash --docu
	10 OPCIONES: -h Ayuda
	11 -v Version
	12 --docu Leer la documentacion incluida.t2t
	13 DEPENDENCIAS: txt2tags, mermaid
	14 BUGS: ---
	15 NOTAS: Los scripts requieren un formato especial.
	16 VERSIONES: 20210227 1.0.1 petrohs/ Diagramas.
	17 20191230 1.0.0 petrohs/ Documentacion.
	18 20191227 0.0.2 petrohs/ Ajustes mayores.
	19 20191226 0.0.1 petrohs/ Creacion.
	20 URL: https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
	21 ';}
	22
	23 #ayuda y version
	24 if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
	25 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} \| cut -d: -f1) + 1)),$(cat ${0}\|wc -l)p ${0} \| less; exit 1;
	26 elif [[ "$1" = "-v" ]] \|\| [[ "$1" = "--version" ]]; then ayuda \| grep VERSIONES \| cut -d: -f2 \| cut -d/ -f1; exit 1; fi;
	27
	28 #argumentos
	29 elScript="$1";
	30 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} \| cut -d: -f1);
	31 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f1);
	32 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f2);
	33 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f3);
	34 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f4);
	35
	36 #creando temporales
	37 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} \| cat -n \| sed -e "s/\e"/"/g" -e "s/'/'/g" -e "s/\e\e\e/\e/g" -e "s/&/&/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" >${elScript}.numerado;
	38 echo -e "Documentación técnica de ${elScript}\en${elAut}\en${laFec}, ${laVer}\en\en%!encoding: UTF-8\en%!style: fancy.css\en%!options: --toc\en%!postproc: ^<CODE> <br /><CODE>" >${elScript}.t2t;
	39 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}\|wc -l)p ${elScript} >>${elScript}.t2t;
	40 echo -e '\en\en== Código ==\en```' >>${elScript}.t2t;
	41 cat ${elScript}.numerado >>${elScript}.t2t;
	42 echo '```' >>${elScript}.t2t;
	43
	44 #ciclo si existe sustitucion de Łineas
	45 pasoI=0;
	46 for eLe in $(grep -n Łinea ${elScript}.t2t \| cut -d: -f1)
	47 do
	48 eLe=$((${eLe}+${pasoI}));
	49 laLinea=$(sed -n ${eLe}p ${elScript}.t2t \| sed -e "s/.Łinea//" -e "s/ .//");
	50 laNueva=$(sed -n ${laLinea}p ${elScript}.numerado \| sed -e "s/^ *//" -e "s/ /:/");
	51 sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\en\e`\e`${laNueva}\e`\e`%" ${elScript}.t2t;
	52 pasoI=$((${pasoI}+1));
	53 done
	54
	55 #Ciclo para grafico
	56 for gra in $( grep -n '^%т' ${elScript}.t2t \| cut -d: -f1)
	57 do
	58 graficador=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f1 \| cut -c4-);
	59 graLi=$((${gra}+2));
	60 graL=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f2);
	61 graLf=$((${graLi}+${graL}-1));
	62 graNombre=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f3);
	63 sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
	64 ${graficador} ${graNombre}.${graficador};
	65 sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
	66 done
	67
	68 #quitando remplazos
	69 sed -i -e "s/"/\e"/g" -e "s/'/'/g" -e "s/\e/\e\e\e/g" -e "s/&/\e\e&/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
	70
	71 #ejecutando conversion con txt2tags
	72 ${formateador} -t html ${elScript}.t2t
	73 ${formateador} -t man ${elScript}.t2t
	74 rm ${elScript}.numerado
	75
	76 #Ser cultos para ser libres
	77 exit 0;
	78
	.fi


	.\" man code generated by txt2tags 3.4 (http://txt2tags.org)
	.\" cmdline: txt2tags -t man extraerDocuFinalDeScript.bash.t2t
	Documentación técnica de extraerDocuFinalDeScript.bash
	petrohs
	20210227, doc v1.00 de script v1.0.1

	%!encoding: UTF-8
	%!style: fancy.css
	%!options: --toc
	%!postproc: ^<CODE> <br /><CODE>
	%ejecutar utileria «extraerDocuFinalDeScript.bash»

	= extraerDocuFinalDeScript =
	Este proceso esta pensado para documentar en el mismo script un pequeño
	manual técnico con un //marcado ligero// y que se pueda extraer para
	convertirlo en //.man y .html//


	== proceso ==
	La idea es que cualquier cosa despues del ``exit`` final ya no se interpreta,
	por lo que se puede emplear para documentar y no tener un archivo separado el
	seudocódigo.

	La documentación inicia con el bloque de ochenta guiones.
	Desde ahí se puede emplear un marcado ligero (la versión 1.00 solo esta probada
	con txt2tags) para describir los procesos.

	Estos pueden incluir el numero de linea y esa se agregara abajo de la línea
	donde se llama al construir el .man y el .html.

	Al final tambien agregara la sección «código» el cual incluira el fuente
	numerado.

	Con la opcion ``--docu`` se puede ver esta documentacion en texto plano.

	== Usando graficos ==
	Probando con ``mermaid``
	[grafica01.mermaid.png]
	```
	graph TD;
	A-->B;
	A-->C;
	B-->D;
	C-->D;
	```

	== formato especial ==
	- Inicia con un bloque de ochenta guiones linea 64
	- Despues de los guiones el separador ð indica el interprete de marcado, la
	fecha, el comentario de versiones.
	- El bloque de documentación debe estar en formato de marcado ligero.
	- La v1.00 usa el formato txt2tags
	https://txt2tags.org/doc/Spanish/userguide-es.pdf
	- Si se quiere agregar la linea mencionada, se debe remplazar la Linea por Ł y
	seguido del numero. Ejemplo Linea24
	``24: if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;``
	- Para el grafico debe iniciar la linea con %т seguda del nombre de la
	herramienta para graficar, separado por comas (,) el segundo campo son la
	cantidad de lineas correspondientes al codigo del grafico, el tercer campo
	es el nombre del archivo que va a generar.


	== to-do ==
	- Probar con markdown a la par que txt2tags.
	- Agregar hoja de estilo.
	- Probar graphviz en lugar de mermaid



	== Código ==
	```
	1 #!/bin/bash
	2 ayuda() { echo '
	3 * extraerDocuFinalDeScript.bash *
	4 DESCRIPCION: Obtiene la documentación descrita al pie del script.
	5 La convierte a man y a html con txt2tags
	6
	7 USO: extraerDocuFinalDeScript.bash scriptParaExtraerDocu
	8 extraerDocuFinalDeScript.bash [-h\|-?\|--help\|--ayuda] [-v]
	9 extraerDocuFinalDeScript.bash --docu
	10 OPCIONES: -h Ayuda
	11 -v Version
	12 --docu Leer la documentacion incluida.t2t
	13 DEPENDENCIAS: txt2tags, mermaid
	14 BUGS: ---
	15 NOTAS: Los scripts requieren un formato especial.
	16 VERSIONES: 20210227 1.0.1 petrohs/ Diagramas.
	17 20191230 1.0.0 petrohs/ Documentacion.
	18 20191227 0.0.2 petrohs/ Ajustes mayores.
	19 20191226 0.0.1 petrohs/ Creacion.
	20 URL: https://gist.github.com/petrohs/014f6446a4b5d76f73f365b5c2571bc5
	21 ';}
	22
	23 #ayuda y version
	24 if [[ "$1" = "" ]] \|\| [[ "$1" = "-h" ]] \|\| [[ "$1" = "--help" ]] \|\| [[ "$1" = "-?" ]] \|\| [[ "$1" = "--ayuda" ]]; then ayuda; exit 1;
	25 elif [[ "$1" = "--docu" ]]; then sed -n $(($(grep -En "^-{80}ð" ${0} \| cut -d: -f1) + 1)),$(cat ${0}\|wc -l)p ${0} \| less; exit 1;
	26 elif [[ "$1" = "-v" ]] \|\| [[ "$1" = "--version" ]]; then ayuda \| grep VERSIONES \| cut -d: -f2 \| cut -d/ -f1; exit 1; fi;
	27
	28 #argumentos
	29 elScript="$1";
	30 separadorDocumentacionLinea=$(grep -En "^-{80}ð" ${elScript} \| cut -d: -f1);
	31 formateador=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f1);
	32 laFec=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f2);
	33 laVer=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f3);
	34 elAut=$(sed -n ${separadorDocumentacionLinea}p ${elScript} \| sed -e "s/^-.*ð//" \| cut -d, -f4);
	35
	36 #creando temporales
	37 sed -n 1,$((${separadorDocumentacionLinea} - 1))p ${elScript} \| cat -n \| sed -e "s/\"/"/g" -e "s/'/'/g" -e "s/\\\/\/g" -e "s/&/&/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" >${elScript}.numerado;
	38 echo -e "Documentación técnica de ${elScript}\n${elAut}\n${laFec}, ${laVer}\n\n%!encoding: UTF-8\n%!style: fancy.css\n%!options: --toc\n%!postproc: ^<CODE> <br /><CODE>" >${elScript}.t2t;
	39 sed -n $((${separadorDocumentacionLinea} + 1)),$(cat ${elScript}\|wc -l)p ${elScript} >>${elScript}.t2t;
	40 echo -e '\n\n== Código ==\n```' >>${elScript}.t2t;
	41 cat ${elScript}.numerado >>${elScript}.t2t;
	42 echo '```' >>${elScript}.t2t;
	43
	44 #ciclo si existe sustitucion de Łineas
	45 pasoI=0;
	46 for eLe in $(grep -n Łinea ${elScript}.t2t \| cut -d: -f1)
	47 do
	48 eLe=$((${eLe}+${pasoI}));
	49 laLinea=$(sed -n ${eLe}p ${elScript}.t2t \| sed -e "s/.Łinea//" -e "s/ .//");
	50 laNueva=$(sed -n ${laLinea}p ${elScript}.numerado \| sed -e "s/^ *//" -e "s/ /:/");
	51 sed -i -e "s%$(sed -n ${eLe}p ${elScript}.t2t)%&\n\`\`${laNueva}\`\`%" ${elScript}.t2t;
	52 pasoI=$((${pasoI}+1));
	53 done
	54
	55 #Ciclo para grafico
	56 for gra in $( grep -n '^%т' ${elScript}.t2t \| cut -d: -f1)
	57 do
	58 graficador=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f1 \| cut -c4-);
	59 graLi=$((${gra}+2));
	60 graL=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f2);
	61 graLf=$((${graLi}+${graL}-1));
	62 graNombre=$(sed -n ${gra}p ${elScript}.t2t \| cut -d, -f3);
	63 sed -n ${graLi},${graLf}p ${elScript}.t2t > ${graNombre}.${graficador};
	64 ${graficador} ${graNombre}.${graficador};
	65 sed -i "${gra}s/.*/[${graNombre}.${graficador}.png]/" ${elScript}.t2t
	66 done
	67
	68 #quitando remplazos
	69 sed -i -e "s/"/\"/g" -e "s/'/'/g" -e "s/\/\\\/g" -e "s/&/\\&/g" -e "s/Łinea/Linea/g" -e "s/Łinea/Łinea/g" -e "s/т/т/g" ${elScript}.t2t;
	70
	71 #ejecutando conversion con txt2tags
	72 ${formateador} -t html ${elScript}.t2t
	73 ${formateador} -t man ${elScript}.t2t
	74 rm ${elScript}.numerado
	75
	76 #Ser cultos para ser libres
	77 exit 0;
	78
	```