reissue 0.4.22 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9e4d5dc8c0b04d5c41514285fa8e8f2e7e87cc028b156ab7de97473e1e58276
-  data.tar.gz: e4af6b1a8061ec686f33e852b0abccd0d4e92335b87ad48c286e0645b7932ed7
+  metadata.gz: 6c5e8636f0e88ac91af9c6dec7033c12a62e55d6c47a0eb2212dc03d51877058
+  data.tar.gz: a83714b57eb820b00a4b3cbfdab77640d5062f7d3e00aba0b52aca83d89cbad0
 SHA512:
-  metadata.gz: 12fe862113b9d5a765f7efd562ce4555b873e8496068c480f3a0531b873fbbcedc10bf44c1d971e7404ab1236f43125f08c31bac988ba88fb800dd78d5021618
-  data.tar.gz: 2235ef992fdfbda13a06e27bf1df4b582cb3ba9cfa034cdcc6bc1e7c61f8fa33167f553031dc7401eefb29edb59fc5e8ecbe699cdec3f2431796002356115b32
+  metadata.gz: 63a416ec48050137cd7ee8ecd1d295395aa2e32b243fbb0835aecd185a48ddf36abebfe1c979450ef6be9cec46a67c2163896fba5b265874dc7b13eb1bc76ad5
+  data.tar.gz: d6b7f8c2e94997cd952c8e84aa74f29659d06cae56d338e20c10d37405ee1eb8dbf5615688268d366855942d1745bd36d7cd2f8881a1c29104c6045ad29a1947

data/CHANGELOG.md

@@ -5,10 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## [0.4.22] - 2026-04-09
+## [0.5.1] - 2026-07-24
+
+### Added
+
+- reissue:next_version task reports the version the next release would use without changing anything (9feb212)
+- reissue:initialize[runbook] scaffolds a starter runbook file (dfa521a)
+
+### Changed
+
+- Runbook finalize and new-version reset preserve a custom title and preamble (a0d874c)
 
 ### Fixed
 
-- changelog sections not following changelog_sections order on release (5f9c475)
+- Releases no longer publish a version whose changelog entry and git tag name the previous version (acf4c1a)
+
+## [0.4.23] - 2026-07-21
+
+### Added
 
-## [0.4.21] - 2026-03-11
+- Optional runbook_file setting maintains a post-release runbook populated from Runbook: git trailers or direct edits (b41ba15)

data/README.md

@@ -345,6 +345,58 @@ Version trailers are case-insensitive:
 - **New features:** Use `Version: minor` for backwards-compatible new functionality
 - **Bug fixes:** Use `Version: patch` for backwards-compatible bug fixes (or omit - patch is the default post-release bump)
 
