• C
    User •

    Generatore programmi - Progetto ambiente sviluppo software programmazione assistita

    Scopo del progetto e' realizzare un ambiente di sviluppo per la programmazione assistita in ambiente Shell ( testato su UBUNTU 8 ) che consenta di creare in automatico script strutturati, dotati di opportuni permessi e annotazioni, con inserite opportune funzioni standardizzate selezionate da una raccolta, che ognuno di voi potra' contribuire ad ampliare.
    Una prima raccolta la trovate nel file allegato "funzioni.zip" da copiare sulla vostra Scrivania (Desktop) unitamente al seguente file "ZIDE1.sh" attribuendogli come al solito i permessi di esecuzione con il comando da Shell:
    $ sudo chmod +x Scrivania/ZIDE1.sh.

    Per scaricare "funzioni.zip" andare su rapidshare.com/files/160813250/funzioni.zip.html

    La prima volta che si lancia ZIDE1.sh viene creata nella nostra Home la dir principale "programmazione" con le sue subdir "A_NOTE" e "A_FUNZIONI".
    In "programmazione" troveremo la voce per la creazione di "Nuovo_script" e la raccolta dei nostri script su cui potremo effettuare:
    Backup_file
    Eseguo_file
    Edito_file
    Rename_file
    Cancello_file
    In "A_FUNZIONI" troveremo la voce per la creazione di "Nuova_funzione" e la raccolta delle funzioni su cui potremo effettuare:
    Edito_file
    Rename_file
    Cancello_file
    In "A_NOTE" troveremo:
    il messaggio di Copyright
    la copia della GNU GENERAL PUBLIC LICENSE
    l'output di man zenity
    alcune icone
    e dove potremo depositare i nostri appunti di programmazione, le pagine WEB e le immagini di nostro interesse;
    cliccando su uno dei file contenuti in questa dir lo visualizzeremo e/o modificheremo tramite il nostro editor oppure lo visualizzeremo direttamente nel nostro Browser.

    Scegliendo creazione di "Nuovo_script" si aprira' una finestra scrollabile con le prime 5 righe di spiegazione di ogni funzione presente in "A_FUNZIONI" in modo da poter scegliere consapevolmente quelle che ci servono dalla lista "Aggiungi Funzioni" che apparira' dopo e sara' creato il nuovo script col nome da noi scelto ( per esempio ultima_prova.sh ) che sara' visualizzato nel nostro editor per la modifica:
    #!/bin/bash

    Script ultima_prova.sh

    creato martedì-04-novembre-2008 da alberto con ZIDE1.sh

    #------------ Descrizione Script------------------

    #------------------variabili globali---------------

    utente="alberto"
    oggi="martedì-04-novembre-2008"
    pass=""
    nome_script="ultima_prova.sh"

    #-----------------------Funzioni-------------------

    #----------------Funzione avviso

    chiamare con "testo messaggio" da

    visualizzare in una finestra a video

    scritta domenica-02-novembre-2008 da xymaster

    .... tutte le altre funzioni scelte

    main () {
    #Funzione principale
    exit
    }
    #--------------Start--------------

    main

    Scegliendo creazione di "Nuova_funzione" sara' creata la nuova funzione col nome da noi scelto (per es. prova) che sara' visualizzato nel nostro editor per la modifica:
    #---------- Funzione prova

    inserire descrizione funzione, parametri

    scritta martedì-04-novembre-2008 da alberto

    function prova () {

    }

    Alla chiusura, ZIDE1.sh chiedera' se si vuole effettuare un backup sincronizzato del nostro ambiente di sviluppo.

    Sperando di non avervi annoiato con questa lunga, ma non esaustiva spiegazione, resto in attesa di vostri commenti e contributi e passo al codice di ZIDE1.sh

    
#!/bin/bash

#"--------variabili globali--------
lista=""
pass=""
editor=""
new_script=""
utente=$(whoami)
oggi="`date +%A-%d-%B-%Y`"
if [ "$utente" = "root" ];then
clear
nome_script="`basename $0`"
echo "Rilanciare $0 come utente normale e non come 'root'. Battere un tasto"
read
exit
fi 
flag_doc_funzioni=true #se true visualizza documentazione Funzioni
#definiamo directory dei nostri script e la sub-directory per i nostri appunti 
#per la dir principale scegliamo 
my_dir="programmazione" la subdir scegliamo A_NOTE
my_subdir="A_NOTE" la il contenitore delle nostre funzioni scegliamo la directory A_FUNZIONI
my_function="A_FUNZIONI" directory di backup
my_backup="_bckup"

