pfetch: iOS support

pfetch: initial solaris support

.github/workflows/main.yml

@@ -6,4 +6,6 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - name: Run shellcheck.
-      run:  shellcheck pfetch
+      run: |
+        shellcheck pfetch
+        TERM=dumb sh pfetch

README.md

@@ -21,24 +21,53 @@ _/\ __)/_)    pkgs   130
 
 ## OS support
 
-- [x] Linux (A myriad of distributions)
+- **Haiku**
-- [x] MacOS
+- **MacOS**
-- [x] OpenBSD
+- **Minix**
-- [x] FreeBSD
+- **Solaris**
-- [x] NetBSD
+- **BSD**
-- [x] Haiku
+    - DragonflyBSD
+    - FreeBSD
+    - NetBSD
+    - OpenBSD
+- **Windows**
+    - Windows subsystem for Linux.
+- **Linux**
+    - Alpine Linux
+    - Arch Linux
+    - Arco Linux
+    - Artix Linux
+    - CentOS
+    - Debian
+    - Elementary
+    - Fedora
+    - Gentoo
+    - Guix
+    - Hyperbola
+    - KISS Linux
+    - Linux Lite
+    - Linux Mint
+    - Mageia
+    - Manjaro
+    - MX Linux
+    - NixOS
+    - OpenSUSE
+    - Parabola
+    - Pop!\_OS
+    - PureOS
+    - Slackware
+    - Ubuntu
+    - Void Linux
+    - Other distributions are supported with a generic penguin logo.
 
 ## TODO
 
 - [ ] Add optional and additional information detection.