+## Post-release Runbook
+
+Reissue can maintain a runbook file listing manual steps to perform after a release — run a rake task, clean up data, re-index documents, and so on. This is aimed at applications; gems are unlikely to need it.
+
+```ruby
+Reissue::Task.create :reissue do |task|
+  task.version_file = "config/version.rb"
+  task.fragment = :git
+  task.runbook_file = "RUNBOOK.md"  # Default: nil (disabled)
+end
+```
+
+You don't have to create the file yourself — the first `rake reissue` or `rake reissue:finalize` writes it when `runbook_file` is set. To start from a template you can customize, run `rake reissue:initialize[runbook]`, which creates `RUNBOOK.md` (pass a different name, e.g. `rake reissue:initialize[OPERATIONS.md]`, to use another path).
+
+The runbook holds only the latest release. Items are checkboxes so operators can tick them off:
+
+```markdown
+# Runbook
+
+Steps to perform after releasing the version below.
+
+## [1.2.3] - 2026-07-21
+
+- [ ] Run `rake data:cleanup` (abc1234)
+- [ ] Re-index search documents (def5678)
+```
+
+The title and the preamble beneath it are yours to edit. Give the file a custom heading and intro and reissue preserves them across finalize and new-version resets — only the version heading and the checklist are rewritten, the same way a custom preamble survives in `CHANGELOG.md`.
+
+### Adding Runbook Items
+
+Add `Runbook:` trailers to commit messages (case-insensitive, independent of the `fragment` setting):
+
+```bash
+git commit -m "Add data migration
+
+Fixed: Duplicate user records
+Runbook: Run \`rake data:cleanup\` after deploy"
+```
+
+You can also edit the checklist under `## [Unreleased]` directly; direct edits and trailers are merged and deduplicated.
+
+Note: `Runbook:` is reserved for the runbook — do not add "Runbook" to `changelog_sections`.
+
+### Lifecycle
+
+1. **During development** — items accumulate from `Runbook:` trailers and direct edits.
+2. **Finalize** (`rake reissue:finalize` / before `rake build`) — trailers since the last version tag are merged into the file and the header is stamped with the release version and date, matching the changelog. The file is committed with the finalize commit, so the release tag contains the finalized runbook.
+3. **New version setup** (`rake reissue` after release) — the runbook is cleared back to a header-only `## [Unreleased]` section. Prior runbooks remain reachable via release tags.
+
+`rake reissue:preview` also shows pending runbook items when `runbook_file` is configured.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt.

data/lib/reissue/fragment_handler/directory_fragment_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "pathname"
-
 module Reissue
   # Handler for reading fragments from a directory
   class DirectoryFragmentHandler < FragmentHandler

data/lib/reissue/fragment_handler/git_fragment_handler.rb

@@ -44,6 +44,16 @@ module Reissue
         find_last_tag
       end
 
+      # Read runbook entries from git commit trailers
+      #
+      # @return [Array<String>] Runbook items with the short SHA appended
+      def read_runbook_entries
+        return [] unless git_available? && in_git_repo?
+
+        commits = commits_since_last_tag
+        parse_runbook_entries_from_commits(commits)
+      end
+
       # Read version bump from git commit trailers
       #
       # @return [Symbol, nil] One of :major, :minor, :patch, or nil if none found
@@ -185,6 +195,44 @@ module Reissue
         result
       end
 
+      RUNBOOK_TRAILER_REGEX = /^runbook:\s*(.+)$/i
+
+      def parse_runbook_entries_from_commits(commits)
+        entries = []
+
+        commits.each do |commit|
+          sha = commit[:sha]
+          lines = commit[:message].lines
+
+          i = 0
+          while i < lines.length
+            line = lines[i].rstrip
+            i += 1
+            next if line.strip.empty?
+
+            if (match = line.match(RUNBOOK_TRAILER_REGEX))
+              trailer_value = match[1].strip
+
+              # Collect continuation lines (non-empty lines that don't start a new trailer)
+              while i < lines.length
+                next_line = lines[i].rstrip
+                break if next_line.strip.empty?
+                break if next_line.match(RUNBOOK_TRAILER_REGEX)
+                break if next_line.match(trailer_regex)
+                break if next_line.match?(/^[A-Za-z][\w-]+:\s/)
+
+                trailer_value += " #{next_line.strip}"
+                i += 1
+              end
+
+              entries << "#{trailer_value} (#{sha})"
+            end
+          end
+        end
+
+        entries
+      end
+
       def normalize_section_name(name)
         # Normalize to proper case (e.g., "FIXED" -> "Fixed", "added" -> "Added")
         name.capitalize

data/lib/reissue/gem.rb

@@ -7,6 +7,30 @@ module Reissue
       super
       @updated_paths << "checksums"
     end
