check_for_upgrade.sh 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
  1. # Migrate .zsh-update file to $ZSH_CACHE_DIR
  2. if [[ -f ~/.zsh-update && ! -f "${ZSH_CACHE_DIR}/.zsh-update" ]]; then
  3. mv ~/.zsh-update "${ZSH_CACHE_DIR}/.zsh-update"
  4. fi
  5. # Get user's update preferences
  6. #
  7. # Supported update modes:
  8. # - prompt (default): the user is asked before updating when it's time to update
  9. # - auto: the update is performed automatically when it's time
  10. # - reminder: a reminder is shown to the user when it's time to update
  11. # - disabled: automatic update is turned off
  12. zstyle -s ':omz:update' mode update_mode || {
  13. update_mode=prompt
  14. # If the mode zstyle setting is not set, support old-style settings
  15. [[ "$DISABLE_UPDATE_PROMPT" != true ]] || update_mode=auto
  16. [[ "$DISABLE_AUTO_UPDATE" != true ]] || update_mode=disabled
  17. }
  18. # Cancel update if:
  19. # - the automatic update is disabled.
  20. # - the current user doesn't have write permissions nor owns the $ZSH directory.
  21. # - git is unavailable on the system.
  22. if [[ "$update_mode" = disabled ]] \
  23. || [[ ! -w "$ZSH" || ! -O "$ZSH" ]] \
  24. || ! command -v git &>/dev/null; then
  25. unset update_mode
  26. return
  27. fi
  28. function current_epoch() {
  29. zmodload zsh/datetime
  30. echo $(( EPOCHSECONDS / 60 / 60 / 24 ))
  31. }
  32. function is_update_available() {
  33. local branch
  34. branch=${"$(builtin cd -q "$ZSH"; git config --local oh-my-zsh.branch)":-master}
  35. local remote remote_url remote_repo
  36. remote=${"$(builtin cd -q "$ZSH"; git config --local oh-my-zsh.remote)":-origin}
  37. remote_url=$(builtin cd -q "$ZSH"; git config remote.$remote.url)
  38. local repo
  39. case "$remote_url" in
  40. https://github.com/*) repo=${${remote_url#https://github.com/}%.git} ;;
  41. git@github.com:*) repo=${${remote_url#git@github.com:}%.git} ;;
  42. *)
  43. # If the remote is not using GitHub we can't check for updates
  44. # Let's assume there are updates
  45. return 0 ;;
  46. esac
  47. # If the remote repo is not the official one, let's assume there are updates available
  48. [[ "$repo" = ohmyzsh/ohmyzsh ]] || return 0
  49. local api_url="https://api.github.com/repos/${repo}/commits/${branch}"
  50. # Get local HEAD. If this fails assume there are updates
  51. local local_head
  52. local_head=$(builtin cd -q "$ZSH"; git rev-parse $branch 2>/dev/null) || return 0
  53. # Get remote HEAD. If no suitable command is found assume there are updates
  54. # On any other error, skip the update (connection may be down)
  55. local remote_head
  56. remote_head=$(
  57. if (( ${+commands[curl]} )); then
  58. curl --conect-timeout 2 -fsSL -H 'Accept: application/vnd.github.v3.sha' $api_url 2>/dev/null
  59. elif (( ${+commands[wget]} )); then
  60. wget -T 2 -O- --header='Accept: application/vnd.github.v3.sha' $api_url 2>/dev/null
  61. elif (( ${+commands[fetch]} )); then
  62. HTTP_ACCEPT='Accept: application/vnd.github.v3.sha' fetch -T 2 -o - $api_url 2>/dev/null
  63. else
  64. exit 0
  65. fi
  66. ) || return 1
  67. # Compare local and remote HEADs (if they're equal there are no updates)
  68. [[ "$local_head" != "$remote_head" ]] || return 1
  69. # If local and remote HEADs don't match, check if there's a common ancestor
  70. # If the merge-base call fails, $remote_head might not be downloaded so assume there are updates
  71. local base
  72. base=$(builtin cd -q "$ZSH"; git merge-base $local_head $remote_head 2>/dev/null) || return 0
  73. # If the common ancestor ($base) is not $remote_head,
  74. # the local HEAD is older than the remote HEAD
  75. [[ $base != $remote_head ]]
  76. }
  77. function update_last_updated_file() {
  78. echo "LAST_EPOCH=$(current_epoch)" >! "${ZSH_CACHE_DIR}/.zsh-update"
  79. }
  80. function update_ohmyzsh() {
  81. if ZSH="$ZSH" zsh -f "$ZSH/tools/upgrade.sh" --interactive; then
  82. update_last_updated_file
  83. fi
  84. }
  85. function has_typed_input() {
  86. # Created by Philippe Troin <phil@fifi.org>
  87. # https://zsh.org/mla/users/2022/msg00062.html
  88. emulate -L zsh
  89. zmodload zsh/zselect
  90. # Back up stty settings prior to disabling canonical mode
  91. # Consider that no input can be typed if stty fails
  92. # (this might happen if stdin is not a terminal)
  93. local termios
  94. termios=$(stty --save 2>/dev/null) || return 1
  95. {
  96. # Disable canonical mode so that typed input counts
  97. # regardless of whether Enter was pressed
  98. stty -icanon
  99. # Poll stdin (fd 0) for data ready to be read
  100. zselect -t 0 -r 0
  101. return $?
  102. } always {
  103. # Restore stty settings
  104. stty $termios
  105. }
  106. }
  107. () {
  108. emulate -L zsh
  109. local epoch_target mtime option LAST_EPOCH
  110. # Remove lock directory if older than a day
  111. zmodload zsh/datetime
  112. zmodload -F zsh/stat b:zstat
  113. if mtime=$(zstat +mtime "$ZSH/log/update.lock" 2>/dev/null); then
  114. if (( (mtime + 3600 * 24) < EPOCHSECONDS )); then
  115. command rm -rf "$ZSH/log/update.lock"
  116. fi
  117. fi
  118. # Check for lock directory
  119. if ! command mkdir "$ZSH/log/update.lock" 2>/dev/null; then
  120. return
  121. fi
  122. # Remove lock directory on exit. `return $ret` is important for when trapping a SIGINT:
  123. # The return status from the function is handled specially. If it is zero, the signal is
  124. # assumed to have been handled, and execution continues normally. Otherwise, the shell
  125. # will behave as interrupted except that the return status of the trap is retained.
  126. # This means that for a CTRL+C, the trap needs to return the same exit status so that
  127. # the shell actually exits what it's running.
  128. trap "
  129. ret=\$?
  130. unset update_mode
  131. unset -f current_epoch is_update_available update_last_updated_file update_ohmyzsh 2>/dev/null
  132. command rm -rf '$ZSH/log/update.lock'
  133. return \$ret
  134. " EXIT INT QUIT
  135. # Create or update .zsh-update file if missing or malformed
  136. if ! source "${ZSH_CACHE_DIR}/.zsh-update" 2>/dev/null || [[ -z "$LAST_EPOCH" ]]; then
  137. update_last_updated_file
  138. return
  139. fi
  140. # Number of days before trying to update again
  141. zstyle -s ':omz:update' frequency epoch_target || epoch_target=${UPDATE_ZSH_DAYS:-13}
  142. # Test if enough time has passed until the next update
  143. if (( ( $(current_epoch) - $LAST_EPOCH ) < $epoch_target )); then
  144. return
  145. fi
  146. # Test if Oh My Zsh directory is a git repository
  147. if ! (builtin cd -q "$ZSH" && LANG= git rev-parse &>/dev/null); then
  148. echo >&2 "[oh-my-zsh] Can't update: not a git repository."
  149. return
  150. fi
  151. # Check if there are updates available before proceeding
  152. if ! is_update_available; then
  153. return
  154. fi
  155. # If in reminder mode or user has typed input, show reminder and exit
  156. if [[ "$update_mode" = reminder ]] || has_typed_input; then
  157. printf '\r\e[0K' # move cursor to first column and clear whole line
  158. echo "[oh-my-zsh] It's time to update! You can do that by running \`omz update\`"
  159. return 0
  160. fi
  161. # Don't ask for confirmation before updating if in auto mode
  162. if [[ "$update_mode" = auto ]]; then
  163. update_ohmyzsh
  164. return $?
  165. fi
  166. # Ask for confirmation and only update on 'y', 'Y' or Enter
  167. # Otherwise just show a reminder for how to update
  168. echo -n "[oh-my-zsh] Would you like to update? [Y/n] "
  169. read -r -k 1 option
  170. [[ "$option" = $'\n' ]] || echo
  171. case "$option" in
  172. [yY$'\n']) update_ohmyzsh ;;
  173. [nN]) update_last_updated_file ;&
  174. *) echo "[oh-my-zsh] You can update manually by running \`omz update\`" ;;
  175. esac
  176. }
  177. unset update_mode
  178. unset -f current_epoch is_update_available update_last_updated_file update_ohmyzsh