changelog.sh 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434
  1. #!/usr/bin/env zsh
  2. ##############################
  3. # CHANGELOG SCRIPT CONSTANTS #
  4. ##############################
  5. #* Holds the list of valid types recognized in a commit subject
  6. #* and the display string of such type
  7. local -A TYPES
  8. TYPES=(
  9. build "Build system"
  10. chore "Chore"
  11. ci "CI"
  12. docs "Documentation"
  13. feat "Features"
  14. fix "Bug fixes"
  15. perf "Performance"
  16. refactor "Refactor"
  17. style "Style"
  18. test "Testing"
  19. )
  20. #* Types that will be displayed in their own section,
  21. #* in the order specified here.
  22. local -a MAIN_TYPES
  23. MAIN_TYPES=(feat fix perf docs)
  24. #* Types that will be displayed under the category of other changes
  25. local -a OTHER_TYPES
  26. OTHER_TYPES=(refactor style other)
  27. #* Commit types that don't appear in $MAIN_TYPES nor $OTHER_TYPES
  28. #* will not be displayed and will simply be ignored.
  29. ############################
  30. # COMMIT PARSING UTILITIES #
  31. ############################
  32. function parse-commit {
  33. # This function uses the following globals as output: commits (A),
  34. # subjects (A), scopes (A) and breaking (A). All associative arrays (A)
  35. # have $hash as the key.
  36. # - commits holds the commit type
  37. # - subjects holds the commit subject
  38. # - scopes holds the scope of a commit
  39. # - breaking holds the breaking change warning if a commit does
  40. # make a breaking change
  41. function commit:type {
  42. local type="$(sed -E 's/^([a-zA-Z_\-]+)(\(.+\))?!?: .+$/\1/' <<< "$1")"
  43. # If $type doesn't appear in $TYPES array mark it as 'other'
  44. if [[ -n "${(k)TYPES[(i)$type]}" ]]; then
  45. echo $type
  46. else
  47. echo other
  48. fi
  49. }
  50. function commit:scope {
  51. local scope
  52. # Try to find scope in "type(<scope>):" format
  53. scope=$(sed -nE 's/^[a-zA-Z_\-]+\((.+)\)!?: .+$/\1/p' <<< "$1")
  54. if [[ -n "$scope" ]]; then
  55. echo "$scope"
  56. return
  57. fi
  58. # If no scope found, try to find it in "<scope>:" format
  59. # Make sure it's not a type before printing it
  60. scope=$(sed -nE 's/^([a-zA-Z_\-]+): .+$/\1/p' <<< "$1")
  61. if [[ -z "${(k)TYPES[(i)$scope]}" ]]; then
  62. echo "$scope"
  63. fi
  64. }
  65. function commit:subject {
  66. # Only display the relevant part of the commit, i.e. if it has the format
  67. # type[(scope)!]: subject, where the part between [] is optional, only
  68. # displays subject. If it doesn't match the format, returns the whole string.
  69. sed -E 's/^[a-zA-Z_\-]+(\(.+\))?!?: (.+)$/\2/' <<< "$1"
  70. }
  71. # Return subject if the body or subject match the breaking change format
  72. function commit:is-breaking {
  73. local subject="$1" body="$2" message
  74. if [[ "$body" =~ "BREAKING CHANGE: (.*)" || \
  75. "$subject" =~ '^[^ :\)]+\)?!: (.*)$' ]]; then
  76. message="${match[1]}"
  77. # remove CR characters (might be inserted in GitHub UI commit description form)
  78. message="${message//$'\r'/}"
  79. # skip next paragraphs (separated by two newlines or more)
  80. message="${message%%$'\n\n'*}"
  81. # ... and replace newlines with spaces
  82. echo "${message//$'\n'/ }"
  83. else
  84. return 1
  85. fi
  86. }
  87. # Return truncated hash of the reverted commit
  88. function commit:is-revert {
  89. local subject="$1" body="$2"
  90. if [[ "$subject" = Revert* && \
  91. "$body" =~ "This reverts commit ([^.]+)\." ]]; then
  92. echo "${match[1]:0:7}"
  93. else
  94. return 1
  95. fi
  96. }
  97. # Ignore commit if it is a merge commit
  98. if [[ $(command git show -s --format=%p $1 | wc -w) -gt 1 ]]; then
  99. return
  100. fi
  101. # Parse commit with hash $1
  102. local hash="$1" subject body warning rhash
  103. subject="$(command git show -s --format=%s $hash)"
  104. body="$(command git show -s --format=%b $hash)"
  105. # Commits following Conventional Commits (https://www.conventionalcommits.org/)
  106. # have the following format, where parts between [] are optional:
  107. #
  108. # type[(scope)][!]: subject
  109. #
  110. # commit body
  111. # [BREAKING CHANGE: warning]
  112. # commits holds the commit type
  113. commits[$hash]="$(commit:type "$subject")"
  114. # scopes holds the commit scope
  115. scopes[$hash]="$(commit:scope "$subject")"
  116. # subjects holds the commit subject
  117. subjects[$hash]="$(commit:subject "$subject")"
  118. # breaking holds whether a commit has breaking changes
  119. # and its warning message if it does
  120. if warning=$(commit:is-breaking "$subject" "$body"); then
  121. breaking[$hash]="$warning"
  122. fi
  123. # reverts holds commits reverted in the same release
  124. if rhash=$(commit:is-revert "$subject" "$body"); then
  125. reverts[$hash]=$rhash
  126. fi
  127. }
  128. #############################
  129. # RELEASE CHANGELOG DISPLAY #
  130. #############################
  131. function display-release {
  132. # This function uses the following globals: output, version,
  133. # commits (A), subjects (A), scopes (A), breaking (A) and reverts (A).
  134. #
  135. # - output is the output format to use when formatting (raw|text|md)
  136. # - version is the version in which the commits are made
  137. # - commits, subjects, scopes, breaking, and reverts are associative arrays
  138. # with commit hashes as keys
  139. # Remove commits that were reverted
  140. local hash rhash
  141. for hash rhash in ${(kv)reverts}; do
  142. if (( ${+commits[$rhash]} )); then
  143. # Remove revert commit
  144. unset "commits[$hash]" "subjects[$hash]" "scopes[$hash]" "breaking[$hash]"
  145. # Remove reverted commit
  146. unset "commits[$rhash]" "subjects[$rhash]" "scopes[$rhash]" "breaking[$rhash]"
  147. fi
  148. done
  149. # If no commits left skip displaying the release
  150. if (( $#commits == 0 )); then
  151. return
  152. fi
  153. ##* Formatting functions
  154. # Format the hash according to output format
  155. # If no parameter is passed, assume it comes from `$hash`
  156. function fmt:hash {
  157. #* Uses $hash from outer scope
  158. local hash="${1:-$hash}"
  159. case "$output" in
  160. raw) printf "$hash" ;;
  161. text) printf "\e[33m$hash\e[0m" ;; # red
  162. md) printf "[\`$hash\`](https://github.com/ohmyzsh/ohmyzsh/commit/$hash)" ;;
  163. esac
  164. }
  165. # Format headers according to output format
  166. # Levels 1 to 2 are considered special, the rest are formatted
  167. # the same, except in md output format.
  168. function fmt:header {
  169. local header="$1" level="$2"
  170. case "$output" in
  171. raw)
  172. case "$level" in
  173. 1) printf "$header\n$(printf '%.0s=' {1..${#header}})\n\n" ;;
  174. 2) printf "$header\n$(printf '%.0s-' {1..${#header}})\n\n" ;;
  175. *) printf "$header:\n\n" ;;
  176. esac ;;
  177. text)
  178. case "$level" in
  179. 1|2) printf "\e[1;4m$header\e[0m\n\n" ;; # bold, underlined
  180. *) printf "\e[1m$header:\e[0m\n\n" ;; # bold
  181. esac ;;
  182. md) printf "$(printf '%.0s#' {1..${level}}) $header\n\n" ;;
  183. esac
  184. }
  185. function fmt:scope {
  186. #* Uses $scopes (A) and $hash from outer scope
  187. local scope="${1:-${scopes[$hash]}}"
  188. # Get length of longest scope for padding
  189. local max_scope=0 padding=0
  190. for hash in ${(k)scopes}; do
  191. max_scope=$(( max_scope < ${#scopes[$hash]} ? ${#scopes[$hash]} : max_scope ))
  192. done
  193. # If no scopes, exit the function
  194. if [[ $max_scope -eq 0 ]]; then
  195. return
  196. fi
  197. # Get how much padding is required for this scope
  198. padding=$(( max_scope < ${#scope} ? 0 : max_scope - ${#scope} ))
  199. padding="${(r:$padding:: :):-}"
  200. # If no scope, print padding and 3 spaces (equivalent to "[] ")
  201. if [[ -z "$scope" ]]; then
  202. printf "${padding} "
  203. return
  204. fi
  205. # Print [scope]
  206. case "$output" in
  207. raw|md) printf "[$scope]${padding} " ;;
  208. text) printf "[\e[38;5;9m$scope\e[0m]${padding} " ;; # red 9
  209. esac
  210. }
  211. # If no parameter is passed, assume it comes from `$subjects[$hash]`
  212. function fmt:subject {
  213. #* Uses $subjects (A) and $hash from outer scope
  214. local subject="${1:-${subjects[$hash]}}"
  215. # Capitalize first letter of the subject
  216. subject="${(U)subject:0:1}${subject:1}"
  217. case "$output" in
  218. raw) printf "$subject" ;;
  219. # In text mode, highlight (#<issue>) and dim text between `backticks`
  220. text) sed -E $'s|#([0-9]+)|\e[32m#\\1\e[0m|g;s|`([^`]+)`|`\e[2m\\1\e[0m`|g' <<< "$subject" ;;
  221. # In markdown mode, link to (#<issue>) issues
  222. md) sed -E 's|#([0-9]+)|[#\1](https://github.com/ohmyzsh/ohmyzsh/issues/\1)|g' <<< "$subject" ;;
  223. esac
  224. }
  225. function fmt:type {
  226. #* Uses $type from outer scope
  227. local type="${1:-${TYPES[$type]:-${(C)type}}}"
  228. [[ -z "$type" ]] && return 0
  229. case "$output" in
  230. raw|md) printf "$type: " ;;
  231. text) printf "\e[4m$type\e[24m: " ;; # underlined
  232. esac
  233. }
  234. ##* Section functions
  235. function display:version {
  236. fmt:header "$version" 2
  237. }
  238. function display:breaking {
  239. (( $#breaking != 0 )) || return 0
  240. case "$output" in
  241. raw) fmt:header "BREAKING CHANGES" 3 ;;
  242. text|md) fmt:header "⚠ BREAKING CHANGES" 3 ;;
  243. esac
  244. local hash subject
  245. for hash message in ${(kv)breaking}; do
  246. echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject "${message}")"
  247. done | sort
  248. echo
  249. }
  250. function display:type {
  251. local hash type="$1"
  252. local -a hashes
  253. hashes=(${(k)commits[(R)$type]})
  254. # If no commits found of type $type, go to next type
  255. (( $#hashes != 0 )) || return 0
  256. fmt:header "${TYPES[$type]}" 3
  257. for hash in $hashes; do
  258. echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)"
  259. done | sort -k3 # sort by scope
  260. echo
  261. }
  262. function display:others {
  263. local hash type
  264. # Commits made under types considered other changes
  265. local -A changes
  266. changes=(${(kv)commits[(R)${(j:|:)OTHER_TYPES}]})
  267. # If no commits found under "other" types, don't display anything
  268. (( $#changes != 0 )) || return 0
  269. fmt:header "Other changes" 3
  270. for hash type in ${(kv)changes}; do
  271. case "$type" in
  272. other) echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)" ;;
  273. *) echo " - $(fmt:hash) $(fmt:scope)$(fmt:type)$(fmt:subject)" ;;
  274. esac
  275. done | sort -k3 # sort by scope
  276. echo
  277. }
  278. ##* Release sections order
  279. # Display version header
  280. display:version
  281. # Display breaking changes first
  282. display:breaking
  283. # Display changes for commit types in the order specified
  284. for type in $MAIN_TYPES; do
  285. display:type "$type"
  286. done
  287. # Display other changes
  288. display:others
  289. }
  290. function main {
  291. # $1 = until commit, $2 = since commit
  292. local until="$1" since="$2"
  293. # $3 = output format (--text|--raw|--md)
  294. # --md: uses markdown formatting
  295. # --raw: outputs without style
  296. # --text: uses ANSI escape codes to style the output
  297. local output=${${3:-"--text"}#--*}
  298. if [[ -z "$until" ]]; then
  299. until=HEAD
  300. fi
  301. if [[ -z "$since" ]]; then
  302. # If $since is not specified:
  303. # 1) try to find the version used before updating
  304. # 2) try to find the first version tag before $until
  305. since=$(command git config --get oh-my-zsh.lastVersion 2>/dev/null) || \
  306. since=$(command git describe --abbrev=0 --tags "$until^" 2>/dev/null) || \
  307. unset since
  308. elif [[ "$since" = --all ]]; then
  309. unset since
  310. fi
  311. # Commit classification arrays
  312. local -A commits subjects scopes breaking reverts
  313. local truncate=0 read_commits=0
  314. local hash version tag
  315. # Get the first version name:
  316. # 1) try tag-like version, or
  317. # 2) try name-rev, or
  318. # 3) try branch name, or
  319. # 4) try short hash
  320. version=$(command git describe --tags $until 2>/dev/null) \
  321. || version=$(command git name-rev --no-undefined --name-only --exclude="remotes/*" $until 2>/dev/null) \
  322. || version=$(command git symbolic-ref --quiet --short $until 2>/dev/null) \
  323. || version=$(command git rev-parse --short $until 2>/dev/null)
  324. # Get commit list from $until commit until $since commit, or until root
  325. # commit if $since is unset, in short hash form.
  326. command git rev-list --abbrev-commit --abbrev=7 ${since:+$since..}$until | while read hash; do
  327. # Truncate list on versions with a lot of commits
  328. if [[ -z "$since" ]] && (( ++read_commits > 35 )); then
  329. truncate=1
  330. break
  331. fi
  332. # If we find a new release (exact tag)
  333. if tag=$(command git describe --exact-match --tags $hash 2>/dev/null); then
  334. # Output previous release
  335. display-release
  336. # Reinitialize commit storage
  337. commits=()
  338. subjects=()
  339. scopes=()
  340. breaking=()
  341. reverts=()
  342. # Start work on next release
  343. version="$tag"
  344. read_commits=1
  345. fi
  346. parse-commit "$hash"
  347. done
  348. display-release
  349. if (( truncate )); then
  350. echo " ...more commits omitted"
  351. echo
  352. fi
  353. }
  354. cd "$ZSH"
  355. # Use raw output if stdout is not a tty
  356. if [[ ! -t 1 && -z "$3" ]]; then
  357. main "$1" "$2" --raw
  358. else
  359. main "$@"
  360. fi