check_for_upgrade.sh 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  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 || update_mode=prompt
  13. # Support old-style settings
  14. [[ "$DISABLE_UPDATE_PROMPT" != true ]] || update_mode=auto
  15. [[ "$DISABLE_AUTO_UPDATE" != true ]] || update_mode=disabled
  16. # Cancel update if:
  17. # - the automatic update is disabled.
  18. # - the current user doesn't have write permissions nor owns the $ZSH directory.
  19. # - git is unavailable on the system.
  20. if [[ "$update_mode" = disabled ]] \
  21. || [[ ! -w "$ZSH" || ! -O "$ZSH" ]] \
  22. || ! command -v git &>/dev/null; then
  23. unset update_mode
  24. return
  25. fi
  26. function current_epoch() {
  27. zmodload zsh/datetime
  28. echo $(( EPOCHSECONDS / 60 / 60 / 24 ))
  29. }
  30. function is_update_available() {
  31. local branch
  32. branch=${"$(cd "$ZSH"; git config --local oh-my-zsh.branch)":-master}
  33. local remote remote_url remote_repo
  34. remote=${"$(cd "$ZSH"; git config --local oh-my-zsh.remote)":-origin}
  35. remote_url=$(cd "$ZSH"; git config remote.$remote.url)
  36. local repo
  37. case "$remote_url" in
  38. https://github.com/*) repo=${${remote_url#https://github.com/}%.git} ;;
  39. git@github.com:*) repo=${${remote_url#git@github.com:}%.git} ;;
  40. *)
  41. # If the remote is not using GitHub we can't check for updates
  42. # Let's assume there are updates
  43. return 0 ;;
  44. esac
  45. # If the remote repo is not the official one, let's assume there are updates available
  46. [[ "$repo" = ohmyzsh/ohmyzsh ]] || return 0
  47. local api_url="https://api.github.com/repos/${repo}/commits/${branch}"
  48. # Get local HEAD. If this fails assume there are updates
  49. local local_head
  50. local_head=$(cd "$ZSH"; git rev-parse $branch 2>/dev/null) || return 0
  51. # Get remote HEAD. If no suitable command is found assume there are updates
  52. # On any other error, skip the update (connection may be down)
  53. local remote_head
  54. remote_head=$(
  55. if (( ${+commands[curl]} )); then
  56. curl -fsSL -H 'Accept: application/vnd.github.v3.sha' $api_url 2>/dev/null
  57. elif (( ${+commands[wget]} )); then
  58. wget -O- --header='Accept: application/vnd.github.v3.sha' $api_url 2>/dev/null
  59. elif (( ${+commands[fetch]} )); then
  60. HTTP_ACCEPT='Accept: application/vnd.github.v3.sha' fetch -o - $api_url 2>/dev/null
  61. else
  62. exit 0
  63. fi
  64. ) || return 1
  65. # Compare local and remote HEADs
  66. [[ "$local_head" != "$remote_head" ]]
  67. }
  68. function update_last_updated_file() {
  69. echo "LAST_EPOCH=$(current_epoch)" >! "${ZSH_CACHE_DIR}/.zsh-update"
  70. }
  71. function update_ohmyzsh() {
  72. if ZSH="$ZSH" zsh -f "$ZSH/tools/upgrade.sh" --interactive; then
  73. update_last_updated_file
  74. fi
  75. }
  76. () {
  77. emulate -L zsh
  78. local epoch_target mtime option LAST_EPOCH
  79. # Remove lock directory if older than a day
  80. zmodload zsh/datetime
  81. zmodload -F zsh/stat b:zstat
  82. if mtime=$(zstat +mtime "$ZSH/log/update.lock" 2>/dev/null); then
  83. if (( (mtime + 3600 * 24) < EPOCHSECONDS )); then
  84. command rm -rf "$ZSH/log/update.lock"
  85. fi
  86. fi
  87. # Check for lock directory
  88. if ! command mkdir "$ZSH/log/update.lock" 2>/dev/null; then
  89. return
  90. fi
  91. # Remove lock directory on exit. `return $ret` is important for when trapping a SIGINT:
  92. # The return status from the function is handled specially. If it is zero, the signal is
  93. # assumed to have been handled, and execution continues normally. Otherwise, the shell
  94. # will behave as interrupted except that the return status of the trap is retained.
  95. # This means that for a CTRL+C, the trap needs to return the same exit status so that
  96. # the shell actually exits what it's running.
  97. trap "
  98. ret=\$?
  99. unset update_mode
  100. unset -f current_epoch is_update_available update_last_updated_file update_ohmyzsh 2>/dev/null
  101. command rm -rf '$ZSH/log/update.lock'
  102. return \$ret
  103. " EXIT INT QUIT
  104. # Create or update .zsh-update file if missing or malformed
  105. if ! source "${ZSH_CACHE_DIR}/.zsh-update" 2>/dev/null || [[ -z "$LAST_EPOCH" ]]; then
  106. update_last_updated_file
  107. return
  108. fi
  109. # Number of days before trying to update again
  110. zstyle -s ':omz:update' frequency epoch_target || epoch_target=${UPDATE_ZSH_DAYS:-13}
  111. # Test if enough time has passed until the next update
  112. if (( ( $(current_epoch) - $LAST_EPOCH ) < $epoch_target )); then
  113. return
  114. fi
  115. # Test if Oh My Zsh directory is a git repository
  116. if ! (cd "$ZSH" && LANG= git rev-parse &>/dev/null); then
  117. echo >&2 "[oh-my-zsh] Can't update: not a git repository."
  118. return
  119. fi
  120. # Check if there are updates available before proceeding
  121. if ! is_update_available; then
  122. return
  123. fi
  124. # Ask for confirmation before updating unless in auto mode
  125. if [[ "$update_mode" = auto ]]; then
  126. update_ohmyzsh
  127. elif [[ "$update_mode" = reminder ]]; then
  128. echo "[oh-my-zsh] It's time to update! You can do that by running \`omz update\`"
  129. else
  130. # input sink to swallow all characters typed before the prompt
  131. # and add a newline if there wasn't one after characters typed
  132. while read -t -k 1 option; do true; done
  133. [[ "$option" != ($'\n'|"") ]] && echo
  134. echo -n "[oh-my-zsh] Would you like to update? [Y/n] "
  135. read -r -k 1 option
  136. [[ "$option" != $'\n' ]] && echo
  137. case "$option" in
  138. [yY$'\n']) update_ohmyzsh ;;
  139. [nN]) update_last_updated_file ;;
  140. esac
  141. fi
  142. }
  143. unset update_mode
  144. unset -f current_epoch is_update_available update_last_updated_file update_ohmyzsh