toys-release 0.1.0

data/toys/_onclosed.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+desc "Process a release pull request"
+
+long_desc \
+  "This tool is called by a GitHub Actions workflow after a release pull" \
+    " request is closed. If the pull request was merged, the requested" \
+    " release is performed and the pull request is updated with the results." \
+    " If the pull request was closed without being merged, the pull request" \
+    " is marked as aborted. This tool also ensures that release branches are" \
+    " deleted once their PRs are closed."
+
+flag :event_path, "--event-path=VAL" do
+  default ::ENV["GITHUB_EVENT_PATH"]
+  desc "Path to the pull request closed event JSON file"
+end
+flag :rubygems_api_key, "--rubygems-api-key=VAL" do
+  desc "Set the Rubygems API key"
+  long_desc \
+    "Use the given Rubygems API key when pushing to Rubygems. Deprecated;" \
+    " prefer just setting the `GEM_HOST_API_KEY` environment variable."
+end
+flag :enable_releases, "--enable-releases=VAL" do
+  desc "Deprecated and unused"
+end
+
+include :exec
+include :terminal, styled: true
+
+def run
+  setup
+
+  delete_release_branch
+  check_for_release_pr
+  if @pull_request.merged?
+    handle_release_merged
+  else
+    handle_release_aborted
+  end
+end
+
+def setup
+  require "json"
+  require "toys/release/environment_utils"
+  require "toys/release/pull_request"
+  require "toys/release/repo_settings"
+  require "toys/release/repository"
+
+  ::Dir.chdir(context_directory)
+  ::ENV["GEM_HOST_API_KEY"] = rubygems_api_key unless rubygems_api_key.to_s.empty?
+
+  @utils = Toys::Release::EnvironmentUtils.new(self)
+  @settings = Toys::Release::RepoSettings.load_from_environment(@utils)
+  @repository = Toys::Release::Repository.new(@utils, @settings)
+
+  @utils.error("GitHub event path missing") unless event_path
+  pr_resource = ::JSON.parse(::File.read(event_path))["pull_request"]
+  @pull_request = Toys::Release::PullRequest.new(@repository, pr_resource)
+end
+
+def delete_release_branch
+  source_ref = @pull_request.head_ref
+  if @repository.release_related_branch?(source_ref)
+    logger.info("Deleting release branch #{source_ref} ...")
+    exec(["git", "push", "--delete", "origin", source_ref])
+    logger.info("Deleted.")
+  end
+end
+
+def check_for_release_pr
+  unless @pull_request.labels.include?(@settings.release_pending_label)
+    logger.info("PR #{@pull_request.number} does not have the release pending label. Ignoring.")
+    exit
+  end
+end
+
+def handle_release_aborted
+  logger.info("Updating release PR #{@pull_request.number} to mark it as aborted.")
+  @pull_request.update(labels: @settings.release_aborted_label, state: "closed")
+  @pull_request.add_comment("Release PR closed without merging.")
+  logger.info "Done."
+end
+
+def handle_release_merged
+  setup_git
+  github_check_errors = @repository.wait_github_checks
+  unless github_check_errors.empty?
+    @utils.error("GitHub checks failed", *github_check_errors)
+  end
+  performer = create_performer
+  performer.perform_pr_releases
+  performer.report_results
+  if performer.error?
+    @utils.error("Releases reported failure")
+  else
+    puts("All releases completed successfully", :bold, :green)
+  end
+end
+
+def setup_git
+  exec(["git", "fetch", "--depth=2", "origin", "+#{@pull_request.merge_commit_sha}:refs/heads/release/current"],
+       e: true)
+  exec(["git", "switch", "release/current"], e: true)
+end
+
+def create_performer
+  require "toys/release/performer"
+  dry_run = /^t/i.match?(::ENV["TOYS_RELEASE_DRY_RUN"].to_s)
+  Toys::Release::Performer.new(@repository,
+                               release_pr: @pull_request,
+                               git_remote: "origin",
+                               dry_run: dry_run)
+end

