Funkce pro výpis aplikací v distribuci Mint a porovnávání mezi systémy pro .profile

Projekt: Vývoj bash funkce

Fáze vývoje: První krok - zjednodušené řešení

Design: ChatGPT 4o

Zadání:

napište mi funkci pro .profile , která vypíše cesty k aplikacím na mint 21.3
základní syntaxe:
a) show-apps all
b) show-apps share
c) show-apps icons
d) show-apps system
e) show-apps plocha
f) show-apps opt
g) jeden argument navíc  -r nebo "--recursive"

declare -f show-apps
show-apps (){
1) zkontrolovat argumenty.
volba all znamená, že projde cesty včetně ~/.local:
Pokud hledáte umístění souborů ikon, desktopových záznamů nebo binárních souborů spojených s baobab, zde jsou některé relevantní cesty:

    Desktop Entry (soubor .desktop, který vidíte):
        Cesta: /usr/share/applications/org.gnome.baobab.desktop
        Tento soubor slouží k registraci aplikace v menu a obsahuje informace, které popisujete.

    Ikona aplikace (soubor s ikonou, kterou vidíte v menu):
        Cesta: /usr/share/icons/hicolor/scalable/apps/org.gnome.baobab.svg
        Ikona může být také v jiných velikostech a formátech v závislosti na ikonovém tématu, například v PNG formátu ve stejném adresáři.

    Binární soubor (spustitelný soubor):
        Cesta: /usr/bin/baobab
        Tento soubor je ten, který se spustí, když otevřete aplikaci.

    Konfigurační soubory aplikace (uživatelské nastavení):
        Cesta: ~/.config/baobab/
        Zde jsou obvykle uloženy konfigurace uživatele. Tento adresář se může vytvořit, až když uživatel spustí aplikaci a provede změny v nastavení.

A pokud je navíc ještě přidán argument "-r nebo --recursive projde všechny soubory. desktop", které lze najít v těchto složkách a podívá se do parametrů kde nasbírá několik typů informací:
jaké aplikace by mohly být nainstalovány

funkce musí mít schopnost rozlišovat mezi system vs. opt vs. all čili: opt říká že chci projít pouze to co je na ~/Plocha a v /opt protože to jsem si tam nejspíš dosadil sám, kdežto jiné zpracování jako system zjistí co obsahuje system jako základ.

rekurzivní zpracování umožní načíst obsah jednotlivých souborů .desktop kterých se ten výpis týká např.  a vypasat skupiny informací:
např.
Name=Disk Usage Analyzer
Comment=Check folder sizes and available disk space
# Translators: Search terms to find this application. Do NOT translate or local>
Keywords=storage;space;cleanup;
TryExec=baobab
Exec=baobab
# Translators: Do NOT translate or transliterate this text (this is an icon fil>
Icon=org.gnome.baobab
Terminal=false
Type=Application
StartupNotify=true
MimeType=inode/directory;
Categories=GTK;GNOME;System;Filesystem;X-GNOME-Utilities;
NotShowIn=KDE;
DBusActivatable=true
X-GNOME-UsesNotifications=true
X-Ubuntu-Gettext-Domain=baobab

kde exec buď 1) obsahuje  cestu nebo 2) neobsahuje cestu. Zde je příklad 2) což naznačuje že je to systémová aplikace a toto je její jméno. A popis je pod Name. Další informace které chci sbírat do polí je icons ze souborů .desktop. Nakonec poslední druh informace co chci zjistit ke každému výpisu zda aplikace je GTK nebo KDE nebo XFce nebo jiná viz popis v "Categories=GTK"
}

