You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1958 lines
58 KiB
1958 lines
58 KiB
#!/bin/sh
|
|
#
|
|
# pfetch - Simple POSIX sh fetch script.
|
|
|
|
# Wrapper around all escape sequences used by pfetch to allow for
|
|
# greater control over which sequences are used (if any at all).
|
|
esc() {
|
|
case $1 in
|
|
CUU) e="${esc_c}[${2}A" ;; # cursor up
|
|
CUD) e="${esc_c}[${2}B" ;; # cursor down
|
|
CUF) e="${esc_c}[${2}C" ;; # cursor right
|
|
CUB) e="${esc_c}[${2}D" ;; # cursor left
|
|
|
|
# text formatting
|
|
SGR)
|
|
case ${PF_COLOR:=1} in
|
|
(1)
|
|
e="${esc_c}[${2}m"
|
|
;;
|
|
|
|
(0)
|
|
# colors disabled
|
|
e=
|
|
;;
|
|
esac
|
|
;;
|
|
|
|
# line wrap
|
|
DECAWM)
|
|
case $TERM in
|
|
(dumb | minix | cons25)
|
|
# not supported
|
|
e=
|
|
;;
|
|
|
|
(*)
|
|
e="${esc_c}[?7${2}"
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Print a sequence to the terminal.
|
|
esc_p() {
|
|
esc "$@"
|
|
printf '%s' "$e"
|
|
}
|
|
|
|
# This is just a simple wrapper around 'command -v' to avoid
|
|
# spamming '>/dev/null' throughout this function. This also guards
|
|
# against aliases and functions.
|
|
has() {
|
|
_cmd=$(command -v "$1") 2>/dev/null || return 1
|
|
[ -x "$_cmd" ] || return 1
|
|
}
|
|
|
|
log() {
|
|
# The 'log()' function handles the printing of information.
|
|
# In 'pfetch' (and 'neofetch'!) the printing of the ascii art and info
|
|
# happen independently of each other.
|
|
#
|
|
# The size of the ascii art is stored and the ascii is printed first.
|
|
# Once the ascii is printed, the cursor is located right below the art
|
|
# (See marker $[1]).
|
|
#
|
|
# Using the stored ascii size, the cursor is then moved to marker $[2].
|
|
# This is simply a cursor up escape sequence using the "height" of the
|
|
# ascii art.
|
|
#
|
|
# 'log()' then moves the cursor to the right the "width" of the ascii art
|
|
# with an additional amount of padding to add a gap between the art and
|
|
# the information (See marker $[3]).
|
|
#
|
|
# When 'log()' has executed, the cursor is then located at marker $[4].
|
|
# When 'log()' is run a second time, the next line of information is
|
|
# printed, moving the cursor to marker $[5].
|
|
#
|
|
# Markers $[4] and $[5] repeat all the way down through the ascii art
|
|
# until there is no more information left to print.
|
|
#
|
|
# Every time 'log()' is called the script keeps track of how many lines
|
|
# were printed. When printing is complete the cursor is then manually
|
|
# placed below the information and the art according to the "heights"
|
|
# of both.
|
|
#
|
|
# The math is simple: move cursor down $((ascii_height - info_height)).
|
|
# If the aim is to move the cursor from marker $[5] to marker $[6],
|
|
# plus the ascii height is 8 while the info height is 2 it'd be a move
|
|
# of 6 lines downwards.
|
|
#
|
|
# However, if the information printed is "taller" (takes up more lines)
|
|
# than the ascii art, the cursor isn't moved at all!
|
|
#
|
|
# Once the cursor is at marker $[6], the script exits. This is the gist
|
|
# of how this "dynamic" printing and layout works.
|
|
#
|
|
# This method allows ascii art to be stored without markers for info
|
|
# and it allows for easy swapping of info order and amount.
|
|
#
|
|
# $[2] ___ $[3] goldie@KISS
|
|
# $[4](.· | $[5] os KISS Linux
|
|
# (<> |
|
|
# / __ \
|
|
# ( / \ /|
|
|
# _/\ __)/_)
|
|
# \/-____\/
|
|
# $[1]
|
|
#
|
|
# $[6] /home/goldie $
|
|
|
|
# End here if no data was found.
|
|
[ "$2" ] || return
|
|
|
|
# Store the values of '$1' and '$3' as we reset the argument list below.
|
|
name=$1
|
|
use_seperator=$3
|
|
|
|
# Use 'set --' as a means of stripping all leading and trailing
|
|
# white-space from the info string. This also normalizes all
|
|
# white-space inside of the string.
|
|
#
|
|
# Disable the shellcheck warning for word-splitting
|
|
# as it's safe and intended ('set -f' disables globbing).
|
|
# shellcheck disable=2046,2086
|
|
{
|
|
set -f
|
|
set +f -- $2
|
|
info=$*
|
|
}
|
|
|
|
# Move the cursor to the right, the width of the ascii art with an
|
|
# additional gap for text spacing.
|
|
esc_p CUF "$ascii_width"
|
|
|
|
# Print the info name and color the text.
|
|
esc_p SGR "3${PF_COL1-4}";
|
|
esc_p SGR 1
|
|
printf '%s' "$name"
|
|
esc_p SGR 0
|
|
|
|
# Print the info name and info data separator, if applicable.
|
|
[ "$use_seperator" ] || printf %s "$PF_SEP"
|
|
|
|
# Move the cursor backward the length of the *current* info name and
|
|
# then move it forwards the length of the *longest* info name. This
|
|
# aligns each info data line.
|
|
esc_p CUB "${#name}"
|
|
esc_p CUF "${PF_ALIGN:-$info_length}"
|
|
|
|
# Print the info data, color it and strip all leading whitespace
|
|
# from the string.
|
|
esc_p SGR "3${PF_COL2-9}"
|
|
printf '%s' "$info"
|
|
esc_p SGR 0
|
|
printf '\n'
|
|
|
|
# Keep track of the number of times 'log()' has been run.
|
|
info_height=$((${info_height:-0} + 1))
|
|
}
|
|
|
|
get_title() {
|
|
# Username is retrieved by first checking '$USER' with a fallback
|
|
# to the 'id -un' command.
|
|
user=${USER:-$(id -un)}
|
|
|
|
# Hostname is retrieved by first checking '$HOSTNAME' with a fallback
|
|
# to the 'hostname' command.
|
|
#
|
|
# Disable the warning about '$HOSTNAME' being undefined in POSIX sh as
|
|
# the intention for using it is allowing the user to overwrite the
|
|
# value on invocation.
|
|
# shellcheck disable=3028,2039
|
|
hostname=${HOSTNAME:-${hostname:-$(hostname)}}
|
|
|
|
# If the hostname is still not found, fallback to the contents of the
|
|
# /etc/hostname file.
|
|
[ "$hostname" ] || read -r hostname < /etc/hostname
|
|
|
|
# Add escape sequences for coloring to user and host name. As we embed
|
|
# them directly in the arguments passed to log(), we cannot use esc_p().
|
|
esc SGR 1
|
|
user=$e$user
|
|
esc SGR "3${PF_COL3:-1}"
|
|
user=$e$user
|
|
esc SGR 1
|
|
user=$user$e
|
|
esc SGR 1
|
|
hostname=$e$hostname
|
|
esc SGR "3${PF_COL3:-1}"
|
|
hostname=$e$hostname
|
|
|
|
log "${user}@${hostname}" " " " " >&6
|
|
}
|
|
|
|
get_os() {
|
|
# This function is called twice, once to detect the distribution name
|
|
# for the purposes of picking an ascii art early and secondly to display
|
|
# the distribution name in the info output (if enabled).
|
|
#
|
|
# On first run, this function displays _nothing_, only on the second
|
|
# invocation is 'log()' called.
|
|
[ "$distro" ] && {
|
|
log os "$distro" >&6
|
|
return
|
|
}
|
|
|
|
case $os in
|
|
(Linux*)
|
|
# Some Linux distributions (which are based on others)
|
|
# fail to identify as they **do not** change the upstream
|
|
# distribution's identification packages or files.
|
|
#
|
|
# It is senseless to add a special case in the code for
|
|
# each and every distribution (which _is_ technically no
|
|
# different from what it is based on) as they're either too
|
|
# lazy to modify upstream's identification files or they
|
|
# don't have the know-how (or means) to ship their own
|
|
# lsb-release package.
|
|
#
|
|
# This causes users to think there's a bug in system detection
|
|
# tools like neofetch or pfetch when they technically *do*
|
|
# function correctly.
|
|
#
|
|
# Exceptions are made for distributions which are independent,
|
|
# not based on another distribution or follow different
|
|
# standards.
|
|
#
|
|
# This applies only to distributions which follow the standard
|
|
# by shipping unmodified identification files and packages
|
|
# from their respective upstreams.
|
|
if has lsb_release; then
|
|
distro=$(lsb_release -sd)
|
|
|
|
# Android detection works by checking for the existence of
|
|
# the follow two directories. I don't think there's a simpler
|
|
# method than this.
|
|
elif [ -d /system/app ] && [ -d /system/priv-app ]; then
|
|
distro="Android $(getprop ro.build.version.release)"
|
|
|
|
elif [ -f /etc/os-release ]; then
|
|
# This used to be a simple '. /etc/os-release' but I believe
|
|
# this is insecure as we blindly executed whatever was in the
|
|
# file. This parser instead simply handles 'key=val', treating
|
|
# the file contents as plain-text.
|
|
while IFS='=' read -r key val; do
|
|
case $key in
|
|
(PRETTY_NAME)
|
|
distro=$val
|
|
;;
|
|
esac
|
|
done < /etc/os-release
|
|
|
|
else
|
|
# Special cases for (independent) distributions which
|
|
# don't follow any os-release/lsb standards whatsoever.
|
|
has crux && distro=$(crux)
|
|
has guix && distro='Guix System'
|
|
fi
|
|
|
|
# 'os-release' and 'lsb_release' sometimes add quotes
|
|
# around the distribution name, strip them.
|
|
distro=${distro##[\"\']}
|
|
distro=${distro%%[\"\']}
|
|
|
|
# Check to see if we're running Bedrock Linux which is
|
|
# very unique. This simply checks to see if the user's
|
|
# PATH contains a Bedrock specific value.
|
|
case $PATH in
|
|
(*/bedrock/cross/*)
|
|
distro='Bedrock Linux'
|
|
;;
|
|
esac
|
|
|
|
# Check to see if Linux is running in Windows 10 under
|
|
# WSL1 (Windows subsystem for Linux [version 1]) and
|
|
# append a string accordingly.
|
|
#
|
|
# If the kernel version string ends in "-Microsoft",
|
|
# we're very likely running under Windows 10 in WSL1.
|
|
if [ "$WSLENV" ]; then
|
|
distro="${distro}${WSLENV+ on Windows 10 [WSL2]}"
|
|
|
|
# Check to see if Linux is running in Windows 10 under
|
|
# WSL2 (Windows subsystem for Linux [version 2]) and
|
|
# append a string accordingly.
|
|
#
|
|
# This checks to see if '$WSLENV' is defined. This
|
|
# appends the Windows 10 string even if '$WSLENV' is
|
|
# empty. We only need to check that is has been _exported_.
|
|
elif [ -z "${kernel%%*-Microsoft}" ]; then
|
|
distro="$distro on Windows 10 [WSL1]"
|
|
fi
|
|
;;
|
|
|
|
(Darwin*)
|
|
# Parse the SystemVersion.plist file to grab the macOS
|
|
# version. The file is in the following format:
|
|
#
|
|
# <key>ProductVersion</key>
|
|
# <string>10.14.6</string>
|
|
#
|
|
# 'IFS' is set to '<>' to enable splitting between the
|
|
# keys and a second 'read' is used to operate on the
|
|
# next line directly after a match.
|
|
#
|
|
# '_' is used to nullify a field. '_ _ line _' basically
|
|
# says "populate $line with the third field's contents".
|
|
while IFS='<>' read -r _ _ line _; do
|
|
case $line in
|
|
# Match 'ProductVersion' and read the next line
|
|
# directly as it contains the key's value.
|
|
ProductVersion)
|
|
IFS='<>' read -r _ _ mac_version _
|
|
continue
|
|
;;
|
|
|
|
ProductName)
|
|
IFS='<>' read -r _ _ mac_product _
|
|
continue
|
|
;;
|
|
esac
|
|
done < /System/Library/CoreServices/SystemVersion.plist
|
|
|
|
# Use the ProductVersion to determine which macOS/OS X codename
|
|
# the system has. As far as I'm aware there's no "dynamic" way
|
|
# of grabbing this information.
|
|
case $mac_version in
|
|
(10.4*) distro='Mac OS X Tiger' ;;
|
|
(10.5*) distro='Mac OS X Leopard' ;;
|
|
(10.6*) distro='Mac OS X Snow Leopard' ;;
|
|
(10.7*) distro='Mac OS X Lion' ;;
|
|
(10.8*) distro='OS X Mountain Lion' ;;
|
|
(10.9*) distro='OS X Mavericks' ;;
|
|
(10.10*) distro='OS X Yosemite' ;;
|
|
(10.11*) distro='OS X El Capitan' ;;
|
|
(10.12*) distro='macOS Sierra' ;;
|
|
(10.13*) distro='macOS High Sierra' ;;
|
|
(10.14*) distro='macOS Mojave' ;;
|
|
(10.15*) distro='macOS Catalina' ;;
|
|
(11*) distro='macOS Big Sur' ;;
|
|
(12*) distro='macOS Monterey' ;;
|
|
(*) distro='macOS' ;;
|
|
esac
|
|
|
|
# Use the ProductName to determine if we're running in iOS.
|
|
case $mac_product in
|
|
(iP*) distro='iOS' ;;
|
|
esac
|
|
|
|
distro="$distro $mac_version"
|
|
;;
|
|
|
|
(Haiku)
|
|
# Haiku uses 'uname -v' for version information
|
|
# instead of 'uname -r' which only prints '1'.
|
|
distro=$(uname -sv)
|
|
;;
|
|
|
|
(Minix|DragonFly)
|
|
distro="$os $kernel"
|
|
|
|
# Minix and DragonFly don't support the escape
|
|
# sequences used, clear the exit trap.
|
|
trap '' EXIT
|
|
;;
|
|
|
|
(SunOS)
|
|
# Grab the first line of the '/etc/release' file
|
|
# discarding everything after '('.
|
|
IFS='(' read -r distro _ < /etc/release
|
|
;;
|
|
|
|
(OpenBSD*)
|
|
# Show the OpenBSD version type (current if present).
|
|
# kern.version=OpenBSD 6.6-current (GENERIC.MP) ...
|
|
IFS=' =' read -r _ distro openbsd_ver _ <<-EOF
|
|
$(sysctl kern.version)
|
|
EOF
|
|
|
|
distro="$distro $openbsd_ver"
|
|
;;
|
|
|
|
(FreeBSD)
|
|
distro="$os $(freebsd-version)"
|
|
;;
|
|
|
|
(*)
|
|
# Catch all to ensure '$distro' is never blank.
|
|
# This also handles the BSDs.
|
|
distro="$os $kernel"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
get_kernel() {
|
|
case $os in
|
|
# Don't print kernel output on some systems as the
|
|
# OS name includes it.
|
|
(*BSD*|Haiku|Minix)
|
|
return
|
|
;;
|
|
esac
|
|
|
|
# '$kernel' is the cached output of 'uname -r'.
|
|
log kernel "$kernel" >&6
|
|
}
|
|
|
|
get_host() {
|
|
case $os in
|
|
(Linux*)
|
|
# Despite what these files are called, version doesn't
|
|
# always contain the version nor does name always contain
|
|
# the name.
|
|
read -r name < /sys/devices/virtual/dmi/id/product_name
|
|
read -r version < /sys/devices/virtual/dmi/id/product_version
|
|
read -r model < /sys/firmware/devicetree/base/model
|
|
|
|
host="$name $version $model"
|
|
;;
|
|
|
|
(Darwin* | FreeBSD* | DragonFly*)
|
|
host=$(sysctl -n hw.model)
|
|
;;
|
|
|
|
(NetBSD*)
|
|
host=$(sysctl -n machdep.dmi.system-vendor \
|
|
machdep.dmi.system-product)
|
|
;;
|
|
|
|
(OpenBSD*)
|
|
host=$(sysctl -n hw.version)
|
|
;;
|
|
|
|
(*BSD* | Minix)
|
|
host=$(sysctl -n hw.vendor hw.product)
|
|
;;
|
|
esac
|
|
|
|
# Turn the host string into an argument list so we can iterate
|
|
# over it and remove OEM strings and other information which
|
|
# shouldn't be displayed.
|
|
#
|
|
# Disable the shellcheck warning for word-splitting
|
|
# as it's safe and intended ('set -f' disables globbing).
|
|
# shellcheck disable=2046,2086
|
|
{
|
|
set -f
|
|
set +f -- $host
|
|
host=
|
|
}
|
|
|
|
# Iterate over the host string word by word as a means of stripping
|
|
# unwanted and OEM information from the string as a whole.
|
|
#
|
|
# This could have been implemented using a long 'sed' command with
|
|
# a list of word replacements, however I want to show that something
|
|
# like this is possible in pure sh.
|
|
#
|
|
# This string reconstruction is needed as some OEMs either leave the
|
|
# identification information as "To be filled by OEM", "Default",
|
|
# "undefined" etc and we shouldn't print this to the screen.
|
|
for word do
|
|
# This works by reconstructing the string by excluding words
|
|
# found in the "blacklist" below. Only non-matches are appended
|
|
# to the final host string.
|
|
case $word in
|
|
(To | [Bb]e | [Ff]illed | [Bb]y | O.E.M. | OEM |\
|
|
Not | Applicable | Specified | System | Product | Name |\
|
|
Version | Undefined | Default | string | INVALID | � | os |\
|
|
Type1ProductConfigId )
|
|
continue
|
|
;;
|
|
esac
|
|
|
|
host="$host$word "
|
|
done
|
|
|
|
# '$arch' is the cached output from 'uname -m'.
|
|
log host "${host:-$arch}" >&6
|
|
}
|
|
|
|
get_uptime() {
|
|
# Uptime works by retrieving the data in total seconds and then
|
|
# converting that data into days, hours and minutes using simple
|
|
# math.
|
|
case $os in
|
|
(Linux* | Minix* | SerenityOS*)
|
|
IFS=. read -r s _ < /proc/uptime
|
|
;;
|
|
|
|
(Darwin* | *BSD* | DragonFly*)
|
|
s=$(sysctl -n kern.boottime)
|
|
|
|
# Extract the uptime in seconds from the following output:
|
|
# [...] { sec = 1271934886, usec = 667779 } Thu Apr 22 12:14:46 2010
|
|
s=${s#*=}
|
|
s=${s%,*}
|
|
|
|
# The uptime format from 'sysctl' needs to be subtracted from
|
|
# the current time in seconds.
|
|
s=$(($(date +%s) - s))
|
|
;;
|
|
|
|
(Haiku)
|
|
# The boot time is returned in microseconds, convert it to
|
|
# regular seconds.
|
|
s=$(($(system_time) / 1000000))
|
|
;;
|
|
|
|
(SunOS)
|
|
# Split the output of 'kstat' on '.' and any white-space
|
|
# which exists in the command output.
|
|
#
|
|
# The output is as follows:
|
|
# unix:0:system_misc:snaptime 14809.906993005
|
|
#
|
|
# The parser extracts: ^^^^^
|
|
IFS=' .' read -r _ s _ <<-EOF
|
|
$(kstat -p unix:0:system_misc:snaptime)
|
|
EOF
|
|
;;
|
|
|
|
(IRIX)
|
|
# Grab the uptime in a pretty format. Usually,
|
|
# 00:00:00 from the 'ps' command.
|
|
t=$(LC_ALL=POSIX ps -o etime= -p 1)
|
|
|
|
# Split the pretty output into days or hours
|
|
# based on the uptime.
|
|
case $t in
|
|
(*-*) d=${t%%-*} t=${t#*-} ;;
|
|
(*:*:*) h=${t%%:*} t=${t#*:} ;;
|
|
esac
|
|
|
|
h=${h#0} t=${t#0}
|
|
|
|
# Convert the split pretty fields back into
|
|
# seconds so we may re-convert them to our format.
|
|
s=$((${d:-0}*86400 + ${h:-0}*3600 + ${t%%:*}*60 + ${t#*:}))
|
|
;;
|
|
esac
|
|
|
|
# Convert the uptime from seconds into days, hours and minutes.
|
|
d=$((s / 60 / 60 / 24))
|
|
h=$((s / 60 / 60 % 24))
|
|
m=$((s / 60 % 60))
|
|
|
|
# Only append days, hours and minutes if they're non-zero.
|
|
case "$d" in ([!0]*) uptime="${uptime}${d}d "; esac
|
|
case "$h" in ([!0]*) uptime="${uptime}${h}h "; esac
|
|
case "$m" in ([!0]*) uptime="${uptime}${m}m "; esac
|
|
|
|
log uptime "${uptime:-0m}" >&6
|
|
}
|
|
|
|
get_pkgs() {
|
|
# This works by first checking for which package managers are
|
|
# installed and finally by printing each package manager's
|
|
# package list with each package one per line.
|
|
#
|
|
# The output from this is then piped to 'wc -l' to count each
|
|
# line, giving us the total package count of whatever package
|
|
# managers are installed.
|
|
packages=$(
|
|
case $os in
|
|
(Linux*)
|
|
# Commands which print packages one per line.
|
|
has bonsai && bonsai list
|
|
has crux && pkginfo -i
|
|
has pacman-key && pacman -Qq
|
|
has dpkg && dpkg-query -f '.\n' -W
|
|
has rpm && rpm -qa
|
|
has xbps-query && xbps-query -l
|
|
has apk && apk info
|
|
has guix && guix package --list-installed
|
|
has opkg && opkg list-installed
|
|
|
|
# Directories containing packages.
|
|
has kiss && printf '%s\n' /var/db/kiss/installed/*/
|
|
has cpt-list && printf '%s\n' /var/db/cpt/installed/*/
|
|
has brew && printf '%s\n' "$(brew --cellar)/"*
|
|
has emerge && printf '%s\n' /var/db/pkg/*/*/
|
|
has pkgtool && printf '%s\n' /var/log/packages/*
|
|
has eopkg && printf '%s\n' /var/lib/eopkg/package/*
|
|
|
|
# 'nix' requires two commands.
|
|
has nix-store && {
|
|
nix-store -q --requisites /run/current-system/sw
|
|
nix-store -q --requisites ~/.nix-profile
|
|
}
|
|
;;
|
|
|
|
(Darwin*)
|
|
# Commands which print packages one per line.
|
|
has pkgin && pkgin list
|
|
has dpkg && dpkg-query -f '.\n' -W
|
|
|
|
# Directories containing packages.
|
|
has brew && printf '%s\n' /usr/local/Cellar/*
|
|
|
|
# 'port' prints a single line of output to 'stdout'
|
|
# when no packages are installed and exits with
|
|
# success causing a false-positive of 1 package
|
|
# installed.
|
|
#
|
|
# 'port' should really exit with a non-zero code
|
|
# in this case to allow scripts to cleanly handle
|
|
# this behavior.
|
|
has port && {
|
|
pkg_list=$(port installed)
|
|
|
|
case "$pkg_list" in
|
|
("No ports are installed.")
|
|
# do nothing
|
|
;;
|
|
|
|
(*)
|
|
printf '%s\n' "$pkg_list"
|
|
;;
|
|
esac
|
|
}
|
|
;;
|
|
|
|
(FreeBSD*|DragonFly*)
|
|
pkg info
|
|
;;
|
|
|
|
(OpenBSD*)
|
|
printf '%s\n' /var/db/pkg/*/
|
|
;;
|
|
|
|
(NetBSD*)
|
|
pkg_info
|
|
;;
|
|
|
|
(Haiku)
|
|
printf '%s\n' /boot/system/package-links/*
|
|
;;
|
|
|
|
(Minix)
|
|
printf '%s\n' /usr/pkg/var/db/pkg/*/
|
|
;;
|
|
|
|
(SunOS)
|
|
has pkginfo && pkginfo -i
|
|
has pkg && pkg list
|
|
;;
|
|
|
|
(IRIX)
|
|
versions -b
|
|
;;
|
|
|
|
(SerenityOS)
|
|
while IFS=" " read -r type _; do
|
|
[ "$type" != dependency ] &&
|
|
printf "\n"
|
|
done < /usr/Ports/packages.db
|
|
;;
|
|
esac | wc -l
|
|
)
|
|
|
|
# 'wc -l' can have leading and/or trailing whitespace
|
|
# depending on the implementation, so strip them.
|
|
# Procedure explained at https://github.com/dylanaraps/pure-sh-bible
|
|
# (trim-leading-and-trailing-white-space-from-string)
|
|
packages=${packages#"${packages%%[![:space:]]*}"}
|
|
packages=${packages%"${packages##*[![:space:]]}"}
|
|
|
|
case $os in
|
|
# IRIX's package manager adds 3 lines of extra
|
|
# output which we must account for here.
|
|
(IRIX)
|
|
packages=$((packages - 3))
|
|
;;
|
|
|
|
# OpenBSD's wc prints whitespace before the output
|
|
# which needs to be stripped.
|
|
(OpenBSD)
|
|
packages=$((packages))
|
|
;;
|
|
esac
|
|
|
|
case $packages in
|
|
(1?*|[2-9]*)
|
|
log pkgs "$packages" >&6
|
|
;;
|
|
esac
|
|
}
|
|
|
|
get_memory() {
|
|
case $os in
|
|
# Used memory is calculated using the following "formula":
|
|
# MemUsed = MemTotal + Shmem - MemFree - Buffers - Cached - SReclaimable
|
|
# Source: https://github.com/KittyKatt/screenFetch/issues/386
|
|
(Linux*)
|
|
# Parse the '/proc/meminfo' file splitting on ':' and 'k'.
|
|
# The format of the file is 'key: 000kB' and an additional
|
|
# split is used on 'k' to filter out 'kB'.
|
|
while IFS=':k ' read -r key val _; do
|
|
case $key in
|
|
(MemTotal)
|
|
mem_used=$((mem_used + val))
|
|
mem_full=$val
|
|
;;
|
|
|
|
(Shmem)
|
|
mem_used=$((mem_used + val))
|
|
;;
|
|
|
|
(MemFree | Buffers | Cached | SReclaimable)
|
|
mem_used=$((mem_used - val))
|
|
;;
|
|
|
|
# If detected this will be used over the above calculation
|
|
# for mem_used. Available since Linux 3.14rc.
|
|
# See kernel commit 34e431b0ae398fc54ea69ff85ec700722c9da773
|
|
(MemAvailable)
|
|
mem_avail=$val
|
|
;;
|
|
esac
|
|
done < /proc/meminfo
|
|
|
|
case $mem_avail in
|
|
(*[0-9]*)
|
|
mem_used=$(((mem_full - mem_avail) / 1024))
|
|
;;
|
|
|
|
*)
|
|
mem_used=$((mem_used / 1024))
|
|
;;
|
|
esac
|
|
|
|
mem_full=$((mem_full / 1024))
|
|
;;
|
|
|
|
# Used memory is calculated using the following "formula":
|
|
# (wired + active + occupied) * 4 / 1024
|
|
(Darwin*)
|
|
mem_full=$(($(sysctl -n hw.memsize) / 1024 / 1024))
|
|
|
|
# Parse the 'vmstat' file splitting on ':' and '.'.
|
|
# The format of the file is 'key: 000.' and an additional
|
|
# split is used on '.' to filter it out.
|
|
while IFS=:. read -r key val; do
|
|
case $key in
|
|
(*' wired'*|*' active'*|*' occupied'*)
|
|
mem_used=$((mem_used + ${val:-0}))
|
|
;;
|
|
esac
|
|
|
|
# Using '<<-EOF' is the only way to loop over a command's
|
|
# output without the use of a pipe ('|').
|
|
# This ensures that any variables defined in the while loop
|
|
# are still accessible in the script.
|
|
done <<-EOF
|
|
$(vm_stat)
|
|
EOF
|
|
|
|
mem_used=$((mem_used * 4 / 1024))
|
|
;;
|
|
|
|
(OpenBSD*)
|
|
mem_full=$(($(sysctl -n hw.physmem) / 1024 / 1024))
|
|
|
|
# This is a really simpler parser for 'vmstat' which grabs
|
|
# the used memory amount in a lazy way. 'vmstat' prints 3
|
|
# lines of output with the needed value being stored in the
|
|
# final line.
|
|
#
|
|
# This loop simply grabs the 3rd element of each line until
|
|
# the EOF is reached. Each line overwrites the value of the
|
|
# previous one so we're left with what we wanted. This isn't
|
|
# slow as only 3 lines are parsed.
|
|
while read -r _ _ line _; do
|
|
mem_used=${line%%M}
|
|
|
|
# Using '<<-EOF' is the only way to loop over a command's
|
|
# output without the use of a pipe ('|').
|
|
# This ensures that any variables defined in the while loop
|
|
# are still accessible in the script.
|
|
done <<-EOF
|
|
$(vmstat)
|
|
EOF
|
|
;;
|
|
|
|
# Used memory is calculated using the following "formula":
|
|
# mem_full - ((inactive + free + cache) * page_size / 1024)
|
|
(FreeBSD*|DragonFly*)
|
|
mem_full=$(($(sysctl -n hw.physmem) / 1024 / 1024))
|
|
|
|
# Use 'set --' to store the output of the command in the
|
|
# argument list. POSIX sh has no arrays but this is close enough.
|
|
#
|
|
# Disable the shellcheck warning for word-splitting
|
|
# as it's safe and intended ('set -f' disables globbing).
|
|
# shellcheck disable=2046
|
|
{
|
|
set -f
|
|
set +f -- $(sysctl -n hw.pagesize \
|
|
vm.stats.vm.v_inactive_count \
|
|
vm.stats.vm.v_free_count \
|
|
vm.stats.vm.v_cache_count)
|
|
}
|
|
|
|
# Calculate the amount of used memory.
|
|
# $1: hw.pagesize
|
|
# $2: vm.stats.vm.v_inactive_count
|
|
# $3: vm.stats.vm.v_free_count
|
|
# $4: vm.stats.vm.v_cache_count
|
|
mem_used=$((mem_full - (($2 + $3 + $4) * $1 / 1024 / 1024)))
|
|
;;
|
|
|
|
(NetBSD*)
|
|
mem_full=$(($(sysctl -n hw.physmem64) / 1024 / 1024))
|
|
|
|
# NetBSD implements a lot of the Linux '/proc' filesystem,
|
|
# this uses the same parser as the Linux memory detection.
|
|
while IFS=':k ' read -r key val _; do
|
|
case $key in
|
|
(MemFree)
|
|
mem_free=$((val / 1024))
|
|
break
|
|
;;
|
|
esac
|
|
done < /proc/meminfo
|
|
|
|
mem_used=$((mem_full - mem_free))
|
|
;;
|
|
|
|
(Haiku)
|
|
# Read the first line of 'sysinfo -mem' splitting on
|
|
# '(', ' ', and ')'. The needed information is then
|
|
# stored in the 5th and 7th elements. Using '_' "consumes"
|
|
# an element allowing us to proceed to the next one.
|
|
#
|
|
# The parsed format is as follows:
|
|
# 3501142016 bytes free (used/max 792645632 / 4293787648)
|
|
IFS='( )' read -r _ _ _ _ mem_used _ mem_full <<-EOF
|
|
$(sysinfo -mem)
|
|
EOF
|
|
|
|
mem_used=$((mem_used / 1024 / 1024))
|
|
mem_full=$((mem_full / 1024 / 1024))
|
|
;;
|
|
|
|
(Minix)
|
|
# Minix includes the '/proc' filesystem though the format
|
|
# differs from Linux. The '/proc/meminfo' file is only a
|
|
# single line with space separated elements and elements
|
|
# 2 and 3 contain the total and free memory numbers.
|
|
read -r _ mem_full mem_free _ < /proc/meminfo
|
|
|
|
mem_used=$(((mem_full - mem_free) / 1024))
|
|
mem_full=$(( mem_full / 1024))
|
|
;;
|
|
|
|
(SunOS)
|
|
hw_pagesize=$(pagesize)
|
|
|
|
# 'kstat' outputs memory in the following format:
|
|
# unix:0:system_pages:pagestotal 1046397
|
|
# unix:0:system_pages:pagesfree 885018
|
|
#
|
|
# This simply uses the first "element" (white-space
|
|
# separated) as the key and the second element as the
|
|
# value.
|
|
#
|
|
# A variable is then assigned based on the key.
|
|
while read -r key val; do
|
|
case $key in
|
|
(*total)
|
|
pages_full=$val
|
|
;;
|
|
|
|
(*free)
|
|
pages_free=$val
|
|
;;
|
|
esac
|
|
done <<-EOF
|
|
$(kstat -p unix:0:system_pages:pagestotal \
|
|
unix:0:system_pages:pagesfree)
|
|
EOF
|
|
|
|
mem_full=$((pages_full * hw_pagesize / 1024 / 1024))
|
|
mem_free=$((pages_free * hw_pagesize / 1024 / 1024))
|
|
mem_used=$((mem_full - mem_free))
|
|
;;
|
|
|
|
(IRIX)
|
|
# Read the memory information from the 'top' command. Parse
|
|
# and split each line until we reach the line starting with
|
|
# "Memory".
|
|
#
|
|
# Example output: Memory: 160M max, 147M avail, .....
|
|
while IFS=' :' read -r label mem_full _ mem_free _; do
|
|
case $label in
|
|
(Memory)
|
|
mem_full=${mem_full%M}
|
|
mem_free=${mem_free%M}
|
|
break
|
|
;;
|
|
esac
|
|
done <<-EOF
|
|
$(top -n)
|
|
EOF
|
|
|
|
mem_used=$((mem_full - mem_free))
|
|
;;
|
|
|
|
(SerenityOS)
|
|
IFS='{}' read -r _ memstat _ < /proc/memstat
|
|
|
|
set -f -- "$IFS"
|
|
IFS=,
|
|
|
|
for pair in $memstat; do
|
|
case $pair in
|
|
(*user_physical_allocated*)
|
|
mem_used=${pair##*:}
|
|
;;
|
|
|
|
(*user_physical_available*)
|
|
mem_free=${pair##*:}
|
|
;;
|
|
esac
|
|
done
|
|
|
|
IFS=$1
|
|
set +f --
|
|
|
|
mem_used=$((mem_used * 4096 / 1024 / 1024))
|
|
mem_free=$((mem_free * 4096 / 1024 / 1024))
|
|
|
|
mem_full=$((mem_used + mem_free))
|
|
;;
|
|
esac
|
|
|
|
log memory "${mem_used:-?}M / ${mem_full:-?}M" >&6
|
|
}
|
|
|
|
get_wm() {
|
|
case $os in
|
|
(Darwin*)
|
|
# Don't display window manager on macOS.
|
|
;;
|
|
|
|
(*)
|
|
# xprop can be used to grab the window manager's properties
|
|
# which contains the window manager's name under '_NET_WM_NAME'.
|
|
#
|
|
# The upside to using 'xprop' is that you don't need to hardcode
|
|
# a list of known window manager names. The downside is that
|
|
# not all window managers conform to setting the '_NET_WM_NAME'
|
|
# atom..
|
|
#
|
|
# List of window managers which fail to set the name atom:
|
|
# catwm, fvwm, dwm, 2bwm, monster, wmaker and sowm [mine! ;)].
|
|
#
|
|
# The final downside to this approach is that it does _not_
|
|
# support Wayland environments. The only solution which supports
|
|
# Wayland is the 'ps' parsing mentioned below.
|
|
#
|
|
# A more naive implementation is to parse the last line of
|
|
# '~/.xinitrc' to extract the second white-space separated
|
|
# element.
|
|
#
|
|
# The issue with an approach like this is that this line data
|
|
# does not always equate to the name of the window manager and
|
|
# could in theory be _anything_.
|
|
#
|
|
# This also fails when the user launches xorg through a display
|
|
# manager or other means.
|
|
#
|
|
#
|
|
# Another naive solution is to parse 'ps' with a hardcoded list
|
|
# of window managers to detect the current window manager (based
|
|
# on what is running).
|
|
#
|
|
# The issue with this approach is the need to hardcode and
|
|
# maintain a list of known window managers.
|
|
#
|
|
# Another issue is that process names do not always equate to
|
|
# the name of the window manager. False-positives can happen too.
|
|
#
|
|
# This is the only solution which supports Wayland based
|
|
# environments sadly. It'd be nice if some kind of standard were
|
|
# established to identify Wayland environments.
|
|
#
|
|
# pfetch's goal is to remain _simple_, if you'd like a "full"
|
|
# implementation of window manager detection use 'neofetch'.
|
|
#
|
|
# Neofetch use a combination of 'xprop' and 'ps' parsing to
|
|
# support all window managers (including non-conforming and
|
|
# Wayland) though it's a lot more complicated!
|
|
|
|
# Don't display window manager if X isn't running.
|
|
[ "$DISPLAY" ] || return
|
|
|
|
# This is a two pass call to xprop. One call to get the window
|
|
# manager's ID and another to print its properties.
|
|
has xprop && {
|
|
# The output of the ID command is as follows:
|
|
# _NET_SUPPORTING_WM_CHECK: window id # 0x400000
|
|
#
|
|
# To extract the ID, everything before the last space
|
|
# is removed.
|
|
id=$(xprop -root -notype _NET_SUPPORTING_WM_CHECK)
|
|
id=${id##* }
|
|
|
|
# The output of the property command is as follows:
|
|
# _NAME 8t
|
|
# _NET_WM_PID = 252
|
|
# _NET_WM_NAME = "bspwm"
|
|
# _NET_SUPPORTING_WM_CHECK: window id # 0x400000
|
|
# WM_CLASS = "wm", "Bspwm"
|
|
#
|
|
# To extract the name, everything before '_NET_WM_NAME = \"'
|
|
# is removed and everything after the next '"' is removed.
|
|
wm=$(xprop -id "$id" -notype -len 25 -f _NET_WM_NAME 8t)
|
|
}
|
|
|
|
# Handle cases of a window manager _not_ populating the
|
|
# '_NET_WM_NAME' atom. Display nothing in this case.
|
|
case $wm in
|
|
(*'_NET_WM_NAME = '*)
|
|
wm=${wm##*_NET_WM_NAME = \"}
|
|
wm=${wm%%\"*}
|
|
;;
|
|
|
|
(*)
|
|
# Fallback to checking the process list
|
|
# for the select few window managers which
|
|
# don't set '_NET_WM_NAME'.
|
|
while read -r ps_line; do
|
|
case $ps_line in
|
|
(*catwm*) wm=catwm ;;
|
|
(*fvwm*) wm=fvwm ;;
|
|
(*dwm*) wm=dwm ;;
|
|
(*2bwm*) wm=2bwm ;;
|
|
(*monsterwm*) wm=monsterwm ;;
|
|
(*wmaker*) wm='Window Maker' ;;
|
|
(*sowm*) wm=sowm ;;
|
|
(*penrose*) wm=penrose ;;
|
|
esac
|
|
done <<-EOF
|
|
$(ps x)
|
|
EOF
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
log wm "$wm" >&6
|
|
}
|
|
|
|
|
|
get_de() {
|
|
# This only supports Xorg related desktop environments though
|
|
# this is fine as knowing the desktop environment on Windows,
|
|
# macOS etc is useless (they'll always report the same value).
|
|
#
|
|
# Display the value of '$XDG_CURRENT_DESKTOP', if it's empty,
|
|
# display the value of '$DESKTOP_SESSION'.
|
|
log de "${XDG_CURRENT_DESKTOP:-$DESKTOP_SESSION}" >&6
|
|
}
|
|
|
|
get_shell() {
|
|
# Display the basename of the '$SHELL' environment variable.
|
|
log shell "${SHELL##*/}" >&6
|
|
}
|
|
|
|
get_editor() {
|
|
# Display the value of '$VISUAL', if it's empty, display the
|
|
# value of '$EDITOR'.
|
|
editor=${VISUAL:-"$EDITOR"}
|
|
|
|
log editor "${editor##*/}" >&6
|
|
}
|
|
|
|
get_palette() {
|
|
# Print the first 8 terminal colors. This uses the existing
|
|
# sequences to change text color with a sequence prepended
|
|
# to reverse the foreground and background colors.
|
|
#
|
|
# This allows us to save hardcoding a second set of sequences
|
|
# for background colors.
|
|
#
|
|
# False positive.
|
|
# shellcheck disable=2154
|
|
{
|
|
esc SGR 7
|
|
palette="$e$c1 $c1 $c2 $c2 $c3 $c3 $c4 $c4 $c5 $c5 $c6 $c6 "
|
|
esc SGR 0
|
|
palette="$palette$e"
|
|
}
|
|
|
|
# Print the palette with a new-line before and afterwards but no seperator.
|
|
printf '\n' >&6
|
|
log "$palette
|
|
" " " " " >&6
|
|
}
|
|
|
|
get_ascii() {
|
|
# This is a simple function to read the contents of
|
|
# an ascii file from 'stdin'. It allows for the use
|
|
# of '<<-EOF' to prevent the break in indentation in
|
|
# this source code.
|
|
#
|
|
# This function also sets the text colors according
|
|
# to the ascii color.
|
|
read_ascii() {
|
|
# 'PF_COL1': Set the info name color according to ascii color.
|
|
# 'PF_COL3': Set the title color to some other color. ¯\_(ツ)_/¯
|
|
PF_COL1=${PF_COL1:-${1:-7}}
|
|
PF_COL3=${PF_COL3:-$((${1:-7}%8+1))}
|
|
|
|
# POSIX sh has no 'var+=' so 'var=${var}append' is used. What's
|
|
# interesting is that 'var+=' _is_ supported inside '$(())'
|
|
# (arithmetic) though there's no support for 'var++/var--'.
|
|
#
|
|
# There is also no $'\n' to add a "literal"(?) newline to the
|
|
# string. The simplest workaround being to break the line inside
|
|
# the string (though this has the caveat of breaking indentation).
|
|
while IFS= read -r line; do
|
|
ascii="$ascii$line
|
|
"
|
|
done
|
|
}
|
|
|
|
# This checks for ascii art in the following order:
|
|
# '$1': Argument given to 'get_ascii()' directly.
|
|
# '$PF_ASCII': Environment variable set by user.
|
|
# '$distro': The detected distribution name.
|
|
# '$os': The name of the operating system/kernel.
|
|
#
|
|
# NOTE: Each ascii art below is indented using tabs, this
|
|
# allows indentation to continue naturally despite
|
|
# the use of '<<-EOF'.
|
|
#
|
|
# False positive.
|
|
# shellcheck disable=2154
|
|
case ${1:-${PF_ASCII:-${distro:-$os}}} in
|
|
([Aa]lpine*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} /\\ /\\
|
|
/${c7}/ ${c4}\\ \\
|
|
/${c7}/ ${c4}\\ \\
|
|
/${c7}// ${c4}\\ \\
|
|
${c7}// ${c4}\\ \\
|
|
${c4}\\
|
|
EOF
|
|
;;
|
|
|
|
([Aa]ndroid*)
|
|
read_ascii 2 <<-EOF
|
|
${c2} ;, ,;
|
|
${c2} ';,.-----.,;'
|
|
${c2} ,' ',
|
|
${c2} / O O \\
|
|
${c2}| |
|
|
${c2}'-----------------'
|
|
EOF
|
|
;;
|
|
|
|
([Aa]rch*)
|
|
read_ascii 4 <<-EOF
|
|
${c6} /\\
|
|
${c6} / \\
|
|
${c6} /\\ \\
|
|
${c4} / \\
|
|
${c4} / ,, \\
|
|
${c4} / | | -\\
|
|
${c4} /_-'' ''-_\\
|
|
EOF
|
|
;;
|
|
|
|
([Aa]rco*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} /\\
|
|
${c4} / \\
|
|
${c4} / /\\ \\
|
|
${c4} / / \\ \\
|
|
${c4} / / \\ \\
|
|
${c4} / / _____\\ \\
|
|
${c4}/_/ \`----.\\_\\
|
|
EOF
|
|
;;
|
|
|
|
([Aa]rtix*)
|
|
read_ascii 6 <<-EOF
|
|
${c4} /\\
|
|
${c4} / \\
|
|
${c4} /\`'.,\\
|
|
${c4} / ',
|
|
${c4} / ,\`\\
|
|
${c4} / ,.'\`. \\
|
|
${c4}/.,'\` \`'.\\
|
|
EOF
|
|
;;
|
|
|
|
([Bb]edrock*)
|
|
read_ascii 4 <<-EOF
|
|
${c7}__
|
|
${c7}\\ \\___
|
|
${c7} \\ _ \\
|
|
${c7} \\___/
|
|
EOF
|
|
;;
|
|
|
|
([Bb]uildroot*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} ___
|
|
${c3} / \` \\
|
|
${c3}| : :|
|
|
${c3}-. _:__.-
|
|
${c3} \` ---- \`
|
|
EOF
|
|
;;
|
|
|
|
([Cc]el[Oo][Ss]*)
|
|
read_ascii 5 0 <<-EOF
|
|
${c5} .////\\\\\//\\.
|
|
${c5} //_ \\\\
|
|
${c5} /_ ${c7}##############
|
|
${c5} // *\\
|
|
${c7}############### ${c5}|#
|
|
${c5} \/ */
|
|
${c5} \* ${c7}##############
|
|
${c5} */, .//
|
|
${c5} '_///\\\\\//_'
|
|
EOF
|
|
;;
|
|
|
|
([Cc]ent[Oo][Ss]*)
|
|
read_ascii 5 <<-EOF
|
|
${c2} ____${c3}^${c5}____
|
|
${c2} |\\ ${c3}|${c5} /|
|
|
${c2} | \\ ${c3}|${c5} / |
|
|
${c5}<---- ${c4}---->
|
|
${c4} | / ${c2}|${c3} \\ |
|
|
${c4} |/__${c2}|${c3}__\\|
|
|
${c2} v
|
|
EOF
|
|
;;
|
|
|
|
([Cc]rystal*[Ll]inux)
|
|
read_ascii 5 5 <<-EOF
|
|
${c5} -//.
|
|
${c5} -//.
|
|
${c5} -//. .
|
|
${c5} -//. '//-
|
|
${c5} /+: :+/
|
|
${c5} .//' .//.
|
|
${c5} . .//.
|
|
${c5} .//.
|
|
${c5} .//.
|
|
EOF
|
|
;;
|
|
|
|
([Dd]ahlia*)
|
|
read_ascii 1 <<-EOF
|
|
${c1} _
|
|
${c1} ___/ \\___
|
|
${c1} | _-_ |
|
|
${c1} | / \ |
|
|
${c1}/ | | \\
|
|
${c1}\\ | | /
|
|
${c1} | \ _ _ / |
|
|
${c1} |___ - ___|
|
|
${c1} \\_/
|
|
EOF
|
|
;;
|
|
|
|
([Dd]ebian*)
|
|
read_ascii 1 <<-EOF
|
|
${c1} _____
|
|
${c1} / __ \\
|
|
${c1}| / |
|
|
${c1}| \\___-
|
|
${c1}-_
|
|
${c1} --_
|
|
EOF
|
|
;;
|
|
|
|
([Dd]evuan*)
|
|
read_ascii 6 <<-EOF
|
|
${c4} ..:::.
|
|
${c4} ..-==-
|
|
${c4} .+#:
|
|
${c4} =@@
|
|
${c4} :+%@#:
|
|
${c4}.:=+#@@%*:
|
|
${c4}#@@@#=:
|
|
EOF
|
|
;;
|
|
|
|
([Dd]ragon[Ff]ly*)
|
|
read_ascii 1 <<-EOF
|
|
,${c1}_${c7},
|
|
('-_${c1}|${c7}_-')
|
|
>--${c1}|${c7}--<
|
|
(_-'${c1}|${c7}'-_)
|
|
${c1}|
|
|
${c1}|
|
|
${c1}|
|
|
EOF
|
|
;;
|
|
|
|
([Ee]lementary*)
|
|
read_ascii <<-EOF
|
|
${c7} _______
|
|
${c7} / ____ \\
|
|
${c7}/ | / /\\
|
|
${c7}|__\\ / / |
|
|
${c7}\\ /__/ /
|
|
${c7}\\_______/
|
|
EOF
|
|
;;
|
|
|
|
([Ee]ndeavour*)
|
|
read_ascii 4 <<-EOF
|
|
${c1}/${c4}\\
|
|
${c1}/${c4}/ \\${c6}\\
|
|
${c1}/${c4}/ \\ ${c6}\\
|
|
${c1}/ ${c4}/ _) ${c6})
|
|
${c1}/_${c4}/___-- ${c6}__-
|
|
${c6}/____--
|
|
EOF
|
|
;;
|
|
|
|
([Ff]edora*)
|
|
read_ascii 4 <<-EOF
|
|
${c4},'''''.
|
|
${c4}| ,. |
|
|
${c4}| | '_'
|
|
${c4} ,....| |..
|
|
${c4}.' ,_;| ..'
|
|
${c4}| | | |
|
|
${c4}| ',_,' |
|
|
${c4} '. ,'
|
|
${c4}'''''
|
|
EOF
|
|
;;
|
|
|
|
([Ff]ree[Bb][Ss][Dd]*)
|
|
read_ascii 1 <<-EOF
|
|
${c1}/\\,-'''''-,/\\
|
|
${c1}\\_) (_/
|
|
${c1}| |
|
|
${c1}| |
|
|
${c1}; ;
|
|
${c1}'-_____-'
|
|
EOF
|
|
;;
|
|
|
|
([Gg]aruda*)
|
|
read_ascii 4 <<-EOF
|
|
${c3} _______
|
|
${c3} __/ \\_
|
|
${c3} _/ / \\_
|
|
${c7} _/ /_________\\
|
|
${c7}_/ |
|
|
${c2}\\ ____________
|
|
${c2} \\_ __/
|
|
${c2} \\__________/
|
|
EOF
|
|
;;
|
|
|
|
([Gg]entoo*)
|
|
read_ascii 5 <<-EOF
|
|
${c5} _-----_
|
|
${c5}( \\
|
|
${c5}\\ 0 \\
|
|
${c7} \\ )
|
|
${c7} / _/
|
|
${c7}( _-
|
|
${c7}\\____-
|
|
EOF
|
|
;;
|
|
|
|
([Gg][Nn][Uu]*)
|
|
read_ascii 3 <<-EOF
|
|
${c2} _-\`\`-, ,-\`\`-_
|
|
${c2} .' _-_| |_-_ '.
|
|
${c2}./ /_._ _._\\ \\.
|
|
${c2}: _/_._\`:'_._\\_ :
|
|
${c2}\\:._/ ,\` \\ \\ \\_.:/
|
|
${c2} ,-';'.@) \\ @) \\
|
|
${c2} ,'/' ..- .\\,-.|
|
|
${c2} /'/' \\(( \\\` ./ )
|
|
${c2} '/'' \\_,----'
|
|
${c2} '/'' ,;/''
|
|
${c2} \`\`;'
|
|
EOF
|
|
;;
|
|
|
|
([Gg]uix[Ss][Dd]*|[Gg]uix*)
|
|
read_ascii 3 <<-EOF
|
|
${c3}|.__ __.|
|
|
${c3}|__ \\ / __|
|
|
${c3}\\ \\ / /
|
|
${c3}\\ \\ / /
|
|
${c3}\\ \\ / /
|
|
${c3}\\ \\/ /
|
|
${c3}\\__/
|
|
EOF
|
|
;;
|
|
|
|
([Hh]aiku*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} ,^,
|
|
${c3} / \\
|
|
${c3}*--_ ; ; _--*
|
|
${c3}\\ '" "' /
|
|
${c3}'. .'
|
|
${c3}.-'" "'-.
|
|
${c3}'-.__. .__.-'
|
|
${c3}|_|
|
|
EOF
|
|
;;
|
|
|
|
([Hh]ydroOS*)
|
|
read_ascii 4 <<-EOF
|
|
${c1}╔╗╔╗──╔╗───╔═╦══╗
|
|
${c1}║╚╝╠╦╦╝╠╦╦═╣║║══╣
|
|
${c1}║╔╗║║║╬║╔╣╬║║╠══║
|
|
${c1}╚╝╚╬╗╠═╩╝╚═╩═╩══╝
|
|
${c1}───╚═╝
|
|
EOF
|
|
;;
|
|
|
|
([Hh]yperbola*)
|
|
read_ascii <<-EOF
|
|
${c7} |\`__.\`/
|
|
${c7} \____/
|
|
${c7} .--.
|
|
${c7} / \\
|
|
${c7} / ___ \\
|
|
${c7}/ .\` \`.\\
|
|
${c7}/.\` \`.\\
|
|
EOF
|
|
;;
|
|
|
|
([Ii]glunix*)
|
|
read_ascii <<-EOF
|
|
${c0} |
|
|
${c0} | |
|
|
${c0} |
|
|
${c0} | ________
|
|
${c0} | /\\ | \\
|
|
${c0} / \\ | \\ |
|
|
${c0} / \\ \\ |
|
|
${c0} / \\________\\
|
|
${c0} \\ / /
|
|
${c0} \\ / /
|
|
${c0} \\ / /
|
|
${c0} \\/________/
|
|
EOF
|
|
;;
|
|
|
|
([Ii]nstant[Oo][Ss]*)
|
|
read_ascii <<-EOF
|
|
${c0} ,-''-,
|
|
${c0}: .''. :
|
|
${c0}: ',,' :
|
|
${c0} '-____:__
|
|
${c0} : \`.
|
|
${c0} \`._.'
|
|
EOF
|
|
;;
|
|
|
|
([Ii][Rr][Ii][Xx]*)
|
|
read_ascii 1 <<-EOF
|
|
${c1} __
|
|
${c1} \\ \\ __
|
|
${c1} \\ \\ / /
|
|
${c1} \\ v /
|
|
${c1} / . \\
|
|
${c1} /_/ \\ \\
|
|
${c1} \\_\\
|
|
EOF
|
|
;;
|
|
|
|
([Kk][Dd][Ee]*[Nn]eon*)
|
|
read_ascii 6 <<-EOF
|
|
${c7} .${c6}__${c7}.${c6}__${c7}.
|
|
${c6} / _${c7}.${c6}_ \\
|
|
${c6} / / \\ \\
|
|
${c7} . ${c6}| ${c7}O${c6} | ${c7}.
|
|
${c6} \\ \\_${c7}.${c6}_/ /
|
|
${c6} \\${c7}.${c6}__${c7}.${c6}__${c7}.${c6}/
|
|
EOF
|
|
;;
|
|
|
|
([Ll]inux*[Ll]ite*|[Ll]ite*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} /\\
|
|
${c3} / \\
|
|
${c3} / ${c7}/ ${c3}/
|
|
${c3}> ${c7}/ ${c3}/
|
|
${c3}\\ ${c7}\\ ${c3}\\
|
|
${c3}\\_${c7}\\${c3}_\\
|
|
${c7} \\
|
|
EOF
|
|
;;
|
|
|
|
([Ll]inux*[Mm]int*|[Mm]int)
|
|
read_ascii 2 <<-EOF
|
|
${c2} ___________
|
|
${c2}|_ \\
|
|
${c2}| ${c7}| _____ ${c2}|
|
|
${c2}| ${c7}| | | | ${c2}|
|
|
${c2}| ${c7}| | | | ${c2}|
|
|
${c2}| ${c7}\\__${c7}___/ ${c2}|
|
|
${c2}\\_________/
|
|
EOF
|
|
;;
|
|
|
|
|
|
([Ll]inux*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} ___
|
|
${c4}(${c7}.. ${c4}|
|
|
${c4}(${c5}<> ${c4}|
|
|
${c4}/ ${c7}__ ${c4}\\
|
|
${c4}( ${c7}/ \\ ${c4}/|
|
|
${c5}_${c4}/\\ ${c7}__)${c4}/${c5}_${c4})
|
|
${c5}\/${c4}-____${c5}\/
|
|
EOF
|
|
;;
|
|
|
|
([Mm]ac[Oo][Ss]*|[Dd]arwin*)
|
|
read_ascii 1 <<-EOF
|
|
${c2} .:'
|
|
${c2} _ :'_
|
|
${c3} .'\`_\`-'_\`\`.
|
|
${c1}:________.-'
|
|
${c1}:_______:
|
|
${c4} :_______\`-;
|
|
${c5} \`._.-._.'
|
|
EOF
|
|
;;
|
|
|
|
([Mm]ageia*)
|
|
read_ascii 2 <<-EOF
|
|
${c6} *
|
|
${c6} *
|
|
${c6} **
|
|
${c7} /\\__/\\
|
|
${c7}/ \\
|
|
${c7}\\ /
|
|
${c7} \\____/
|
|
EOF
|
|
;;
|
|
|
|
([Mm]anjaro*)
|
|
read_ascii 2 <<-EOF
|
|
${c2}||||||||| ||||
|
|
${c2}||||||||| ||||
|
|
${c2}|||| ||||
|
|
${c2}|||| |||| ||||
|
|
${c2}|||| |||| ||||
|
|
${c2}|||| |||| ||||
|
|
${c2}|||| |||| ||||
|
|
EOF
|
|
;;
|
|
|
|
([Mm]inix*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} ,, ,,
|
|
${c4};${c7},${c4} ', ,' ${c7},${c4};
|
|
${c4}; ${c7}',${c4} ',,' ${c7},'${c4} ;
|
|
${c4}; ${c7}',${c4} ${c7},'${c4} ;
|
|
${c4}; ${c7};, '' ,;${c4} ;
|
|
${c4}; ${c7};${c4};${c7}',,'${c4};${c7};${c4} ;
|
|
${c4}', ${c7};${c4};; ;;${c7};${c4} ,'
|
|
${c4} '${c7};${c4}' '${c7};${c4}'
|
|
EOF
|
|
;;
|
|
|
|
([Mm][Xx]*)
|
|
read_ascii <<-EOF
|
|
${c7} \\\\ /
|
|
${c7} \\\\/
|
|
${c7} \\\\
|
|
${c7} /\\/ \\\\
|
|
${c7} / \\ /\\
|
|
${c7} / \\/ \\
|
|
${c7}/__________\\
|
|
EOF
|
|
;;
|
|
|
|
([Nn]et[Bb][Ss][Dd]*)
|
|
read_ascii 3 <<-EOF
|
|
${c7}\\\\${c3}\`-______,----__
|
|
${c7} \\\\ ${c3}__,---\`_
|
|
${c7} \\\\ ${c3}\`.____
|
|
${c7} \\\\${c3}-______,----\`-
|
|
${c7} \\\\
|
|
${c7} \\\\
|
|
${c7} \\\\
|
|
EOF
|
|
;;
|
|
|
|
([Nn]ix[Oo][Ss]*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} \\\\ \\\\ //
|
|
${c4} ==\\\\__\\\\/ //
|
|
${c4} // \\\\//
|
|
${c4}==// //==
|
|
${c4} //\\\\___//
|
|
${c4}// /\\\\ \\\\==
|
|
${c4} // \\\\ \\\\
|
|
EOF
|
|
;;
|
|
|
|
([Oo]pen[Bb][Ss][Dd]*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} _____
|
|
${c3} \\- -/
|
|
${c3} \\_/ \\
|
|
${c3} | ${c7}O O${c3} |
|
|
${c3} |_ < ) 3 )
|
|
${c3} / \\ /
|
|
${c3} /-_____-\\
|
|
EOF
|
|
;;
|
|
|
|
([Oo]pen[Ss][Uu][Ss][Ee]*[Tt]umbleweed*)
|
|
read_ascii 2 <<-EOF
|
|
${c2} _____ ______
|
|
${c2} / ____\\ / ____ \\
|
|
${c2}/ / \`/ / \\ \\
|
|
${c2}\\ \\____/ /,____/ /
|
|
${c2} \\______/ \\_____/
|
|
EOF
|
|
;;
|
|
|
|
([Oo]pen[Ss][Uu][Ss][Ee]*|[Oo]pen*SUSE*|SUSE*|suse*)
|
|
read_ascii 2 <<-EOF
|
|
${c2} _______
|
|
${c2}__| __ \\
|
|
${c2} / .\\ \\
|
|
${c2} \\__/ |
|
|
${c2} _______|
|
|
${c2} \\_______
|
|
${c2}__________/
|
|
EOF
|
|
;;
|
|
|
|
([Oo]pen[Ww]rt*)
|
|
read_ascii 1 <<-EOF
|
|
${c1} _______
|
|
${c1}| |.-----.-----.-----.
|
|
${c1}| - || _ | -__| |
|
|
${c1}|_______|| __|_____|__|__|
|
|
${c1} ________|__| __
|
|
${c1}| | | |.----.| |_
|
|
${c1}| | | || _|| _|
|
|
${c1}|________||__| |____|
|
|
EOF
|
|
;;
|
|
|
|
([Pp]arabola*)
|
|
read_ascii 5 <<-EOF
|
|
${c5} __ __ __ _
|
|
${c5}.\`_//_//_/ / \`.
|
|
${c5} / .\`
|
|
${c5} / .\`
|
|
${c5} /.\`
|
|
${c5} /\`
|
|
EOF
|
|
;;
|
|
|
|
([Pp]op!_[Oo][Ss]*)
|
|
read_ascii 6 <<-EOF
|
|
${c6}______
|
|
${c6}\\ _ \\ __
|
|
${c6}\\ \\ \\ \\ / /
|
|
${c6}\\ \\_\\ \\ / /
|
|
${c6}\\ ___\\ /_/
|
|
${c6} \\ \\ _
|
|
${c6} __\\_\\__(_)_
|
|
${c6}(___________)
|
|
EOF
|
|
;;
|
|
|
|
([Pp]ure[Oo][Ss]*)
|
|
read_ascii <<-EOF
|
|
${c7} _____________
|
|
${c7}| _________ |
|
|
${c7}| | | |
|
|
${c7}| | | |
|
|
${c7}| |_________| |
|
|
${c7}|_____________|
|
|
EOF
|
|
;;
|
|
|
|
([Rr]aspbian*)
|
|
read_ascii 1 <<-EOF
|
|
${c2} __ __
|
|
${c2} (_\\)(/_)
|
|
${c1} (_(__)_)
|
|
${c1}(_(_)(_)_)
|
|
${c1} (_(__)_)
|
|
${c1} (__)
|
|
EOF
|
|
;;
|
|
|
|
([Ss]erenity[Oo][Ss]*)
|
|
read_ascii 4 <<-EOF
|
|
${c7} _____
|
|
${c1} ,-${c7} -,
|
|
${c1} ;${c7} ( ;
|
|
${c1}| ${c7}. \_${c1}.,${c7} |
|
|
${c1}| ${c7}o _${c1} ',${c7} |
|
|
${c1} ; ${c7}(_)${c1} )${c7} ;
|
|
${c1} '-_____-${c7}'
|
|
EOF
|
|
;;
|
|
|
|
([Ss]lackware*)
|
|
read_ascii 4 <<-EOF
|
|
${c4} ________
|
|
${c4} / ______|
|
|
${c4} | |______
|
|
${c4} \\______ \\
|
|
${c4} ______| |
|
|
${c4}| |________/
|
|
${c4}|____________
|
|
EOF
|
|
;;
|
|
|
|
([Ss]olus*)
|
|
read_ascii 4 <<-EOF
|
|
${c6}
|
|
${c6} /|
|
|
${c6} / |\\
|
|
${c6} / | \\ _
|
|
${c6} /___|__\\_\\
|
|
${c6} \\ /
|
|
${c6} \`-------´
|
|
EOF
|
|
;;
|
|
|
|
([Ss]un[Oo][Ss]|[Ss]olaris*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} . .; .
|
|
${c3} . :; :: ;: .
|
|
${c3} .;. .. .. .;.
|
|
${c3}.. .. .. ..
|
|
${c3} .;, ,;.
|
|
EOF
|
|
;;
|
|
|
|
([Uu]buntu*)
|
|
read_ascii 3 <<-EOF
|
|
${c3} _
|
|
${c3} ---(_)
|
|
${c3} _/ --- \\
|
|
${c3}(_) | |
|
|
${c3} \\ --- _/
|
|
${c3} ---(_)
|
|
EOF
|
|
;;
|
|
|
|
([Vv]oid*)
|
|
read_ascii 2 <<-EOF
|
|
${c2} _______
|
|
${c2} _ \\______ -
|
|
${c2}| \\ ___ \\ |
|
|
${c2}| | / \ | |
|
|
${c2}| | \___/ | |
|
|
${c2}| \\______ \\_|
|
|
${c2} -_______\\
|
|
EOF
|
|
;;
|
|
|
|
([Xx]eonix*)
|
|
read_ascii 2 <<-EOF
|
|
${c2} ___ ___
|
|
${c2}___ \ \/ / ___
|
|
${c2}\ \ \ / / /
|
|
${c2} \ \/ \/ /
|
|
${c2} \ /\ /
|
|
${c2} \__/ \__/
|
|
EOF
|
|
;;
|
|
|
|
(*)
|
|
# On no match of a distribution ascii art, this function calls
|
|
# itself again, this time to look for a more generic OS related
|
|
# ascii art (KISS Linux -> Linux).
|
|
[ "$1" ] || {
|
|
get_ascii "$os"
|
|
return
|
|
}
|
|
|
|
printf 'error: %s is not currently supported.\n' "$os" >&6
|
|
printf 'error: Open an issue for support to be added.\n' >&6
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
# Store the "width" (longest line) and "height" (number of lines)
|
|
# of the ascii art for positioning. This script prints to the screen
|
|
# *almost* like a TUI does. It uses escape sequences to allow dynamic
|
|
# printing of the information through user configuration.
|
|
#
|
|
# Iterate over each line of the ascii art to retrieve the above
|
|
# information. The 'sed' is used to strip '\033[3Xm' color codes from
|
|
# the ascii art so they don't affect the width variable.
|
|
while read -r line; do
|
|
ascii_height=$((${ascii_height:-0} + 1))
|
|
|
|
# This was a ternary operation but they aren't supported in
|
|
# Minix's shell.
|
|
[ "${#line}" -gt "${ascii_width:-0}" ] &&
|
|
ascii_width=${#line}
|
|
|
|
# Using '<<-EOF' is the only way to loop over a command's
|
|
# output without the use of a pipe ('|').
|
|
# This ensures that any variables defined in the while loop
|
|
# are still accessible in the script.
|
|
done <<-EOF
|
|
$(printf %s "$ascii" | sed 's/\[3.m//g')
|
|
EOF
|
|
|
|
# Add a gap between the ascii art and the information.
|
|
ascii_width=$((ascii_width + 4))
|
|
|
|
# Print the ascii art and position the cursor back where we
|
|
# started prior to printing it.
|
|
{
|
|
esc_p SGR 1
|
|
printf '%s' "$ascii"
|
|
esc_p SGR 0
|
|
esc_p CUU "$ascii_height"
|
|
} >&6
|
|
}
|
|
|
|
main() {
|
|
case $* in
|
|
-v)
|
|
printf '%s 0.7.0\n' "${0##*/}"
|
|
return 0
|
|
;;
|
|
|
|
-d)
|
|
# Below exec is not run, stderr is shown.
|
|
;;
|
|
|
|
'')
|
|
exec 2>/dev/null
|
|
;;
|
|
|
|
*)
|
|
cat <<EOF
|
|
${0##*/} show system information
|
|
${0##*/} -d show stderr (debug mode)
|
|
${0##*/} -v show version information
|
|
EOF
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
# Hide 'stdout' and selectively print to it using '>&6'.
|
|
# This gives full control over what it displayed on the screen.
|
|
exec 6>&1 >/dev/null
|
|
|
|
# Store raw escape sequence character for later reuse.
|
|
esc_c=$(printf '\033')
|
|
|
|
# Allow the user to execute their own script and modify or
|
|
# extend pfetch's behavior.
|
|
# shellcheck source=/dev/null
|
|
! [ -f "$PF_SOURCE" ] || . "$PF_SOURCE"
|
|
|
|
# Ensure that the 'TMPDIR' is writable as heredocs use it and
|
|
# fail without the write permission. This was found to be the
|
|
# case on Android where the temporary directory requires root.
|
|
[ -w "${TMPDIR:-/tmp}" ] || export TMPDIR=~
|
|
|
|
# Generic color list.
|
|
# Disable warning about unused variables.
|
|
# shellcheck disable=2034
|
|
for _c in c1 c2 c3 c4 c5 c6 c7 c8; do
|
|
esc SGR "3${_c#?}" 0
|
|
export "$_c=$e"
|
|
done
|
|
|
|
# Disable line wrapping and catch the EXIT signal to enable it again
|
|
# on exit. Ideally you'd somehow query the current value and retain
|
|
# it but I'm yet to see this irk anyone.
|
|
esc_p DECAWM l >&6
|
|
trap 'esc_p DECAWM h >&6' EXIT
|
|
|
|
# Store the output of 'uname' to avoid calling it multiple times
|
|
# throughout the script. 'read <<EOF' is the simplest way of reading
|
|
# a command into a list of variables.
|
|
read -r os kernel arch <<-EOF
|
|
$(uname -srm)
|
|
EOF
|
|
|
|
# Always run 'get_os' for the purposes of detecting which ascii
|
|
# art to display.
|
|
get_os
|
|
|
|
# Allow the user to specify the order and inclusion of information
|
|
# functions through the 'PF_INFO' environment variable.
|
|
# shellcheck disable=2086
|
|
{
|
|
# Disable globbing and set the positional parameters to the
|
|
# contents of 'PF_INFO'.
|
|
set -f
|
|
set +f -- ${PF_INFO-ascii title os host kernel uptime pkgs memory}
|
|
|
|
# Iterate over the info functions to determine the lengths of the
|
|
# "info names" for output alignment. The option names and subtitles
|
|
# match 1:1 so this is thankfully simple.
|
|
for info do
|
|
command -v "get_$info" >/dev/null || continue
|
|
|
|
# This was a ternary operation but they aren't supported in
|
|
# Minix's shell.
|
|
[ "${#info}" -gt "${info_length:-0}" ] &&
|
|
info_length=${#info}
|
|
done
|
|
|
|
# Add an additional space of length to act as a gap.
|
|
info_length=$((info_length + 1))
|
|
|
|
# Iterate over the above list and run any existing "get_" functions.
|
|
for info do
|
|
"get_$info"
|
|
done
|
|
}
|
|
|
|
# Position the cursor below both the ascii art and information lines
|
|
# according to the height of both. If the information exceeds the ascii
|
|
# art in height, don't touch the cursor (0/unset), else move it down
|
|
# N lines.
|
|
#
|
|
# This was a ternary operation but they aren't supported in Minix's shell.
|
|
[ "${info_height:-0}" -lt "${ascii_height:-0}" ] &&
|
|
cursor_pos=$((ascii_height - info_height))
|
|
|
|
# Print '$cursor_pos' amount of newlines to correctly position the
|
|
# cursor. This used to be a 'printf $(seq X X)' however 'seq' is only
|
|
# typically available (by default) on GNU based systems!
|
|
while [ "${i:=0}" -le "${cursor_pos:-0}" ]; do
|
|
printf '\n'
|
|
i=$((i + 1))
|
|
done >&6
|
|
}
|
|
|
|
main "$@"
|