#------------Funzioni------------
function avviso () {
#chiamare con testo messaggio
    zenity --info --window-icon="$my_subdir/Italy.png" --text="$1"
}
function crea_dir () { con pathname directory da creare
        mkdir $1>|/tmp/prv.$$ 2>&1
        gest_err "Creazione $1"
        chmod -R 755 $1
        chown $utente:$utente $1
}
function crea_file () { con pathname file da creare
        touch "$1"
        chmod 755 "$1"
        chown $utente:$utente $1
}
function data_modifica () {
#restituisce nella variabile interna $REPLY nome script, data ed ora sua ultima modifica
nome_script="`basename $0`"
stat $0 | grep Modify | cut -f2 -d" " > /tmp/prv.data
ora=`stat $0 | grep Modify | cut -f3 -d" " | cut -c-8`
gg=`cat /tmp/prv.data | cut -c9-10`
mm=`cat /tmp/prv.data | cut -c6-7`
aaaa=`cat /tmp/prv.data | cut -c1-4`
rm -f /tmp/prv.data
REPLY=$(echo "Script $nome_script\nUltima modifica $gg/$mm/$aaaa $ora\n")
}
function get_password () {
pass=`zenity --entry --hide-text --text="immetti la password di $utente:"`
#azzera il timestamp di sudo (quello che vi consente di non digitare la password se ripetete sudo entro tot tempo)
sudo -k
#cancella completamente il timestamp
sudo -K
echo "$pass" | sudo -S ls > /dev/null
if [ $? != 0 ];then
    avviso "Password errata. Termino lo script"
    exit
fi
}
my_help () {
#selezioniamo l'editor da usare a seconda che si tratti di una Kubuntu o di una Ubuntu    
editor=`which kedit` || editor=`which gedit` 
my_dir="/home/$utente/$my_dir"
my_subdir="$my_dir/$my_subdir"
my_backup="$my_dir$my_backup"
my_function="$my_dir/$my_function"

data_modifica
msg_licenza=`cat $my_subdir/copyright`
msg_help="$REPLY\n $msg_licenza"

if domanda "$msg_help";then
    zenity --text-info --title="Licenza GNU" --height=400 --width=600 --filename $my_subdir/licenza.txt
fi
#utente=$(pwd | cut -f3 -d'/')
clear
get_password
    if test ! -e $my_dir ;then 
        crea_dir "$my_dir"
    fi
    if test ! -e $my_subdir ;then 
        crea_dir "$my_subdir"
        man zenity > $my_subdir/Man_Zenity
    fi
    if test ! -e $my_function ;then 
        crea_dir "$my_function"
        cd $my_function
        unzip /home/$utente/Scrivania/funzioni.zip 
        mv *.png $my_subdir/
        mv copyright $my_subdir/
        mv licenza.txt $my_subdir/
        cd
    fi
    
}
gest_err (){ con nome operazione da controllare 
#esempio: gest_err "Cancellazione" restituisce Cancellazione OK opppure elenco di errori in nuova finestra
if [ $? != 0 ]
then 
gdialog --title "Visualizza Errori" --textbox /tmp/prv.$$ 22 72
elif [ $# = 1 ];then
        avviso "$1 OK"
fi
rm -rf /tmp/prv.$$ 2> /dev/null
}

domanda () { con testo domanda finestra con testo domanda con bottoni Ok per rispondere si o annulla per rifiutare
    zenity --question --text "$1"
    return $?
}
rename_file () {
# chiamare con pathname completo del file da rinominare
# chiede nuovo nome e restituisce messaggio risultato operazione
local dir_file="$(dirname "$1")"
local old_name="$(basename "$1")"
local new_name=""
if new_name=`zenity --entry --width=300 --title="Rename file" --text="Inserisci il nome del nuovo file" --entry-text="$old_name"`;then
##accetta solo caratteri alfanumerici _ - e .i nel nome file.Cambia gli altri con carattere _
new_name=`echo "$new_name" | sed "s/[^a-zA-Z0-9_-.]/_/g"`
    if [ -e "$dir_file/$new_name" ];then
        avviso "Il nome richiesto, \"$new_name\" e\` gia\` assegnato a un documento esistente"
    else
        if mv -f "$1" "$dir_file/$new_name";then
            avviso "$old_name cambiato in $new_name"
        else
            avviso "$old_name NON CAMBIATO!"
        fi
    fi
else
avviso "Errore nella funzione"
fi
}
function backup_dir (){
# effettua backup sincronizzato Directory "$my_dir" in "$my_backup"
# consente installazione rsync e gestisce errori tramite funzione gest_err
sincronizza=`which rsync`
if [ "$sincronizza" = "" ];then
    if domanda "rsync non presente. Vuoi Installarlo ?";then
        echo "$pass" | sudo -S apt-get install rsync >|/tmp/prv.$$ 2>&1
        gest_err "Installazione rsync"
    else
        avviso "Backup $my_dir ANNULLATO!"
        return
    fi
fi
if test ! -e $my_backup ;then 
    crea_dir "$my_backup"
fi
echo "$pass" | sudo -S rsync -av --exclude='*~' --delete --force $my_dir $my_backup>|/tmp/prv.$$ 2>&1
# | zenity --progress percentage=0 --title ?Backup $my_dir in corso?
gest_err "Backup $my_dir"
}
function select_run_file (){ principale
my_help
while true; do
clear
forma_lista "$my_dir"
lista="Nuovo_script $lista"
    if menu=` zenity --title "Selezione Script/directory" --list --column="elenco Script" $lista `;then
        if [ -d "$my_dir/$menu" ];then
            avviso "$menu e' una directory, la apro"
            if [ "$my_dir/$menu" = "$my_function" ];then
                crea_function $my_dir/$menu
            else    
                apri_dir "$my_dir/$menu"
            fi
        else
            if [ -f "$my_dir/$menu" ];then
                if submenu=` zenity --title "Operazioni su file" --list --column="lista opzioni" Backup_file Eseguo_file Edito_file Rename_file Cancello_file`;then
                    case $submenu in
                        Backup_file)cp "$my_dir/$menu" "$my_dir/$menu.bckp">|/tmp/prv.$$ 2>&1;gest_err "Backup";;
                         Eseguo_file)
                         if [ -x "$my_dir/$menu" ];then
                             echo "$pass" | sudo -S $my_dir/$menu>|/tmp/prv.$$ 2>&1;gest_err
                         else
                             avviso "$menu non e' un file seguibile. Lo Edito"
                             $editor $my_dir/$menu>|/tmp/prv.$$ 2>&1;gest_err
                         fi;;
                        Edito_file)$editor $my_dir/$menu>|/tmp/prv.$$ 2>&1;gest_err;;
                        Rename_file)rename_file "$my_dir/$menu";;
                        Cancello_file)
                        if domanda "Vuoi cancellare il file \"$menu\"?";then
                            rm -f "$my_dir/$menu">|/tmp/prv.$$ 2>&1;gest_err "Cancellazione"
                            rm -f "$my_dir/$menu~" 2>&1;gest_err
                        fi;;
                        *)break;;
                    esac
                fi
            elif [ "$menu" = "Nuovo_script" ];then
                    if new_script=`zenity --entry --width=300 --title="Nuovo Script" --text="Inserisci il nome del nuovo script"`;then
                        ##accetta solo caratteri alfanumerici _ - e . nel nome file.Cambia gli altri con carattere _
                        new_script=`echo "$new_script" | sed "s/[^a-zA-Z0-9_-.]/_/g"`
                        if [ -e "$my_dir/$new_script" ];then
                            avviso "Il nome richiesto, \"$new_script\" e\` gia\` assegnato a un documento esistente."
                            continue
                        fi
                        nuovo_script "$my_dir/$new_script"
                    fi
            fi    
        fi
    else
        break
    fi
