Actualicé el programita para consultar el diccionario de la RAE desde
consola.
Saludos.
############################################################################
#!/bin/sh
# ###########################################################################
#
# Autor: Miguel Angel Rodríguez (aka timeo)
# Email: [EMAIL PROTECTED] || [EMAIL PROTECTED]
#
# Versión 0.01: 09 de enero de 2004.
# Versión 0.02: 29 de abril de 2005.
# Versión 0.03: 15 de octubre de 2005.
# Última versión (0.04): 09 de febrero de 2007.
#
# Descripción:
# Script para buscar definiciones de términos
# en el diccionario de la R.A.E "on line".
#
# bRAE.sh busca definiciones de términos en la base de datos de la RAE,
# los muestra en pantalla y guarda una copia comprimida en un directorio
# creado por el programa para tal efecto. Además posee varias opciones
# de búsqueda y "limpieza" de archivos de definiciones. La idea base es
# tener un script para consultar en línea el diccionario de la Real
# Academia de la Lengua y a la vez ir almacenando el resultado de estas
# consultas en nuestro disco duro.
#
# Dependencias:
# Lynx 2.8.X
# less
# nmap
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
#
#
# ###########################################################################
# Borramos el fichero de bloqueo al salir.
RM=/bin/rm
BLOQUEO=${HOME}/.brae.lock
test -x $RM || exit 0
trap "$RM -f $BLOQUEO" 1 3 9 15
# Los insoslayables "caminos".
PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin
export PATH
# "Localización".
# No usamos LANG="C" porque el script es para trabajar
# exclusivamente con palabras del idioma castellano.
if [[ -z $LANG ]]
then
LANG="es_ES.ISO-8859-1"
export LANG
fi
# Nos aseguramos de que esté establecido
# el entorno para que less pueda abrir
# ficheros comprimidos con gzip.
LESSFILE=/usr/bin/lessfile
test -x $LESSFILE || exit 0
eval "$(lessfile)"
################################################
#
# Algunas constantes para hacernos la vida más
# cómoda.
#
################################################
# Definimos una constante para el nombre del
# programa. (Gracias Aitor Moreno Martínez.)
BASENAME=/usr/bin/basename
test -x $BASENAME || exit 0
PROGRAMA=`$BASENAME $0`
# Definimos la interfaz de red que nos conecta
# a internet. Poner la que corresponda: pppX,
# ethX, etc..
DISPOSITIVO="ppp0"
# Nombre (URL) del servidor de la RAE.
SERVIDOR="buscon.rae.es"
# Dirección URL del servidor de la base de datos
# de la RAE.
URL="http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&LEMA=";
# Directorio en donde se guardan las archivos
# de términos encontrados y comprimidos.
BD=${HOME}/DRAE/
# Fichero que se usa para escribir la lista de
# palabras que se desean buscar de una sola vez.
FICHEROPALABRAS=${HOME}/palabrasRAE.txt
# Fichero usado para guardar temporalmente la
# lista de palabras que todavía faltan buscar.
FICHEROPALABRASTMP=${HOME}/palabrasRAE-TMP.txt
# Ficheros de texto usados para crear un
# listado de palabras a partir de un fichero
# cualquiera.
FICHEROTEMP1=${HOME}/listadoPalabras-TMP1.txt
FICHEROTEMP2=${HOME}/listadoPalabras-TMP2.txt
# Fichero que contiene el listado completo de
# palabras del DRAE que existen en el directorio
# del usuario ($HOME/DRAE).
# Falta poner el listado oficial (${HOME}/listadoPalabrasDRAE-O.txt).
PALABRAS=${HOME}/listadoPalabrasDRAE-U.txt
# Ficheros para guardar temporalmente el resultado
# de una búsqueda.
FICHERODEFTEMP1=${HOME}/fichero_def_temp-TMP1.txt
FICHERODEFTEMP2=${HOME}/fichero_def_temp-TMP2.txt
# Cadena de texto que muestra el servidor de la RAE
# al pie del artículo.
PIEARTICULO="Real Academia Española © Todos los derechos reservados"
# Cadena de texto que muestra el servidor de la RAE
# al comienzo de cada artículo. Esta característica
# apareció en febrero de 2007. Se la quitamos.
CABECERAARTICULO="Emblema de la Real Academia Española"
# Frase para cuando no se halló el artículo en el servidor
# de la RAE.
NOARTICULO='La palabra consultada no está en el Diccionario.'
# Caracteres especiales excluidos. ¿Falta alguno?
CARESPECIALES="[]ªº\!\|\"[EMAIL
PROTECTED]&\/\(\)\=\?¿\'¡Çç\{\}\*\+\^\_\;\:\.,\<\>\`\\½«»~¬[-]"
# Caracteres especiales, letras mayúsculas, letras mayúsculas con
# diacríticos y números a borrar de un archivo de texto que se
# va a usar como listado de palabras, cuyos significados se
# buscarán en el DRAE.
CARESPECIALESBORRAR="\\] - ª º ! | \" @ © · # \\$ % & ( ) \= \? ¿ ' ¡ Ç ç { \\}
\* + \\\ \\/ _ ; : , \\. < > \` ½ « » ~ ¬ \^ 0 1 2 3 4 5 6 7 8 9 \\["
MAYUSCULASBORRAR="A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z Á É Í Ó
Ú Ä Ë Ï Ö Ü"
# Array de letras minúsculas para reemplazar a sus correspondientes mayúsculas.
MINUSCULAS=(a b c d e f g h i j k l m n ñ o p q r s t u v w x y z á é í ó ú ä ë
ï ö ü)
# Número máximo de caracteres que puede tener
# una palabra
let TAMPALABRA=30
# Comandos/programas con sus paths absolutos.
CAT=/bin/cat
CP=/bin/cp
DATE=/bin/date
ECHO=/bin/echo
GREP=/bin/grep
GZIP=/bin/gzip
LS=/bin/ls
MV=/bin/mv
PING=/bin/ping
SED=/bin/sed
ZGREP=/bin/zgrep
IFCONFIG=/sbin/ifconfig
CLEAR=/usr/bin/clear
CUT=/usr/bin/cut
FILE=/usr/bin/file
FIND=/usr/bin/find
HEAD=/usr/bin/head
LESS=/usr/bin/less
LYNX=/usr/bin/lynx
NMAP=/usr/bin/nmap
TAIL=/usr/bin/tail
STAT=/usr/bin/stat
TOUCH=/usr/bin/touch
WC=/usr/bin/wc
# Creamos una función de error para:
# 1. Indicar cuál es el programa o comando que no existe;
# 2 Indicar que una cadena de entrada es errónea; y
# 3. Indicar el fallo en la ejecución de un programa.
test -x $ECHO || exit 0
FALLOS=(1 2 3)
mensaje_error() {
M_CADENA=$1
M_OPCION=$2
if [[ $M_OPCION = ${FALLOS[0]} ]]
then
$ECHO -e "\nNo existe «$M_CADENA».\n"
elif [[ $M_OPCION = ${FALLOS[1]} ]]
then
$ECHO -e "\nUse parámetro «$M_CADENA».\n"
elif [[ $M_OPCION = ${FALLOS[2]} ]]
then
$ECHO -e "\nFallo en la ejecución de «$M_CADENA».\n"
else
$ECHO -e "\nError en función «mensaje_error».\n"
fi
$RM -f $BLOQUEO
exit 0
}
# Comprobamos que existen todos los comandos/programas
# que usaremos en nuestro script.
test -x $CAT || mensaje_error "cat-1" "1"
test -x $CP || mensaje_error "cp-1" "1"
test -x $DATE || mensaje_error "date-1" "1"
test -x $GREP || mensaje_error "grep-1" "1"
test -x $GZIP || mensaje_error "gzip-1" "1"
test -x $LS || mensaje_error "ls-1" "1"
test -x $MV || mensaje_error "mv-1" "1"
test -x $PING || mensaje_error "ping-1" "1"
test -x $SED || mensaje_error "sed-1" "1"
test -x $ZGREP || mensaje_error "zgrep-1" "1"
test -x $IFCONFIG || mensaje_error "ifconfig-1" "1"
test -x $CLEAR || mensaje_error "clear-1" "1"
test -x $CUT || mensaje_error "cut-1" "1"
test -x $FILE || mensaje_error "file-1" "1"
test -x $FIND || mensaje_error "find-1" "1"
test -x $HEAD || mensaje_error "head-1" "1"
test -x $LESS || mensaje_error "less-1" "1"
test -x $LYNX || mensaje_error "lynx-1" "1"
test -x $NMAP || mensaje_error "nmap-1" "1"
test -x $STAT || mensaje_error "stat-1" "1"
test -x $TAIL || mensaje_error "tail-1" "1"
test -x $TOUCH || mensaje_error "touch-1" "1"
test -x $WC || mensaje_error "wc-1" "1"
################################################
#
# Requisitos para correr el programa:
# 1. No ejecutarse con permisos de root.
# 2. Existir el directorio /home/.
# 3. No haber otro proceso bRAE.sh.
#
################################################
# Primeramente comprobamos que el programa
# no se ejecutará con permisos de superusuario.
# Esto no es Windows ;).
if [[ `id -u` -lt 1000 ]]
then
$ECHO -e "\nNo puede tener permisos de superusuario \
para ejecutar este programa.\n"
exit 1
fi
# Luego comprobamos si existe el directorio $HOME.
DIR_HOME="$HOME"
if [[ ! -d $DIR_HOME ]]
then
$ECHO -e "\nNo existe el directorio $DIR_HOME.\n"
exit 0
fi
# Nos cercioramos de que no se esté ejecutando
# un proceso "bRAE.sh". Para ello creamos un
# rudimentario fichero de bloqueo
# ($HOME/.brae.lock).
if [[ -s $BLOQUEO ]]
then
$ECHO -e "\nTiene otro proceso \"bRAE.sh\" en memoria.\n"
exit 1
else
$ECHO "1" > $BLOQUEO
fi
################################################
#
# Funciones para escribir menos y ocupar menos
# espacio ;-).
#
################################################
buscar_borrar_ficheros() {
# Para determinar cuáles ficheros no contienen definiciones
# medimos su extensión (100 b), constatamos la existencia
# -o no- de dos cadenas de texto especiales y, por último,
# comprobamos el tipo de fichero (si es comprimido o no).
# Síntesis: comprobamos tamaño (stat), contenido (zgrep)
# y formato (file).
B_FICHERO=$1
B_OPCION=$2
nom_fichero=`$ECHO $B_FICHERO | $CUT -c 6- | $CUT -f2 -dE | $CUT -c 2-
| $CUT -f1 -d.`
if [[ `$STAT -c %s $B_FICHERO` -le 100 || -n `$ZGREP 'La palabra
'\"$nom_fichero\"' \
no está en el Diccionario.' $B_FICHERO` || -n `$ZGREP 'The requested URL could
not be retrieved' $B_FICHERO` \
|| -z `$FILE -b $B_FICHERO | $GREP -s 'gzip compressed data'` ]]
then
case "$B_OPCION" in
"0")
let numero=numero+1
$ECHO -e "\nBorrando ficheros vacíos... $B_FICHERO
[$numero]\n"
$RM -f $B_FICHERO || mensaje_error "rm-1" "3"
;;
"1")
let numero=numero+1
$ECHO -e "\nMostrando ficheros vacíos... $B_FICHERO
[$numero]\n"
;;
esac
fi
}
crear_listado_palabras() {
C_FICHERO=$1
# Comprobamos la entrada para fichero.
if [[ ! -f $C_FICHERO ]]
then
# ¿Existe el fichero?
$ECHO -e "\nFichero \"$C_FICHERO\" no existe.\n"
$RM -f $BLOQUEO || mensaje_error "rm-2" "3"
exit 1
elif [[ ! `$FILE -b $C_FICHERO | $GREP -s 'text'` ]]
then
# ¿Es un fichero de texto?
$ECHO -e "\nNo es un fichero de texto.\n"
$RM -f $BLOQUEO
exit 1
else
# Ok.
# Si se trata de un fichero html efectuamos un
# volcado de la salida del navegador, para evitar
# copiar las etiquetas del lenguaje html para
# caracteres especiales (acute, tilde, etc.).
if [[ `$FILE -b $C_FICHERO | $GREP -s 'HTML'` || `$FILE -b $C_FICHERO |
$GREP -s 'SGML'` ]]
then
$LYNX -dump -nolist $C_FICHERO > $FICHEROTEMP2 || mensaje_error
"lynx-2" "3"
# Suprimimos las líneas en blanco.
$SED /^$/d $FICHEROTEMP2 > $FICHEROTEMP1 || mensaje_error
"sed-2" "3"
else
$SED /^$/d $C_FICHERO > $FICHEROTEMP1 || mensaje_error "sed-3"
"3"
fi
$ECHO -e "\nCreando listado de palabras a buscar...\n"
fi
# Reemplazamos caracteres especiales por espacios en blanco.
for caracterespecial in $CARESPECIALESBORRAR
do
$SED s/$caracterespecial/\ /g $FICHEROTEMP1 > $FICHEROTEMP2 ||
mensaje_error "sed-4" "3"
$CP $FICHEROTEMP2 $FICHEROTEMP1 || mensaje_error "cp-2" "3"
done
# Reemplazamos letras mayúsculas por sus correspondientes minúsculas.
let letra=0
for caractermayuscula in $MAYUSCULASBORRAR
do
$SED s/$caractermayuscula/${MINUSCULAS[letra++]}/g $FICHEROTEMP1 >
$FICHEROTEMP2 || mensaje_error "sed-5" "3"
$CP $FICHEROTEMP2 $FICHEROTEMP1 || mensaje_error "cp-3" "3"
done
# Creamos el fichero "palabrasRAE.txt".
$CP $FICHEROTEMP1 $FICHEROPALABRAS || mensaje_error "cp-4" "3"
# Borramos los ficheros temporales.
$RM -f $FICHEROTEMP1 $FICHEROTEMP2 || mensaje_error "rm-3" "3"
}
# Los nombres de las funciones explican lo que hace
# cada una de ellas. ¿O no?
comprobar_fichero() {
if [[ -s $FICHEROPALABRAS ]]
then
palabras=`$CAT $FICHEROPALABRAS`
else
$ECHO -e "\nNo existe fichero de palabras a buscar, o está
vacío.\n"
$RM -f $BLOQUEO || mensaje_error "rm-4" "3"
exit 0
fi
}
comprobar_fichero_2() {
CO_FICHERO=$1
if [[ ! -f $CO_FICHERO ]]
then
$TOUCH $CO_FICHERO || mensaje_error "touch-2" "3"
fi
}
comprobar_directorio() {
if [[ ! -d $BD ]]
then
mkdir $BD || mensaje_error "mkdir" "3"
fi
}
comprobar_entradas() {
# Comprobamos si los caracteres introducidos son
# válidos. No aceptamos mayúsculas ni dígitos
# ni caracteres especiales.
COM_ENTRADA=$1
COM_PATRON=$2
COM_OPCION=$3
case "$COM_OPCION" in
"0")
comando="$CAT"
;;
"1")
comando="echo"
;;
esac
if [[ `$comando $COM_ENTRADA | $GREP [[:upper:]]` \
|| `$comando $COM_ENTRADA | $GREP [[:digit:]]` \
|| `$comando $COM_ENTRADA | $GREP -e $COM_PATRON` \
|| (! -e $COM_ENTRADA && `$comando $COM_ENTRADA | $WC -m` -gt $TAMPALABRA) ]]
then
$ECHO -e "\nIntroduzca una cadena válida. Debe estar compuesta
sólo\n\
de letras minúsculas y tener menos de $TAMPALABRA caracteres.\n"
$RM -f $BLOQUEO || mensaje_error "rm-5" "3"
exit 0
fi
# Comprobamos la longitud de las palabras del fichero,
# pues en el anterior if no lo habíamos hecho.
if [[ $COM_ENTRADA = $FICHEROPALABRAS ]]
then
for palabra_fichero in `$comando $COM_ENTRADA`
do
if [[ `$ECHO $palabra_fichero | $WC -m` -gt $TAMPALABRA
]]
then
$ECHO -e "\nPalabra demasiado larga.\n"
$RM -f $BLOQUEO || mensaje_error "rm-6" "3"
exit 1
fi
done
fi
}
comprobar_conexion() {
# Usamos triple comprobación por si es el caso
# de una máquina parte de una LAN con IP MASQUERADE
# y con un cortafuegos que filtra el puerto 7.
# Es preciso tener nmap instalado :-(.
#
# 1. ifconfig,
# 2. ping,
# 3. nmap.
COMP_OPCION=$1
if [[ -z `$IFCONFIG $DISPOSITIVO 2> /dev/null | $GREP 'inet addr:' |
$CUT -f2 -d: | $CUT -f1 -dP` ]]
then
if [[ -z `$PING -c 1 $SERVIDOR 2> /dev/null | $GREP 'from' |
$CUT -f2 -dm | $CUT -f1 -d:` ]]
then
if [[ `$NMAP -sP buscon.rae.es 2> /dev/null | $GREP
'Nmap run completed' | $CUT -c 23` == 0 ]]
then
case "$COMP_OPCION" in
"0")
# Opción sólo usada con el parámetro "-a".
$ECHO -e "\nNo existe conexión a
Internet.\n"
$RM -f $BLOQUEO || mensaje_error "rm-7"
"3"
exit 0
;;
"1")
conexion=0
;;
esac
fi
fi
fi
}
buscar_definicion() {
# Buscamos la definición del término y el
# resultado de la búsqueda lo convertimos
# en texto plano y lo guardamos en una
# variable. Comprobamos su contenido. Si
# es una definición válida lo guardamos
# en un fichero comprimido en el directorio
# $HOME/DRAE/.
B_TERMINO=$1
B_NUMERO=$2
B_OPCION=$3
$ECHO -e "\nBuscando definición de «$B_TERMINO»... $B_NUMERO"
def_temp=`$LYNX -dump -nolist ${URL}${B_TERMINO}` || mensaje_error
"lynx-3" "3"
if [[ -z `$ECHO "$def_temp" | $GREP -Fs "$PIEARTICULO"` ]]
then
$ECHO -e "\n$NOARTICULO\n"
case $B_OPCION in
"0")
$RM -f $BLOQUEO || mensaje_error "rm-8" "3"
exit 0
;;
"1")
# !El poder de sed!... y el enorme consumo de ciclos de reloj para
# hacer una "virguería" en un ficherito. :->
# Este es un HACK, y de los peores.
$SED s/$B_TERMINO//g $FICHEROPALABRAS >
$FICHEROPALABRASTMP || mensaje_error "sed-6" "3"
$SED '/^$/d' $FICHEROPALABRASTMP > $FICHEROPALABRAS ||
mensaje_error "sed-7" "3"
$RM -f $FICHEROPALABRASTMP || mensaje_error "rm-9" "3"
let fallos=fallos+1
return
;;
esac
fi
# Última comprobación: nos cercioramos de que el nombre
# del artículo buscado se corresponda con su definición.
# A veces (poquísimas), con el parámetro "-a", el servidor
# de la RAE devuelve alguna "incoherencia".
if [[ -n `$ECHO "$def_temp" | $HEAD -7 | $TAIL -2 | $GREP -s
"$B_TERMINO"` ]]
then
# Guardamos la definición encontrada en un fichero temporal.
$ECHO "$def_temp" > $FICHERODEFTEMP1
# Le quitamos al texto de la definición la cabecera de la RAE.
$SED s/"$CABECERAARTICULO"// $FICHERODEFTEMP1 >
$FICHERODEFTEMP2 || mensaje_error "sed-8" "3"
# Le quitamos al texto de la definición las líneas en blanco.
$SED /^$/d $FICHERODEFTEMP2 > ${BD}${B_TERMINO} ||
mensaje_error "sed-9" "3"
# Guardamos la definición en un fichero comprimido, en su
directorio.
$GZIP -9 -f ${BD}${B_TERMINO} || mensaje_error "gzip-2" "3"
# Borramos los dos ficheros temporales que habíamos creado.
$RM -f $FICHERODEFTEMP1 || mensaje_error "rm-10" "3"
$RM -f $FICHERODEFTEMP2 || mensaje_error "rm-11" "3"
else
$ECHO -e "\nError en el servidor de la RAE: `$ECHO "$def_temp" \
| $HEAD -2 | $SED /^$/d` != $B_TERMINO.\n"
$RM -f $BLOQUEO || mensaje_error "rm-12" "3"
exit 1
fi
}
################################################
#
# Comienza el programa... o las opciones.
#
################################################
$CAT << EOF
$PROGRAMA
EOF
if [[ ! $# -ge 1 ]]
then
$ECHO -e "\nIntroduzca un vocablo. O use el parámetro -m.\n"
$RM -f $BLOQUEO || mensaje_error "rm-13" "3"
exit 0
################################################
#
# Buscamos la definición de una serie de
# palabras que se encuentran en un fichero
# ($HOME/palabrasRAE.txt).
# Tenemos la opción de ver o no la definición de
# cada una de ellas mediante el parámetro [-t].
#
################################################
elif [[ $1 = "-a" ]]
then
# Averiguamos si estamos conectados a Internet.
comprobar_conexion "0"
# Comprobamos la existencia del fichero de palabras
# y, si existe, pasamos su contenido a la variable
# $palabras.
comprobar_fichero
# Probamos la validez de los caracteres introducidos.
comprobar_entradas "$FICHEROPALABRAS" "$CARESPECIALES" "0"
# Buscamos las palabras, primero en nuestro disco duro.
# Si no se encuentran aquí, buscamos en el servidor de la RAE.
let numero=0
for termino in $palabras
do
if [[ -s ${BD}${termino}.gz ]]
then
case "$2" in
"")
$ECHO -e "\nCaché...\n"
;;
"-t")
$LESS -sSC -~ ${BD}${termino}.gz ||
mensaje_error "less-2" "3"
;;
*)
mensaje_error "-t" "2"
;;
esac
else
comprobar_directorio
let numero=numero+1
case "$2" in
"")
buscar_definicion "$termino" "$numero" "1"
;;
"-t")
buscar_definicion "$termino" "$numero" "1"
$LESS -sSC -~ ${BD}${termino}.gz ||
mensaje_error "less-3" "3"
;;
*)
mensaje_error "-t" "2"
;;
esac
fi
done
let cero=0
resultado=${fallos:=$cero}
encontradas=`expr $numero - $resultado` # Variable $fallos viene de
función
$CLEAR # buscar_definición().
$ECHO -e "\n$numero palabras buscadas en el servidor.\n
$encontradas definiciones halladas.\n
$resultado no encontradas.\n"
# Creamos o actualizamos el listado de palabras
# que tenemos en el directorio $HOME/DRAE.
cd $BD
$LS -1 | $GREP -s '.gz' | $CUT -d '.' -f 1 > $PALABRAS || mensaje_error
"ls-2" "3"
cd
################################################
#
# Buscamos la definición de una palabras que
# ya se encuentra en nuestro directorio, y la
# sobrescribimos. Sirve para actualizar.
#
################################################
elif [[ $1 = "-r" ]]
then
if [[ -z $2 ]]
then
$ECHO -e "\nIntroduzca la palabra que desea actualizar.\n"
$RM -f $BLOQUEO || mensaje_error "rm-14" "3"
exit 0
fi
comprobar_entradas "$2" "$CARESPECIALES" "1"
# Comprobamos si estamos conectados a Internet.
# El resultado lo alojamos en la variable $conexion.
comprobar_conexion "1"
if [[ -s ${BD}${2}.gz ]]
then
if [[ $conexion = "0" ]]
then
$ECHO -e "\nNo existe conexión a Internet.\n"
$RM -f $BLOQUEO || mensaje_error "rm-15" "3"
exit 0
else
comprobar_directorio
buscar_definicion "$2" "(actualización)" "0"
$LESS -sSC -~ ${BD}${2}.gz || mensaje_error "less-4" "3"
$CLEAR
fi
else
$ECHO -e "\nLa palabra que intenta actualizar («$2») no está en
su directorio.\n"
$RM -f $BLOQUEO || mensaje_error "rm-16" "3"
exit 0
fi
################################################
#
# Creamos el fichero de palabras a buscar a
# partir de cualquier fichero de texto.
#
################################################
elif [[ $1 = "-f" ]]
then
crear_listado_palabras "$2"
################################################
#
# Borramos los archivos generados por búsquedas
# fallidas.
#
# - Con el parámetro [-b] sin nada más, buscamos
# y borramos todos los ficheros comprimidos
# (*.gz).
# - Con el parámetro opcional [-t] buscamos
# todos los ficheros vacíos, y los borramos.
# - Con el parámetro opcional [-h] buscamos y
# borramos los ficheros comprimidos de hoy.
# - Con el parámetro opcional [-th] borramos
# todos los ficheros (comprimidos o no) de hoy.
#
# Las opciones [-b] y [-b -t] pueden llegar a
# ser extremadamente lentas.
#
################################################
elif [[ $1 = "-b" ]]
then
$ECHO -e "\nBuscando ficheros vacíos..."
for ficheros in ${BD}*
do
case "$2" in
"")
if [[ `$FIND $ficheros -daystart -name '*.gz' -print` ]]
then
buscar_borrar_ficheros "$ficheros" "0"
fi
;;
-t)
buscar_borrar_ficheros "$ficheros" "0"
;;
-h)
if [[ `$FIND $ficheros -daystart -name '*.gz' -ctime -1
-print` ]]
then
buscar_borrar_ficheros "$ficheros" "0"
fi
;;
-th)
if [[ `$FIND $ficheros -daystart -name '*' -ctime -1
-print` ]]
then
buscar_borrar_ficheros "$ficheros" "0"
fi
;;
*)
mensaje_error "-t, -h, o -th" "2"
;;
esac
done
if [[ $numero -gt 0 ]]
then
$CLEAR
$ECHO -e "\n$numero entradas borradas."
$RM -f $BLOQUEO || mensaje_error "rm-17" "3"
exit 0
else
$ECHO -e "\nNo encontré ficheros para borrar. I'sorry... :-)\n"
$RM -f $BLOQUEO || mensaje_error "rm-18" "3"
exit 0
fi
################################################
#
# Buscamos los archivos generados por búsquedas
# fallidas. Igual que con el parámetro [-b] pero
# sin borrar nada.
#
# - Con el parámetro [-v] sin nada más, buscamos
# todos los ficheros comprimidos (*.gz).
# - Con el parámetro opcional [-t] buscamos la
# totalidad de los ficheros vacíos.
# - Con el parámetro opcional [-h] buscamos sólo
# los ficheros comprimidos (*.gz) de hoy.
# - Con el parámetro opcional [-th] buscamos la
# totalidad de los ficheros vacíos de hoy.
#
# Las opciones [-v] y [-v -t] pueden llegar a
# ser extremadamente lentas.
#
# Opción para curiosos 8-).
#
################################################
elif [[ $1 = "-v" ]]
then
$ECHO -e "\nBuscando ficheros vacíos..."
for ficheros in ${BD}*
do
case "$2" in
"")
if [[ `$FIND $ficheros -daystart -name '*.gz' -print` ]]
then
buscar_borrar_ficheros "$ficheros" "1"
fi
;;
-t)
buscar_borrar_ficheros "$ficheros" "1"
;;
-h)
if [[ `$FIND $ficheros -daystart -name '*.gz' -ctime -1
-print` ]]
then
buscar_borrar_ficheros "$ficheros" "1"
fi
;;
-th)
if [[ `$FIND $ficheros -daystart -name '*' -ctime -1
-print` ]]
then
buscar_borrar_ficheros "$ficheros" "1"
fi
;;
*)
mensaje_error "-t, -h, o -th" "2"
;;
esac
done
if [[ $numero -gt 0 ]]
then
$CLEAR
$ECHO -e "\nEncontré $numero ficheros vacíos. ¿Muchos?\n"
$RM -f $BLOQUEO || mensaje_error "rm-19" "3"
exit 0
else
$ECHO -e "\nNo encontré ficheros vacíos. I'sorry... :-)\n"
$RM -f $BLOQUEO || mensaje_error "rm-20" "3"
exit 0
fi
################################################
#
# Opción para mostrarnos el número total de
# entradas en el directorio del diccionario.
#
# - Con el parámetro [-n] sin nada más, nos
# muestra la totalidad de entradas comprimidas
# (*.gz).
# - Con el parámetro opcional [-t] nos muestra
# el número total de entradas.
# - Con el parámetro opcional [-h] nos muestra
# el número de ficheros comprimidos de hoy.
# - Con el parámetro opcional [-th] nos muestra
# el número total de ficheros de hoy.
#
# Otra opción para curiosos.
#
################################################
elif [[ $1 = "-n" ]]
then
case "$2" in
"")
cantidad=`$FIND $BD -mindepth 1 -name '*.gz' -print | $WC -l`
$ECHO -e "\nHay $cantidad palabras en el diccionario.\n"
;;
-t)
cantidad_total=`$FIND $BD -mindepth 1 -name '*' -print | $WC -l`
$ECHO -e "\nHay $cantidad_total palabras en el diccionario
(total).\n"
;;
-h)
fecha=`$DATE +%d-%m-%y`
cantidad_hoy=`$FIND $BD -mindepth 1 -daystart -name '*.gz'
-ctime -1 -print | $WC -l`
$ECHO -e "\nHay $cantidad_hoy palabras en el diccionario (hoy:
$fecha).\n"
;;
-th)
fecha=`$DATE +%d-%m-%y`
cantidad_total_hoy=`$FIND $BD -mindepth 1 -daystart -name '*'
-ctime -1 -print | $WC -l`
$ECHO -e "\nHay $cantidad_total_hoy palabras en el diccionario
(total hoy: $fecha).\n"
;;
*)
mensaje_error "-t, -h, o -th" "2"
;;
esac
################################################
#
# Limpiamos el archivo $HOME/palabrasRAE.txt.
# Sólo dejamos las palabras cuya definición aún
# debemos hallar.
#
################################################
elif [[ $1 = "-l" ]]
then
# Pasamos el contenido del fichero a la
# variable $palabras
comprobar_fichero
comprobar_fichero_2 "$FICHEROPALABRASTMP"
let numero=0
for termino in $palabras
do
if [[ ! -s ${BD}${termino}.gz ]]
then
$ECHO -e $termino >> $FICHEROPALABRASTMP
let numero=numero+1
fi
done
$MV $FICHEROPALABRASTMP $FICHEROPALABRAS || mensaje_error "mv-2" "3"
$ECHO -e "\n$numero palabras guardadas.\n"
################################################
#
# Menú para no olvidarnos del uso para el cual
# fue hecho este script :-).
#
################################################
elif [[ $1 = "-m" ]]
then
espacio=`$ECHO -e "\t\t"`
declare -a MENU
MENU=(
"Busca definiciones en el DRAE \"on line\"."
"Versión: 0.04"
"Autor: Miguel Angel Rodríguez"
""
"-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"
"Licencia: Este programa es software libre. Vea el código
fuente"
"para las condiciones de copia. No hay NINGUNA GARANTÍA;"
"ni siquiera la que implique garantía de COMERCIABILIDAD"
"o IDONEIDAD PARA UN FIN DETERMINADO."
"-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"
""
"Modo de uso:"
"----------- bRAE.sh [PALABRA] busca definición de [PALABRA]."
""
"[-r] [palabra] -> busca definiciones ya encontradas y las
sobrescribe."
"[-a] -----------> busca definiciones de palabras desde un
fichero especial."
"[-a] [-t] ------> ídem anterior pero mostrando cada una de las
definiciones."
"[-f] [FICHERO] -> crea fichero especial a partir de un fichero
cualquiera."
""
"[-b] -----------> busca y borra las entradas vacías con
extensión <*.gz>."
"[-b] [-t] ------> busca y borra todas las entradas vacías."
"[-b] [-h] ------> busca y borra las entradas vacías con
extensión <*.gz> de hoy."
"[-b] [-th] -----> busca y borra todas las entradas vacías de
hoy."
""
"[-v] -----------> busca los ficheros vacíos con extensión
<*.gz>."
"[-v] [-t] ------> busca todos los ficheros vacíos."
"[-v] [-h] ------> busca los ficheros vacíos con extensión
<*.gz> de hoy."
"[-v] [-th] -----> busca todos los ficheros vacíos de hoy."
""
"[-n] -----------> muestra cantidad de ficheros con extensión
<*.gz>."
"[-n] [-t] ------> muestra total de ficheros."
"[-n] [-h] ------> muestra la cantidad de ficheros con
extensión <*.gz> de hoy."
"[-n] [-th] -----> muestra el total de ficheros de hoy."
""
"[-l] -----------> limpia el fichero de palabras encontradas."
""
"[-m] -----------> este menú."
""
"Comunicar bugs y modificaciones a <[EMAIL PROTECTED]>."
""
)
let numero=0
while [ $numero -lt 40 ]
do
$ECHO ${MENU[numero++]}
done
################################################
#
# Buscamos la definición de una palabra mediante
# una consulta al servidor de la RAE.
#
################################################
else
comprobar_entradas "$1" "$CARESPECIALES" "1"
# Comprobamos si estamos conectados a Internet.
# El resultado lo alojamos en la variable $conexion.
comprobar_conexion "1"
if [[ -s ${BD}${1}.gz ]]
then
$ECHO -e "\nCaché...\n"
$LESS -sSC -~ ${BD}${1}.gz || mensaje_error "less-5" "3"
elif [[ $conexion = "0" ]]
then
$ECHO -e "\nNo existe conexión a Internet.\n"
comprobar_fichero_2 "$FICHEROPALABRAS"
if [[ ! `$GREP -w $1 $FICHEROPALABRAS` ]]
then
$ECHO -e "Palabra guardada para su posterior
búsqueda.\n"
$ECHO "$1" >> $FICHEROPALABRAS
else
$ECHO -e "Esta palabra ya fue guardada para su
posterior búsqueda.\n"
fi
$RM -f $BLOQUEO || mensaje_error "rm-21" "3"
exit 0
else
comprobar_directorio
buscar_definicion "$1" "" "0"
$LESS -sSC -~ ${BD}${1}.gz || mensaje_error "less-6" "3"
$CLEAR
fi
fi
# Salida del programa.
if [[ $? = 0 ]]
then
$ECHO "."
$RM -f $BLOQUEO || mensaje_error "rm-22" "3"
exit 0
else
$ECHO -e "\n ${PROGRAMA}: El programa terminó con error.\n"
$RM -f $BLOQUEO || mensaje_error "rm-23" "3"
exit 1
fi
# -=-= fin de bRAE.sh =-=-
# Para escribir este shellscript se usó
# VIM - Vi IMproved 7.0 (2006 May 7, compiled Oct 10 2006 00:48:23)
############################################################################
--
Miguel Ángel Rodríguez
mailto:[EMAIL PROTECTED]
http://www.cefeidas.homelinux.org
Linux User Registered #65964
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Para obtener mi clave pública escríbeme un email
con el Subject: enviar clave publica
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
The effort to understand the universe is one of the very few things
that lifts human life a little above the level of farce, and gives
it some of the grace of tragedy.
(Steven Weinberg, The First Three Minutes)
--
To UNSUBSCRIBE, email to [EMAIL PROTECTED]
with a subject of "unsubscribe". Trouble? Contact [EMAIL PROTECTED]
