release-yamlscript

#!/usr/bin/env ys-0

# This script is for automating the YAMLScript release process as much as
# possible. The release process involves many steps, and might need to be
# restarted at a certain step.
#
# Usage: release-yamlscript <old-version> <new-version> [<starting-step>]
#
# The following environment variables can be used to control the script:
#
# * YS_RELEASE_DRYRUN=1     - Don't actually run any commands, just show them
# * YS_RELEASE_VERBOSE=1    - Show more information about what's happening
# * YS_RELEASE_LAST_STEP=n  - The last step to run (default is 10)

version-file =: '.version.ys'

steps =: 11

bindings =::
- java
- clojure
- go
- julia
- nodejs
- perl
- perl-alien
- python
- raku
- ruby
- rust

# verbose =: B(ENV.YS_RELEASE_VERBOSE)
verbose =: true

dryrun =: boolean(ENV.YS_RELEASE_DRYRUN)
last-step =: (ENV.YS_RELEASE_LAST_STEP || steps):N


#------------------------------------------------------------------------------
# Run each step in succession, starting at the specified step number if given
# and ending at the specified last step number if given.
#------------------------------------------------------------------------------

defn main(old-version=0 new-version=0 start=1):
  ctx =:
    if dryrun || ENV.RELEASE_ID:
      then: -{}
      else:
        check-args: old-version new-version start

  say: "\nReleasing YAMLScript v$new-version at $(ctx.date-time)\n"

  if ENV.RELEASE_ID:
    step-9: ctx
    each i (1 .. steps):
      when (i >= start) && (i <= last-step):
        resolve(symbol("step-$i")): ctx

  say: ''


#------------------------------------------------------------------------------
# Change the .version.ys version bump script to use the new version string.
#------------------------------------------------------------------------------

defn step-1(ctx):
  o: 'Step 1) Do nothing, Step no longer needed'


#------------------------------------------------------------------------------
# Change all current version strings in dozens of files to the new version.
#------------------------------------------------------------------------------

defn step-2(ctx):
  o: "Step 2) Run 'make bump'"

  run:: make bump

  when verbose:
    run:: git -P diff


#------------------------------------------------------------------------------
# Collect the git log subject lines since the last release, reverse them and
# then create a new Changes file entry and add it to the top of the Changes
# file.
#
# Open the file in an editor to review the entry and update if needed.
#------------------------------------------------------------------------------

defn step-3(ctx):
  o: "Step 3) Update the 'Changes' file"

  when-not dryrun:
    changes =:
      make-changes-entry: ctx

    spit 'release-changes.txt': changes

    prompt: "Press Enter to edit the 'Changes' file."
    editor =: ENV.EDITOR || 'vi'
    run: "$editor release-changes.txt"
    prompt: 'Press Enter to continue or Ctrl-C to abort.'

    validate-yaml: slurp('release-changes.txt')

  when verbose:
    # Show git changes since last release:
    run: "grep -F -B999 '$(ctx.old)' Changes"


#------------------------------------------------------------------------------
# Run 'make test' to ensure everything is working as expected.
#------------------------------------------------------------------------------

defn step-4(ctx):
  o: "Step 4) Run 'make test'"

  run:: make test

  # Update Changes if tests pass:
  when-not dryrun:
    changes =: slurp('release-changes.txt')

    file-prepend 'Changes': |
      - version: $(ctx.new)
        date:    $(ctx.date-time)
        changes:
      $(changes:str/trimr)

    validate-yaml: slurp('Changes')

    changes =: changes.replace(/(?m)^  -/ '*')

    spit 'release-changes.txt': changes


#------------------------------------------------------------------------------
# Some of the binding library directories have a change log file.
# Update them.
#------------------------------------------------------------------------------