done
if domanda "Vuoi effettuare il backup sincronizzato di $my_dir?";then
    backup_dir
fi

return 
}

function nuovo_script () { con "$my_dir/$new_script"
rm -f $my_function/*~
forma_lista "$my_function"
#lista="AA_Descrizione_Funzioni $lista"
# echo "${lista[@]}" visualizza tutti gli elementi dell'array elenco
elenco=""
if $flag_doc_funzioni;then
    echo "-----------------Documentazione Funzioni------------------" > /tmp/prv.$$
    for n in `echo "${lista[@]}"`;do
        sed -n -e "1,5p" $my_function/$n >> /tmp/prv.$$
        i=`echo "false $n "`
        if [ "$n" = "avviso" -o "$n" = "domanda" ];then
            continue
        fi
        elenco+=$i
    done
    gdialog --clear --title "Documentazione FUNZIONI" --textbox "/tmp/prv.$$" 50 50
    rm -f /tmp/prv.$$
fi
new_script=`basename $1`
if menu=`zenity --title "Aggiungi Funzioni a $new_script" --list --checklist --multiple --column="clicca " --column="Funzione scelta" --separator " " $elenco`;then
    copyright=false
    echo "-----------------Documentazione Funzioni------------------" > /tmp/prv.$$
    sed -n -e "1,5p" $my_function/avviso >> /tmp/prv.$$
    sed -n -e "1,5p" $my_function/domanda >> /tmp/prv.$$
    for n in `echo "${menu[@]}"`;do
        sed -n -e "1,5p" $my_function/$n >> /tmp/prv.$$
        if [ "$n" = "copyright1" ];then
            copyright=true
        fi
    done
    if domanda "Vuoi procedere con la creazione di $new_script?";then
        crea_file "$1"
        echo "#!/bin/bash" >> $1
        echo -n "#               Script ">> $1 
        echo -n $(basename $new_script)>> $1
        echo -en "\n# creato ">> $1
        echo "$oggi da $utente con ZIDE1.sh">> $1
        echo -e "#------------ Descrizione Script------------------">> $1
        echo -e "#                                                 #">> $1
        echo -e "#                                                 #">> $1
        echo -e "#------------------variabili globali---------------\n">> $1
        echo -e "utente=\"$utente\"">> $1
        echo -e "oggi=\"$oggi\"\npass=\"\"">> $1
        echo -e "nome_script=\"`basename \$new_script`\"\n\n">> $1
        echo -e "#-----------------------Funzioni-------------------\n" >> $1
        cat $my_function/avviso >> $1
        cat $my_function/domanda >> $1
        splash=false
        for n in `echo "${menu[@]}"`;do
            if [ "$n" = "AA_Descrizione_Funzioni" -o "$n" = "avviso" -o "$n" = "domanda" ];then
                continue
            else
                cat $my_function/$n >> $1
            fi    
            if [ "$n" = "splash" ];then
                splash=true
            fi
        done
        if $splash;then
            echo -e "main () {\n#Funzione principale\nsplash\nexit\n}" >> $1
        else
            echo -e "main () {\n#Funzione principale\nexit\n}" >> $1
        fi
        echo -e "#--------------Start--------------\n" >> $1
        if $copyright;then
            echo -e "copyright1\n" >> $1
        fi
        echo -e "main\n" >> $1
        `$editor $my_dir/$new_script` 2> /dev/null
    fi
fi
}
function forma_lista (){
    lista=`ls "$1" | sort -u`
}
function crea_function () {
while true; do
forma_lista "$1"
lista="Nuova_funzione $lista"
clear
if menu=` zenity --title "Selezione FUNZIONI" --list --column="elenco funzioni" $lista `;then
    if [ "$menu" = "Nuova_funzione" ];then
        if new_script=`zenity --entry --width=300 --title="Nuova Funzione" --text="Inserisci il nome della funzione"`;then
        ##accetta solo caratteri alfanumerici _ - e .i nel nome file.Cambia gli altri con carattere _
        new_script=`echo "$new_script" | sed "s/[^a-zA-Z0-9_-.]/_/g"`
            if [ -e "$my_function/$new_script" ];then
                avviso "Il nome richiesto, \"$new_script\" e\` gia\` assegnato a un documento esistente."
                #break
                continue
            fi
        crea_file "$my_function/$new_script"
        echo -e "#---------- Funzione $new_script">> $my_function/$new_script
        echo -e "# inserire descrizione funzione, parametri  #">> $my_function/$new_script
        echo -e "#                                           ">> $my_function/$new_script
        echo -e "#                                           ">> $my_function/$new_script
        echo -e "#                                           ">> $my_function/$new_script
        echo -e "# scritta $oggi da $utente">> $my_function/$new_script
        echo -e "function $new_script () {\n\n}\n" >> $my_function/$new_script
        `$editor $my_function/$new_script` 2> /dev/null
        fi 
    else
        if submenu=` zenity --title "Operazioni su file" --list --column="lista opzioni" Edito_file Rename_file Cancello_file`;then
            case $submenu in
                Edito_file)$editor $1/$menu>|/tmp/prv.$$ 2>&1;gest_err;;
                Rename_file)rename_file "$1/$menu";;
                Cancello_file)
                    if domanda "Vuoi cancellare il file \"$menu\"?";then
                        rm -f "$1/$menu">|/tmp/prv.$$ 2>&1;gest_err "Cancellazione"
                        rm -f "$1/$menu~" 2>&1;gest_err
                    fi;;
                *)break;;
            esac
        fi
    fi
else
break
fi
done
avviso "Rientro alla directory principale"
}
function apri_dir (){
forma_lista "$1"
while true; do
    clear
    if menu=` zenity --title "Selezione file" --list --column="elenco files" $lista `;then
        if [ -d "$1/$menu" ];then
            avviso "$menu e' una directory, la apro"
            apri_dir "$1/$menu"
            break
        fi
        estensione=${menu##*.}
        if [ "$estensione" = "html" -o "$estensione" = "htm" -o "$estensione" = "gif" -o "$estensione" = "png" -o "$estensione" = "jpg" ];then
            x-www-browser "$1/$menu" 2> /dev/null
        else
            `$editor $1/$menu` 2> /dev/null
        fi
    else
        break
    fi
done
avviso "Rientro alla directory principale"
}
#--------------Start--------------
select_run_file
#--------------Stop---------------
    0
Effettua l'accesso per rispondere