Stig-Ørjan Smelror
dd518d733b
- Indent zrep_init call properly. - Add else block to handle setup abort. - Provide feedback message for setup abortion.
877 lines
29 KiB
Bash
Executable File
877 lines
29 KiB
Bash
Executable File
#!/usr/bin/zsh
|
|
|
|
setopt extendedglob
|
|
|
|
VERSION="0.0.2" # Sat-2024-03-13
|
|
ZREP="Zsh Repository Tool"
|
|
# Define the default path to .zreprc
|
|
ZREP_CONFIG="${HOME}/.zreprc"
|
|
|
|
function zrep_fpath() {
|
|
local base_dir="${1}"
|
|
|
|
# Check if the base directory exists
|
|
if [[ ! -d "${base_dir}" ]]; then
|
|
echo "Error: Base directory '${base_dir}' does not exist."
|
|
return 1
|
|
fi
|
|
|
|
# Add directories containing at least one file to fpath
|
|
for dir in ${base_dir}/**/*(/N); do
|
|
if [[ -n $(ls -A "${dir}/") ]]; then
|
|
fpath=(${dir} $fpath)
|
|
fi
|
|
done
|
|
}
|
|
|
|
if [[ ${1} != "init" ]]; then
|
|
zrep_fpath ${HOME}/.zrep/functions
|
|
autoload -Uz zini
|
|
fi
|
|
|
|
# Define a list of colors available to use in themes
|
|
typeset -A base_colors=(
|
|
[green]="\033[0;32m"
|
|
[yellow]="\033[1;33m"
|
|
[red]="\033[0;31m"
|
|
[bold_yellow]="\033[1;33m"
|
|
[magenta]="\033[0;35m"
|
|
[white]="\033[1;37m"
|
|
[green_bg]="\033[42m"
|
|
[white_on_green]="\033[1;37m\033[42m" # Combined color
|
|
[end]="\033[0m"
|
|
[black]="\033[0;30m"
|
|
[blue]="\033[0;34m"
|
|
[cyan]="\033[0;36m"
|
|
[bold_black]="\033[1;30m"
|
|
[bold_red]="\033[1;31m"
|
|
[bold_green]="\033[1;32m"
|
|
[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"
|
|
[yellow_bg]="\033[43m"
|
|
[blue_bg]="\033[44m"
|
|
[magenta_bg]="\033[45m"
|
|
[cyan_bg]="\033[46m"
|
|
[white_bg]="\033[47m"
|
|
[underline]="\033[4m"
|
|
[italic]="\033[3m"
|
|
)
|
|
|
|
# Define the global associative array to hold the current theme
|
|
declare -A current_theme
|
|
|
|
zrep_load_theme() {
|
|
local theme_name="$1"
|
|
local theme_file="${config[main_zrep_install_dir]}/themes/${theme_name}"
|
|
|
|
if [[ ! -f "$theme_file" ]]; then
|
|
echo "Error: Theme file for '${theme_name}' not found. Falling back to the 'classic' theme."
|
|
theme_file="${config[main_zrep_install_dir]}/themes/classic"
|
|
fi
|
|
|
|
# Source the theme file, which should define 'theme_colors'
|
|
source "$theme_file"
|
|
|
|
# Copy 'theme_colors' to 'current_theme'
|
|
for key value in ${(kv)theme_colors}; do
|
|
current_theme[$key]="$value"
|
|
done
|
|
}
|
|
|
|
function zrep_main_version_string() {
|
|
echo "${base_colors[bold_black]}${base_colors[white_bg]} ${ZREP} ${base_colors[end]}${base_colors[bold_white]}${base_colors[black_bg]} ${VERSION} ${base_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 '${base_colors[${current_theme[help]}]}${ZSH_SCRIPT:t} help${base_colors[end]}${base_colors[${current_theme[info]}]}' for more info${base_colors[end]}"
|
|
exit
|
|
}
|
|
|
|
# This function is used to display messages and use colors
|
|
# from the loaded theme.
|
|
function zrep_msg() {
|
|
local msg_type="$1"
|
|
local message="$2"
|
|
local color="${base_colors[end]}" # Default color is NONE
|
|
|
|
# Retrieve the color key from the current theme
|
|
local theme_color_key="${current_theme[$msg_type]}"
|
|
|
|
# Check if a valid color was found based on the key
|
|
if [[ -n "${base_colors[$theme_color_key]}" ]]; then
|
|
color="${base_colors[$theme_color_key]}"
|
|
else
|
|
# Handle invalid theme color key if needed
|
|
echo "Warning: Theme color key '$theme_color_key' not found. Using default." >&2
|
|
fi
|
|
|
|
printf "%b\n" "${color}${message}${base_colors[end]}"
|
|
}
|
|
|
|
# Function to check if a given string exists in ~/.zshrc
|
|
function zrep_find_string() {
|
|
local searchString="$1"
|
|
local found=0
|
|
|
|
while IFS= read -r line || [[ -n $line ]]; do
|
|
if [[ "$line" == *"$searchString"* ]]; then
|
|
found=1
|
|
break
|
|
fi
|
|
done < "${HOME}/.zshrc"
|
|
|
|
echo $found
|
|
}
|
|
|
|
function zrep_check_for_deps() {
|
|
# Array of required external programs
|
|
local required_programs=('jq' "${config[global_downloader]}")
|
|
|
|
# Iterate over the array
|
|
for program in "${required_programs[@]}"; do
|
|
# Check if the program is available in the system's PATH
|
|
if ! command -v "$program" &> /dev/null; then
|
|
# Program not found, display a message
|
|
echo "Required program not found: $program"
|
|
fi
|
|
done
|
|
}
|
|
|
|
# The first step after downloading zrep.
|
|
# Here we create the default file and directory structure
|
|
function zrep_init() {
|
|
local zshrc_file="${HOME}/.zshrc"
|
|
local zrep_addons="${HOME}/.zrep_addons"
|
|
local install_dir
|
|
|
|
# Check if .zreprc exists
|
|
if [[ ! -f ${ZREP_CONFIG} ]]; then
|
|
echo "${ZREP_CONFIG} not found. Creating it..."
|
|
# Prompt user for install directory
|
|
read "install_dir?Enter zrep installation directory [${HOME}/.zrep]: "
|
|
install_dir=${install_dir:-"${HOME}/.zrep"}
|
|
mkdir -p ${install_dir}
|
|
read "downloader?Choose command to download packages [curl, wget, wget2]: "
|
|
if [[ ${downloader} != curl && ${downloader} != wget && ${downloader} != wget2 ]]; then
|
|
echo "Invalid choice: '$downloader'. Try again."
|
|
read "downloader?Choose command to download packages [curl, wget, wget2] "
|
|
if [[ ${downloader} != curl && ${downloader} != wget && ${downloader} != wget2 ]]; then
|
|
echo "Invalid choice: '$downloader'. Exiting."
|
|
exit
|
|
fi
|
|
fi
|
|
|
|
# Write to .zreprc
|
|
cat > "${ZREP_CONFIG}" <<EOF
|
|
[main]
|
|
zrep_install_dir = ${install_dir}
|
|
|
|
[global]
|
|
repo_url = https://kekepower.com/zrep
|
|
theme = classic
|
|
downloader = ${downloader}
|
|
EOF
|
|
echo "The file '${ZREP_CONFIG}' has been created."
|
|
else
|
|
zrep_fpath ${HOME}/.zrep/functions
|
|
autoload -Uz zini
|
|
echo "Loading configuration from ${ZREP_CONFIG}"
|
|
zini ${ZREP_CONFIG}
|
|
# install_dir=${config[main_zrep_install_dir]}
|
|
fi
|
|
|
|
if [[ $(zrep_find_string zini) -eq 0 ]]; then
|
|
mkdir -p "${install_dir}/functions/zini"
|
|
curl -s https://raw.githubusercontent.com/kekePower/zini/main/zini -o "${install_dir}/functions/zini/zini"
|
|
echo "Adding 'zini' path to fpath in ${zshrc_file}"
|
|
echo "fpath=(${install_dir}/functions/zini \$fpath)" >> ${zshrc_file}
|
|
autoload -Uz zini
|
|
fi
|
|
|
|
# Check if .zshrc already sources .zrep_addons, if not, add it
|
|
if [[ $(zrep_find_string "source ${zrep_addons}") -eq 0 ]]; then
|
|
echo "Adding source command for .zrep_addons to .zshrc..."
|
|
echo "source ${zrep_addons}" >> "${zshrc_file}"
|
|
fi
|
|
|
|
# Create or update the .zrep_addons file
|
|
if [[ ! -f ${zrep_addons} ]]; then
|
|
echo "Creating file ${zrep_addons}..."
|
|
touch ${install_dir}/.addons
|
|
cat > "${zrep_addons}" <<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
|
|
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
|
|
|
|
if [[ ! -d ${install_dir}/themes ]]; then
|
|
echo "Installing the Classic theme to ${install_dir}/themes"
|
|
mkdir -p ${install_dir}/themes
|
|
curl -s https://git.kekepower.com/kekePower/zrep/raw/branch/main/themes/classic -o ${install_dir}/themes/classic
|
|
fi
|
|
echo "zrep initialization complete."
|
|
echo "Remember to 'source ${zshrc_file}' to load the 'zrep' settings."
|
|
}
|
|
|
|
function zrep_installed_json() {
|
|
|
|
# Check if installed.json exists
|
|
if [[ ! -f "${config[main_zrep_install_dir]}/installed.json" ]]; then
|
|
zrep_msg debug "\nError: installed.json not found."
|
|
return 1
|
|
else
|
|
installed_json="${config[main_zrep_install_dir]}/installed.json"
|
|
export installed_json=${installed_json}
|
|
fi
|
|
|
|
}
|
|
|
|
# Function to parse remote JSON data and extract author, script, and version
|
|
# and return the correct download url
|
|
function zrep_parse_remote() {
|
|
local url="${1}"
|
|
local package="${2}"
|
|
local author_name="${package%%/*}"
|
|
local script_name="${package#*/}"
|
|
local json_data
|
|
|
|
# Fetch JSON data from the URL
|
|
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
|
|
|
|
else
|
|
zrep_msg debug "\nPackage ${package} not found."
|
|
fi
|
|
}
|
|
|
|
# Function to write to installed.json after successful install
|
|
function zrep_update_installed_json() {
|
|
local author="${1}"
|
|
local script="${2}"
|
|
local version="${3}"
|
|
zrep_installed_json
|
|
|
|
# Ensure the JSON file exists and is not empty, creating an empty object if necessary
|
|
if [[ ! -f "${installed_json}" ]] || [[ ! -s "${installed_json}" ]]; then
|
|
echo "{}" > "${installed_json}"
|
|
fi
|
|
|
|
# Update or add the script entry
|
|
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' "$installed_json" > "$installed_json.tmp" && mv "$installed_json.tmp" "$installed_json"
|
|
|
|
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() {
|
|
zrep_installed_json
|
|
|
|
# Check if installed.json exists and is not empty
|
|
if [[ ! -s "${installed_json}" ]]; then
|
|
zrep_msg info "\nNo packages installed."
|
|
return
|
|
fi
|
|
|
|
# Parse installed.json and list packages
|
|
zrep_msg sub "\nInstalled packages:"
|
|
|
|
# Check if the JSON file is effectively empty ({} or [])
|
|
if jq -e 'if type == "object" then . == {} elif type == "array" then . == [] else false end' "${installed_json}" >/dev/null; then
|
|
zrep_msg info "\nNo packages installed."
|
|
return
|
|
fi
|
|
|
|
# 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
|
|
local package_name=$(echo "${package_info}" | cut -d ' ' -f1) # Extract package name before the version
|
|
local is_active="${base_colors[white]}(${base_colors[end]}${base_colors[bold_red]}Inactive${base_colors[end]}${base_colors[white]})${base_colors[end]}" # Set default to Inactive
|
|
|
|
zmodload zsh/regex
|
|
# Check if the package is active (only modify if active)
|
|
if [[ $(<${config[main_zrep_install_dir]}/.addons) =~ "\b${package_name}\b" ]]; then
|
|
is_active="${base_colors[white]}(${base_colors[end]}${base_colors[bold_green]}Active${base_colors[end]}${base_colors[white]})${base_colors[end]}"
|
|
fi
|
|
|
|
zrep_msg info " |> ${package_info} ${is_active}"
|
|
done
|
|
}
|
|
|
|
function zrep_list_package() {
|
|
zrep_installed_json
|
|
local package_names=""
|
|
|
|
# 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
|
|
package_names+="${package_info} "
|
|
done
|
|
|
|
# Assuming you want to print out the concatenated package names
|
|
if [[ -n "${package_names}" ]]; then
|
|
zrep_msg info "\nInstalled packages: ${package_names}"
|
|
else
|
|
zrep_msg debug "\nNo packages found."
|
|
fi
|
|
}
|
|
|
|
# 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
|
|
|
|
if [[ -f "${ZREP_CONFIG}" ]]; then
|
|
zini "${ZREP_CONFIG}"
|
|
zrep_fpath ${config[main_zrep_install_dir]}
|
|
else
|
|
if [[ "${1}" == "init" ]]; then
|
|
echo "\nWelcome to zrep. Looks like this is the first time you are"
|
|
echo "running me."
|
|
read "response?Are you ready to set up zrep? (y/n): "
|
|
if [[ "${response}" =~ ^[Yy]$ ]]; then
|
|
zrep_init
|
|
else
|
|
echo "Setup aborted. Try again later."
|
|
fi
|
|
else
|
|
# echo "${ZREP_CONFIG} not found."
|
|
# Ask the user if they want to run 'zrep init'
|
|
echo "\nWelcome to zrep. I was unable to find the config file."
|
|
read "response?Would you like to run 'zrep init' to set up? (y/n): "
|
|
if [[ "${response}" =~ ^[Yy]$ ]]; then
|
|
zrep_init
|
|
else
|
|
echo "Initialization canceled. Please run 'zrep init' manually to set up."
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
function zrep_remove_package() {
|
|
local package_name="${1}"
|
|
zrep_installed_json
|
|
|
|
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="${author:0:1:l}"
|
|
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
|
|
|
|
if [[ "${REPLY}" =~ ^[Yy]$ ]]; then
|
|
# Remove the package directory from disk
|
|
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}"
|
|
zrep_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' "$installed_json")
|
|
|
|
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"
|
|
zrep_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)"' "$installed_json")
|
|
|
|
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
|
|
|
|
if [[ ${updates} == "false" ]]; then
|
|
zrep_msg info "\nNo updates found."
|
|
fi
|
|
|
|
}
|
|
|
|
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
|
|
zrep_msg info "\nNo 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
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Enhanced zrep_downloader function with error handling and retry logic.
|
|
# It attempts to download a file from a given URL to a specified zip file using curl, wget, or wget2 based on the global configuration.
|
|
# This function supports retries and delays between attempts for robust error handling.
|
|
#
|
|
# Usage: zrep_download_package ZipFile DownloadURL
|
|
#
|
|
# Parameters:
|
|
# DownloadURL: The URL from which to download the file.
|
|
# ZipFile: The name of the file to save the downloaded content to.
|
|
|
|
function zrep_download_package() {
|
|
local ZipFile="${1}"
|
|
local DownloadURL="${2}"
|
|
local retries=5
|
|
local delay=5
|
|
local attempt=1
|
|
local downloader=""
|
|
local http_status
|
|
local cmd
|
|
|
|
case "${config[global_downloader]}" in
|
|
curl)
|
|
downloader="curl"
|
|
cmd="curl -s -o \"$ZipFile\" \"$DownloadURL\" -w \"%{http_code}\""
|
|
;;
|
|
wget)
|
|
downloader="wget"
|
|
cmd="wget -q -O \"$ZipFile\" \"$DownloadURL\"; echo $?"
|
|
;;
|
|
wget2)
|
|
downloader="wget2"
|
|
cmd="wget2 -q -O \"$ZipFile\" \"$DownloadURL\"; echo $?"
|
|
;;
|
|
*)
|
|
zrep_msg debug "Unsupported or unspecified downloader: '${config[global_downloader]}'."
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
while (( attempt <= retries )); do
|
|
zrep_msg sub "Attempt $attempt of $retries: Downloading using $downloader..."
|
|
|
|
if [[ $downloader == "curl" ]]; then
|
|
eval $cmd
|
|
http_status="${PIPESTATUS[0]}"
|
|
else # wget or wget2
|
|
http_status=$(eval $cmd)
|
|
fi
|
|
|
|
# Check if download command was successful (0 exit status) and, for curl, HTTP status is 200 (OK)
|
|
if [[ $down_status -eq 0 && ($downloader != "curl" || $http_status -eq 200) ]]; then
|
|
zrep_msg sub "Download successful."
|
|
return 0
|
|
else
|
|
zrep_msg debug "Error: Failed to download the package. HTTP status (curl only): ${http_status}."
|
|
((attempt++))
|
|
zrep_msg info "Waiting ${delay} seconds before retrying..."
|
|
sleep $delay
|
|
fi
|
|
done
|
|
|
|
zrep_msg debug "Error: The download failed after $retries attempts."
|
|
return 1
|
|
}
|
|
|
|
# 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}"
|
|
|
|
local tmpDir="${config[main_zrep_install_dir]}/tmp"
|
|
|
|
mkdir -p "${tmpDir}"
|
|
|
|
local zipFile="${tmpDir}/${author}-${script}-${version}.zip"
|
|
zrep_download_package "${zipFile}" "${dlurl}"
|
|
|
|
unzip -q -aa -o "${zipFile}" -d "${config[main_zrep_install_dir]}"
|
|
|
|
if [[ $? -ne 0 ]]; then
|
|
zrep_msg debug "\nError: Failed to unzip the package."
|
|
return 1
|
|
else
|
|
zrep_update_installed_json "${author}" "${script}" "${version}"
|
|
fi
|
|
|
|
rm "${zipFile}"
|
|
}
|
|
|
|
# Function to parse installed.json
|
|
function zrep_parse_installed_json() {
|
|
|
|
zrep_installed_json
|
|
jq -c '.' "${installed_json}"
|
|
|
|
}
|
|
|
|
function zrep_parse_package_name() {
|
|
package_name="${1}"
|
|
zrep_installed_json
|
|
author="${package_name%/*}"
|
|
script="${package_name#*/}"
|
|
local first_letter="${author:0:1:l}"
|
|
addon_path="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
|
|
|
|
# Check if the package is installed
|
|
if ! jq -e --arg author "$author" --arg script "$script" '.[$author] | any(.script == $script)' "${installed_json}" &>/dev/null; then
|
|
zrep_msg debug "\nError: Package '${package_name}' is not installed."
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function zrep_enable() {
|
|
local package_name="${1}"
|
|
zrep_parse_package_name "${package_name}"
|
|
|
|
# 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
|
|
if [[ "${addon}" == "${addon_path}" ]]; then
|
|
addon_exists=1
|
|
break
|
|
fi
|
|
done
|
|
|
|
if ((addon_exists)); then
|
|
echo "Package '${package_name}' is already enabled."
|
|
return 0
|
|
fi
|
|
|
|
# Add addon path to the array
|
|
addons+=("${addon_path}")
|
|
|
|
# Reconstruct .zrep_addons file with the updated addons array
|
|
{
|
|
echo "addons=("
|
|
for addon in "${addons[@]}"; do
|
|
echo " '${addon}'"
|
|
done
|
|
echo ")"
|
|
} > "${config[main_zrep_install_dir]}/.addons"
|
|
|
|
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() {
|
|
local package_name="${1}"
|
|
zrep_parse_package_name "${package_name}"
|
|
|
|
# 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
|
|
if [[ "${addon}" == "${addon_path}" ]]; then
|
|
found=1
|
|
else
|
|
new_addons+=("${addon}")
|
|
fi
|
|
done
|
|
|
|
if ((found == 0)); then
|
|
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
|
|
echo " '${addon}'"
|
|
done
|
|
echo ")"
|
|
} > ${config[main_zrep_install_dir]}/.addons
|
|
|
|
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]"
|
|
zrep_msg info "Available commands:"
|
|
if [[ ! -f ${ZREP_CONFIG} ]]; then
|
|
zrep_msg info " init: Initialize zrep"
|
|
fi
|
|
zrep_msg info " install (i) <author/package>:\t\t\tInstall a package"
|
|
zrep_msg info " remove (rm, delete, del) <author/package>:\tRemove a package"
|
|
zrep_msg info " update (u) <author/package>:\t\t\tUpdate zrep package"
|
|
zrep_msg info " enable <author/package>:\t\t\tEnable zrep package"
|
|
zrep_msg info " disable <author/package>:\t\t\tDisable zrep package"
|
|
zrep_msg info " version:\t\t\t\t\tDisplay zrep version"
|
|
zrep_msg info " list:\t\t\t\t\t\tList installed packages"
|
|
zrep_msg info " <author/package> help:\t\t\tDisplay help for pacakage (if available)"
|
|
|
|
}
|
|
|
|
function zrep_package_info() {
|
|
local package_name="${1}"
|
|
zrep_installed_json # Ensure installed.json is loaded and available
|
|
|
|
# Parse the package name to extract author and script
|
|
local author="${package_name%/*}"
|
|
local script="${package_name#*/}"
|
|
local first_letter="${author:0:1:l}" # Get the first letter of the author's name to construct the URL
|
|
|
|
# Check if the package is installed and get its version
|
|
if zrep_check_if_installed "${package_name}"; then
|
|
local installed_version="${installed_version}" # This variable is set by zrep_check_if_installed
|
|
local package_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
|
|
local zrep_url="${config[global_repo_url]}/${first_letter}/${author}/${script}"
|
|
|
|
# Display package information
|
|
zrep_msg info "\nAuthor/Package:\t\t${author}/${script}"
|
|
zrep_msg info "Version installed:\t${installed_version}"
|
|
zrep_msg info "Location on disk:\t${package_dir}"
|
|
zrep_msg info "zrep URL:\t\t${zrep_url}"
|
|
else
|
|
zrep_msg debug "\nPackage '${package_name}' is not installed."
|
|
fi
|
|
}
|
|
|
|
function zrep_read_usage() {
|
|
local package_name="${1}"
|
|
# Parse the package name to extract author and script
|
|
local author="${package_name%/*}"
|
|
local script="${package_name#*/}"
|
|
local first_letter="${author:0:1:l}"
|
|
|
|
# Construct the path to the USAGE file
|
|
local usage_file="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}/USAGE"
|
|
|
|
# Check if the USAGE file exists
|
|
if [[ -f "${usage_file}" ]]; then
|
|
# Display the content of the USAGE file
|
|
zrep_msg sub "\n${package_name}:"
|
|
local usage_buffer=$(<${usage_file})
|
|
zrep_msg info "${usage_buffer}"
|
|
else
|
|
zrep_msg debug "No USAGE file found for package '${package_name}'."
|
|
fi
|
|
}
|
|
|
|
function main() {
|
|
|
|
zrep_main_version_string
|
|
zrep_load_config ${1}
|
|
zrep_load_theme ${config[global_theme]}
|
|
|
|
# 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
|
|
|
|
# Example command handling structure
|
|
case "${1}" in
|
|
init)
|
|
zrep_init
|
|
zrep_check_for_deps
|
|
exit
|
|
;;
|
|
install | i)
|
|
zrep_install_package ${2}
|
|
;;
|
|
remove | delete | rm | del)
|
|
# Parse the command argument to extract the package name
|
|
zrep_remove_package_name="${2:-}"
|
|
if [[ -z "${zrep_remove_package_name}" ]]; then
|
|
zrep_msg info "\nUsage: zrep ${1} author/package"
|
|
else
|
|
zrep_remove_package "${zrep_remove_package_name}"
|
|
fi
|
|
;;
|
|
update | u)
|
|
zrep_update_package ${2}
|
|
;;
|
|
version | -v | --version)
|
|
zrep_version
|
|
;;
|
|
list)
|
|
zrep_list_installed_packages
|
|
;;
|
|
help | -h | --help)
|
|
zrep_help
|
|
;;
|
|
enable)
|
|
zrep_enable ${2}
|
|
;;
|
|
disable)
|
|
zrep_disable ${2}
|
|
;;
|
|
info)
|
|
zrep_package_info ${2}
|
|
;;
|
|
*)
|
|
zrep_help
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Call main with all passed arguments
|
|
main "$@"
|