+
+    # Keep bundler's gemspec in step with the bump.
+    #
+    # Bundler loads the gemspec when bundler/gem_tasks is required, well before
+    # reissue:bump rewrites the version file. `gem build` shells out and re-reads
+    # the file, so the gem itself carries the bumped version, but the release tag
+    # and bundler's confirmation messages read the copy held in memory. Without
+    # this they name the version from before the bump, and the release publishes
+    # one version under another version's tag.
+    def apply_version_bump(updater, bump)
+      new_version = super
+      sync_bundler_gemspec_version(new_version)
+      new_version
+    end
+
+    # @param new_version [String] the version the bump landed on
+    def sync_bundler_gemspec_version(new_version)
+      return unless defined?(Bundler::GemHelper)
+
+      helper = Bundler::GemHelper.instance
+      return unless helper&.gemspec
+
+      helper.gemspec.version = ::Gem::Version.new(new_version)
+    end
   end
 end
 Reissue::Task.prepend Reissue::Gem

data/lib/reissue/rake.rb

@@ -37,6 +37,12 @@ module Reissue
     # Provide a callable to decide how to store the files.
     attr_accessor :retain_changelogs
 
+    # The path to a runbook file listing steps to perform after a release.
+    # Populated from "Runbook:" git trailers or direct edits, finalized with
+    # the release version, and cleared when a new version is prepared.
+    # Default: nil (disabled).
+    attr_accessor :runbook_file
+
     # The fragment configuration for changelog entries.
     # @return [String, nil] nil (disabled) or a directory path string for fragment files
     # @example Using directory-based fragments
@@ -126,6 +132,7 @@ module Reissue
       @updated_paths = []
       @changelog_file = "CHANGELOG.md"
       @retain_changelogs = false
+      @runbook_file = nil
       @fragment = nil
       @clear_fragments = false
       @commit = true
@@ -181,15 +188,87 @@ module Reissue
       end
     end
 
+    # The version the next release would use, derived exactly the way reissue:bump
+    # derives it, without writing anything.
+    #
+    # @return [Gem::Version] the version a release would publish
+    def next_release_version
+      require_relative "fragment_handler"
+      require_relative "version_updater"
+
+      # reissue:bump only consults git trailers for :git fragments.
+      handler = (Reissue::FragmentHandler.for(:git, tag_pattern: tag_pattern) if fragment == :git)
+      tag_version = handler&.last_tag_version
+      bump = handler&.read_version_bump
+      updater = Reissue::VersionUpdater.new(version_file, version_redo_proc: version_redo_proc)
+
+      if deferred_versioning
+        # The version file holds "Unreleased"; finalize resolves the real version
+        # from the last tag and the trailer.
+        unless tag_version && bump
+          raise "Cannot determine the next version. Deferred versioning resolves it from " \
+                "the last version tag and a Version: trailer, and one of those is missing."
+        end
+        return updater.redo(tag_version, bump)
+      end
+
+      current_version = ::Gem::Version.new(File.read(version_file).match(Reissue::VersionUpdater::VERSION_MATCH)[0])
+
+      if bump.nil?
+        current_version
+      elsif tag_version && tag_version != current_version
+        # A post-release bump already moved the file past the tag, so the trailer
+        # only counts if it would land beyond where the file already is.
+        [updater.redo(tag_version, bump), current_version].max
+      else
+        updater.redo(current_version, bump)
+      end
+    end
+
+    # Apply a version bump and leave the changelog agreeing with it.
+    #
+    # @param updater [Reissue::VersionUpdater] the updater to bump with
+    # @param bump [Symbol] the segment to bump
+    # @return [String] the version the bump landed on
+    def apply_version_bump(updater, bump)
+      new_version = updater.call(bump)
+      realign_unreleased_changelog(new_version)
+      bundle
+      puts "Version bumped (#{bump}) to #{new_version}"
+      new_version
+    end
+
+    # Point the changelog's unreleased entry at the version just bumped to.
+    #
+    # The bump moves the version file forward, but the unreleased entry still
+    # carries the number from the previous cycle. reissue:finalize dates whatever
+    # that entry says, so leaving it alone publishes a gem built at the new
+    # version while the only dated changelog entry names the old one.
+    #
+    # @param new_version [String] the version the bump landed on
+    def realign_unreleased_changelog(new_version)
+      return unless changelog_file && File.exist?(changelog_file)
+
+      changelog = Reissue::Parser.parse(File.read(changelog_file))
+      unreleased = changelog["versions"].find { |version| version["date"] == "Unreleased" }
+      return if unreleased.nil? || unreleased["version"] == new_version
+
+      unreleased["version"] = new_version
+
+      changelog_updater = Reissue::ChangelogUpdater.new(changelog_file)
+      changelog_updater.instance_variable_set(:@changelog, changelog)
+      changelog_updater.write(changelog_file)
+    end
+
     # Check if there are staged changes ready to commit.
     def changes_to_commit?
       _, _, status = Open3.capture3("git diff --cached --quiet")
       !status.success?
     end
 
