Pradėkime nuo pradžių: skriptas, kuris kuria skriptus

 

Kai pradėjau mokytis rašyti bash skriptus, greitai supratau, kad reikia sistemingo metodo. Kaskart kurdamas naują skriptą, turėdavau jį pavadinti, suteikti vykdymo teises, sukurti alias ir atidaryti redaktoriuje. Tai tapo rutina, ir kaip bet kuri rutina, ji prašėsi automatizavimo. Taip gimė mano pirmasis ir, ko gero, svarbiausias skriptas – skriptas, kuris kuria kitus skriptus.

Versija 1: Klasikinis terminalas

Pradėjau nuo klasikinio terminalo varianto. Štai skriptas, pavadintas create_script.sh:

#!/bin/bash
 
# Klausiame vartotojo failo pavadinimo
read -p "Įveskite failo pavadinimą (be .sh plėtinio): " filename
 
# Sukuriame failo kelią
script_path="$HOME/git/${filename}.sh"
 
# Sukuriame failą
touch "$script_path"
 
# Suteikiame vykdymo teises
chmod +x "$script_path"
 
# Sukuriame alias
echo "alias $filename='$script_path'" >> "$HOME/.bash_aliases"
 
# Perskaitome .bash_aliases failą iš naujo
source "$HOME/.bash_aliases"
source "$HOME/.bashrc"
 
# Atidarome failą su nano
nano "$script_path"
source "$HOME/.bash_aliases"

Kaip tai veikia?

1. Skriptas klausia jūsų failo pavadinimo.
2. Sukuria failą $HOME/git/ kataloge (visi mano skriptai ten).
3. Suteikia jam vykdymo teises su chmod +x.
4. Prideda alias į .bash_aliases, kad galėčiau iškviesti skriptą iš bet kur.
5. Iš karto įkelia naują alias su source.
6. Atidaro failą su nano redaktoriumi.

Kaip naudotis?

Suteikite create_script.sh vykdymo teises:
Įsitikinkite, kad $HOME/git/ katalogas egzistuoja.

chmod +x ~/git/create_script.sh

Paleiskite:

~/git/create_script.sh

Įveskite failo pavadinimą ir pradėkite rašyti kodą nano redaktoriuje.

Arba dar geriau, pridėkite jį prie sparčiųjų klavišų su komanda konsole --new-tab --workdir ~ -e bash -c "~/git/create_script.sh; exec bash" (aš naudoju Ctrl+Shift+U)

1. 
   

Patobulinimai

• Leisti pasirinkti redaktorių (vim, emacs, ir t.t.).
• Pridėti parametrą, leidžiantį pasirinkti kitą katalogą, ne tik ~/git/.
• Įtraukti šablonus (pvz., --type=python įterptų Python šabloną).
• Patikrinti, ar pavadinimas jau egzistuoja.

Versija 2: Grafinis vartotojo interfeisas su KDialog

KDE Plasma aplinkoje turime puikių GUI įrankių. Perdariau skriptą naudodamas kdialog:

#!/bin/bash
 
# Funkcija tikrinti, ar pavadinimas tinkamas
validate_filename() {
    if [ -z "$1" ]; then
        kdialog --title "Klaida" --error "Pavadinimas negali būti tuščias."
        return 1
    elif [ -e "$HOME/git/$1.sh" ]; then
        kdialog --title "Klaida" --error "Skriptas $1.sh jau egzistuoja."
        return 1
    elif [[ "$1" =~ [^a-zA-Z0-9_] ]]; then
        kdialog --title "Klaida" --error "Pavadinimas gali turėti tik raides, skaičius ir pabraukimo brūkšnius."
        return 1
    fi
    return 0
}
 
# Klausiame vartotojo failo pavadinimo
while true; do
    filename=$(kdialog --title "Naujas skriptas" --inputbox "Įveskite failo pavadinimą (be .sh plėtinio):")
 
    # Jei vartotojas atšaukė, išeiname
    if [ $? -ne 0 ]; then
        exit 1
    fi
 
    # Tikriname pavadinimą
    if validate_filename "$filename"; then
        break
    fi
done
 
# Pasirenkame katalogą
directory=$(kdialog --title "Katalogo pasirinkimas" --menu "Pasirinkite katalogą:" \
    1 "$HOME/git/" \
    2 "$HOME/bin/" \
    3 "Kitas...")
 