-    - [ ] CPU
+    - [ ] Terminal Emulator ([#12](https://github.com/dylanaraps/pfetch/pull/12))
-    - [ ] Terminal Emulator
         - The way I implement this in `neofetch` is interesting.
-    - [ ] Terminal colors
-    - [ ] ???
 - [ ] Expand operating system support.
-    - [ ] Solaris ([#5](https://github.com/dylanaraps/pfetch/issues/5))
+    - [ ] Android
-    - [ ] MINIX ([#6](https://github.com/dylanaraps/pfetch/issues/6))
+    - [ ] iOS
     - [ ] AIX ([#7](https://github.com/dylanaraps/pfetch/issues/7))
     - [ ] IRIX ([#8](https://github.com/dylanaraps/pfetch/issues/8))
     - [ ] FreeMiNT ([#9](https://github.com/dylanaraps/pfetch/issues/9))
@@ -46,7 +75,6 @@ _/\ __)/_)    pkgs   130
         - [ ] CYGWIN
         - [ ] MSYS
         - [ ] MINGW
-        - [ ] WSL (*this is fairly simple*)
 
 ## Configuration
 
@@ -58,14 +86,14 @@ _/\ __)/_)    pkgs   130
 # Default: first example below
 # Valid: space separated string
 #
-# OFF by default: shell
+# OFF by default: shell editor wm de palette
-PF_INFO="ascii title distro host kernel uptime pkgs memory"
+PF_INFO="ascii title os host kernel uptime pkgs memory"
 
 # Example: Only ASCII.
 PF_INFO="ascii"
 
 # Example: Only Information.
-PF_INFO="title distro host kernel uptime pkgs memory"
+PF_INFO="title os host kernel uptime pkgs memory"
 
 # Separator between info name and info data.
 # Default: unset
@@ -96,6 +124,26 @@ PF_ALIGN=""
 # Default: unset (auto)
 # Valid: string
 PF_ASCII="openbsd"
+
+# The below environment variables control more
+# than just 'pfetch' and can be passed using
+# 'HOSTNAME=cool_pc pfetch' to restrict their
+# usage solely to 'pfetch'.
+
+# Which user to display.
+USER=""
+
+# Which hostname to display.
+HOSTNAME=""
+
+# Which editor to display.
+EDITOR=""
+
+# Which shell to display.
+SHELL=""
+
+# Which desktop environment to display.
+XDG_CURRENT_DESKTOP=""
 ```
 
 ## Credit

pfetch

@@ -64,7 +64,7 @@ log() {
 
     # Use 'set --' as a means of stripping all leading and trailing
     # white-space from the info string. This also normalizes all
-    # whitespace inside of the string.
+    # white-space inside of the string.
     #
     # Disable the shellcheck warning for word-splitting
     # as it's safe and intended ('set -f' disables globbing).
@@ -95,13 +95,13 @@ log() {
     printf '[3%sm%s\n' "${PF_COL2-7}" "$info"
 
     # Keep track of the number of times 'log()' has been run.
-    : $((info_height+=1))
+    info_height=$((${info_height:-0} + 1))
 }
 
 get_title() {
     # Username is retrieved by first checking '$USER' with a fallback
-    # to the 'whoami' command.
+    # to the 'id -un' command.
-    user=${USER:-$(whoami)}
+    user=${USER:-$(id -un)}
 
     # Hostname is retrieved by first checking '$HOSTNAME' with a fallback
     # to the 'hostname' command.
@@ -155,16 +155,44 @@ get_os() {
                 distro=$(lsb_release -sd)
 
             else
-                # Disable warning about shellcheck not being able
+                # This used to be a simple '. /etc/os-release' but I believe
-                # to read '/etc/os-release'. This is fine.
+                # this is insecure as we blindly executed whatever was in the
-                # shellcheck source=/dev/null
+                # file. This parser instead simply handles 'key=val', treating
-                . /etc/os-release && distro=$PRETTY_NAME
+                # 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
             fi
 
+            # 'os-release' and 'lsb_release' sometimes add quotes
+            # around the distribution name, strip them.
+            distro=${distro##[\"\']}
+            distro=${distro%%[\"\']}
+
             # Special cases for (independent) distributions which
             # don't follow any os-release/lsb standards whatsoever.
-            command -v crux        && distro=$(crux)
+            command -v crux && distro=$(crux)
-            command -v guix        && distro='Guix System'
+            command -v guix && distro='Guix System'
+
+            # 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.
+            [ "${kernel%%*-Microsoft}" ] ||
+                distro="$distro on Windows 10 [WSL1]"
+
+            # 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_.
+            distro="${distro}${WSLENV+ on Windows 10 [WSL2]}"
         ;;
 
         Darwin*)
@@ -182,41 +210,65 @@ get_os() {
             # 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
+                    # Match the key and read the next line
                     # directly as it contains the key's value.
-                    ProductVersion)
+                    #
-                        IFS='<>' read -r _ _ mac_version _
+                    # Define a shell variable using the key's value.
+                    ProductName|ProductVersion)
+                        IFS='<>' read -r _ _ "${line?}"  _
                         break
                     ;;
                 esac
             done < /System/Library/CoreServices/SystemVersion.plist
 
-            # Use the ProductVersion to determine which macOS/OS X codename
+            case ${ProductName?} in
-            # the system has. As far as I'm aware there's no "dynamic" way
+                iPhone*)
-            # of grabbing this information.
+                    distro="iOS ${ProductVersion?}"
-            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' ;;
-                *)      distro='macOS' ;;
-            esac
 
-            distro="$distro $mac_version"
+                *)
+                    # 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 ${ProductVersion?} 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' ;;
+                        *)      distro='macOS' ;;
+                    esac
+
+                    distro="$distro ${ProductVersion?}"
+                ;;
+            esac
         ;;
 
         Haiku)
             # Haiku uses 'uname -v' for version information
-            # instead of 'uname -r'.
+            # instead of 'uname -r' which only prints '1'.
-            distro="Haiku $(uname -v)"
+            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
         ;;
 
         *)
@@ -231,7 +283,7 @@ get_kernel() {
     case $os in
         # Don't print kernel output on some systems as the
         # OS name includes it.
-        *BSD*|Haiku) ;;
+        *BSD*|Haiku|Minix) ;;
 
         *)
             # '$kernel' is the cached output of 'uname -r'.
@@ -253,7 +305,7 @@ get_host() {
             host="$name $version $model"
         ;;
 
-        Darwin*|FreeBSD*)
+        Darwin*|FreeBSD*|DragonFly*)
             host=$(sysctl -n hw.model)
         ;;
 
@@ -314,11 +366,11 @@ get_uptime() {
     # converting that data into days, hours and minutes using simple
     # math.
     case $os in
-        Linux*)
+        Linux*|Minix*)
             IFS=. read -r s _ < /proc/uptime
         ;;
 
-        Darwin*|*BSD*)
+        Darwin*|*BSD*|DragonFly*)
             s=$(sysctl -n kern.boottime)
 
             # Extract the uptime in seconds from the following output:
@@ -336,6 +388,19 @@ get_uptime() {
             # 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
+        ;;
     esac
 
     # Convert the uptime from seconds into days, hours and minutes.
@@ -352,6 +417,10 @@ get_uptime() {
 }
 
 get_pkgs() {
+    # This is just a simple wrapper around 'command -v' to avoid
+    # spamming '>/dev/null' throughout this function.
+    has() { command -v "$1" >/dev/null; }
+
     # 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.
@@ -372,27 +441,22 @@ get_pkgs() {
         case $os in
             Linux*)
                 # Commands which print packages one per line.
-                command -v kiss       && kiss l
+                has bonsai     && bonsai list
-                command -v bonsai     && bonsai list
+                has pacman-key && pacman -Qq
-                command -v pacman-key && pacman -Qq
+                has dpkg       && dpkg-query -f '.\n' -W
-                command -v dpkg       && dpkg-query -f '.\n' -W
+                has rpm        && rpm -qa
-                command -v rpm        && rpm -qa
+                has xbps-query && xbps-query -l
-                command -v xbps-query && xbps-query -l
+                has apk        && apk info
-                command -v apk        && apk info
+                has guix       && guix package --list-installed
 
                 # Directories containing packages.
-                command -v brew       && printf '%s\n' "$(brew --cellar)/"*
+                has kiss       && printf '%s\n' /var/db/kiss/installed/*/
-                command -v emerge     && printf '%s\n' /var/db/pkg/*/*/
+                has brew       && printf '%s\n' "$(brew --cellar)/"*
-                command -v pkgtool    && printf '%s\n' /var/log/packages/*
+                has emerge     && printf '%s\n' /var/db/pkg/*/*/
+                has pkgtool    && printf '%s\n' /var/log/packages/*
 
-                # GUIX requires two commands.
+                # 'nix' requires two commands.
-                command -v guix       && {
+                has nix-store  && {
-                    guix package -p /run/current-system/profile -I
-                    guix package -I
-                }
-
-                # NIX requires two commands.
-                command -v nix-store  && {
                     nix-store -q --requisites /run/current-system/sw
                     nix-store -q --requisites ~.nix-profile
                 }
@@ -400,14 +464,14 @@ get_pkgs() {
 
             Darwin*)
                 # Commands which print packages one per line.
-                command -v pkgin      && pkgin list
+                has pkgin      && pkgin list
-                command -v port       && port installed
+                has port       && port installed
 
                 # Directories containing packages.
-                command -v brew       && printf '%s\n' /usr/local/Cellar/*
+                has brew       && printf '%s\n' /usr/local/Cellar/*
             ;;
 
-            FreeBSD*)
+            FreeBSD*|DragonFly*)
                 pkg info
             ;;
 
@@ -422,6 +486,15 @@ get_pkgs() {
             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
+            ;;
         esac | wc -l
     `
 
@@ -430,14 +503,14 @@ get_pkgs() {
 
 get_memory() {
     case $os in
-        # Used memory is calculated using the following "formula" (Linux):
+        # 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
+            while IFS=':k '  read -r key val _; do
                 case $key in
                     MemTotal)
                         mem_used=$((mem_used + val))
@@ -458,7 +531,7 @@ get_memory() {
             mem_full=$((mem_full / 1024))
         ;;
 
-        # Used memory is calculated using the following "formula" (MacOS):
+        # Used memory is calculated using the following "formula":
         # (wired + active + occupied) * 4 / 1024
         Darwin*)
             mem_full=$(($(sysctl -n hw.memsize) / 1024 / 1024))
@@ -508,9 +581,9 @@ get_memory() {
 			EOF
         ;;
 
-        # Used memory is calculated using the following "formula" (FreeBSD):
+        # Used memory is calculated using the following "formula":
-        # (inactive_count + free_count + cache_count) * page_size / 1024
+        # mem_full - ((inactive + free + cache) * page_size / 1024)
-        FreeBSD*)
+        FreeBSD*|DragonFly*)
             mem_full=$(($(sysctl -n hw.physmem) / 1024 / 1024))
 
             # Use 'set --' to store the output of the command in the
@@ -532,7 +605,7 @@ get_memory() {
             # $2: vm.stats.vm.v_inactive_count
             # $3: vm.stats.vm.v_free_count
             # $4: vm.stats.vm.v_cache_count
-            mem_used=$((($2 + $3 + $4) * $1 / 1024 / 1024))
+            mem_used=$((mem_full - (($2 + $3 + $4) * $1 / 1024 / 1024)))
         ;;
 
         NetBSD*)
@@ -540,7 +613,7 @@ get_memory() {
 
             # 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
+            while IFS=':k ' read -r key val _; do
                 case $key in
                     MemFree)
                         mem_free=$((val / 1024))
@@ -567,135 +640,173 @@ get_memory() {
             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))
+        ;;
     esac
 
     log memory "${mem_used:-?}M / ${mem_full:-?}M" >&6
 }
 
-get_term() {
+get_wm() {
-    # Workaround for macOS systems that don't support the
+    case $os in
-    # "algorithm" of obtaining the terminal program name.
+        # Don't display window manager on macOS.
-    #
+        Darwin*) ;;
-    # This also doubles as a means of allowing the user to
+
-    # set whatever value they like here through the
+        *)
-    # '$TERM_PROGRAM' environment variable.
+            # xprop can be used to grab the window manager's properties
-    case $TERM_PROGRAM in
+            # which contains the window manager's name under '_NET_WM_NAME'.
-        iTerm.app)    term=iTerm2 ;;
+            #
-        Terminal.app) term='Apple Terminal' ;;
+            # The upside to using 'xprop' is that you don't need to hardcode
-        Hyper)        term=HyperTerm ;;
+            # a list of known window manager names. The downside is that
-        *)            term=${TERM_PROGRAM%%.app} ;;
+            # 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 and monster.
+            #
+            # 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.
+            command -v 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)
+                wm=${wm##*_NET_WM_NAME = \"}
+                wm=${wm%%\"*}
+            }
+        ;;
     esac
 
-    # Special case for TosWin2 (FreeMiNT) which doesn't
+    log wm "$wm" >&6
-    # support the "algorithm" of obtaining the terminal
+}
-    # program name.
-    [ "$TERM" = tw52 ] || [ "$TERM" = tw100 ] &&
-        term=TosWin2
 
-    # Special case for when 'pfetch' is run over SSH.
-    [ "$SSH_CONNECTION" ] &&
-        term=$SSH_TTY
 
-    # This surprisingly reliable method of detecting the current
+get_de() {
-    # terminal emulator is kinda neat.
+    # This only supports Xorg related desktop environments though
+    # this is fine as knowing the desktop envrionment on Windows,
+    # macOS etc is useless (they'll always report the same value).
     #
-    # It works by looping through each parent of each process
+    # Display the value of '$XDG_CURRENT_DESKTOP', if it's empty,
-    # starting with '$PPID' (the parent process ID) until we
+    # display the value of '$DESKTOP_SESSION'.
-    # find a match or hit PID 1 (init).
+    log de "${XDG_CURRENT_DESKTOP:-$DESKTOP_SESSION}" >&6
-    #
-    # On each iteration the name of the current parent process
-    # is checked against a list of good values and bad values.
-    # If no match is found we check the parent of the parent
-    # and so on.
-    #
-    # Using this method *no* terminal emulator names are
-    # hardcoded and the list remains small and general. In short
-    # it's basically a list of what *isn't* a terminal emulator
-    # and a list of places we should *stop*.
-    while [ -z "$term" ]; do
-        # This block is OS-specific and handles the fetching of
-        # the parent process (of the parent) and the fetching of
-        # said process' name.
-        case $os in
-            Linux*)
-                # On Linux some implementation of 'ps' aren't POSIX
-                # compliant, thankfully Linux provides this information
-                # though the '/proc' filesystem.
-                #
-                # This loops line by line over the '/proc/PID/status'
-                # file splitting at ':' and '<TAB>', we then look for
-                # the key containing 'PPid' and grab the value.
-                while IFS=':	' read -r key val; do
-                    case $key in
-                        PPid)
-                            ppid=$val
-                            break
-                        ;;
-                    esac
-                done < "/proc/${ppid:-$PPID}/status"
-
-                # Get the name of the parent process.
-                read -r name < "/proc/$ppid/comm"
-            ;;
-
-            Windows*)
-                # I need some assistance to add Windows support
-                # as the 'ps' command used in MINGW, MSYS and CYGWIN
-                # isn't POSIX compliant(?).
-                return
-            ;;
-
-            *)
-                # POSIX compliant 'ps' makes this really easy,
-                # just two simple commands to grab the parent
-                # process ID and the ID's name.
-                ppid=$(ps -p "${ppid:-$PPID}" -o ppid=)
-                name=$(ps -p "$ppid"          -o comm=)
-            ;;
-        esac
-
-        # Check the parent process name against a list of good and bad
-        # values. On a bad value we either keep iterating up the parent
-        # process list or we stop altogether (PID 1 for example).
-        case $name in
-            # If the parent process name matches the user's shell (or
-            # anything that looks like a shell), do another iteration.
-            #
-            # This also includes 'screen' and anything that looks like
-            # 'su' or 'sudo'.
-            ${SHELL##*/} | *sh | screen | su* ) ;;
-
-            # If the parent process name matches 'login', 'init' or
-            # '*Login*' we're most likely in the TTY and not a graphical
-            # session. In this case 'term' is set to the current TTY and
-            # we end here.
-            login* | *Login* | init)
-                term=$(tty)
-            ;;
-
-            # If the parent process name matches anything in this list
-            # we can no longer continue. We've either hit PID 1 or a parent
-            # which *won't* lead to the terminal emulator's PID.
-            ruby      | systemd  | python*  | 1  | sshd* | tmux* |\
-            USER*PID* | kdeinit* | launchd* | '' )
-                break
-            ;;
-
-            # If none of the above have matched we've reached the terminal
-            # emulator's PID and we can end here.
-            *)
-                term=${name##*/}
-            ;;
-        esac
-    done
-
-    [ "$term" ] && log term "$term" >&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'.
+    log editor "${VISUAL:-$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.
+    palette="  $c1  $c2  $c3  $c4  $c5  $c6  $c7  "
+
+    # Print the palette with a newline before and after.
+    # The '\033[%sC' moves the text to the right, the
+    # length of the ascii art.
+    printf '\n[%sC%s\n' "${ascii_width-1}" "$palette" >&6
+}
+
 get_ascii() {
     # This is a simple function to read the contents of
     # an ascii file from 'stdin'. It allows for the use
@@ -744,6 +855,17 @@ get_ascii() {
 			EOF
         ;;
 
+        [Aa]ndroid*)
+            read_ascii 2 <<-EOF
+				${c2}  ;,           ,;
+				   ';,.-----.,;'
+				  ,'           ',
+				 /    O     O    \\
+				|                 |
+				'-----------------'
+			EOF
+        ;;
+
         [Aa]rch*)
             read_ascii 4 <<-EOF
 				${c6}      /\\