-    # Stage updated_paths that exist on disk.
+    # Stage updated_paths (and the runbook file) that exist on disk.
     def stage_updated_paths
-      existing = updated_paths.select { |p| File.exist?(p) }
+      existing = (updated_paths + [runbook_file].compact).select { |p| File.exist?(p) }
       if existing.any?
         run_command("git add #{existing.join(" ")}", "Failed to stage additional paths: #{existing.join(", ")}")
       end
@@ -206,7 +285,8 @@ module Reissue
             changelog_file:,
             version_limit:,
             fragment: fragment,
-            tag_pattern:
+            tag_pattern:,
+            runbook_file:
           )
         else
           segment = args[:segment] || "patch"
@@ -217,7 +297,8 @@ module Reissue
             version_limit:,
             version_redo_proc:,
             fragment: fragment,
-            tag_pattern:
+            tag_pattern:,
+            runbook_file:
           )
         end
         bundle
@@ -287,7 +368,8 @@ module Reissue
             fragment: fragment,
             tag_pattern:,
             version_file:,
-            version_redo_proc:
+            version_redo_proc:,
+            runbook_file:
           )
         else
           date = args[:version_or_segment] || Time.now.strftime("%Y-%m-%d")
@@ -297,7 +379,8 @@ module Reissue
             retain_changelogs:,
             fragment: fragment,
             tag_pattern:,
-            version_file:
+            version_file:,
+            runbook_file:
           )
         end
 
@@ -348,6 +431,15 @@ module Reissue
             end
           end
 
+          # Preview reports; it does not fail. next_release_version raises when
+          # deferred versioning has no tag or trailer to resolve from.
+          previewed_version = begin
+            next_release_version
+          rescue RuntimeError
+            nil
+          end
+          puts "Version to be released: #{previewed_version || "cannot be determined"}\n\n"
+
           entries = handler.read
 
           if entries.empty?
@@ -375,6 +467,20 @@ module Reissue
           puts "Fragment handling is not configured."
           puts "Set task.fragment to a directory path or :git to enable changelog fragments."
         end
+
+        if runbook_file
+          require_relative "fragment_handler"
+          runbook_entries = Reissue::FragmentHandler.for(:git, tag_pattern: tag_pattern).read_runbook_entries
+
+          puts
+          if runbook_entries.empty?
+            puts "No runbook items found."
+            puts "  (No Runbook: trailers found since last version tag)"
+          else
+            puts "Runbook items that will be added to #{runbook_file}:\n\n"
+            runbook_entries.each { |item| puts "- [ ] #{item}" }
+          end
+        end
       end
 
       desc "Clear fragments"
@@ -393,6 +499,11 @@ module Reissue
         end
       end
 
+      desc "Print the version the next release would use, without changing anything"
+      task "#{name}:next_version" do
+        puts next_release_version
+      end
+
       desc "Bump version based on git trailers"
       task "#{name}:bump" do
         next if deferred_versioning
@@ -416,9 +527,7 @@ module Reissue
         if tag_version && current_version == tag_version
           if bump
             updater = Reissue::VersionUpdater.new(version_file, version_redo_proc: version_redo_proc)
