Make easier to publish new versions by not having to type json

Author: rafaelfranca

.github/workflows/publish-new-ruby-versions.yaml

@@ -6,19 +6,37 @@ on:
       ruby_versions:
         type: string
         required: true
-        description: List of ruby versions to build. Should be an array ["3.3.1","3.2.4"]
+        description: Comma or newline-separated Ruby versions (example: 3.3.1, 3.2.4)
       image_versions:
         type: string
-        required: true
-        description: List of image versions to build. Should be an array ["ruby-1.1.0"]
+        required: false
+        description: Optional comma or newline-separated image versions (example: 1.1.0, 1.2.0 or ruby-1.1.0). If empty, latest ruby-* tag is used.
 
 jobs:
+  setup:
+    name: Normalize Inputs
+    runs-on: ubuntu-24.04
+    outputs:
+      ruby_versions_json: ${{ steps.normalize.outputs.ruby_versions_json }}
+      image_versions_json: ${{ steps.normalize.outputs.image_versions_json }}
+    steps:
+      - name: Checkout (GitHub)
+        uses: actions/checkout@v6
+
+      - id: normalize
+        run: |
+          ruby bin/normalize-publish-inputs \
+            --ruby-versions '${{ github.event.inputs.ruby_versions }}' \
+            --image-versions '${{ github.event.inputs.image_versions }}' \
+            --repository '${{ github.repository }}'
+
   publish:
     name: Publish Images
+    needs: setup
     uses: ./.github/workflows/publish-images-reusable.yaml
     with:
-      ruby_versions_json: ${{ github.event.inputs.ruby_versions }}
-      image_versions_json: ${{ github.event.inputs.image_versions }}
+      ruby_versions_json: ${{ needs.setup.outputs.ruby_versions_json }}
+      image_versions_json: ${{ needs.setup.outputs.image_versions_json }}
       repository_owner: ${{ github.repository_owner }}
     secrets:
       gh_token: ${{ secrets.GITHUB_TOKEN }}

