595 lines
19 KiB
Bash
Executable File
595 lines
19 KiB
Bash
Executable File
#!/usr/bin/zsh
|
|
|
|
setopt extendedglob
|
|
|
|
VERSION="0.0.1" # Sat-2024-02-24
|
|
ZREP="Zsh Repository Tool"
|
|
# Define the 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
|
|
}
|
|
|
|
zrep_fpath ${HOME}/.zrep/functions
|
|
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[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() {
|
|
local zshrc_file="${HOME}/.zshrc"
|
|
local addons_file="${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"}
|
|
|
|
# Write to .zreprc
|
|
echo "[main]" > ${ZREP_CONFIG}
|
|
echo "zrep_install_dir='${install_dir}'" >> "${ZREP_CONFIG}"
|
|
else
|
|
echo "Loading configuration from ${ZREP_CONFIG}"
|
|
zini ${ZREP_CONFIG}
|
|
install_dir=${config[main_zrep_install_dir]}
|
|
fi
|
|
|
|
# Ensure zrep_install_dir exists
|
|
mkdir -p "${install_dir}/functions/zini"
|
|
curl -s https://raw.githubusercontent.com/kekePower/zini/main/zini -o "${install_dir}/functions/zini/zini"
|
|
echo "fpath=(${install_dir}/functions/zini \$fpath)" >> ${zshrc_file}
|
|
|
|
# Check if .zshrc already sources .zrep_addons, if not, add it
|
|
if ! grep -q "source ${addons_file}" "${zshrc_file}"; then
|
|
echo "Adding source command for .zrep_addons to .zshrc..."
|
|
echo "source ${addons_file}" >> "${zshrc_file}"
|
|
fi
|
|
|
|
# Create or update the .zrep_addons file
|
|
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
|
|
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."
|
|
}
|
|
|
|
# Function to parse remote JSON data and extract author, script, and version
|
|
function zrep_parse_remote() {
|
|
|
|
local url="${1}"
|
|
local json_data
|
|
|
|
# Fetch JSON data from the URL
|
|
json_data=$(curl -s "${url}")
|
|
|
|
# Extract author, script, and version using jq
|
|
author=$(echo "${json_data}" | jq -r '.authors[0].name')
|
|
script=$(echo "${json_data}" | jq -r '.authors[0].scripts[0].name')
|
|
version=$(echo "${json_data}" | jq -r '.authors[0].scripts[0].version')
|
|
|
|
# Set the variables as global
|
|
export author
|
|
export script
|
|
export version
|
|
|
|
}
|
|
|
|
# Function to write to installed.json after successful install
|
|
function zrep_update_installed_json() {
|
|
local author="${1}"
|
|
local script="${2}"
|
|
local version="${3}"
|
|
local json_file="${config[main_zrep_install_dir]}/installed.json"
|
|
|
|
# Check if the JSON file exists and create it if not
|
|
if [[ ! -f "${json_file}" ]]; then
|
|
echo "{}" > "${json_file}" # Initialize with an empty object
|
|
fi
|
|
|
|
# Proper jq command to update the JSON
|
|
jq --arg author "${author}" --arg script "${script}" --arg version "${version}" \
|
|
'if .[${author}] then
|
|
.[${author}] += [{"script": ${script}, "version": ${version}}]
|
|
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 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
|
|
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
|
|
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)
|
|
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
|
|
|
|
zrep_msg info " - ${package_info} ${is_active}"
|
|
done
|
|
}
|
|
|
|
function zrep_list_package() {
|
|
local installed_json="${config[main_zrep_install_dir]}/installed.json"
|
|
local package_names=""
|
|
|
|
# Check if installed.json exists
|
|
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
|
|
package_names+="${package_info} "
|
|
done
|
|
|
|
# Assuming you want to print out the concatenated package names
|
|
if [[ -n "${package_names}" ]]; then
|
|
echo "Installed packages: ${package_names}"
|
|
else
|
|
echo "No 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 "${ZREP_CONFIG} not found. Proceeding with 'zrep init'..."
|
|
zrep_init
|
|
else
|
|
echo "${ZREP_CONFIG} not found."
|
|
# Ask the user if they want to run 'zrep init'
|
|
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}"
|
|
local installed_json="${config[main_zrep_install_dir]}/installed.json"
|
|
|
|
# Check if installed.json exists
|
|
if [[ ! -f "${installed_json}" ]]; then
|
|
echo "Error: installed.json not found."
|
|
return 1
|
|
fi
|
|
|
|
# Get package information from installed.json
|
|
local package_info
|
|
package_info=$(zrep_parse_installed_json | jq ".[] | select(.author + \"/\" + .script == \"${package_name}\")")
|
|
|
|
# Check if the package is installed
|
|
if [[ -z "${package_info}" ]]; then
|
|
echo "Error: Package '${package_name}' is not installed."
|
|
return 1
|
|
fi
|
|
|
|
local author=$(echo "${package_info}" | jq -r '.author')
|
|
local script=$(echo "${package_info}" | jq -r '.script')
|
|
local first_letter=$(echo "${author}" | cut -c 1 | tr '[:upper:]' '[:lower:]')
|
|
local package_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
|
|
|
|
echo "Package information:"
|
|
echo "${package_info}" | jq .
|
|
|
|
# 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}"
|
|
echo "Package directory '${package_dir}' removed successfully."
|
|
else
|
|
echo "Warning: Package directory '${package_dir}' not found."
|
|
fi
|
|
|
|
# Safely check and remove author and first letter directories if empty
|
|
local author_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}"
|
|
if [[ -d "${author_dir}" && ! "$(ls -A "${author_dir}")" ]]; then
|
|
rmdir "${author_dir}"
|
|
echo "Author directory '${author_dir}' removed successfully."
|
|
fi
|
|
|
|
if [[ -d "${config[main_zrep_install_dir]}/${first_letter}" && ! "$(ls -A "${config[main_zrep_install_dir]}/${first_letter}")" ]]; then
|
|
rmdir "${config[main_zrep_install_dir]}/${first_letter}"
|
|
echo "First letter directory '${config[main_zrep_install_dir]}/${first_letter}' removed successfully."
|
|
fi
|
|
|
|
# Remove the package from installed.json
|
|
jq "del(.[] | select(.author == \"${author}\" and .script == \"${script}\"))" "${installed_json}" > "${installed_json}.tmp" && mv "${installed_json}.tmp" "${installed_json}"
|
|
echo "Package '${package_name}' removed successfully from installed.json."
|
|
else
|
|
echo "Removal canceled."
|
|
fi
|
|
}
|
|
|
|
# Function to install a package by unzipping it to ${config[main_zrep_install_dir]}
|
|
function zrep_install_package() {
|
|
|
|
zrep_parse_remote "https://kekepower.com/zrep/packages.json"
|
|
|
|
# Construct the download URL
|
|
local dlurl="https://kekepower.com/zrep/download.php?a=${author}&s=${script}&v=${version}"
|
|
|
|
# Get the base directory where the package will be installed
|
|
local baseDir="${config[main_zrep_install_dir]}/"
|
|
local tmpDir="${baseDir}/tmp"
|
|
|
|
# Create the directory if it doesn't exist
|
|
mkdir -p "${tmpDir}"
|
|
|
|
# Download the package zip file
|
|
local zipFile="${tmpDir}/${author}_${package}_${version}.zip"
|
|
curl -s -o "${zipFile}" "${dlurl}"
|
|
|
|
# Check if the download was successful
|
|
if [[ $? -ne 0 ]]; then
|
|
echo "Error: Failed to download the package."
|
|
return 1
|
|
fi
|
|
|
|
# Unzip the package to the installation directory
|
|
unzip -q "${zipFile}" -d "${baseDir}"
|
|
|
|
# Check if the unzip operation was successful
|
|
if [[ $? -ne 0 ]]; then
|
|
echo "Error: Failed to unzip the package."
|
|
return 1
|
|
else
|
|
zrep_update_installed_json "${author}" "${script}" "${version}"
|
|
fi
|
|
|
|
# Clean up: Remove the downloaded zip file
|
|
rm "${zipFile}"
|
|
|
|
}
|
|
|
|
# Function to parse installed.json
|
|
function zrep_parse_installed_json() {
|
|
|
|
local installed_json="${config[main_zrep_install_dir]}/installed.json"
|
|
jq -c '.' "${installed_json}"
|
|
|
|
}
|
|
|
|
function zrep_parse_package_name() {
|
|
# echo "Looking for package ${1}"
|
|
package_name="${1}"
|
|
installed_json="${config[main_zrep_install_dir]}/installed.json"
|
|
author="${package_name%/*}"
|
|
script="${package_name#*/}"
|
|
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
|
|
echo "Error: Package '${package_name}' is not installed."
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function zrep_enable() {
|
|
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
|
|
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"
|
|
|
|
# Source the updated .zrep_addons to apply changes
|
|
source "${HOME}/.zrep_addons"
|
|
autoload -Uz "${script}"
|
|
|
|
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}"
|
|
|
|
# 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
|
|
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
|
|
|
|
# Source the updated .zrep_addons to apply changes
|
|
source ${HOME}/.zrep_addons
|
|
unfunction ${script} 2>/dev/null || true
|
|
|
|
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:"
|
|
zrep_msg info " init: Initialize zrep"
|
|
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() {
|
|
local package_name="${1}"
|
|
# Parse the package name to extract author and script
|
|
local author="${package_name%/*}"
|
|
local script="${package_name#*/}"
|
|
local first_letter=$(echo "${author}" | cut -c 1 | tr '[:upper:]' '[:lower:]')
|
|
|
|
# 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
|
|
|
|
# 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_fpath ${config[main_zrep_install_dir]}
|
|
exit
|
|
;;
|
|
install | i)
|
|
zrep_msg info "Install function here"
|
|
zrep_install_package ${1}
|
|
;;
|
|
remove | delete | rm)
|
|
# Parse the command argument to extract the package name
|
|
zrep_remove_package_name="${2:-}"
|
|
if [[ -z "${zrep_remove_package_name}" ]]; then
|
|
echo "Usage: zrep remove author/package"
|
|
else
|
|
zrep_remove_package "${zrep_remove_package_name}"
|
|
fi
|
|
;;
|
|
update | u)
|
|
zrep_msg info "Update function here"
|
|
;;
|
|
version | -v | --version)
|
|
zrep_version
|
|
;;
|
|
list)
|
|
zrep_list_installed_packages
|
|
;;
|
|
help | -h | --help)
|
|
zrep_help
|
|
;;
|
|
enable)
|
|
zrep_enable ${2}
|
|
source "${HOME}/.zrep_addons"
|
|
;;
|
|
disable)
|
|
zrep_disable ${2}
|
|
source "${HOME}/.zrep_addons"
|
|
;;
|
|
*)
|
|
zrep_help
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Call main with all passed arguments
|
|
main "$@"
|