zpi/zrep

709 lines
24 KiB
Plaintext
Raw Normal View History

2024-02-27 18:39:09 +01:00
#!/usr/bin/zsh
setopt extendedglob
2024-02-27 18:39:09 +01:00
VERSION="0.0.1" # Sat-2024-02-24
ZREP="Zsh Repository Tool"
# Define the path to .zreprc
2024-03-10 13:31:19 +01:00
ZREP_CONFIG="${HOME}/.zreprc"
2024-02-27 16:50:07 +01:00
function zrep_fpath() {
2024-03-10 13:31:19 +01:00
local base_dir="${1}"
2024-02-27 16:50:07 +01:00
# Check if the base directory exists
2024-03-10 13:31:19 +01:00
if [[ ! -d "${base_dir}" ]]; then
echo "Error: Base directory '${base_dir}' does not exist."
2024-02-27 16:50:07 +01:00
return 1
fi
# Add directories containing at least one file to fpath
2024-03-10 13:31:19 +01:00
for dir in ${base_dir}/**/*(/N); do
if [[ -n $(ls -A "${dir}/") ]]; then
fpath=(${dir} $fpath)
2024-02-27 16:50:07 +01:00
fi
done
}
zrep_fpath ${HOME}/.zrep/functions
2024-02-27 16:50:07 +01:00
autoload -Uz zini
# List of colors available
typeset -A colors
colors=(
black "\033[0;30m"
red "\033[0;31m"
green "\033[0;32m"
yellow "\033[0;33m"
blue "\033[0;34m"
magenta "\033[0;35m"
cyan "\033[0;36m"
white "\033[0;37m"
bold_black "\033[1;30m"
bold_red "\033[1;31m"
bold_green "\033[1;32m"
bold_yellow "\033[1;33m"
bold_blue "\033[1;34m"
bold_magenta "\033[1;35m"
bold_cyan "\033[1;36m"
bold_white "\033[1;37m"
black_bg "\033[40m"
red_bg "\033[41m"
green_bg "\033[42m"
yellow_bg "\033[43m"
blue_bg "\033[44m"
magenta_bg "\033[45m"
cyan_bg "\033[46m"
white_bg "\033[47m"
end "\033[0m"
)
function zrep_main_version_string() {
echo "${colors[bold_black]}${colors[white_bg]} ${ZREP} ${colors[end]}${colors[bold_white]}${colors[black_bg]} ${VERSION} ${colors[end]}"
}
function zrep_version() {
zrep_msg info "\nCreated by kekePower - 2024"
zrep_msg info "License: MIT"
zrep_msg info "https://git.kekepower.com/kekePower/zrep/"
zrep_msg info "Please see '${colors[bold_green]}${ZSH_SCRIPT:t} help${colors[end]}'${colors[yellow]} for more info"
exit
}
function zrep_msg() {
local color=${colors[end]} # Default to no color if type is unrecognized
case ${1} in
std) color=${colors[green]} ;;
info) color=${colors[yellow]} ;;
debug) color=${colors[red]} ;;
other) color=${colors[bold_yellow]} ;;
sub) color=${colors[magenta]} ;;
main) color="${colors[white]} ${colors[green_bg]}" ;;
esac
printf "${color}%b${colors[end]}\n" "${2}"
}
function zrep_init() {
2024-03-10 13:31:19 +01:00
local zshrc_file="${HOME}/.zshrc"
local addons_file="${HOME}/.zrep_addons"
local install_dir
# Check if .zreprc exists
2024-03-10 13:31:19 +01:00
if [[ ! -f ${ZREP_CONFIG} ]]; then
echo "${ZREP_CONFIG} not found. Creating it..."
# Prompt user for install directory
2024-03-10 13:31:19 +01:00
read "install_dir?Enter zrep installation directory [${HOME}/.zrep]: "
install_dir=${install_dir:-"${HOME}/.zrep"}
# Write to .zreprc
cat > "${ZREP_CONFIG}" <<EOF
[main]
zrep_install_dir = ${install_dir}
[global]
repo_url = https://kekepower.com/zrep
EOF
else
2024-03-10 13:31:19 +01:00
echo "Loading configuration from ${ZREP_CONFIG}"
zini ${ZREP_CONFIG}
install_dir=${config[main_zrep_install_dir]}
fi
2024-03-10 13:31:19 +01:00
mkdir -p "${install_dir}/functions/zini"
curl -s https://raw.githubusercontent.com/kekePower/zini/main/zini -o "${install_dir}/functions/zini/zini"
if ! grep -q "zini" "${zshrc_file}"; then
echo "Adding 'zini' path to fpath in ${zshrc_file}"
echo "fpath=(${install_dir}/functions/zini \$fpath)" >> ${zshrc_file}
fi
# Check if .zshrc already sources .zrep_addons, if not, add it
2024-03-10 13:31:19 +01:00
if ! grep -q "source ${addons_file}" "${zshrc_file}"; then
echo "Adding source command for .zrep_addons to .zshrc..."
2024-03-10 13:31:19 +01:00
echo "source ${addons_file}" >> "${zshrc_file}"
fi
# Create or update the .zrep_addons file
2024-03-10 13:31:19 +01:00
if [[ ! -f ${addons_file} ]]; then
echo "Creating file ${addons_file}..."
cat > "${addons_file}" <<EOF
# Source the .addons file from the zrep installation directory
source "${install_dir}/.addons"
# If addons array is defined and not empty, add its elements to fpath
if [[ -n \${addons[@]} ]]; then
for addon in "\${addons[@]}"; do
2024-03-10 13:31:19 +01:00
if [[ -d \${addon} ]] && [[ ! " \${fpath[*]} " =~ " \${addon} " ]]; then
fpath=(\${addon} "\${fpath[@]}") # Prepend the new addon to fpath
fi
autoload -Uz $(basename ${addon})
done
else
echo "zrep: No addons enabled."
fi
EOF
echo "File .zrep_addons created and configured."
else
echo "File .zrep_addons already exists. Review manually if update is needed."
fi
echo "zrep initialization complete."
echo "Remember to 'source ${zshrc_file}' to load the 'zrep' settings."
}
# Function to parse remote JSON data and extract author, script, and version
# and return the correct download url
function zrep_parse_remote() {
2024-03-10 13:31:19 +01:00
local url="${1}"
local package="${2}"
local author_name="${package%%/*}"
local script_name="${package#*/}"
local json_data
# Fetch JSON data from the URL
2024-03-10 13:31:19 +01:00
json_data=$(curl -s "${url}")
# Directly extract the details based on author_name and script_name
dlurl=$(echo "${json_data}" | jq -r --arg author_name "$author_name" --arg script_name "$script_name" '.authors[] | select(.name==$author_name) | .scripts[] | select(.name==$script_name) | .dlurl')
version=$(echo "${json_data}" | jq -r --arg author_name "$author_name" --arg script_name "$script_name" '.authors[] | select(.name==$author_name) | .scripts[] | select(.name==$script_name) | .version')
# Check if the dlurl and version are found
if [[ -n "$dlurl" && -n "$version" ]]; then
# Set the details as global
export author="$author_name"
export script="$script_name"
export version
export dlurl
#echo "Download URL: ${dlurl}"
#echo "Author: ${author}, Script: ${script}, Version: ${version}"
else
echo "Package ${package} not found."
fi
}
# Function to write to installed.json after successful install
function zrep_update_installed_json() {
2024-03-10 13:31:19 +01:00
local author="${1}"
local script="${2}"
local version="${3}"
local json_file="${config[main_zrep_install_dir]}/installed.json"
# Ensure the JSON file exists, creating an empty object if not
2024-03-10 13:31:19 +01:00
if [[ ! -f "${json_file}" ]]; then
echo "{}" > "${json_file}"
fi
# Correctly handle updating or adding script entries within the nested array
jq --arg author "$author" --arg script "$script" --arg version "$version" \
'if has($author) then
.[$author] |= map(if .script == $script then .version = $version else . end) |
if .[$author] | all(.script != $script) then .[$author] += [{"script": $script, "version": $version}] else . end
else
.[$author] = [{"script": $script, "version": $version}]
end' "$json_file" > "$json_file.tmp" && mv "$json_file.tmp" "$json_file"
zrep_msg info " - Package '$script' by '$author' version $version installed/updated successfully."
}
# Function to list installed packages from installed.json
function zrep_list_installed_packages() {
local installed_json="${config[main_zrep_install_dir]}/installed.json"
# Check if installed.json exists
2024-03-10 13:31:19 +01:00
if [[ ! -f "${installed_json}" ]]; then
zrep_msg debug "No installed packages found."
return 0
fi
# Parse installed.json and list packages
zrep_msg sub "\nInstalled packages:"
# Iterate through each author and their packages
jq -r 'to_entries | .[] | .key as $author | .value[] | "\($author)/\(.script) (\(.version))"' "${installed_json}" | while IFS= read -r package_info; do
2024-03-10 13:31:19 +01:00
local package_name=$(echo "${package_info}" | cut -d ' ' -f1) # Extract package name before the version
local is_active="${colors[white]}(${colors[end]}${colors[bold_red]}Inactive${colors[end]}${colors[white]})${colors[end]}" # Set default to Inactive
# Check if the package is active (only modify if active)
2024-03-10 13:31:19 +01:00
if grep -q "${package_name}" ${config[main_zrep_install_dir]}/.addons; then
is_active="${colors[white]}(${colors[end]}${colors[bold_green]}Active${colors[end]}${colors[white]})${colors[end]}"
fi
2024-03-10 13:31:19 +01:00
zrep_msg info " - ${package_info} ${is_active}"
done
}
2024-02-27 16:50:07 +01:00
function zrep_list_package() {
local installed_json="${config[main_zrep_install_dir]}/installed.json"
local package_names=""
# Check if installed.json exists
2024-03-10 13:31:19 +01:00
if [[ ! -f "${installed_json}" ]]; then
echo "No installed packages found."
return 0
fi
# Parse installed.json and concatenate package names
jq -r 'to_entries[] | .key as $author | .value[] | "\($author)/\(.script) (\(.version))"' "${installed_json}" | while IFS= read -r package_info; do
2024-03-10 13:31:19 +01:00
package_names+="${package_info} "
done
# Assuming you want to print out the concatenated package names
2024-03-10 13:31:19 +01:00
if [[ -n "${package_names}" ]]; then
echo "Installed packages: ${package_names}"
else
echo "No packages found."
fi
}
2024-02-27 16:50:07 +01:00
# Function to load configuration
function zrep_load_config() {
# Check if jq is available
if ! command -v jq &> /dev/null; then
echo "Error: 'jq' is not installed. Please install jq to continue."
exit 1
fi
2024-03-10 13:31:19 +01:00
if [[ -f "${ZREP_CONFIG}" ]]; then
zini "${ZREP_CONFIG}"
zrep_fpath ${config[main_zrep_install_dir]}
2024-02-27 16:50:07 +01:00
else
2024-03-10 13:31:19 +01:00
if [[ "${1}" == "init" ]]; then
echo "${ZREP_CONFIG} not found. Proceeding with 'zrep init'..."
2024-02-27 16:50:07 +01:00
zrep_init
else
2024-03-10 13:31:19 +01:00
echo "${ZREP_CONFIG} not found."
2024-02-27 16:50:07 +01:00
# Ask the user if they want to run 'zrep init'
read "response?Would you like to run 'zrep init' to set up? (y/n): "
2024-03-10 13:31:19 +01:00
if [[ "${response}" =~ ^[Yy]$ ]]; then
2024-02-27 16:50:07 +01:00
zrep_init
else
echo "Initialization canceled. Please run 'zrep init' manually to set up."
exit 1
fi
fi
fi
2024-02-27 16:50:07 +01:00
}
function zrep_remove_package() {
2024-03-10 13:31:19 +01:00
local package_name="${1}"
local installed_json="${config[main_zrep_install_dir]}/installed.json"
# Check if installed.json exists
2024-03-10 13:31:19 +01:00
if [[ ! -f "${installed_json}" ]]; then
zrep_msg debug "\nError: installed.json not found."
return 1
fi
local author="${package_name%%/*}"
local script="${package_name#*/}"
# Verify if the package is installed and get its version (if any)
local installed_version=$(jq -r --arg author "$author" --arg script "$script" \
'.[$author][] | select(.script == $script) | .version' "$installed_json")
if [[ -z "$installed_version" || "$installed_version" == "null" ]]; then
zrep_msg debug "\nError: Package '${package_name}' is not installed."
zrep_msg info "Please see 'zrep list' for installed packages."
return 1
fi
local first_letter=$(echo "${author:0:1}" | tr '[:upper:]' '[:lower:]')
2024-03-10 13:31:19 +01:00
local package_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
zrep_msg info "\nFound installed package: $package_name, version: $installed_version"
# Ask user for confirmation with default response "Y"
read "REPLY?Are you sure you want to remove this package? (y/n) [Y]: "
REPLY=${REPLY:-Y}
echo
2024-03-10 13:31:19 +01:00
if [[ "${REPLY}" =~ ^[Yy]$ ]]; then
# Remove the package directory from disk
2024-03-10 13:31:19 +01:00
if [[ -d "${package_dir}" ]]; then
rm -rf "${package_dir}"
zrep_msg sub "Package directory '${package_dir}' removed successfully."
else
zrep_msg debug "Warning: Package directory '${package_dir}' not found."
fi
# Remove the package from installed.json
jq --arg author "$author" --arg script "$script" \
'(.[$author] |= map(select(.script != $script))) |
if .[$author] == [] then del(.[$author]) else . end' \
"$installed_json" > "$installed_json.tmp" && mv "$installed_json.tmp" "$installed_json"
zrep_msg sub "Package '${package_name}' removed successfully from installed.json."
else
zrep_msg info "Removal canceled."
fi
}
function zrep_check_if_installed() {
local package="${1}"
local installedJson="${config[main_zrep_install_dir]}/installed.json"
local author_name="${package%%/*}"
local script_name="${package#*/}"
# Initialize version to an empty string
typeset -g installed_version=""
# Check if the package is already installed and retrieve its version
installed_version=$(jq -r --arg author "$author_name" --arg script "$script_name" \
'.[$author][] | select(.script == $script) | .version' "$installedJson")
if [[ -n "${installed_version}" && "${installed_version}" != "null" ]]; then
# Package is installed, and version is stored in installed_version
# echo "Package $package is installed with version $installed_version."
return 0 # Package is installed
else
# echo "Package $package is not installed."
return 1 # Package is not installed
fi
}
typeset -A updatesAvailable
function zrep_check_for_updates() {
local remoteFile="${config[global_repo_url]}/packages.json"
local localFile="${config[main_zrep_install_dir]}/installed.json"
local remotePackages=$(curl -s "${remoteFile}")
# Reset global variables
updatesAvailable=()
typeset -g updates=false # Global declaration, initializes to false
# Process updates
local authorsScripts=$(jq -r '. | to_entries[] | .key as $author | .value[] | "\($author)/\(.script):\(.version)"' "$localFile")
for entry in ${(f)authorsScripts}; do
local author="${entry%%/*}"
local rest="${entry#*/}"
local script="${rest%%:*}"
local installed_version="${rest##*:}"
local remote_version=$(jq -r --arg author "$author" --arg script "$script" \
'.authors[] | select(.name==$author) | .scripts[] | select(.name==$script) | .version' <<<"$remotePackages")
if [[ "${remote_version}" > "${installed_version}" ]]; then
updatesAvailable[${author}/${script}]="${remote_version}"
zrep_msg info "\n${author}/${script} can be updated from ${installed_version} to ${remote_version}"
updates=true # Mark that updates are available
fi
done
}
function zrep_update_package() {
local specificPackage=${1}
zrep_check_for_updates
# Check if in update mode or specific package update
if [[ -n "${specificPackage}" ]]; then
# Logic for updating a specific package
# Assuming specificPackage format is "author/script"
local version=${updatesAvailable[${specificPackage}]}
if [[ -n "$version" ]]; then
local author="${specificPackage%%/*}"
local script="${specificPackage#*/}"
local dlurl="${config[global_repo_url]}/download.php?a=${author}&s=${script}&v=${version}"
# echo "Updating $specificPackage to version $version..."
local install_pkg="${author}/${script}"
zrep_install_package u ${install_pkg}
else
echo "No update available for ${specificPackage}."
fi
else
if [[ ${updates} == "true" ]]; then
# General update mode: update all packages listed in updatesAvailable
for package in ${(k)updatesAvailable}; do
local author=${package%%/*}
local script=${package#*/}
local version=${updatesAvailable[${package}]}
# local dlurl="${config[global_repo_url]}/download.php?a=${author}&s=${script}&v=${version}"
# echo "Preparing to update $package to version $version..."
local install_pkg="${author}/${script}"
zrep_install_package u ${install_pkg}
done
else
zrep_msg info "\nNo updates found."
fi
fi
}
# Function to install a package by unzipping it to ${config[main_zrep_install_dir]}
function zrep_install_package() {
if [[ ${1} == "u" ]]; then
updates=true
local package=${2}
# echo "zrep_install_package: package=$package"
else
updates=false
local package="${1}"
# Call zrep_check_if_installed to check if the package is already installed
if zrep_check_if_installed "${package}"; then
zrep_msg info "Package ${package} is already installed."
zrep_msg info "Use 'zrep list' to see installed packages."
return 0
fi
fi
# If not installed, proceed with fetching the package information
zrep_parse_remote "${config[global_repo_url]}/packages.json" "${package}"
# echo "zrep_install_package: $dlurl"
#local baseDir="${config[main_zrep_install_dir]}"
local tmpDir="${config[main_zrep_install_dir]}/tmp"
2024-03-10 13:31:19 +01:00
mkdir -p "${tmpDir}"
local zipFile="${tmpDir}/${author}-${script_name}-${version}.zip"
2024-03-10 13:31:19 +01:00
curl -s -o "${zipFile}" "${dlurl}"
if [[ $? -ne 0 ]]; then
echo "Error: Failed to download the package."
return 1
fi
unzip -q -o "${zipFile}" -d "${config[main_zrep_install_dir]}"
if [[ $? -ne 0 ]]; then
echo "Error: Failed to unzip the package."
return 1
else
2024-03-10 13:31:19 +01:00
zrep_update_installed_json "${author}" "${script}" "${version}"
fi
#rm "${zipFile}"
}
# Function to parse installed.json
function zrep_parse_installed_json() {
local installed_json="${config[main_zrep_install_dir]}/installed.json"
2024-03-10 13:31:19 +01:00
jq -c '.' "${installed_json}"
}
function zrep_parse_package_name() {
# echo "Looking for package ${1}"
2024-03-10 13:31:19 +01:00
package_name="${1}"
installed_json="${config[main_zrep_install_dir]}/installed.json"
author="${package_name%/*}"
script="${package_name#*/}"
2024-03-10 13:31:19 +01:00
first_letter=$(echo "${author}" | cut -c 1 | tr '[:upper:]' '[:lower:]')
addon_path="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
# Check if the package is installed
if [[ ! -f "${installed_json}" ]] || ! jq -e --arg author "$author" --arg script "$script" '.[$author] | any(.script == $script)' "${installed_json}" &>/dev/null; then
2024-03-10 13:31:19 +01:00
echo "Error: Package '${package_name}' is not installed."
return 1
fi
}
function zrep_enable() {
2024-03-10 13:31:19 +01:00
local package_name="${1}"
zrep_parse_package_name "${package_name}"
# Assuming zrep_parse_package_name sets 'addon_path' correctly
# and 'package_name' is in 'author/script' format
# Initialize addons array if .zrep_addons does not exist
if [ ! -f "${config[main_zrep_install_dir]}/.addons" ]; then
addons=()
else
# Load existing addons from ${config[main_zrep_install_dir]}/.addons
source "${config[main_zrep_install_dir]}/.addons"
fi
# Check if the addon is already enabled
local addon_exists=0
for addon in "${addons[@]}"; do
2024-03-10 13:31:19 +01:00
if [[ "${addon}" == "${addon_path}" ]]; then
addon_exists=1
break
fi
done
if ((addon_exists)); then
2024-03-10 13:31:19 +01:00
echo "Package '${package_name}' is already enabled."
return 0
fi
# Add addon path to the array
2024-03-10 13:31:19 +01:00
addons+=("${addon_path}")
# Reconstruct .zrep_addons file with the updated addons array
{
echo "addons=("
for addon in "${addons[@]}"; do
2024-03-10 13:31:19 +01:00
echo " '${addon}'"
done
echo ")"
} > "${config[main_zrep_install_dir]}/.addons"
# Source the updated .zrep_addons to apply changes
source "${HOME}/.zrep_addons"
autoload -Uz "${script}"
2024-03-10 13:31:19 +01:00
zrep_msg info "\nPackage '${package_name}' has been enabled and added to fpath."
zrep_msg info "You may have to run 'source ~/.zrep_addons' to get access to it."
}
function zrep_disable() {
2024-03-10 13:31:19 +01:00
local package_name="${1}"
zrep_parse_package_name "${package_name}"
# Assuming zrep_parse_package_name sets 'addon_path' correctly
# and 'package_name' is in 'author/script' format
# Initialize addons array if .zrep_addons does not exist
if [ ! -f "${config[main_zrep_install_dir]}/.addons" ]; then
addons=()
else
# Load existing addons from ${config[main_zrep_install_dir]}/.addons
source "${config[main_zrep_install_dir]}/.addons"
fi
# Initialize a new array for addons
local new_addons=()
# Flag to check if addon was found and removed
local found=0
# Iterate through existing addons
for addon in "${addons[@]}"; do
2024-03-10 13:31:19 +01:00
if [[ "${addon}" == "${addon_path}" ]]; then
found=1
else
2024-03-10 13:31:19 +01:00
new_addons+=("${addon}")
fi
done
if ((found == 0)); then
2024-03-10 13:31:19 +01:00
zrep_msg debug "\nPackage '${package_name}' is not currently enabled."
return 0
fi
# Reconstruct .zrep_addons file with the new addons array
{
echo "addons=("
for addon in "${new_addons[@]}"; do
2024-03-10 13:31:19 +01:00
echo " '${addon}'"
done
echo ")"
} > ${config[main_zrep_install_dir]}/.addons
# Source the updated .zrep_addons to apply changes
source ${HOME}/.zrep_addons
unfunction ${script} 2>/dev/null || true
2024-03-10 13:31:19 +01:00
zrep_msg info "\nPackage '${package_name} (${script})' has been disabled and removed from fpath."
zrep_msg info "You may have to run 'source ~/.zrep_addons' to remove it from your shell."
}
# Help function to display available options
function zrep_help() {
zrep_msg sub "\nUsage: zrep <command> [arguments]"
2024-03-10 13:31:19 +01:00
zrep_msg info "Available commands:"
if [[ ! -f ${ZREP_CONFIG} ]]; then
zrep_msg info " init: Initialize zrep"
fi
zrep_msg info " check: Check for updates"
2024-03-10 13:31:19 +01:00
zrep_msg info " install (i) <author/package>: Install a package"
zrep_msg info " remove (rm, delete) <author/package>: Remove a package"
zrep_msg info " update (u) <author/package>: Update zrep package"
zrep_msg info " enable <author/package>: Enable zrep package"
zrep_msg info " disable <author/package>: Disable zrep package"
zrep_msg info " version: Display zrep version"
zrep_msg info " list: List installed packages"
zrep_msg info " <author/package> help: Display help for pacakage (if available)"
}
function zrep_read_usage() {
2024-03-10 13:31:19 +01:00
local package_name="${1}"
# Parse the package name to extract author and script
local author="${package_name%/*}"
local script="${package_name#*/}"
2024-03-10 13:31:19 +01:00
local first_letter=$(echo "${author}" | cut -c 1 | tr '[:upper:]' '[:lower:]')
# Construct the path to the USAGE file
2024-03-10 13:31:19 +01:00
local usage_file="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}/USAGE"
# Check if the USAGE file exists
2024-03-10 13:31:19 +01:00
if [[ -f "${usage_file}" ]]; then
# Display the content of the USAGE file
2024-03-10 13:31:19 +01:00
zrep_msg sub "\n${package_name}:"
local usage_buffer=$(<${usage_file})
2024-03-10 13:31:19 +01:00
zrep_msg info "${usage_buffer}"
else
2024-03-10 13:31:19 +01:00
zrep_msg debug "No USAGE file found for package '${package_name}'."
fi
}
function main() {
zrep_main_version_string
zrep_load_config
2024-02-27 16:50:07 +01:00
# Check if the second argument is "help" and the first argument is not empty
if [[ "${2}" == "help" && -n "${1}" ]]; then
zrep_read_usage "${1}"
exit
fi
2024-02-27 16:50:07 +01:00
# Example command handling structure
case "${1}" in
2024-02-27 16:50:07 +01:00
init)
zrep_init
2024-03-10 14:03:27 +01:00
# zrep_fpath ${config[main_zrep_install_dir]}
exit
2024-02-27 16:50:07 +01:00
;;
check)
zrep_check_for_updates
;;
install | i)
zrep_install_package ${2}
;;
remove | delete | rm)
# Parse the command argument to extract the package name
zrep_remove_package_name="${2:-}"
2024-03-10 13:31:19 +01:00
if [[ -z "${zrep_remove_package_name}" ]]; then
2024-03-10 14:03:27 +01:00
echo "Usage: zrep ${1} author/package"
else
2024-03-10 13:31:19 +01:00
zrep_remove_package "${zrep_remove_package_name}"
fi
2024-02-27 16:50:07 +01:00
;;
update | u)
zrep_update_package ${2}
;;
version | -v | --version)
zrep_version
;;
list)
zrep_list_installed_packages
;;
help | -h | --help)
zrep_help
2024-02-27 16:50:07 +01:00
;;
enable)
zrep_enable ${2}
;;
disable)
zrep_disable ${2}
;;
2024-02-27 16:50:07 +01:00
*)
zrep_help
2024-02-27 16:50:07 +01:00
;;
esac
}
# Call main with all passed arguments
main "$@"