bin/normalize-publish-inputs

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "optparse"
+require_relative "../lib/commands/publish_input_normalizer"
+
+options = {
+  ruby_versions: nil,
+  image_versions: "",
+  repository: ENV["GITHUB_REPOSITORY"]
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: ruby bin/normalize-publish-inputs --ruby-versions LIST [--image-versions LIST] [--repository OWNER/REPO]"
+
+  opts.on("--ruby-versions VALUE", "Comma/newline-separated Ruby versions") do |value|
+    options[:ruby_versions] = value
+  end
+
+  opts.on("--image-versions VALUE", "Optional comma/newline-separated image versions") do |value|
+    options[:image_versions] = value
+  end
+
+  opts.on("--repository VALUE", "Repository in OWNER/REPO format (defaults to GITHUB_REPOSITORY)") do |value|
+    options[:repository] = value
+  end
+
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    exit 0
+  end
+end
+
+begin
+  parser.parse!
+
+  unless options[:ruby_versions] && !options[:ruby_versions].strip.empty?
+    warn "--ruby-versions is required"
+    warn parser
+    exit 1
+  end
+
+  result = Commands::PublishInputNormalizer.call(
+    ruby_versions_input: options[:ruby_versions],
+    image_versions_input: options[:image_versions],
+    repository: options[:repository]
+  )
+
+  if ENV["GITHUB_OUTPUT"]
+    File.open(ENV["GITHUB_OUTPUT"], "a") do |f|
+      f.puts "ruby_versions_json=#{result[:ruby_versions_json]}"
+      f.puts "image_versions_json=#{result[:image_versions_json]}"
+    end
+  else
+    puts JSON.pretty_generate({
+      ruby_versions_json: result[:ruby_versions_json],
+      image_versions_json: result[:image_versions_json]
+    })
+  end
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+  warn e.message
+  warn parser
+  exit 1
+rescue Commands::PublishInputNormalizer::Error => e
+  warn e.message
+  exit 1
+end

lib/commands/publish_input_normalizer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "rubygems"
+
+module Commands
+  class PublishInputNormalizer
+    class Error < StandardError; end
+
+    class << self
+      def call(ruby_versions_input:, image_versions_input:, repository:, latest_tag_fetcher: nil)
+        new(
+          ruby_versions_input: ruby_versions_input,
+          image_versions_input: image_versions_input,
+          repository: repository,
+          latest_tag_fetcher: latest_tag_fetcher
+        ).call
+      end
+    end
+
+    attr_reader :ruby_versions_input, :image_versions_input, :repository, :latest_tag_fetcher
+
+    def initialize(ruby_versions_input:, image_versions_input:, repository:, latest_tag_fetcher: nil)
+      @ruby_versions_input = ruby_versions_input.to_s
+      @image_versions_input = image_versions_input.to_s
+      @repository = repository.to_s
+      @latest_tag_fetcher = latest_tag_fetcher || method(:fetch_latest_image_tag)
+    end
+
+    def call
+      ruby_versions = normalize_list(ruby_versions_input)
+      raise Error, "Ruby versions input is empty" if ruby_versions.empty?
+
+      images_source = image_versions_input
+      if blank_list?(images_source)
+        images_source = latest_tag_fetcher.call(repository)
+      end
+
+      image_versions = normalize_image_versions(normalize_list(images_source))
+      raise Error, "Image versions input is empty" if image_versions.empty?
+
+      {
+        ruby_versions: ruby_versions,
+        image_versions: image_versions,
+        ruby_versions_json: JSON.generate(ruby_versions),
+        image_versions_json: JSON.generate(image_versions)
+      }
+    end
+
+    private
+
+    def blank_list?(value)
+      value.to_s.gsub(/[\s,]/, "").empty?
+    end
+
+    def normalize_list(value)
+      value
+        .to_s
+        .split(/[\n,]/)
+        .map(&:strip)
+        .reject(&:empty?)
+    end
+
+    def normalize_image_versions(versions)
+      versions.map { |version| version.start_with?("ruby-") ? version : "ruby-#{version}" }
+    end
+
+    def fetch_latest_image_tag(repo)
+      raise Error, "Repository is required to discover latest image tag" if repo.empty?
+
+      stdout, status = Open3.capture2(
+        "git",
+        "ls-remote",
+        "--tags",
+        "--refs",
+        "https://github.com/#{repo}.git",
+        "refs/tags/ruby-*"
+      )
+
+      unless status.success?
+        raise Error, "Unable to resolve latest ruby-* image tag"
+      end
+
+      tags = stdout.lines.map do |line|
+        ref = line.split[1]
+        ref&.sub("refs/tags/", "")
+      end.compact
+
+      latest = tags.max_by { |tag| version_for(tag) }
+      raise Error, "Unable to resolve latest ruby-* image tag" unless latest
+
+      latest
+    end
+
+    def version_for(tag)
+      raw = tag.sub(/^ruby-/, "")
+      Gem::Version.new(raw)
+    rescue ArgumentError
+      Gem::Version.new("0")
+    end
+  end
+end

test/commands/publish_input_normalizer_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "../../lib/commands/publish_input_normalizer"
+
+class Commands::PublishInputNormalizerTest < Minitest::Test
+  def test_normalizes_comma_and_newline_lists
+    result = Commands::PublishInputNormalizer.call(
+      ruby_versions_input: "3.3.1, 3.2.4\n3.1.9",
+      image_versions_input: "1.1.0, ruby-1.2.0",
+      repository: "rails/devcontainer"
+    )
+
+    assert_equal ["3.3.1", "3.2.4", "3.1.9"], result[:ruby_versions]
+    assert_equal ["ruby-1.1.0", "ruby-1.2.0"], result[:image_versions]
+    assert_equal '["3.3.1","3.2.4","3.1.9"]', result[:ruby_versions_json]
+    assert_equal '["ruby-1.1.0","ruby-1.2.0"]', result[:image_versions_json]
+  end
+
+  def test_uses_latest_image_tag_when_image_versions_blank
+    fetcher = ->(_repo) { "ruby-2.0.0" }
+
+    result = Commands::PublishInputNormalizer.call(
+      ruby_versions_input: "3.3.1",
+      image_versions_input: "  ,  \n",
+      repository: "rails/devcontainer",
+      latest_tag_fetcher: fetcher
+    )
+
+    assert_equal ["ruby-2.0.0"], result[:image_versions]
+    assert_equal '["ruby-2.0.0"]', result[:image_versions_json]
+  end
+
+  def test_raises_for_empty_ruby_versions
+    error = assert_raises(Commands::PublishInputNormalizer::Error) do
+      Commands::PublishInputNormalizer.call(
+        ruby_versions_input: " , \n",
+        image_versions_input: "1.1.0",
+        repository: "rails/devcontainer"
+      )
+    end
+
+    assert_match(/Ruby versions input is empty/, error.message)
+  end
+
+  def test_raises_when_latest_tag_is_missing
+    fetcher = ->(_repo) { nil }
+
+    error = assert_raises(Commands::PublishInputNormalizer::Error) do
+      Commands::PublishInputNormalizer.call(
+        ruby_versions_input: "3.3.1",
+        image_versions_input: "",
+        repository: "rails/devcontainer",
+        latest_tag_fetcher: fetcher
+      )
+    end
+
+    assert_match(/Image versions input is empty/, error.message)
+  end
+end