feat(CLI): add omz changelog command

lib/cli.zsh

@@ -22,10 +22,11 @@ function omz {
 function _omz {
   local -a cmds subcmds
   cmds=(
+    'changelog:Print the changelog'
     'help:Usage information'
-        'plugin:Commands for Oh My Zsh plugins management'
-        'pr:Commands for Oh My Zsh Pull Requests management'
-        'theme:Commands for Oh My Zsh themes management'
+    'plugin:Manage plugins'
+    'pr:Manage Oh My Zsh Pull Requests'
+    'theme:Manage themes'
     'update:Update Oh My Zsh'
   )
 
@@ -33,6 +34,9 @@ function _omz {
     _describe 'command' cmds
   elif (( CURRENT == 3 )); then
     case "$words[2]" in
+      changelog) local -a refs
+        refs=("${(@f)$(command git for-each-ref --format="%(refname:short):%(subject)" refs/heads refs/tags)}")
+        _describe 'command' refs ;;
       plugin) subcmds=('list:List plugins')
         _describe 'command' subcmds ;;
       pr) subcmds=('test:Test a Pull Request' 'clean:Delete all Pull Request branches')
@@ -52,21 +56,7 @@ function _omz {
 
 compdef _omz omz
 
-
-function _omz::help {
-    cat <<EOF
-Usage: omz <command> [options]
-
-Available commands:
-
-    help                Print this help message
-    plugin <command>    Manage plugins
-    pr <command>        Manage Oh My Zsh Pull Requests
-    theme <command>     Manage themes
-    update              Update Oh My Zsh
-
-EOF
-}
+## Utility functions
 
 function _omz::confirm {
   # If question supplied, ask it before reading the answer
@@ -111,6 +101,41 @@ function _omz::log {
   esac >&2
 }
 
+## User-facing commands
+
+function _omz::help {
+  cat <<EOF
+Usage: omz <command> [options]
+
+Available commands:
+
+  help                Print this help message
+  changelog           Print the changelog
+  plugin <command>    Manage plugins
+  pr     <command>    Manage Oh My Zsh Pull Requests
+  theme  <command>    Manage themes
+  update              Update Oh My Zsh
+
+EOF
+}
+
+function _omz::changelog {
+  local version=${1:-HEAD} format=${3:-"--text"}
+
+  if ! command git -C "$ZSH" show-ref --verify refs/heads/$version &>/dev/null && \
+    ! command git -C "$ZSH" show-ref --verify refs/tags/$version &>/dev/null && \
+    ! command git -C "$ZSH" rev-parse --verify "${version}^{commit}" &>/dev/null; then
+    cat <<EOF
+Usage: omz changelog [version]
+
+NOTE: <version> must be a valid branch, tag or commit.
+EOF
+    return 1
+  fi
+
+  "$ZSH/tools/changelog.sh" "$version" "${2:-}" "$format"
+}
+
 function _omz::plugin {
   (( $# > 0 && $+functions[_omz::plugin::$1] )) || {
     cat <<EOF
@@ -351,10 +376,16 @@ function _omz::theme::use {
 
 function _omz::update {
   # Run update script
-    env ZSH="$ZSH" sh "$ZSH/tools/upgrade.sh"
+  env ZSH="$ZSH" zsh -f "$ZSH/tools/upgrade.sh"
+  local ret=$?
   # Update last updated file
   zmodload zsh/datetime
   echo "LAST_EPOCH=$(( EPOCHSECONDS / 60 / 60 / 24 ))" >! "${ZSH_CACHE_DIR}/.zsh-update"
   # Remove update lock if it exists
   command rm -rf "$ZSH/log/update.lock"
+  # Restart the zsh session
+  if [[ $ret -eq 0 ]]; then
+    # Check whether to run a login shell
+    [[ "$ZSH_ARGZERO" = -* ]] && exec -l "${ZSH_ARGZERO#-}" || exec "$ZSH_ARGZERO"
+  fi
 }

lib/functions.zsh

@@ -14,12 +14,18 @@ function upgrade_oh_my_zsh() {
   fi
 
   # Run update script
-  env ZSH="$ZSH" sh "$ZSH/tools/upgrade.sh"
+  env ZSH="$ZSH" zsh -f "$ZSH/tools/upgrade.sh"
+  local ret=$?
   # Update last updated file
   zmodload zsh/datetime
   echo "LAST_EPOCH=$(( EPOCHSECONDS / 60 / 60 / 24 ))" >! "${ZSH_CACHE_DIR}/.zsh-update"
   # Remove update lock if it exists
   command rm -rf "$ZSH/log/update.lock"
+  # Restart the zsh session
+  if [[ $ret -eq 0 ]]; then
+    # Check whether to run a login shell
+    [[ "$ZSH_ARGZERO" = -* ]] && exec -l "${ZSH_ARGZERO#-}" || exec "$ZSH_ARGZERO"
+  fi
 }
 
 function take() {

tools/changelog.sh

@@ -0,0 +1,418 @@
+#!/usr/bin/env zsh
+
+##############################
+# CHANGELOG SCRIPT CONSTANTS #
+##############################
+
+#* Holds the list of valid types recognized in a commit subject
+#* and the display string of such type
+local -A TYPES
+TYPES=(
+  [build]="Build system"
+  [chore]="Chore"
+  [ci]="CI"
+  [docs]="Documentation"
+  [feat]="Features"
+  [fix]="Bug fixes"
+  [perf]="Performance"
+  [refactor]="Refactor"
+  [style]="Style"
+  [test]="Testing"
+)
+
+#* Types that will be displayed in their own section,
+#* in the order specified here.
+local -a MAIN_TYPES
+MAIN_TYPES=(feat fix perf docs)
+
+#* Types that will be displayed under the category of other changes
+local -a OTHER_TYPES
+OTHER_TYPES=(refactor style other)
+
+#* Commit types that don't appear in $MAIN_TYPES nor $OTHER_TYPES
+#* will not be displayed and will simply be ignored.
+
+
+############################
+# COMMIT PARSING UTILITIES #
+############################
+
+function parse-commit {
+
+  # This function uses the following globals as output: commits (A),
+  # subjects (A), scopes (A) and breaking (A). All associative arrays (A)
+  # have $hash as the key.
+  # - commits holds the commit type
+  # - subjects holds the commit subject
+  # - scopes holds the scope of a commit
+  # - breaking holds the breaking change warning if a commit does
+  #   make a breaking change
+
+  function commit:type {
+    local type="$(sed -E 's/^([a-zA-Z_\-]+)(\(.+\))?!?: .+$/\1/' <<< "$1")"
+
+    # If $type doesn't appear in $TYPES array mark it as 'other'
+    if [[ -n "${(k)TYPES[(i)$type]}" ]]; then
+      echo $type
+    else
+      echo other
+    fi
+  }
+
+  function commit:scope {
+    local scope
+
+    # Try to find scope in "type(<scope>):" format
+    scope=$(sed -nE 's/^[a-zA-Z_\-]+\((.+)\)!?: .+$/\1/p' <<< "$1")
+    if [[ -n "$scope" ]]; then
+      echo "$scope"
+      return
+    fi
+
+    # If no scope found, try to find it in "<scope>:" format
+    # Make sure it's not a type before printing it
+    scope=$(sed -nE 's/^([a-zA-Z_\-]+): .+$/\1/p' <<< "$1")
+    if [[ -z "${(k)TYPES[(i)$scope]}" ]]; then
+      echo "$scope"
+    fi
+  }
+
+  function commit:subject {
+    # Only display the relevant part of the commit, i.e. if it has the format
+    # type[(scope)!]: subject, where the part between [] is optional, only
+    # displays subject. If it doesn't match the format, returns the whole string.
+    sed -E 's/^[a-zA-Z_\-]+(\(.+\))?!?: (.+)$/\2/' <<< "$1"
+  }
+
+  # Return subject if the body or subject match the breaking change format
+  function commit:is-breaking {
+    local subject="$1" body="$2"
+
+    if [[ "$body" =~ "BREAKING CHANGE: (.*)" || \
+      "$subject" =~ '^[^ :\)]+\)?!: (.*)$' ]]; then
+      echo "${match[1]}"
+    else
+      return 1
+    fi
+  }
+
+  # Return truncated hash of the reverted commit
+  function commit:is-revert {
+    local subject="$1" body="$2"
+
+    if [[ "$subject" = Revert* && \
+      "$body" =~ "This reverts commit ([^.]+)\." ]]; then
+      echo "${match[1]:0:7}"
+    else
+      return 1
+    fi
+  }
+
+  # Parse commit with hash $1
+  local hash="$1" subject body warning rhash
+  subject="$(command git show -s --format=%s $hash)"
+  body="$(command git show -s --format=%b $hash)"
+
+  # Commits following Conventional Commits (https://www.conventionalcommits.org/)
+  # have the following format, where parts between [] are optional:
+  #
+  #  type[(scope)][!]: subject
+  #
+  #  commit body
+  #  [BREAKING CHANGE: warning]
+
+  # commits holds the commit type
+  commits[$hash]="$(commit:type "$subject")"
+  # scopes holds the commit scope
+  scopes[$hash]="$(commit:scope "$subject")"
+  # subjects holds the commit subject
+  subjects[$hash]="$(commit:subject "$subject")"
+
+  # breaking holds whether a commit has breaking changes
+  # and its warning message if it does
+  if warning=$(commit:is-breaking "$subject" "$body"); then
+    breaking[$hash]="$warning"
+  fi
+
+  # reverts holds commits reverted in the same release
+  if rhash=$(commit:is-revert "$subject" "$body"); then
+    reverts[$hash]=$rhash
+  fi
+}
+
+#############################
+# RELEASE CHANGELOG DISPLAY #
+#############################
+
+function display-release {
+
+  # This function uses the following globals: output, version,
+  # commits (A), subjects (A), scopes (A), breaking (A) and reverts (A).
+  #
+  # - output is the output format to use when formatting (raw|text|md)
+  # - version is the version in which the commits are made
+  # - commits, subjects, scopes, breaking, and reverts are associative arrays
+  #   with commit hashes as keys
+
+  # Remove commits that were reverted
+  local hash rhash
+  for hash rhash in ${(kv)reverts}; do
+    if (( ${+commits[$rhash]} )); then
+      # Remove revert commit
+      unset "commits[$hash]" "subjects[$hash]" "scopes[$hash]" "breaking[$hash]"
+      # Remove reverted commit
+      unset "commits[$rhash]" "subjects[$rhash]" "scopes[$rhash]" "breaking[$rhash]"
+    fi
+  done
+
+  # If no commits left skip displaying the release
+  if (( $#commits == 0 )); then
+    return
+  fi
+
+  ##* Formatting functions
+
+  # Format the hash according to output format
+  # If no parameter is passed, assume it comes from `$hash`
+  function fmt:hash {
+    #* Uses $hash from outer scope
+    local hash="${1:-$hash}"
+    case "$output" in
+    raw) printf "$hash" ;;
+    text) printf "\e[33m$hash\e[0m" ;; # red
+    md) printf "[\`$hash\`](https://github.com/ohmyzsh/ohmyzsh/commit/$hash)" ;;
+    esac
+  }
+
+  # Format headers according to output format
+  # Levels 1 to 2 are considered special, the rest are formatted
+  # the same, except in md output format.
+  function fmt:header {
+    local header="$1" level="$2"
+    case "$output" in
+    raw)
+      case "$level" in
+      1) printf "$header\n$(printf '%.0s=' {1..${#header}})\n\n" ;;
+      2) printf "$header\n$(printf '%.0s-' {1..${#header}})\n\n" ;;
+      *) printf "$header:\n\n" ;;
+      esac ;;
+    text)
+      case "$level" in
+      1|2) printf "\e[1;4m$header\e[0m\n\n" ;; # bold, underlined
+      *) printf "\e[1m$header:\e[0m\n\n" ;; # bold
+      esac ;;
+    md) printf "$(printf '%.0s#' {1..${level}}) $header\n\n" ;;
+    esac
+  }
+
+  function fmt:scope {
+    #* Uses $scopes (A) and $hash from outer scope
+    local scope="${1:-${scopes[$hash]}}"
+
+    # Get length of longest scope for padding
+    local max_scope=0 padding=0
+    for hash in ${(k)scopes}; do
+      max_scope=$(( max_scope < ${#scopes[$hash]} ? ${#scopes[$hash]} : max_scope ))
+    done
+
+    # If no scopes, exit the function
+    if [[ $max_scope -eq 0 ]]; then
+      return
+    fi
+
+    # Get how much padding is required for this scope
+    padding=$(( max_scope < ${#scope} ? 0 : max_scope - ${#scope} ))
+    padding="${(r:$padding:: :):-}"
+
+    # If no scope, print padding and 3 spaces (equivalent to "[] ")
+    if [[ -z "$scope" ]]; then
+      printf "${padding}   "
+      return
+    fi
+
+    # Print [scope]
+    case "$output" in
+    raw|md) printf "[$scope]${padding} " ;;
+    text) printf "[\e[38;5;9m$scope\e[0m]${padding} " ;; # red 9
+    esac
+  }
+
+  # If no parameter is passed, assume it comes from `$subjects[$hash]`
+  function fmt:subject {
+    #* Uses $subjects (A) and $hash from outer scope
+    local subject="${1:-${subjects[$hash]}}"
+
+    # Capitalize first letter of the subject
+    subject="${(U)subject:0:1}${subject:1}"
+
+    case "$output" in
+    raw) printf "$subject" ;;
+    # In text mode, highlight (#<issue>) and dim text between `backticks`
+    text) sed -E $'s|#([0-9]+)|\e[32m#\\1\e[0m|g;s|`(.+)`|`\e[2m\\1\e[0m`|g' <<< "$subject" ;;
+    # In markdown mode, link to (#<issue>) issues
+    md) sed -E 's|#([0-9]+)|[#\1](https://github.com/ohmyzsh/ohmyzsh/issues/\1)|g' <<< "$subject" ;;
+    esac
+  }
+
+  function fmt:type {
+    #* Uses $type from outer scope
+    local type="${1:-${TYPES[$type]:-${(C)type}}}"
+    [[ -z "$type" ]] && return 0
+    case "$output" in
+    raw|md) printf "$type: " ;;
+    text) printf "\e[4m$type\e[24m: " ;; # underlined
+    esac
+  }
+
+  ##* Section functions
+
+  function display:version {
+    fmt:header "$version" 2
+  }
+
+  function display:breaking {
+    (( $#breaking != 0 )) || return 0
+
+    case "$output" in
+    raw) display:type-header "BREAKING CHANGES" ;;
+    text|md) display:type-header "⚠ BREAKING CHANGES" ;;
+    esac
+
+    local hash subject
+    for hash message in ${(kv)breaking}; do
+      echo " - $(fmt:hash) $(fmt:subject "${message}")"
+    done | sort
+    echo
+  }
+
+  function display:type {
+    local hash type="$1"
+
+    local -a hashes
+    hashes=(${(k)commits[(R)$type]})
+
+    # If no commits found of type $type, go to next type
+    (( $#hashes != 0 )) || return 0
+
+    fmt:header "${TYPES[$type]}" 3
+    for hash in $hashes; do
+      echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)"
+    done | sort -k3 # sort by scope
+    echo
+  }
+
+  function display:others {
+    local hash type
+
+    # Commits made under types considered other changes
+    local -A changes
+    changes=(${(kv)commits[(R)${(j:|:)OTHER_TYPES}]})
+
+    # If no commits found under "other" types, don't display anything
+    (( $#changes != 0 )) || return 0
+
+    fmt:header "Other changes" 3
+    for hash type in ${(kv)changes}; do
+      case "$type" in
+      other) echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)" ;;
+      *) echo " - $(fmt:hash) $(fmt:scope)$(fmt:type)$(fmt:subject)" ;;
+      esac
+    done | sort -k3 # sort by scope
+    echo
+  }
+
+  ##* Release sections order
+
+  # Display version header
+  display:version
+
+  # Display breaking changes first
+  display:breaking
+
+  # Display changes for commit types in the order specified
+  for type in $MAIN_TYPES; do
+    display:type "$type"
+  done
+
+  # Display other changes
+  display:others
+}
+
+function main {
+  # $1 = until commit, $2 = since commit
+  # $3 = output format (--raw|--text|--md)
+  local until="$1" since="$2"
+  local output=${${3:-"--text"}#--*}
+
+  if [[ -z "$until" ]]; then
+    until=HEAD
+  fi
+
+  # If $since is not specified, look up first version tag before $until
+  if [[ -z "$since" ]]; then
+    since=$(command git describe --abbrev=0 --tags "$until^" 2>/dev/null) || \
+    unset since
+  elif [[ "$since" = --all ]]; then
+    unset since
+  fi
+
+  # Commit classification arrays
+  local -A commits subjects scopes breaking reverts
+  local truncate=0 read_commits=0
+  local hash version tag
+
+  # Get the first version name:
+  # 1) try tag-like version, or
+  # 2) try name-rev, or
+  # 3) try branch name, or
+  # 4) try short hash
+  version=$(command git describe --tags $until 2>/dev/null) \
+    || version=$(command git name-rev --no-undefined --name-only --exclude="remotes/*" $until 2>/dev/null) \
+    || version=$(command git symbolic-ref --quiet --short $until 2>/dev/null) \
+    || version=$(command git rev-parse --short $until 2>/dev/null)
+
+  # Get commit list from $until commit until $since commit, or until root
+  # commit if $since is unset, in short hash form.
+  # --first-parent is used when dealing with merges: it only prints the
+  # merge commit, not the commits of the merged branch.
+  command git rev-list --first-parent --abbrev-commit --abbrev=7 ${since:+$since..}$until | while read hash; do
+    # Truncate list on versions with a lot of commits
+    if [[ -z "$since" ]] && (( ++read_commits > 35 )); then
+      truncate=1
+      break
+    fi
+
+    # If we find a new release (exact tag)
+    if tag=$(command git describe --exact-match --tags $hash 2>/dev/null); then
+      # Output previous release
+      display-release
+      # Reinitialize commit storage
+      commits=()
+      subjects=()
+      scopes=()
+      breaking=()
+      reverts=()
+      # Start work on next release
+      version="$tag"
+      read_commits=1
+    fi
+
+    parse-commit "$hash"
+  done
+
+  display-release
+
+  if (( truncate )); then
+    echo " ...more commits omitted"
+    echo
+  fi
+}
+
+cd "$ZSH"
+
+# Use raw output if stdout is not a tty
+if [[ ! -t 1 && -z "$3" ]]; then
+  main "$1" "$2" --raw
+else
+  main "$@"
+fi

tools/check_for_upgrade.sh

@@ -24,7 +24,7 @@ function update_last_updated_file() {
 }
 
 function update_ohmyzsh() {
-    ZSH="$ZSH" sh "$ZSH/tools/upgrade.sh"
+  ZSH="$ZSH" zsh -f "$ZSH/tools/upgrade.sh"
   update_last_updated_file
 }
 
@@ -51,7 +51,11 @@ function update_ohmyzsh() {
   #  The return status from the function is handled specially. If it is zero, the signal is
   #  assumed to have been handled, and execution continues normally. Otherwise, the shell
   #  will behave as interrupted except that the return status of the trap is retained.
-    trap "command rm -rf '$ZSH/log/update.lock'; return 1" EXIT INT QUIT
+  trap "
+  unset -f current_epoch update_last_updated_file update_ohmyzsh
+  command rm -rf '$ZSH/log/update.lock'
+  return 1
+  " EXIT INT QUIT
 
   # Create or update .zsh-update file if missing or malformed
   if ! source "${ZSH_CACHE_DIR}/.zsh-update" 2>/dev/null || [[ -z "$LAST_EPOCH" ]]; then
@@ -84,5 +88,3 @@ function update_ohmyzsh() {
     esac
   fi
 }
-
-unset -f current_epoch update_last_updated_file update_ohmyzsh

tools/upgrade.sh

@@ -1,13 +1,23 @@
-# Use colors, but only if connected to a terminal, and that terminal
-# supports them.
+#!/usr/bin/env zsh
+
+cd "$ZSH"
+
+# Use colors, but only if connected to a terminal
+# and that terminal supports them.
+
+local -a RAINBOW
+local RED GREEN YELLOW BLUE UNDER BOLD RESET
+
 if [ -t 1 ]; then
-  RB_RED=$(printf '\033[38;5;196m')
-  RB_ORANGE=$(printf '\033[38;5;202m')
-  RB_YELLOW=$(printf '\033[38;5;226m')
-  RB_GREEN=$(printf '\033[38;5;082m')
-  RB_BLUE=$(printf '\033[38;5;021m')
-  RB_INDIGO=$(printf '\033[38;5;093m')
-  RB_VIOLET=$(printf '\033[38;5;163m')
+  RAINBOW=(
+    "$(printf '\033[38;5;196m')"
+    "$(printf '\033[38;5;202m')"
+    "$(printf '\033[38;5;226m')"
+    "$(printf '\033[38;5;082m')"
+    "$(printf '\033[38;5;021m')"
+    "$(printf '\033[38;5;093m')"
+    "$(printf '\033[38;5;163m')"
+  )
 
   RED=$(printf '\033[31m')
   GREEN=$(printf '\033[32m')
@@ -16,25 +26,19 @@ if [ -t 1 ]; then
   BOLD=$(printf '\033[1m')
   UNDER=$(printf '\033[4m')
   RESET=$(printf '\033[m')
-else
-  RB_RED=""
-  RB_ORANGE=""
-  RB_YELLOW=""
-  RB_GREEN=""
-  RB_BLUE=""
-  RB_INDIGO=""
-  RB_VIOLET=""
-
-  RED=""
-  GREEN=""
-  YELLOW=""
-  BLUE=""
-  UNDER=""
-  BOLD=""
-  RESET=""
 fi
 
-cd "$ZSH"
+# Update upstream remote to ohmyzsh org
+git remote -v | while read remote url _; do
+  case "$url" in
+  https://github.com/robbyrussell/oh-my-zsh(|.git))
+    git remote set-url "$remote" "https://github.com/ohmyzsh/ohmyzsh.git"
+    break ;;
+  git@github.com:robbyrussell/oh-my-zsh(|.git))
+    git remote set-url "$remote" "git@github.com:ohmyzsh/ohmyzsh.git"
+    break ;;
+  esac
+done
 
 # Set git-config values known to fix git errors
 # Line endings (#4069)
@@ -45,30 +49,43 @@ git config fsck.zeroPaddedFilemode ignore
 git config fetch.fsck.zeroPaddedFilemode ignore
 git config receive.fsck.zeroPaddedFilemode ignore
 # autostash on rebase (#7172)
-resetAutoStash=$(git config --bool rebase.autoStash 2>&1)
+resetAutoStash=$(git config --bool rebase.autoStash 2>/dev/null)
 git config rebase.autoStash true
 
-# Update upstream remote to ohmyzsh org
-remote=$(git remote -v | awk '/https:\/\/github\.com\/robbyrussell\/oh-my-zsh\.git/{ print $1; exit }')
-if [ -n "$remote" ]; then
-  git remote set-url "$remote" "https://github.com/ohmyzsh/ohmyzsh.git"
-fi
+local ret=0
 
+# Update Oh My Zsh
 printf "${BLUE}%s${RESET}\n" "Updating Oh My Zsh"
-if git pull --rebase --stat origin master
-then
-  printf '%s         %s__      %s           %s        %s       %s     %s__   %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf '%s  ____  %s/ /_    %s ____ ___  %s__  __  %s ____  %s_____%s/ /_  %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf '%s / __ \%s/ __ \  %s / __ `__ \%s/ / / / %s /_  / %s/ ___/%s __ \ %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf '%s/ /_/ /%s / / / %s / / / / / /%s /_/ / %s   / /_%s(__  )%s / / / %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf '%s\____/%s_/ /_/ %s /_/ /_/ /_/%s\__, / %s   /___/%s____/%s_/ /_/  %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf '%s    %s        %s           %s /____/ %s       %s     %s          %s\n' $RB_RED $RB_ORANGE $RB_YELLOW $RB_GREEN $RB_BLUE $RB_INDIGO $RB_VIOLET $RB_RESET
-  printf "${BLUE}%s\n" "Hooray! Oh My Zsh has been updated and/or is at the current version."
-  printf "${BLUE}${BOLD}%s ${UNDER}%s${RESET}\n" "To keep up on the latest news and updates, follow us on Twitter:" "https://twitter.com/ohmyzsh"
+last_commit=$(git rev-parse HEAD)
+if git pull --rebase --stat origin master; then
+  # Check if it was really updated or not
+  if [[ "$(git rev-parse HEAD)" = "$last_commit" ]]; then
+    message="Oh My Zsh is already at the latest version."
+    ret=80 # non-zero exit code to indicate no changes pulled
+  else
+    message="Hooray! Oh My Zsh has been updated!"
+
+    # Display changelog with less if available, otherwise just print it to the terminal
+    if (( $+commands[less] )); then
+      command less -R <("$ZSH/tools/changelog.sh" HEAD "$last_commit")
+    else
+      "$ZSH/tools/changelog.sh" HEAD "$last_commit"
+    fi
+  fi
+
+  printf '%s         %s__      %s           %s        %s       %s     %s__   %s\n' $RAINBOW $RESET
+  printf '%s  ____  %s/ /_    %s ____ ___  %s__  __  %s ____  %s_____%s/ /_  %s\n' $RAINBOW $RESET
+  printf '%s / __ \%s/ __ \  %s / __ `__ \%s/ / / / %s /_  / %s/ ___/%s __ \ %s\n' $RAINBOW $RESET
+  printf '%s/ /_/ /%s / / / %s / / / / / /%s /_/ / %s   / /_%s(__  )%s / / / %s\n' $RAINBOW $RESET
+  printf '%s\____/%s_/ /_/ %s /_/ /_/ /_/%s\__, / %s   /___/%s____/%s_/ /_/  %s\n' $RAINBOW $RESET
+  printf '%s    %s        %s           %s /____/ %s       %s     %s          %s\n' $RAINBOW $RESET
+  printf '\n'
+  printf "${BLUE}%s${RESET}\n" "$message"
+  printf "${BLUE}${BOLD}%s ${UNDER}%s${RESET}\n" "To keep up with the latest news and updates, follow us on Twitter:" "https://twitter.com/ohmyzsh"
   printf "${BLUE}${BOLD}%s ${UNDER}%s${RESET}\n" "Want to get involved in the community? Join our Discord:" "https://discord.gg/ohmyzsh"
   printf "${BLUE}${BOLD}%s ${UNDER}%s${RESET}\n" "Get your Oh My Zsh swag at:" "https://shop.planetargon.com/collections/oh-my-zsh"
 else
-  status=$?
+  ret=$?
   printf "${RED}%s${RESET}\n" 'There was an error updating. Try again later?'
 fi
 
@@ -79,4 +96,4 @@ case "$resetAutoStash" in
 esac
 
 # Exit with `1` if the update failed
-exit $status
+exit $ret