@@ -803,6 +925,18 @@ get_ascii() {
 			EOF
         ;;
 
+        [Dd]ragon[Ff]ly*)
+            read_ascii 1 <<-EOF
+				    ,${c1}_${c7},
+				 ('-_${c1}|${c7}_-')
+				  >--${c1}|${c7}--<
+				 (_-'${c1}|${c7}'-_)
+				     ${c1}|
+				     |
+				     |
+			EOF
+        ;;
+
         [Ee]lementary*)
             read_ascii <<-EOF
 				${c7}  _______
@@ -961,6 +1095,19 @@ get_ascii() {
 			EOF
         ;;
 
+        [Mm]inix*)
+            read_ascii 4 <<-EOF
+				${c4} ,,        ,,
+				;${c7},${c4} ',    ,' ${c7},${c4};
+				; ${c7}',${c4} ',,' ${c7},'${c4} ;
+				;   ${c7}',${c4}  ${c7},'${c4}   ;
+				;  ${c7};, '' ,;${c4}  ;
+				;  ${c7};${c4};${c7}',,'${c4};${c7};${c4}  ;
+				', ${c7};${c4};;  ;;${c7};${c4} ,'
+				  '${c7};${c4}'    '${c7};${c4}'
+			EOF
+        ;;
+
         [Mm][Xx]*)
             read_ascii <<-EOF
 				${c7}    \\\\  /