Připravený kód

    
declare -f show-apps
show-apps() {
    # Funkce pro načítání .desktop souborů a jejich zpracování
    process_desktop_files() {
        local search_paths=("$@")
        local new_paths=()
        local processed_paths=()

        for path in "${search_paths[@]}"; do
            # Expandovat ~ na domovský adresář
            expanded_path=$(eval echo "$path")

            # Pokud cesta byla již zpracována, přeskočte
            if [[ " ${processed_paths[*]} " == *" $expanded_path "* ]]; then
                continue
            fi

            processed_paths+=("$expanded_path")
            echo "Prohledávám: $expanded_path"

            # Vyhledání .desktop souborů v aktuální cestě
            desktop_files=$(find "$expanded_path" -type f -name "*.desktop")

            for file in $desktop_files; do
                # Zkontrolovat, zda soubor existuje
                if [[ -f "$file" ]]; then
                    echo "Nalezen .desktop soubor: $file"
                    name=$(grep -m 1 "^Name=" "$file" | cut -d '=' -f 2-)
                    exec_path=$(grep -m 1 "^Exec=" "$file" | cut -d '=' -f 2-)
                    icon=$(grep -m 1 "^Icon=" "$file" | cut -d '=' -f 2-)
                    categories=$(grep -m 1 "^Categories=" "$file" | cut -d '=' -f 2-)

                    # Zvýraznění názvu aplikace světle zelenou barvou
                    echo -e "  \e[92mNázev aplikace: $name\e[0m"

                    # Kontrola, jestli Exec je cesta, skript, nebo název programu
                    if [[ "$exec_path" == /* ]]; then
                        if [[ "$exec_path" == *.sh ]]; then
                            echo "  Spustitelný skript: $exec_path"
                        else
                            echo "  Spustitelná cesta: $exec_path"
                        fi
                    else
                        # Zvýraznění spouštěcího příkazu žlutou barvou
                        echo -e "  \e[93mSpouštění: $exec_path\e[0m"
                    fi

                    echo "  Ikona: $icon"

                    # Filtrování kategorií pro zobrazení pouze KDE, GTK a XFCE
                    filtered_categories=$(echo "$categories" | grep -o -E '(KDE|GTK|XFCE)')
                    echo "  Kategorie: $filtered_categories"

                    # Pokud je exec_path skutečná cesta, přidáme ji do nových cest
                    if [[ "$exec_path" == /* && ! " ${processed_paths[*]} " == *" $exec_path "* ]]; then
                        if [ -d "$exec_path" ]; then
                            new_paths+=("$exec_path")
                        else
                            exec_dir=$(dirname "$exec_path")
                            if [ -d "$exec_dir" ] && ! [[ " ${processed_paths[*]} " == *" $exec_dir "* ]]; then
                                new_paths+=("$exec_dir")
                            fi
                        fi
                    fi

                    echo ""
                else
                    echo "Přeskočen soubor: $file (soubor neexistuje)"
                fi
            done
        done

        # Pokud existují nové cesty, zpracujeme je rekurzivně
        if [ ${#new_paths[@]} -ne 0 ]; then
            process_desktop_files "${new_paths[@]}"
        fi
    }

    # Zpracování argumentů
    case "$1" in
        all)
            paths=(
                "/usr/share/applications"
                "~/.local/share/applications"
                "/opt"
                "~/Plocha"
            )
            ;;
        share)
            paths=(
                "/usr/share/applications"
                "~/.local/share/applications"
            )
            ;;
        system)
            paths=(
                "/usr/share/applications"
            )
            ;;
        plocha)
            paths=(
                "~/Plocha"
            )
            ;;
        opt)
            paths=(
                "/opt"
            )
            ;;
        *)
            echo "Neplatný argument. Použijte: all, share, icons, system, plocha, opt"
            return 1
            ;;
    esac

    # Zahájení zpracování souborů .desktop
    process_desktop_files "${paths[@]}"
}

Popis:

1. show-apps all: Prohledá všechny hlavní cesty včetně systémových a uživatelských složek.
2. show-apps share: Prohledá složky share, které obsahují .desktop soubory.
3. show-apps icons: Vyhledá ikony aplikací.
4. show-apps system: Prohledá základní systémové cesty pro aplikace.
5. show-apps plocha: Prohledá složku ~/Plocha.
6. show-apps opt: Prohledá složku /opt.

(vynechal -r --recursive - ve skutečnosti nejde o rekurzivitu, ale o doplnění informací podle toho co je v těch souborech .desktop)

Jak to funguje:

1. process_desktop_files:

   • Zpracovává seznam cest k prohledání, nachází .desktop soubory a extrahuje z nich potřebné informace.
   • Pokud se v .desktop souboru najde cesta (Exec), která odpovídá skutečné cestě na disku, přidá ji do seznamu new_paths, pokud ještě nebyla zpracována.
   • Zpracovává nové cesty rekurzivně, dokud nejsou všechny cesty zpracovány.

2. show-apps:

   • Podle zadaného argumentu (all, share, icons, system, plocha, opt) inicializuje seznam cest k prohledání a předá je funkci process_desktop_files.

3. Ošetření duplicitních cest:

   • Pomocí pole processed_paths se sleduje, které cesty již byly zpracovány, aby nedošlo k duplicitnímu výpisu.

Jak to nyní funguje:

• Exec cesta je skutečná cesta: Pokud hodnota v Exec začíná /, považuje se to za skutečnou cestu. Pokud končí na .sh, je to identifikováno jako spustitelný skript a výstup to uvede jako "Spustitelný skript: ...". Jinak je to uvedeno jako "Spustitelná cesta: ...".
• Exec není cesta: Pokud hodnota v Exec nezačíná /, je považována za název programu a výstup to uvede jako "Spouštění: ...".

Upravená funkce show-apps splňuje požadavky filtrování typu grafického prostředí:

1. Filtrování kategorií: Budou vyfiltrovány pouze kategorie "KDE", "GTK" nebo "XFCE".
2. Barevné zvýraznění: Název aplikace bude zvýrazněn světle zelenou barvou, zatímco spouštěcí příkaz bude zvýrazněn žlutou barvou.
3. Ošetření chybových výpisů: Problém se zpracováním .desktop souborů, které nejsou skutečnými soubory, bude řešen kontrolou existence souboru před zpracováním.

Fáze vývoje: Druhý krok - rozšíření na připojené systémy

Design: ChatGPT 4o (zadání je moje)

Zadání:

 ZADÁNÍ ROZŠÍŘENÍ. Aktuálně funkce vyhledá a vypíše aplikace, které našla na aktuálním systému. Nicméně předpokládejme že A) chci to samé udělat na jiném systému, který je připojen v jiném adresáři. Pak bych využil dalších argumentů, podle účelu použití. --mounted-device=/media/toshiba/ ... kde je připojen disk s jiným linuxem mint 21.3.  Dále  v mém případě ale mám na jednom oddílu home a na druhém oddílu root / . takže argumenty v tomto případě by byly navíc takto:   --mounted-root=/media/toshiba/root   --mounted-home=/media/toshiba/home  ... to znamená, že pomocí těchto tří argumentů by šlo změnit cestu tak, aby se prohledaly aplikace na externím systému, tak aby se neprohledávat aktuálně připojený root jako / ... ale pod danou cestou /media/toshiba/root ... apod. B) Na druhou stranu když už máme tuto příležitost pracovat se dvěma systémy, bylo by dobré mít možnost porovnat je mezi sebou, tj. to které je pro mě aktuální root a to co je připojené jako externí zařízení kde právě mám systém z notebooku toshiba. Pro to by tedy měl existovat třetí argument: --compare který by standardně porovnával aplikace na aktuálním systému s připojeným externím zařízením ... zde toshiba.  Případně by bylo možné to provést v opačném směru, že se porovnají aplikace nalezené na tom externím zařízení/externím systému root a home pod media. To by tedy znamenalo, že ty zdrojová pole (aplikace), které se budou porovnávat s cílovými poli (aplikacemi) by byly naplněny obsahem z externího disku, výstupem by byly informace o tom v čem se liší jeden systém od druhého. Takže v tomto případě by byl třeba ještě jeden argument, který určí směr porovnávání. Defaultně tedy --compare porovnává root device vs. external mounted media device/root/home. Ale --compare=reverse by to mohl udělat obráceně. C) bylo by možné takto porovna mezi sebou také dva připojené systémy v případě, že prostě do PC připojím dva externí disky ze dvou notebooků a každý z nich má svůj vlastní systém a chci porovnat které aplikace jsou na kterém systému.  Toto se týká i těch konfiguračních souborů co aplikace používají ať už to jsou .xml, .conf nebo jiné co by mohly používat, možná soubory s historií nebo uživatelkými daty, které uživatel může chtít později zazálohovat (čímž se otevírá možnost bodu D pro přípravu designu funkce nebo funkcí, že bude uživatel může v budoucnu chtít jednak uložit ty rozdíly do souboru, nebo případně zkopírovat soubory někam... zazálohovat, nebo zkopírovat apod.) Takže k bodu C) bych navíc přidal argumenty pro do druhé zařízení. Pokud bude přítomen některý z těchto tří argumentů je nutné pamatovat informaci, že se nebude prohledávat aktuální systém jako aplikace na současném PC a systému, ale jen ty externě připojené. Takže toto jsou další argumenty:   --mounted-next-device=/media/hp/root   --mounted-next-home=/media/hp/home   --mounted-next-root=/media/hp/root  ... díky těmto dvěma až čtyřem   argumentům (např. vs --mounted-root --mounted-next-root --mounted-home --mounted-next-home) bude možné porovnat mezi sebou dva externí systémy a zjistit které aplikace se nachází na tom druhém navíc (--compare),  které v tom prvním nejsou, nebo naopak, které tam schází oproti prvnímu (--compare=reverse)

Kód:

show-apps() {
    # Funkce pro načítání .desktop souborů a jejich zpracování
    process_desktop_files() {
        local search_paths=("$@")
        local new_paths=()
        local processed_paths=()
        local app_list_name="$2"
        declare -n app_list="$app_list_name"

        for path in "${search_paths[@]}"; do
            # Expandovat ~ na domovský adresář
            expanded_path=$(eval echo "$path")

            # Pokud cesta byla již zpracována, přeskočte
            if [[ " ${processed_paths[*]} " == *" $expanded_path "* ]]; then
                continue
            fi

            processed_paths+=("$expanded_path")
            echo "Prohledávám: $expanded_path"

            # Vyhledání .desktop souborů v aktuální cestě
            desktop_files=$(find "$expanded_path" -type f -name "*.desktop")

            for file in $desktop_files; do
                # Zkontrolovat, zda soubor existuje
                if [[ -f "$file" ]]; then
                    echo "Nalezen .desktop soubor: $file"
                    name=$(grep -m 1 "^Name=" "$file" | cut -d '=' -f 2-)
                    exec_path=$(grep -m 1 "^Exec=" "$file" | cut -d '=' -f 2-)
                    icon=$(grep -m 1 "^Icon=" "$file" | cut -d '=' -f 2-)
                    categories=$(grep -m 1 "^Categories=" "$file" | cut -d '=' -f 2-)

                    # Zvýraznění názvu aplikace světle zelenou barvou
                    echo -e "  \e[92mNázev aplikace: $name\e[0m"

                    # Přidání aplikace do seznamu
                    app_list+=("$name")

                    # Kontrola, jestli Exec je cesta, skript, nebo název programu
                    if [[ "$exec_path" == /* ]]; then
                        if [[ "$exec_path" == *.sh ]]; then
                            echo "  Spustitelný skript: $exec_path"
                        else
                            echo "  Spustitelná cesta: $exec_path"
                        fi
                    else
                        # Zvýraznění spouštěcího příkazu žlutou barvou
                        echo -e "  \e[93mSpouštění: $exec_path\e[0m"
                    fi

                    echo "  Ikona: $icon"

                    # Filtrování kategorií pro zobrazení pouze KDE, GTK a XFCE
                    filtered_categories=$(echo "$categories" | grep -o -E '(KDE|GTK|XFCE)')
                    echo "  Kategorie: $filtered_categories"

                    # Pokud je exec_path skutečná cesta, přidáme ji do nových cest
                    if [[ "$exec_path" == /* && ! " ${processed_paths[*]} " == *" $exec_path "* ]]; then
                        if [ -d "$exec_path" ]; then
                            new_paths+=("$exec_path")
                        else
                            exec_dir=$(dirname "$exec_path")
                            if [ -d "$exec_dir" ] && ! [[ " ${processed_paths[*]} " == *" $exec_dir "* ]]; then
                                new_paths+=("$exec_dir")
                            fi
                        fi
                    fi

                    echo ""
                else
                    echo "Přeskočen soubor: $file (soubor neexistuje)"
                fi
            done
        done

        # Pokud existují nové cesty, zpracujeme je rekurzivně
        if [ ${#new_paths[@]} -ne 0 ]; then
            process_desktop_files "${new_paths[@]}" "$app_list_name"
        fi
    }

    # Funkce pro porovnávání aplikací mezi systémy
    compare_apps() {
        local -n apps1="$1"
        local -n apps2="$2"
        local mode="$3"

        echo "Porovnávání aplikací..."

        if [[ "$mode" == "normal" ]]; then
            echo "Aplikace, které jsou pouze v prvním systému:"
            for app in "${apps1[@]}"; do
                if [[ ! " ${apps2[*]} " == *" $app "* ]]; then
                    echo "- $app"
                fi
            done

            echo "Aplikace, které jsou pouze v druhém systému:"
            for app in "${apps2[@]}"; do
                if [[ ! " ${apps1[*]} " == *" $app "* ]]; then
                    echo "- $app"
                fi
            done

        elif [[ "$mode" == "reverse" ]]; then
            echo "Aplikace, které jsou v obou systémech:"
            for app in "${apps1[@]}"; do
                if [[ " ${apps2[*]} " == *" $app "* ]]; then
                    echo "- $app"
                fi
            done
        fi

        # Uložení výsledků do souboru
        save_results "$mode" "${apps1[@]}" "${apps2[@]}"
    }

    # Funkce pro uložení výsledků do souboru
    save_results() {
        local mode="$1"
        shift
        local apps1=("$@")
        shift ${#apps1[@]}
        local apps2=("$@")

        local filename="comparison_result_$(date +%Y%m%d_%H%M%S).txt"

        echo "Ukládání výsledků do $filename..."

        {
            echo "Výsledky porovnávání aplikací ($mode):"
            echo "--------------------------------------"

            if [[ "$mode" == "normal" ]]; then
                echo "Aplikace pouze v prvním systému:"
                for app in "${apps1[@]}"; do
                    if [[ ! " ${apps2[*]} " == *" $app "* ]]; then
                        echo "- $app"
                    fi
                done

                echo "Aplikace pouze v druhém systému:"
                for app in "${apps2[@]}"; do
                    if [[ ! " ${apps1[*]} " == *" $app "* ]]; then
                        echo "- $app"
                    fi
                done

            elif [[ "$mode" == "reverse" ]]; then
                echo "Aplikace v obou systémech:"
                for app in "${apps1[@]}"; do
                    if [[ " ${apps2[*]} " == *" $app "* ]]; then
                        echo "- $app"
                    fi
                done
            fi
        } > "$filename"

        echo "Výsledky byly uloženy do $filename"
    }

    # Inicializace proměnných
    local paths=()
    local root_path="/"
    local home_path="$HOME"
    local external_root=""
    local external_home=""
    local next_external_root=""
    local next_external_home=""
    local compare_mode=""

    # Zpracování argumentů
    while [[ "$#" -gt 0 ]]; do
        case "$1" in
            all)
                paths=(
                    "$root_path/usr/share/applications"
                    "$home_path/.local/share/applications"
                    "$root_path/usr/share/icons"
                    "$home_path/.local/share/icons"
                    "$root_path/opt"
                    "$home_path/Plocha"

                    "$home/.local/share/xfce4/helpers"
                )
                ;;
            share)
                paths=(
                    "$root_path/usr/share/applications"
                    "$home_path/.local/share/applications"
                )
                ;;
            icons)
                paths=(
                    "$root_path/usr/share/icons"
                    "$home_path/.local/share/icons"
                )
                ;;
            system)
                paths=(
                    "$root_path/usr/share/applications"
                )
                ;;
            plocha)
                paths=(
                    "$home_path/Plocha"
                )
                ;;
            opt)
                paths=(
                    "$root_path/opt"
                )
                ;;
            --mounted-device=*)
                external_root="${1#*=}"
                ;;
            --mounted-root=*)
                external_root="${1#*=}"
                ;;
            --mounted-home=*)
                external_home="${1#*=}"
                ;;
            --mounted-next-device=*)
                next_external_root="${1#*=}"
                ;;
            --mounted-next-root=*)
                next_external_root="${1#*=}"
                ;;
            --mounted-next-home=*)
                next_external_home="${1#*=}"
                ;;
            --compare)
                compare_mode="normal"
                ;;
            --compare=reverse)
                compare_mode="reverse"
                ;;
            *)
                echo "Neplatný argument: $1"
                return 1
                ;;
        esac
        shift
    done

    # Pokud jsou zadány externí cesty, nahraďte root_path a home_path
    if [[ -n "$external_root" ]]; then
        root_path="$external_root"
    fi
    if [[ -n "$external_home" ]]; then
        home_path="$external_home"
    fi

    # Pokud je nastaveno porovnávání, načteme aplikace z obou systémů
    if [[ -n "$compare_mode" ]]; then
        local apps_current_system=()
        local apps_external_system=()
        local apps_next_external_system=()

        process_desktop_files "${paths[@]}" apps_current_system

        if [[ -n "$external_root" ]]; then
            paths=(
                "$external_root/usr/share/applications"
                "$external_home/.local/share/applications"
                "$external_root/opt"
                "$external_home/Plocha"

                "$external_home/.local/share/xfce4/helpers"

            )
            process_desktop_files "${paths[@]}" apps_external_system
        fi

        if [[ -n "$next_external_root" ]]; then
            paths=(
                "$next_external_root/usr/share/applications"
                "$next_external_home/.local/share/applications"
                "$next_external_root/usr/share/icons"
                "$next_external_home/.local/share/icons"
                "$next_external_root/usr/bin"
                "$next_external_root/opt"
                "$next_external_home/Plocha"
            )
            process_desktop_files "${paths[@]}" apps_next_external_system
        fi

        # Porovnání aktuálního systému s externím zařízením
        if [[ -n "$external_root" ]]; then
            compare_apps apps_current_system apps_external_system "$compare_mode"
        fi

        # Porovnání dvou externích zařízení
        if [[ -n "$next_external_root" ]]; then
            compare_apps apps_external_system apps_next_external_system "$compare_mode"
        fi
    else
        # Pokud není zadáno porovnávání, normálně zpracujeme soubory
        process_desktop_files "${paths[@]}" apps_current_system
    fi
}

Nové funkce a argumenty

Přidáme podporu pro následující nové argumenty:

1. --mounted-device nebo --mounted-root, --mounted-home: Umožňuje specifikovat cesty pro externí root a home systémů.
2. --compare: Porovnání aplikací na aktuálním systému s externím zařízením.
3. --compare=reverse: Porovnání aplikací na externím zařízení s aktuálním systémem.
4. --mounted-next-device, --mounted-next-root, --mounted-next-home: Umožňuje porovnání mezi dvěma externími systémy.

Kroky které měly být implementovány (ovšem já přerušil výpis nevšiml jsem ti že ChatGPT má tam mít to tlačítko porkačovat ve výpisu:

1. Zpracování argumentů: Rozšíříme funkci o podporu nových argumentů.
2. Změna hledaných cest: Podle argumentů přepneme cesty, které se mají prohledávat, na externí zařízení.
3. Porovnání aplikací: Implementujeme funkci, která porovná seznam aplikací mezi dvěma systémy.

Shrnutí změn a funkcí:

1. Porovnání aplikací: Funkce compare_apps umožňuje porovnání dvou seznamů aplikací mezi systémy. Můžete porovnávat aktuální systém s připojeným zařízením nebo porovnávat dva externí systémy mezi sebou.

2. Externí systémy: Přidány argumenty pro externí kořenové a domovské adresáře (--mounted-root, --mounted-home, --mounted-next-root, --mounted-next-home), což umožňuje práci se systémy na externích zařízeních.

3. Směr porovnávání: Argument --compare může být použit k nastavení směru porovnávání. --compare znamená porovnání aktuálního systému s externím zařízením, zatímco --compare=reverse provede opačné porovnání.

KONTROLA ZADÁNÍ - VÝSLEDEK:

Zkontroloval jsem, zda vámi poskytovaný kód splňuje všechny požadavky, které jste zadal. Rozdělím zpětnou vazbu do tří hlavních částí:

1) Požadavky na funkci show-apps pro původní zadání:

• Zpracování různých cest (all, share, icons, system, plocha, opt): Funkce správně zpracovává cesty pro různé argumenty.
• Rekurzivní vyhledávání .desktop souborů: Funkce správně implementuje rekurzivní vyhledávání a zpracování souborů .desktop, včetně zobrazení informací jako název aplikace, cesta ke spustitelnému souboru, ikona a kategorie (GTK, KDE, XFCE).
• Rozpoznávání systémových souborů vs. uživatelských: Funkce rozlišuje mezi různými typy aplikací a cestami, podle poskytnutého argumentu (např. opt, system).
• Filtrace kategorií a zvýraznění určitých informací: Výstup z funkce správně filtruje kategorie a zvýrazňuje klíčové informace (název aplikace, cesta ke spuštění apod.).

Shrnutí: Všechny požadavky původního zadání jsou ve funkci splněny.

2) Rozšíření funkcí o nové argumenty:

• Přidání podpory pro externí zařízení (--mounted-device, --mounted-root, --mounted-home): Pro rozšíření o zpracování externího zařízení, v kódu aktuálně chybí implementace argumentů jako --mounted-device, --mounted-root, a --mounted-home, které by přepsaly standardní cesty pro hledání aplikací a místo toho by prohledávaly externí zařízení.
• Porovnání aplikací mezi dvěma systémy (--compare, --compare=reverse): Pro porovnávání aplikací mezi aktuálním systémem a připojeným externím zařízením, případně mezi dvěma externími systémy, je třeba doplnit argumenty jako --compare, --compare=reverse, --mounted-next-device, --mounted-next-root, --mounted-next-home. Tyto funkce aktuálně chybí.

Shrnutí: Pro plné splnění rozšířeného zadání je nutné přidat podporu pro nové argumenty, které umožní zpracování a porovnávání aplikací na externích zařízeních.

3) Doporučení pro další postup:

• Implementace externího zpracování: Přidat logiku do funkce, která bude podporovat nové argumenty a podle nich měnit cesty k adresářům aplikací.
• Porovnání mezi dvěma systémy: Přidat mechanismus pro načítání dat z dvou různých systémů a jejich porovnání. To může zahrnovat uložení výstupu do dočasných souborů nebo proměnných a následnou analýzu rozdílů.

4) Nové Implementace (realizace bodu 3) - Vysvětlení přidaných funkcí:

• compare_apps: Tato funkce porovnává seznamy aplikací mezi dvěma systémy. V režimu "normal" ukazuje aplikace, které jsou v jednom systému, ale ne v druhém. V režimu "reverse" zobrazuje aplikace, které jsou v obou systémech.
• save_results: Ukládá výsledky porovnání do textového souboru. Výsledky jsou uloženy ve formátu, který ukazuje rozdíly mezi systémy.

Nyní můžete spouštět skript s různými argumenty, jako jsou --compare a --mounted-device, a porovnávat aplikace mezi různými systémy. Výsledky budou automaticky uloženy do textových souborů.

5) Zkontrolovat a otestovat kód a zjistit zda dělá vše co měl

Pozn. Ačkoliv to píšu pro .profile, asi by bylo lepší to mít jako samostatný skript, ale volaný z funkce.