case $directory in
    1) script_dir="$HOME/git/" ;;
    2) 
        script_dir="$HOME/bin/"
        mkdir -p "$script_dir"
        ;;
    3)
        script_dir=$(kdialog --title "Kitas katalogas" --getexistingdirectory "$HOME")
        if [ $? -ne 0 ]; then
            exit 1
        fi
        ;;
esac
 
# Sukuriame failo kelią
script_path="${script_dir}/${filename}.sh"
 
# Sukuriame failą ir suteikiame teises
touch "$script_path"
chmod +x "$script_path"
 
# Pasirenkame šabloną
template=$(kdialog --title "Šablono pasirinkimas" --radiolist "Pasirinkite šabloną:" \
    1 "Tuščias" on \
    2 "Bash" off \
    3 "Python" off \
    4 "Node.js" off)
 
case $template in
    2) echo '#!/bin/bash
 
# Pavadinimas: '"$filename"'
# Autorius: '"$USER"'
# Data: '"$(date +%Y-%m-%d)"'
# Aprašymas: 
 
# Kintamieji
 
# Funkcijos
 
# Pagrindinė programa
 
' > "$script_path" ;;
    3) echo '#!/usr/bin/env python3
 
"""
Pavadinimas: '"$filename"'
Autorius: '"$USER"'
Data: '"$(date +%Y-%m-%d)"'
Aprašymas: 
"""
 
# Importai
 
# Funkcijos
 
# Pagrindinė programa
if __name__ == "__main__":
    pass
' > "$script_path" ;;
    4) echo '#!/usr/bin/env node
 
/**
 * Pavadinimas: '"$filename"'
 * Autorius: '"$USER"'
 * Data: '"$(date +%Y-%m-%d)"'
 * Aprašymas: 
 */
 
// Importai
 
// Funkcijos
 
// Pagrindinė programa
 
' > "$script_path" ;;
esac
 
# Klausiame, ar pridėti į PATH
if kdialog --title "Pridėti į PATH" --yesno "Ar pridėti '$script_dir' į PATH?"; then
    if ! grep -q "$script_dir" "$HOME/.bashrc"; then
        echo 'export PATH="'"$script_dir"':$PATH"' >> "$HOME/.bashrc"
        source "$HOME/.bashrc"
        kdialog --passivepopup "Katalogas pridėtas į PATH" 3
    else
        kdialog --passivepopup "Katalogas jau yra PATH" 3
    fi
fi
 
# Klausiame, ar sukurti alias
if kdialog --title "Sukurti alias" --yesno "Ar sukurti alias '$filename'?"; then
    echo "alias $filename='$script_path'" >> "$HOME/.bash_aliases"
    source "$HOME/.bash_aliases"
    kdialog --passivepopup "Alias '$filename' sukurtas" 3
fi
 
# Rodome sėkmės pranešimą
kdialog --title "Sėkmė" --msgbox "Sukurtas skriptas: $script_path"
 
# Atidarome failą su kate
kate "$script_path"

Kaip tai veikia?

1. Naudoja kdialog --inputbox, kad paprašytų failo pavadinimo grafinėje sąsajoje.
2. Sukuria failą ir suteikia teises, kaip ir anksčiau.
3. Prideda alias į .bash_aliases.
4. Rodo sėkmės pranešimą su kdialog --msgbox.
5. Atidaro failą su kate, KDE teksto redaktoriumi.

Kaip naudotis?

1. Įsitikinkite, kad įdiegtas kdialog:

sudo apt-get install kdialog

Paleiskite skriptą:

~/git/create_script.sh

Arba dar geriau, pridėkite jį prie sparčiųjų klavišų (aš naudoju Ctrl+Shift+I). Įveskite pavadinimą grafinėje sąsajoje ir pradėkite koduoti kate redaktoriuje.

Patobulinimai

1. Pavadinimo validavimas:
   • Sukūriau funkciją validate_filename, kuri tikrina:
     • Ar pavadinimas ne tuščias.
     • Ar toks skriptas jau neegzistuoja.
     • Ar pavadinime yra tik leistini simboliai (raidės, skaičiai, pabraukimo brūkšniai).
   • Jei pavadinimas netinkamas, rodomas klaidos pranešimas.
2. Katalogo pasirinkimas:
   • Leidžiama pasirinkti iš populiarių katalogų (~/git/, ~/bin/) arba bet kurio kito.
   • Jei pasirenkamas ~/bin/, katalogas sukuriamas, jei jo nėra.