@@ -1068,6 +1215,27 @@ get_ascii() {
 			EOF
         ;;
 
+        [Ss]un[Oo][Ss])
+            read_ascii 3 <<-EOF
+				${c3}       .   .;   .
+				   .   :;  ::  ;:   .
+				   .;. ..      .. .;.
+				..  ..             ..  ..
+				 .;,                 ,;.
+			EOF
+        ;;
+
+        [Uu]buntu*)
+            read_ascii 3 <<-EOF
+				${c3}         _
+				     ---(_)
+				 _/  ---  \\
+				(_) |   |
+				  \\  --- _/
+				     ---(_)
+			EOF
+        ;;
+
         [Vv]oid*)
             read_ascii 2 <<-EOF
 				${c2}    _______
@@ -1104,8 +1272,12 @@ get_ascii() {
     # information. The 'sed' is used to strip 'm' color codes from
     # the ascii art so they don't affect the width variable.
     while read -r line; do
-        : $((ascii_height+=1))
+        ascii_height=$((${ascii_height:-0} + 1))
-        ascii_width=$((${#line} > ascii_width ? ${#line} : ascii_width))
+
+        # 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 ('|').
@@ -1116,24 +1288,17 @@ get_ascii() {
 	EOF
 
     # Add a gap between the ascii art and the information.
-    : $((ascii_width+=4))
+    ascii_width=$((ascii_width + 4))
 
     # Print the ascii art and position the cursor back where we
     # started prior to printing it.
-    # '[?7l':  Disable line-wrapping.
-    # '[?25l': Hide the cursor.
     # '[1m':   Print the ascii in bold.
     # '[m':    Clear bold.
     # '[%sA':  Move the cursor up '$ascii_height' amount of lines.
-    printf '[?7l[?25l%s[%sA' "$ascii" "$ascii_height" >&6
+    printf '%s[%sA' "$ascii" "$ascii_height" >&6
 }
 
 main() {
-    # Leave the terminal how we found it on exit or Ctrl+C.
-    # '[?7h':  Enable line-wrapping.
-    # '[?25h': Un-hide the cursor.
-    trap 'printf [?7h[?25h >&6' EXIT
-
     # Hide 'stderr' unless the first argument is '-v'. This saves
     # polluting the script with '2>/dev/null'.
     [ "$1" = -v ] || exec 2>/dev/null
@@ -1152,6 +1317,26 @@ main() {
         c7=''; c8=''
     }
 
+    # Avoid text-wrapping from wrecking the program output
+    # and hide the cursor to hide its moving around during
+    # the printing process.
+    #
+    # Some terminals don't support these sequences, nor do they
+    # silently conceal them if they're printed resulting in
+    # partial sequences being printed to the terminal!
+    [ "$TERM" = dumb ]   ||
+    [ "$TERM" = minix ]  ||
+    [ "$TERM" = cons25 ] || {
+        # '[?7l':  Disable line-wrapping.
+        # '[?25l': Hide the cursor.
+        printf '[?7l[?25l' >&6
+
+        # Leave the terminal how we found it on exit or Ctrl+C.
+        # '[?7h':  Enable line-wrapping.
+        # '[?25h': Show the cursor.
+        trap 'printf [?7h[?25h >&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.
@@ -1170,18 +1355,22 @@ main() {
         # Disable globbing and set the positional parameters to the
         # contents of 'PF_INFO'.
         set -f
-        set +f ${PF_INFO-ascii title os host kernel term uptime pkgs memory}
+        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 &&
+            command -v "get_$info" >/dev/null || continue
-                info_length=$((${#info} > info_length ? ${#info} : info_length))
+
+            # 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+=1))
+        info_length=$((info_length + 1))
 
         # Iterate over the above list and run any existing "get_" functions.
         for info; do "get_$info"; done
@@ -1189,15 +1378,19 @@ main() {
 
     # 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, else move it down N lines.
+    # art in height, don't touch the cursor (0/unset), else move it down
-    cursor_pos=$((info_height > ascii_height ? 0 : ascii_height - info_height))
+    # N lines.
+    #
+    # This was a ternary operation but they aren't supported in Minix's shell.
+    [ "$info_height" -lt "$ascii_height" ] &&
+        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" ]; do
+    while [ "${i:=0}" -le "${cursor_pos:-0}" ]; do
         printf '\n'
-        : $((i+=1))
+        i=$((i + 1))
     done >&6
 }