data/toys/_onopen.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+desc "Check a pull request"
+
+long_desc \
+  "This tool is called by a GitHub Actions workflow when any pull request" \
+    " is opened or synchronized. It checks the commit messages and/or pull" \
+    " request title (as appropriate) for conventional commit style."
+
+flag :event_path, "--event-path=VAL" do
+  default ::ENV["GITHUB_EVENT_PATH"]
+  desc "Path to the pull request event JSON file"
+end
+
+include :exec
+include :terminal, styled: true
+
+def run
+  setup
+  lint_commit_messages if @utils.commit_lint_active?
+end
+
+def setup
+  ::Dir.chdir(context_directory)
+
+  require "json"
+  require "toys/release/environment_utils"
+  require "toys/release/pull_request"
+  require "toys/release/repo_settings"
+  require "toys/release/repository"
+
+  @utils = Toys::Release::EnvironmentUtils.new(self)
+  @settings = Toys::Release::RepoSettings.load_from_environment(@utils)
+  @repository = Toys::Release::Repository.new(@utils, @settings)
+
+  @utils.error("GitHub event path missing") unless event_path
+  pr_resource = ::JSON.parse(::File.read(event_path))["pull_request"]
+  @pull_request = Toys::Release::PullRequest.new(@repository, pr_resource)
+end
+
+def lint_commit_messages
+  errors = []
+  shas = find_shas
+  if shas.size == 1 || !@settings.commit_lint_merge.intersection(["merge", "rebase"]).empty?
+    lint_sha_messages(shas, errors)
+  end
+  if shas.size > 1 && @settings.commit_lint_merge.include?("squash")
+    lint_pr_message(errors)
+  end
+  if errors.empty?
+    puts "No conventional commit format problems found.", :green, :bold
+  else
+    report_lint_errors(errors)
+    if @settings.commit_lint_fail_checks?
+      @utils.error("Failing due to conventional commit format problems")
+    end
+  end
+end
+
+def find_shas
+  @repository.git_unshallow("origin", branch: @pull_request.head_sha)
+  log = capture(["git", "log", "#{@pull_request.base_sha}..#{@pull_request.head_sha}", "--format=%H"], e: true)
+  shas = log.split("\n").reverse
+  shas.find_all do |sha|
+    parents = capture(["git", "show", "-s", "--pretty=%p", sha], e: true).strip.split
+    @utils.log("Omitting merge commit #{sha}") if parents.size > 1
+    parents.size == 1
+  end
+end
+
+def lint_sha_messages(shas, errors)
+  shas.each do |sha|
+    @utils.log("Checking commit #{sha} ...")
+    message = capture(["git", "log", "#{sha}^..#{sha}", "--format=%B"], e: true).strip
+    lint_message(message) do |err|
+      @utils.warning("Commit #{sha}: #{err}")
+      suggestion = "Please consider amending the commit message."
+      if @settings.commit_lint_merge == ["squash"]
+        suggestion += " Alternately, because this pull request will be squashed when merged, you" \
+                      " can add multiple commits, and instead make sure the pull request _title_" \
+                      " conforms to the Conventional Commit format."
+      end
+      err =
+        [
+          "The message for commit #{sha} does not conform to the Conventional Commit format.",
+          "",
+          "```",
+        ] + message.split("\n") + [
+          "```",
+          "",
+          err,
+          suggestion,
+        ]
+      errors << err
+    end
+  end
+end
+
+def lint_pr_message(errors)
+  @utils.log("Checking Pull request title ...")
+  lint_message(@pull_request.title) do |err|
+    @utils.warning("PR title: #{err}")
+    header = "The pull request title does not conform to the Conventional Commit format."
+    header +=
+      if @settings.commit_lint_merge == ["squash"]
+        " (The title will be used as the merge commit message when this pull request is merged.)"
+      else
+        " (The title may be used as the merge commit message if this pull request is squashed" \
+          " when merged.)"
+      end
+    errors << [
+      header,
+      "",
+      "```",
+      @pull_request.title,
+      "```",
+      "",
+      err,
+    ]
+  end
+end
+
+def lint_message(message)
+  lines = message.split("\n")
+  matches = /^([\w-]+)(?:\(([^()]+)\))?!?:\s(.+)$/.match(lines.first)
+  unless matches
+    yield "The first line should follow the form `<type>: <description>`."
+    return
+  end
+  allowed_types = @settings.commit_lint_allowed_types
+  if allowed_types && !allowed_types.include?(matches[1].downcase)
+    yield "The type `#{matches[1]}` is not allowed by this repository." \
+          " Please use one of the types: `#{allowed_types.inspect}`."
+  end
+  if lines.size > 1 && !lines[1].empty?
+    yield "You may not use multiple conventional commit formatted lines." \
+          " If you want to include a body or footers in your commit message," \
+          " they must be separated from the main message by a blank line." \
+          " If you are making multiple semantic changes, please use separate" \
+          " commits/pull requets."
+  end
+end
+
+def report_lint_errors(errors)
+  header = <<~STR
+    Please use [Conventional Commit](https://conventionalcommits.org/) format \
+    for commit messages and pull request titles. The automated linter found \
+    the following problems in this pull request:
+  STR
+  lines = [header]
+  errors.each do |error_lines|
+    lines << "" << " *  #{error_lines.first}"
+    error_lines[1..].each do |err_line|
+      lines << (err_line.empty? ? "" : "    #{err_line}")
+    end
+  end
+  @pull_request.add_comment(lines.join("\n"))
+end

data/toys/_onpush.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+desc "Update open releases after a push"
+
+long_desc \
+  "This tool is called by a GitHub Actions workflow after a commit is pushed" \
+    " to a releasable branch. It adds a warning note to any relevant open" \
+    " releases that additional commits have been added."
+
+include :exec
+include :terminal, styled: true
+
+def run
+  setup
+  update_open_release_prs
+end
+
+def setup
+  ::Dir.chdir(context_directory)
+
+  require "toys/release/environment_utils"
+  require "toys/release/repo_settings"
+  require "toys/release/repository"
+
+  @utils = Toys::Release::EnvironmentUtils.new(self)
+  @settings = Toys::Release::RepoSettings.load_from_environment(@utils)
+  @repository = Toys::Release::Repository.new(@utils, @settings)
+end
+
+def update_open_release_prs
+  push_branch = @repository.current_branch
+  logger.info("Searching for open release PRs targeting branch #{push_branch} ...")
+  pr_message = nil
+  @repository.find_release_prs(branch: push_branch).each do |pull|
+    pr_message ||= build_pr_message
+    logger.info("Updating PR #{pull.number} ...")
+    pull.add_comment(pr_message)
+  end
+  if pr_message
+    logger.info("Finished updating existing release PRs.")
+  else
+    logger.info("No existing release PRs target branch #{push_branch}.")
+  end
+end
+
+def build_pr_message
+  commit_message = capture(["git", "log", "-1", "--pretty=%B"], e: true)
+  <<~STR
+    WARNING: An additional commit was added while this release PR was open.
+    You may need to add to the changelog, or close this PR and prepare a new one.
+
+    Commit link: https://github.com/#{@settings.repo_path}/commit/#{@repository.current_sha}
+
+    Message:
+    #{commit_message}
+  STR
+end

data/toys/create-labels.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+desc "Create GitHub labels for releases"
+
+long_desc \
+  "This tool ensures that the proper GitHub labels are present for the" \
+    " release automation scripts."
+
+flag :yes, "--yes", "-y" do
+  desc "Automatically answer yes to all confirmations"
+end
+
+include :exec
+include :terminal, styled: true
+
+def run
+  require "json"
+  require "cgi"
+  require "toys/release/environment_utils"
+  require "toys/release/repo_settings"
+
+  @utils = Toys::Release::EnvironmentUtils.new(self)
+  @settings = Toys::Release::RepoSettings.load_from_environment(@utils)
+
+  unless @settings.enable_release_automation?
+    puts "Release automation disabled in settings."
+    unless yes || confirm("Create labels anyway? ", default: false)
+      @utils.error("Aborted.")
+    end
+  end
+
+  expected_labels = create_expected_labels
+  cur_labels = load_existing_labels
+  update_labels cur_labels, expected_labels
+end
+
+def create_expected_labels
+  [
+    {
+      "name" => @settings.release_pending_label,
+      "color" => "ddeeff",
+      "description" => "Automated release is pending",
+    },
+    {
+      "name" => @settings.release_error_label,
+      "color" => "ffdddd",
+      "description" => "Automated release failed with an error",
+    },
+    {
+      "name" => @settings.release_aborted_label,
+      "color" => "eeeeee",
+      "description" => "Automated release was aborted",
+    },
+    {
+      "name" => @settings.release_complete_label,
+      "color" => "ddffdd",
+      "description" => "Automated release completed successfully",
+    },
+  ]
+end
+
+def load_existing_labels
+  output = capture(["gh", "api", "repos/#{@settings.repo_path}/labels",
+                    "-H", "Accept: application/vnd.github.v3+json"])
+  ::JSON.parse(output)
+end
+
+def update_labels(cur_labels, expected_labels)
+  expected_labels.each do |expected|
+    cur = cur_labels.find { |label| label["name"] == expected["name"] }
+    if cur
+      if cur["color"] != expected["color"] || cur["description"] != expected["description"]
+        update_label(expected)
+      end
+    else
+      create_label(expected)
+    end
+  end
+  release_related_labels = [
+    @settings.release_pending_label,
+    @settings.release_error_label,
+    @settings.release_aborted_label,
+    @settings.release_complete_label,
+  ]
+  cur_labels.each do |cur|
+    next unless release_related_labels.include?(cur["name"])
+    delete_label(cur) unless expected_labels.find { |label| label["name"] == cur["name"] }
+  end
+end
+
+def create_label(label)
+  label_name = label["name"]
+  return unless yes || confirm("Label \"#{label_name}\" doesn't exist. Create? ", default: true)
+  body = ::JSON.dump(label)
+  exec(["gh", "api", "repos/#{@settings.repo_path}/labels", "--input", "-",
+        "-H", "Accept: application/vnd.github.v3+json"],
+       in: [:string, body], out: :null, e: true)
+end
+
+def update_label(label)
+  label_name = label["name"]
+  return unless yes || confirm("Update fields of \"#{label_name}\"? ", default: true)
+  body = ::JSON.dump(color: label["color"], description: label["description"])
+  exec(["gh", "api", "-XPATCH", "repos/#{@settings.repo_path}/labels/#{label_name}",
+        "--input", "-", "-H", "Accept: application/vnd.github.v3+json"],
+       in: [:string, body], out: :null, e: true)
+end
+
+def delete_label(label)
+  label_name = label["name"]
+  return unless yes || confirm("Label \"#{label_name}\" unrecognized. Delete? ", default: true)
+  exec(["gh", "api", "-XDELETE", "repos/#{@settings.repo_path}/labels/#{label_name}",
+        "-H", "Accept: application/vnd.github.v3+json"],
+       out: :null, e: true)
+end

data/toys/gen-gh-pages.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+desc "Generate gh-pages documentation site"
+
+long_desc "This tool generates an initial gh-pages documentation site."
+
+flag :working_dir, "--working-dir=PATH" do
+  desc "Set the working directory for the gh-pages checkout"
+end
+flag :git_remote, "--git-remote=REMOTE" do
+  desc "Use the specified remote (default is `origin`)"
+  default "origin"
+end
+flag :yes, "--yes", "-y" do
+  desc "Automatically answer yes to all confirmations"
+end
+flag :dry_run
+
+include :exec
+include :terminal, styled: true
+
+# Context for ERB templates
+class ErbContext
+  def initialize(data)
+    data.each { |name, value| instance_variable_set("@#{name}", value) }
+  end
+
+  def self.get(data)
+    new(data).instance_eval { binding }
+  end
+end
+
+def run
+  setup
+  generate_gh_pages
+  push_gh_pages
+  cleanup
+end
+
+def setup
+  require "erb"
+  require "fileutils"
+  require "toys/release/artifact_dir"
+  require "toys/release/environment_utils"
+  require "toys/release/repo_settings"
+  require "toys/release/repository"
+
+  ::Dir.chdir(context_directory)
+  @utils = Toys::Release::EnvironmentUtils.new(self)
+  @settings = Toys::Release::RepoSettings.load_from_environment(@utils)
+  @repository = Toys::Release::Repository.new(@utils, @settings)
+  @artifact_dir = Toys::Release::ArtifactDir.new(working_dir)
+  @gh_pages_dir = @repository.checkout_separate_dir(
+    branch: "gh-pages", remote: git_remote, dir: @artifact_dir.get("gh-pages"),
+    gh_token: ::ENV["GITHUB_TOKEN"], create: true
+  )
+end
+
+def cleanup
+  @artifact_dir.cleanup
+end
+
+def generate_gh_pages
+  relevant_component_settings = @settings.all_component_settings.find_all(&:gh_pages_enabled)
+  url_base = "#{@settings.repo_owner}.github.io/#{@settings.repo_name}"
+  default_url = "https://#{url_base}/#{relevant_component_settings.first.gh_pages_directory}/latest"
+
+  ::Dir.chdir(@gh_pages_dir) do
+    ::File.write(".nojekyll", "")
+    generate_file("gh-pages-gitignore.erb", ".gitignore", {})
+
+    data = {
+      relevant_component_settings: relevant_component_settings,
+      url_base: url_base,
+      default_url: default_url,
+    }
+    generate_file("gh-pages-404.html.erb", "404.html", data) do |content, old_content|
+      update_versions(content, old_content)
+    end
+
+    generate_file("gh-pages-index.html.erb", "index.html", {default_url: default_url})
+
+    relevant_component_settings.each do |component_settings|
+      generate_file("gh-pages-empty.html.erb", "#{component_settings.gh_pages_directory}/v0.0.0/index.html",
+                    {component_settings: component_settings}, remove_dir: true)
+    end
+  end
+  puts "Files generated into #{@gh_pages_dir}", :bold
+end
+
+def push_gh_pages
+  ::Dir.chdir(@gh_pages_dir) do
+    @repository.git_commit("Generated initial gh-pages", signoff: @settings.signoff_commits?)
+    if dry_run
+      puts "DRY RUN: Skipped git push.", :green, :bold
+    else
+      @utils.exec(["git", "push", git_remote, "gh-pages"], e: true)
+      puts "Pushed gh-pages.", :green, :bold
+    end
+  end
+end
+
+def generate_file(template, destination, data, remove_dir: false)
+  old_content = file_generation_confirmations(destination, remove_dir)
+  return if old_content == :cancel
+  template_path = find_data("templates/#{template}")
+  raise "Unable to find template #{template}" unless template_path
+  erb = ::ERB.new(::File.read(template_path))
+  content = erb.result(ErbContext.get(data))
+  content = yield(content, old_content) if block_given? && old_content
+  ::File.write(destination, content)
+  puts "Wrote #{destination}."
+end
+
+def file_generation_confirmations(destination, remove_dir)
+  old_content = nil
+  if ::File.readable?(destination)
+    old_content = ::File.read(destination)
+    puts "Destination file #{destination} exists.", :yellow, :bold
+    return :cancel unless yes || confirm("Overwrite? ", default: true)
+  else
+    return :cancel unless yes || confirm("Create file #{destination}? ", default: true)
+  end
+  dir = ::File.dirname(destination)
+  unless dir == "."
+    if remove_dir && ::File.directory?(dir)
+      puts "Old version directory #{dir} exists.", :yellow, :bold
+      return :cancel unless yes || confirm("Remove? ", default: true)
+      ::FileUtils.remove_entry(dir, true)
+    end
+    ::FileUtils.mkdir_p(dir)
+  end
+  old_content
+end
+
+def update_versions(content, old_content)
+  @settings.all_component_settings.each do |component_settings|
+    next unless component_settings.gh_pages_enabled
+    match = /#{component_settings.gh_pages_version_var} = "([\w.]+)";/.match(old_content)
+    if match
+      content.sub!("#{component_settings.gh_pages_version_var} = \"0.0.0\";",
+                   "#{component_settings.gh_pages_version_var} = \"#{match[1]}\";")
+    end
+  end
+  content
+end

data/toys/gen-settings.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+desc "Generate initial settings file"
+
+long_desc \
+  "This tool generates an initial settings file for this repo." \
+    " You will generally need to make additional edits to this file after" \
+    " initial generation."
+
+required_arg :repo do
+  desc "GitHub repo owner and name (e.g. dazuma/toys)"
+end
+
+flag :yes, "--yes", "-y" do
+  desc "Automatically answer yes to all confirmations"
+end
+
+include :exec
+include :terminal, styled: true
+
+def run
+  file_path = ::File.join(context_directory, ".toys", ".data", "releases.yml")
+  if ::File.readable?(file_path)
+    puts "Cannot overwrite existing file: #{file_path}", :red, :bold
+    exit(1)
+  end
+  return unless yes || confirm("Create file #{file_path}? ", default: true)
+  ::File.open(file_path, "w") do |file|
+    write_settings(file)
+  end
+  puts("Wrote initial settings file: #{file_path}.", :green, :bold)
+end
+
+def write_settings(file)
+  file.puts("repo: #{repo}")
+  file.puts("# Insert additional repo-level settings here.")
+  file.puts
+  file.puts("gems:")
+  ::Dir.glob("**/*.gemspec").each do |gemspec|
+    gem_name = ::File.basename(gemspec, ".gemspec")
+    file.puts("  - name: #{gem_name}")
+    dir = ::File.dirname(gemspec)
+    file.puts("    directory: #{dir}") if dir != gem_name
+    file.puts("    # Insert additional gem-level settings here.")
+  end
+end