-            updater.call(bump)
-            bundle
-            puts "Version bumped (#{bump}) to #{updater.instance_variable_get(:@new_version)}"
+            apply_version_bump(updater, bump)
           end
         elsif tag_version && current_version != tag_version
           if bump
@@ -426,9 +535,7 @@ module Reissue
             desired_version = updater.redo(tag_version, bump)
 
             if desired_version > current_version
-              updater.call(bump)
-              bundle
-              puts "Version bumped (#{bump}) to #{updater.instance_variable_get(:@new_version)}"
+              apply_version_bump(updater, bump)
             else
               puts "Version already bumped (#{tag_version} → #{current_version}), skipping"
             end
@@ -437,9 +544,7 @@ module Reissue
           end
         elsif bump
           updater = Reissue::VersionUpdater.new(version_file, version_redo_proc: version_redo_proc)
-          updater.call(bump)
-          bundle
-          puts "Version bumped (#{bump}) to #{updater.instance_variable_get(:@new_version)}"
+          apply_version_bump(updater, bump)
         end
       end
     end
@@ -449,8 +554,8 @@ end
 # Define the reissue:initialize task as a standalone task
 # This works without any configuration, allowing users to bootstrap their project
 namespace :reissue do
-  desc "Initialize reissue by creating a CHANGELOG.md and showing Rakefile configuration"
-  task :initialize do
+  desc "Initialize reissue by creating a CHANGELOG.md and showing Rakefile configuration. Pass [runbook] to also create a RUNBOOK.md."
+  task :initialize, [:runbook] do |task, args|
     changelog_file = "CHANGELOG.md"
 
     if File.exist?(changelog_file)
@@ -460,6 +565,16 @@ namespace :reissue do
       puts "✓ Created #{changelog_file}"
     end
 
+    if args[:runbook]
+      runbook_file = (args[:runbook] == "runbook") ? "RUNBOOK.md" : args[:runbook]
+      if File.exist?(runbook_file)
+        puts "✓ #{runbook_file} already exists"
+      else
+        Reissue::Runbook.new(runbook_file).generate
+        puts "✓ Created #{runbook_file}"
+      end
+    end
+
     puts
     puts "Add the following to your Rakefile to enable reissue tasks:"
     puts
@@ -487,6 +602,10 @@ namespace :reissue do
         # task.fragment = "changelog_fragments"   # Or use a directory of fragment files
         task.clear_fragments = false              # Clear fragment files after release. Not necessary when using git trailers.
 
+        # Post-release runbook (mainly for applications)
+        # task.runbook_file = "RUNBOOK.md"        # Maintain a runbook from Runbook: git trailers
+        #                                         # Seed a starter file with: rake reissue:initialize[runbook]
+
         # Git workflow options
         task.commit = true                        # Auto-commit version bumps
         task.commit_finalize = true               # Auto-commit changelog finalization