defn step-5(ctx):
  o: 'Step 5) Update the Change Log files for the binding modules'

  when-not dryrun:
    # A change log (YAML) entry for Perl:
    perl-entry =: |

      ---
      version: $(ctx.new)
      date:    $(ctx.date-time)
      changes:
      - libyamlscript $(ctx.new)

    validate-yaml: perl-entry

    file-prepend 'perl/Changes': perl-entry
    when verbose:
      run:: head perl/Changes

    file-prepend 'perl-alien/Changes': perl-entry
    when verbose:
      run:: head perl-alien/Changes

    # Change log entry for Ruby:
    ruby-entry =: |+
      ## [$(ctx.new)] - $(ctx.date)

      - libyamlscript $(ctx.new)

    file-prepend 'ruby/ChangeLog.md': ruby-entry

    when verbose:
      run:: head ruby/ChangeLog.md


#------------------------------------------------------------------------------
# git commit the release changes we've made so far.
#------------------------------------------------------------------------------

defn step-6(ctx):
  o: 'Step 6) Commit the release changes to git'

  run: "git commit -a -m 'release: $(ctx.new)'"


#------------------------------------------------------------------------------
# git tag using the new version
#------------------------------------------------------------------------------

defn step-7(ctx):
  o: 'Step 7) Add git tag for the new version'

  run: "git tag $(ctx.new)"


#------------------------------------------------------------------------------
# git push commit and tag
#------------------------------------------------------------------------------

defn step-8(ctx):
  o: 'Step 8) Push the git commit and tag'

  run:: git push

  run:: git push --tags


#------------------------------------------------------------------------------
# Call 'make release'
#------------------------------------------------------------------------------

defn step-9(ctx):
  o: "Step 9) Run 'make release-assets'"

  run:: make test-core test-ys

  run:: make release-assets

  run:: make install

  when-not dryrun || ENV.RELEASE_ID:
    shell {:out "release-id.txt"}: "grep '^Release id:' release-$(ctx.new).log"
    run:: cat release-id.txt

#------------------------------------------------------------------------------
# For each of the many binding libraries, run 'make release'
#------------------------------------------------------------------------------

defn step-10(ctx):
  o: "Step 10) Run 'make release' for each language binding library"

  prompt: 'Press Enter when ready to continue.'

  each dir bindings:
    try:
      run: "make -C $dir release"
      catch Exception e:
        if (dir == 'clojure') || (dir == 'java'):
          warn: "Failed to release $dir. Continuing."
          die: "Failed to release $dir. Exiting."

  try:
    run: "git tag -d v$(ctx.new)"
    run: "git push origin :v$(ctx.new)"
    catch Exception e:

  run: 'git checkout -- perl perl-alien'

  when verbose:
    run:: git -P diff

#------------------------------------------------------------------------------
# Publish the website. A new release will change the content of some pages.
#------------------------------------------------------------------------------

defn step-11(ctx):
  o: 'Step 11) Publish the yamlscript.org website'

  run: 'make -C www realclean publish'


#------------------------------------------------------------------------------
# Helper functions:
#------------------------------------------------------------------------------
defn o(msg): say("\n$msg")

defn prompt(msg):
  print: "$msg "
  trim: read-line()

defn file-prepend(file text):
  spit file:
    str: text slurp(file)

defn make-changes-entry(ctx):
  lines =:
    sh("git log --oneline $(ctx.old)..HEAD")
      .out:str/split-lines:reverse

  str/join "\n":
    map \(str/replace %1, /^\w+ /, '  - '): lines

defn validate-yaml(yaml):
  when-not dryrun:
    try:
      yaml/load: yaml

      catch Exception e:
        die: "Invalid YAML: $e"

defn run(cmd):
  say: "+ $cmd"

  when-not dryrun:
    shell: cmd

defn check-args(old new start):
  when-not (string? old) && (re-matches /0\.\d+\.\d+/ old):
    die: "Invalid old version '$old'"

  when-not (string? new) && (re-matches /0\.\d+\.\d+/ new):
    die: "Invalid new version '$new'"

  when-not (number? start) && (start >= 1) && (start <= steps):
    die: "Invalid starting step number '$start'"

  # Return context mapping:
  =>::
    old:: old
    new:: new
    date:: sh('date +%Y-%m-%d').out:str/trim-newline
    date-time:: sh('date').out:str/trim-newline