changelog.sh 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441
  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. # Get length of longest scope for padding
  154. local max_scope=0
  155. for hash in ${(k)scopes}; do
  156. max_scope=$(( max_scope < ${#scopes[$hash]} ? ${#scopes[$hash]} : max_scope ))
  157. done
  158. ##* Formatting functions
  159. # Format the hash according to output format
  160. # If no parameter is passed, assume it comes from `$hash`
  161. function fmt:hash {
  162. #* Uses $hash from outer scope
  163. local hash="${1:-$hash}"
  164. case "$output" in
  165. raw) printf "$hash" ;;
  166. text) printf "\e[33m$hash\e[0m" ;; # red
  167. md) printf "[\`$hash\`](https://github.com/ohmyzsh/ohmyzsh/commit/$hash)" ;;
  168. esac
  169. }
  170. # Format headers according to output format
  171. # Levels 1 to 2 are considered special, the rest are formatted
  172. # the same, except in md output format.
  173. function fmt:header {
  174. local header="$1" level="$2"
  175. case "$output" in
  176. raw)
  177. case "$level" in
  178. 1) printf "$header\n$(printf '%.0s=' {1..${#header}})\n\n" ;;
  179. 2) printf "$header\n$(printf '%.0s-' {1..${#header}})\n\n" ;;
  180. *) printf "$header:\n\n" ;;
  181. esac ;;
  182. text)
  183. case "$level" in
  184. 1|2) printf "\e[1;4m$header\e[0m\n\n" ;; # bold, underlined
  185. *) printf "\e[1m$header:\e[0m\n\n" ;; # bold
  186. esac ;;
  187. md) printf "$(printf '%.0s#' {1..${level}}) $header\n\n" ;;
  188. esac
  189. }
  190. function fmt:scope {
  191. #* Uses $scopes (A) and $hash from outer scope
  192. local scope="${1:-${scopes[$hash]}}"
  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. local padding=0
  199. padding=$(( max_scope < ${#scope} ? 0 : max_scope - ${#scope} ))
  200. padding="${(r:$padding:: :):-}"
  201. # If no scope, print padding and 3 spaces (equivalent to "[] ")
  202. if [[ -z "$scope" ]]; then
  203. printf "${padding} "
  204. return
  205. fi
  206. # Print [scope]
  207. case "$output" in
  208. raw|md) printf "[$scope]${padding} " ;;
  209. text) printf "[\e[38;5;9m$scope\e[0m]${padding} " ;; # red 9
  210. esac
  211. }
  212. # If no parameter is passed, assume it comes from `$subjects[$hash]`
  213. function fmt:subject {
  214. #* Uses $subjects (A) and $hash from outer scope
  215. local subject="${1:-${subjects[$hash]}}"
  216. # Capitalize first letter of the subject
  217. subject="${(U)subject:0:1}${subject:1}"
  218. case "$output" in
  219. raw) printf "$subject" ;;
  220. # In text mode, highlight (#<issue>) and dim text between `backticks`
  221. text) sed -E $'s|#([0-9]+)|\e[32m#\\1\e[0m|g;s|`([^`]+)`|`\e[2m\\1\e[0m`|g' <<< "$subject" ;;
  222. # In markdown mode, link to (#<issue>) issues
  223. md) sed -E 's|#([0-9]+)|[#\1](https://github.com/ohmyzsh/ohmyzsh/issues/\1)|g' <<< "$subject" ;;
  224. esac
  225. }
  226. function fmt:type {
  227. #* Uses $type from outer scope
  228. local type="${1:-${TYPES[$type]:-${(C)type}}}"
  229. [[ -z "$type" ]] && return 0
  230. case "$output" in
  231. raw|md) printf "$type: " ;;
  232. text) printf "\e[4m$type\e[24m: " ;; # underlined
  233. esac
  234. }
  235. ##* Section functions
  236. function display:version {
  237. fmt:header "$version" 2
  238. }
  239. function display:breaking {
  240. (( $#breaking != 0 )) || return 0
  241. case "$output" in
  242. text) fmt:header "\e[31mBREAKING CHANGES" 3 ;;
  243. raw) fmt:header "BREAKING CHANGES" 3 ;;
  244. md) fmt:header "BREAKING CHANGES ⚠" 3 ;;
  245. esac
  246. local hash message
  247. local wrap_width=$(( (COLUMNS < 100 ? COLUMNS : 100) - 3 ))
  248. for hash message in ${(kv)breaking}; do
  249. # Format the BREAKING CHANGE message by word-wrapping it at maximum 100
  250. # characters (use $COLUMNS if smaller than 100)
  251. message="$(fmt -w $wrap_width <<< "$message")"
  252. # Display hash and scope in their own line, and then the full message with
  253. # blank lines as separators and a 3-space left padding
  254. echo " - $(fmt:hash) $(fmt:scope)\n\n$(fmt:subject "$message" | sed 's/^/ /')\n"
  255. done
  256. }
  257. function display:type {
  258. local hash type="$1"
  259. local -a hashes
  260. hashes=(${(k)commits[(R)$type]})
  261. # If no commits found of type $type, go to next type
  262. (( $#hashes != 0 )) || return 0
  263. fmt:header "${TYPES[$type]}" 3
  264. for hash in $hashes; do
  265. echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)"
  266. done | sort -k3 # sort by scope
  267. echo
  268. }
  269. function display:others {
  270. local hash type
  271. # Commits made under types considered other changes
  272. local -A changes
  273. changes=(${(kv)commits[(R)${(j:|:)OTHER_TYPES}]})
  274. # If no commits found under "other" types, don't display anything
  275. (( $#changes != 0 )) || return 0
  276. fmt:header "Other changes" 3
  277. for hash type in ${(kv)changes}; do
  278. case "$type" in
  279. other) echo " - $(fmt:hash) $(fmt:scope)$(fmt:subject)" ;;
  280. *) echo " - $(fmt:hash) $(fmt:scope)$(fmt:type)$(fmt:subject)" ;;
  281. esac
  282. done | sort -k3 # sort by scope
  283. echo
  284. }
  285. ##* Release sections order
  286. # Display version header
  287. display:version
  288. # Display breaking changes first
  289. display:breaking
  290. # Display changes for commit types in the order specified
  291. for type in $MAIN_TYPES; do
  292. display:type "$type"
  293. done
  294. # Display other changes
  295. display:others
  296. }
  297. function main {
  298. # $1 = until commit, $2 = since commit
  299. local until="$1" since="$2"
  300. # $3 = output format (--text|--raw|--md)
  301. # --md: uses markdown formatting
  302. # --raw: outputs without style
  303. # --text: uses ANSI escape codes to style the output
  304. local output=${${3:-"--text"}#--*}
  305. if [[ -z "$until" ]]; then
  306. until=HEAD
  307. fi
  308. if [[ -z "$since" ]]; then
  309. # If $since is not specified:
  310. # 1) try to find the version used before updating
  311. # 2) try to find the first version tag before $until
  312. since=$(command git config --get oh-my-zsh.lastVersion 2>/dev/null) || \
  313. since=$(command git describe --abbrev=0 --tags "$until^" 2>/dev/null) || \
  314. unset since
  315. elif [[ "$since" = --all ]]; then
  316. unset since
  317. fi
  318. # Commit classification arrays
  319. local -A commits subjects scopes breaking reverts
  320. local truncate=0 read_commits=0
  321. local hash version tag
  322. # Get the first version name:
  323. # 1) try tag-like version, or
  324. # 2) try name-rev, or
  325. # 3) try branch name, or
  326. # 4) try short hash
  327. version=$(command git describe --tags $until 2>/dev/null) \
  328. || version=$(command git name-rev --no-undefined --name-only --exclude="remotes/*" $until 2>/dev/null) \
  329. || version=$(command git symbolic-ref --quiet --short $until 2>/dev/null) \
  330. || version=$(command git rev-parse --short $until 2>/dev/null)
  331. # Get commit list from $until commit until $since commit, or until root
  332. # commit if $since is unset, in short hash form.
  333. command git rev-list --abbrev-commit --abbrev=7 ${since:+$since..}$until | while read hash; do
  334. # Truncate list on versions with a lot of commits
  335. if (( ++read_commits > 40 )); then
  336. truncate=1
  337. break
  338. fi
  339. # If we find a new release (exact tag)
  340. if tag=$(command git describe --exact-match --tags $hash 2>/dev/null); then
  341. # Output previous release
  342. display-release
  343. # Reinitialize commit storage
  344. commits=()
  345. subjects=()
  346. scopes=()
  347. breaking=()
  348. reverts=()
  349. # Start work on next release
  350. version="$tag"
  351. read_commits=1
  352. fi
  353. parse-commit "$hash"
  354. done
  355. display-release
  356. if (( truncate )); then
  357. echo " ...more commits omitted"
  358. echo
  359. fi
  360. }
  361. cd "$ZSH"
  362. # Use raw output if stdout is not a tty
  363. if [[ ! -t 1 && -z "$3" ]]; then
  364. main "$1" "$2" --raw
  365. else
  366. main "$@"
  367. fi