data/lib/reissue/runbook.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Reissue
+  # Maintains a post-release runbook file listing steps to perform after
+  # releasing a version. The file holds only the latest release.
+  class Runbook
+    ITEM_PATTERN = /^- (?:\[(?<checked>[ xX])\] )?(?<text>.+)$/
+
+    DEFAULT_TITLE = "Runbook"
+    DEFAULT_PREAMBLE = "Steps to perform after releasing the version below."
+
+    def initialize(runbook_file)
+      @runbook_file = runbook_file
+    end
+
+    attr_reader :runbook_file
+
+    # Writes a header-only template for the given version, preserving any
+    # custom title and preamble already in the file.
+    def generate(version: "Unreleased")
+      title, preamble = parsed_header
+      File.write(runbook_file, template(heading(version), title:, preamble:))
+    end
+
+    alias_method :clear, :generate
+
+    # Returns the text of each checklist item, without checkbox markers.
+    def items
+      parsed_items.map { |item| item[:text] }
+    end
+
+    # Stamps the header with the release version and date, merging directly
+    # edited items with trailer items (deduplicated by text). Preserves any
+    # custom title and preamble already in the file.
+    def finalize(version:, date:, trailer_items: [])
+      title, preamble = parsed_header
+      merged = parsed_items
+      texts = merged.map { |item| item[:text] }
+      trailer_items.each do |text|
+        merged << {text: text, checked: false} unless texts.include?(text)
+      end
+      File.write(runbook_file, template(heading(version, date), merged, title:, preamble:))
+    end
+
+    private
+
+    # Returns the [title, preamble] found before the first version heading,
+    # falling back to the defaults when the file is missing or header-only.
+    def parsed_header
+      return [DEFAULT_TITLE, DEFAULT_PREAMBLE] unless File.exist?(runbook_file)
+
+      header_chunk = File.read(runbook_file).split(/^## /, 2).first.to_s
+      title_match = header_chunk.match(/^#\s+(?<title>.+)$/)
+      title = title_match ? title_match[:title].strip : DEFAULT_TITLE
+      preamble = (title_match ? header_chunk.sub(title_match[0], "") : header_chunk).strip
+      preamble = DEFAULT_PREAMBLE if preamble.empty?
+      [title, preamble]
+    end
+
+    def parsed_items
+      return [] unless File.exist?(runbook_file)
+
+      File.read(runbook_file).lines.filter_map do |line|
+        match = line.rstrip.match(ITEM_PATTERN)
+        next unless match
+        {text: match[:text], checked: match[:checked]&.downcase == "x"}
+      end
+    end
+
+    def heading(version, date = nil)
+      date ? "## [#{version}] - #{date}" : "## [#{version}]"
+    end
+
+    def template(heading, items = [], title: DEFAULT_TITLE, preamble: DEFAULT_PREAMBLE)
+      header = <<~MARKDOWN
+        # #{title}
+
+        #{preamble}
+
+        #{heading}
+      MARKDOWN
+      return header if items.empty?
+
+      list = items.map { |item| "- [#{item[:checked] ? "x" : " "}] #{item[:text]}" }.join("\n")
+      "#{header}\n#{list}\n"
+    end
+  end
+end

data/lib/reissue/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Reissue
-  VERSION = "0.4.22"
-  RELEASE_DATE = "2026-04-09"
+  VERSION = "0.5.1"
+  RELEASE_DATE = "2026-07-24"
 end

data/lib/reissue/version_updater.rb

@@ -21,12 +21,12 @@ module Reissue
         when :patch
           segments.slice(0, 2) + segments.slice(2..-1).then { |array|
             array[-1] = array[-1].next
-            [array.map(&:to_s).join]
+            [array.join]
           }
         when :pre
           segments.slice(0, 3) + segments.slice(3..-1).then { |array|
             array[-1] = array[-1].next
-            [array.map(&:to_s).join]
+            [array.join]
           }
         else
           raise ArgumentError, "Invalid segment name: #{segment_name}"

data/lib/reissue.rb

@@ -4,6 +4,7 @@ require_relative "reissue/version"
 require_relative "reissue/version_updater"
 require_relative "reissue/changelog_updater"
 require_relative "reissue/fragment_handler"
+require_relative "reissue/runbook"
 
 # Reissue is a module that provides functionality for updating version numbers and changelogs.
 module Reissue
@@ -40,7 +41,8 @@ module Reissue
     version_redo_proc: nil,
     fragment: nil,
     fragment_directory: nil,
-    tag_pattern: nil
+    tag_pattern: nil,
+    runbook_file: nil
   )
     # Handle deprecation
     if fragment_directory && !fragment
@@ -55,10 +57,11 @@ module Reissue
       changelog_updater = ChangelogUpdater.new(changelog_file)
       changelog_updater.call(new_version, date:, changes:, changelog_file:, version_limit:, retain_changelogs:, fragment:, tag_pattern:)
     end
+    Runbook.new(runbook_file).clear if runbook_file
     new_version
   end
 
-  def self.deferred_call(version_file:, changelog_file: "CHANGELOG.md", version_limit: 2, retain_changelogs: false, fragment: nil, tag_pattern: nil)
+  def self.deferred_call(version_file:, changelog_file: "CHANGELOG.md", version_limit: 2, retain_changelogs: false, fragment: nil, tag_pattern: nil, runbook_file: nil)
     version_updater = VersionUpdater.new(version_file)
     version_updater.set_version("Unreleased", version_file:)
     version_updater.update_release_date("Unreleased", version_file:)
@@ -68,10 +71,11 @@ module Reissue
       changelog_updater.call("Unreleased", date: nil, changes: {}, changelog_file:, version_limit:, retain_changelogs:, fragment:, tag_pattern:)
     end
 
+    Runbook.new(runbook_file).clear if runbook_file
     "Unreleased"
   end
 
-  def self.deferred_finalize(date = Date.today, version: nil, segment: nil, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, tag_pattern: nil, version_file: nil, version_redo_proc: nil)
+  def self.deferred_finalize(date = Date.today, version: nil, segment: nil, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, tag_pattern: nil, version_file: nil, version_redo_proc: nil, runbook_file: nil)
     resolved_version = if version&.match?(/^\d/)
       version
     elsif segment || version
@@ -145,7 +149,14 @@ module Reissue
     end
 
     changelog = changelog_updater.finalize(date: date, changelog_file: changelog_file, retain_changelogs: retain_changelogs, resolved_version: resolved_version)
-    changelog["versions"].first.slice("version", "date").values
+    changelog["versions"].first.slice("version", "date").values.tap do |finalized_version, finalized_date|
+      finalize_runbook(runbook_file, version: finalized_version, date: finalized_date, tag_pattern:) if runbook_file
+    end
+  end
+
+  private_class_method def self.finalize_runbook(runbook_file, version:, date:, tag_pattern: nil)
+    trailer_items = FragmentHandler.for(:git, tag_pattern:).read_runbook_entries
+    Runbook.new(runbook_file).finalize(version:, date:, trailer_items:)
   end
 
   private_class_method def self.resolve_version_from_tag(segment, tag_pattern: nil, version_redo_proc: nil)
@@ -165,7 +176,7 @@ module Reissue
   # @param fragment_directory [String] @deprecated Use fragment parameter instead
   #
   # @return [Array] The version number and release date.
-  def self.finalize(date = Date.today, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, fragment_directory: nil, tag_pattern: nil, version_file: nil)
+  def self.finalize(date = Date.today, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, fragment_directory: nil, tag_pattern: nil, version_file: nil, runbook_file: nil)
     # Handle deprecation
     if fragment_directory && !fragment
       warn "[DEPRECATION] `fragment_directory` parameter is deprecated. Please use `fragment` instead."
@@ -224,7 +235,9 @@ module Reissue
       version_updater.update_release_date(date.to_s, version_file:)
     end
 
-    changelog["versions"].first.slice("version", "date").values
+    changelog["versions"].first.slice("version", "date").values.tap do |finalized_version, finalized_date|
+      finalize_runbook(runbook_file, version: finalized_version, date: finalized_date, tag_pattern:) if runbook_file
+    end
   end
 
   # Reformats the changelog file to ensure it is correctly formatted.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reissue
 version: !ruby/object:Gem::Version
-  version: 0.4.22
+  version: 0.5.1
 platform: ruby
 authors:
 - Jim Gay
@@ -46,6 +46,7 @@ files:
 - lib/reissue/parser.rb
 - lib/reissue/printer.rb
 - lib/reissue/rake.rb
+- lib/reissue/runbook.rb
 - lib/reissue/version.rb
 - lib/reissue/version_updater.rb
 homepage: https://github.com/SOFware/reissue
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Keep your versions and changelogs up to date and prepared for release.
 test_files: []