3. Šablonai:
   • Galima pasirinkti iš kelių šablonų: tuščio, Bash, Python, Node.js.
   • Šablonai turi komentarus su autoriaus, datos ir aprašymo laukais.
   • Python ir Node.js šablonai turi tinkamus shebang ir bazinę struktūrą.
4. PATH ir alias parinktys:
   • Klausiama, ar pridėti katalogą į PATH. Jei taip, eilutė pridedama į .bashrc.
   • Klausiama, ar sukurti alias. Jei taip, pridedama į .bash_aliases.
   • Naudojami passivepopup pranešimai, kad parodytų, jog veiksmas atliktas.
5. Geresnis klaidų apdorojimas:
   • Jei vartotojas atšaukia bet kurį veiksmą, skriptas baigia darbą.
   • Jei katalogas jau yra PATH, pranešama apie tai.
6. Estetika ir UX:
   • Naudojamas --menu dialogas katalogui pasirinkti.
   • Naudojamas --radiolist šablonui pasirinkti.
   • Naudojami --yesno ir --passivepopup paprastiems patvirtinimams.

Šie patobulinimai suteikia daugiau funkcijų ir saugumo:

• Išvengiama tuščių pavadinimų ir failų perrašymo.
• Leidžiama lanksčiai pasirinkti katalogą ir šabloną.
• Suteikiama galimybė lengvai pridėti skriptą į PATH arba sukurti alias.
• Gerinamas vartotojo patyrimas su aiškiais pranešimais ir pasirinkimais.

Papildomi patobulinimai galėtų būti:

• Git inicializavimas naujame skripte.
• Daugiau šablonų (pvz., Rust, Go).
• Integracija su projektų valdymo įrankiais.
• Galimybė pasirinkti redaktorių (Kate, VSCode, ir t.t.).
• Automatinis testavimas (pvz., shellcheck Bash skriptams).

Šis patobulintas skriptas ne tik apsaugo nuo klaidų, bet ir suteikia daugiau galimybių, padėdamas jums greitai ir efektyviai kurti naujus skriptus pagal savo poreikius.

Kodėl tai svarbu?

1. Nuoseklumas: Visi skriptai tame pačiame kataloge, vienodai pavadinti.
2. Efektyvumas: Jokio rankinio chmod, echo, source.
3. Integracija: Skriptai iškart prieinami per alias.
4. Patogumas: Tiesioginis redagavimas iš skriptų kūrėjo.

GUI vs Terminalas

• Terminalas: Greitas, veikia visur, nereikia papildomų paketų. Bet mažiau intuityvus.
• GUI: Draugiškas, informatyvus, integruotas į darbalaukį. Bet reikia įdiegti kdialog.

Asmeniškai, aš pamėgau GUI versiją. KDE Plasma aplinkoje ji atrodo natūraliai, o pranešimai ir dialogo langai suteikia aiškumo. Be to, sparčiųjų klavišų integracija leidžia man sukurti skriptą vos keliais mygtukų paspaudimais.

Išplėtimas ir pritaikymas

• Python, Node.js: Pridėkite šablonus kitiems kalboms.
• Git integracija: Automatiškai inicijuokite Git repozitoriją.
• Dokumentacija: Įterpkite komentarus su autoriaus ir datos informacija.
• Išmanus kelias: Skirtingi katalogai skirtingiems projektams.
• Atsarginės kopijos: Automatiškai kurkite .bak failus.

Pabaigai

Pradėjęs nuo paprasto skripto, sukūriau įrankį, kuris dabar yra mano darbo eigos šerdis. Jis ne tik automatizuoja rutininius veiksmus, bet ir užtikrina, kad mano skriptų biblioteka būtų tvarkinga ir prieinama. Nesvarbu, ar naudojate terminalą, ar mėgstate GUI, toks skriptas gali žymiai pagerinti jūsų produktyvumą.

Svarbiausia pamoka? Pirmasis skriptas, kurį turėtumėte parašyti, yra tas, kuris padės jums kurti visus kitus. Tai tarsi statant namą – pirmiausia pasigaminate įrankius. Šis metodas ne tik pagreitina darbą, bet ir padeda išlaikyti tvarką, o tai ypač svarbu augant jūsų skriptų kolekcijai.

Tad nesvarbu, ar esate pradedantysis, ar patyręs, pagalvokite apie savo darbo eigą. Raskite pasikartojančias užduotis ir automatizuokite jas. Ilgainiui šie maži patobulinimai gali turėti didžiulį poveikį. Ir viskas prasideda nuo to pirmojo skripto – to, kuris padeda kurti visus kitus.