ratatui_ruby 1.2.2 → 1.3.0

data/tasks/bump/cargo_lockfile.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Lockfiles need to be refreshed by a tool after Manifests are changed.
+class CargoLockfile < Data.define(:path, :dir, :name)
+  def exists?
+    File.exist?(path)
+  end
+
+  def refresh
+    return unless exists?
+
+    Dir.chdir(dir) do
+      system("cargo update -p #{name} --offline")
+    end
+  end
+end

data/tasks/bump/changelog.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require_relative "links"
+require_relative "unreleased_section"
+require_relative "history"
+require_relative "header"
+
+# Changelog manages the project's CHANGELOG.md file.
+class Changelog
+  # Creates a new Changelog for the file at the given path.
+  def initialize(path: "CHANGELOG.md")
+    @path = path
+  end
+
+  # Releases a new version in the changelog.
+  # This moves the unreleased changes to a new version heading and resets the unreleased section.
+  def release(new_version)
+    content = File.read(@path)
+
+    header = Header.parse(content)
+    unreleased = UnreleasedSection.parse(content)
+    links = Links.from_markdown(content)
+
+    raise "Could not parse CHANGELOG.md" unless header && unreleased && links
+
+    history = History.parse(content, header.length, unreleased.to_s.length, links.to_s)
+
+    links.release(new_version)
+    history.add(unreleased.as_version(new_version))
+
+    File.write(@path, "#{header}#{UnreleasedSection.fresh}\n\n#{history}\n#{links}")
+    nil
+  end
+
+  # Removes entries from [Unreleased] that were released in the given version.
+  # Used when creating a release branch from trunk.
+  def prune_released_entries(released_entries)
+    content = File.read(@path)
+
+    header = Header.parse(content)
+    unreleased = UnreleasedSection.parse(content)
+    links = Links.from_markdown(content)
+
+    raise "Could not parse CHANGELOG.md" unless header && unreleased && links
+
+    history = History.parse(content, header.length, unreleased.to_s.length, links.to_s)
+
+    pruned = unreleased.without_entries(released_entries)
+
+    File.write(@path, "#{header}#{pruned}\n\n#{history}\n#{links}")
+    nil
+  end
+
+  # Imports a release section from another branch's changelog.
+  # Adds the version section to history and dedupes from [Unreleased].
+  # Uses "first wins" — if entry already deduped, doesn't re-add it.
+  def import_release(version, release_changelog_content)
+    release_section = extract_version_section(release_changelog_content, version)
+    return unless release_section
+
+    content = File.read(@path)
+
+    header = Header.parse(content)
+    unreleased = UnreleasedSection.parse(content)
+    links = Links.from_markdown(content)
+
+    raise "Could not parse CHANGELOG.md" unless header && unreleased && links
+
+    history = History.parse(content, header.length, unreleased.to_s.length, links.to_s)
+
+    # Add the release section to history (inserted in version order)
+    history.add(release_section)
+    links.release(version)
+
+    # Dedupe from [Unreleased] (first-wins: if already gone, no-op)
+    release_entries = release_section.lines.select { |l| l.strip.start_with?("- ") }.map(&:strip)
+    pruned = unreleased.without_entries(release_entries)
+
+    File.write(@path, "#{header}#{pruned}\n\n#{history}\n#{links}")
+    nil
+  end
+
+  def commit_message(version)
+    content = File.read(@path)
+    unreleased = UnreleasedSection.parse(content)
+    return nil unless unreleased
+
+    "chore: release v#{version}\n\n#{unreleased.commit_body}"
+  end
+
+  private def extract_version_section(changelog_content, version)
+    # Match the version heading and capture until the next version heading or links section
+    pattern = /^## \[#{Regexp.escape(version.to_s)}\][^\n]*\n(.*?)(?=^## \[|\n\[Unreleased\]:)/m
+    match = changelog_content.match(pattern)
+    return nil unless match
+
+    "## [#{version}]#{match[0].split("\n", 2).first.split(']', 2).last}\n#{match[1]}"
+  end
+end

data/tasks/bump/header.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Header manages the header section of the changelog.
+class Header
+  PATTERN = /^(.*?)(?=## \[Unreleased\])/m
+
+  # Extracts the header section from the given content.
+  def self.parse(content)
+    match = content.match(PATTERN)
+    new(match[1]) if match
+  end
+
+  # Creates a new Header from the given content.
+  def initialize(content)
+    @content = content.dup
+  end
+
+  # Returns the length of the header content.
+  def length
+    @content.length
+  end
+
+  # Returns the current state of the header as a string.
+  def to_s
+    @content
+  end
+end

data/tasks/bump/history.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# History manages the versioned history of the changelog.
+class History
+  # Extracts the history section from the given content, between unreleased and links.
+  def self.parse(content, header_length, unreleased_length, links_text)
+    start = header_length + unreleased_length
+    text = "#{content[start...(content.index(links_text))].strip}\n"
+    new(text)
+  end
+
+  # Creates a new History from the given content.
+  def initialize(content)
+    @content = content.dup
+  end
+
+  # Adds a new versioned section to the history.
+  def add(section)
+    @content = "#{"#{section}\n\n#{@content}".strip}\n"
+    nil
+  end
+
+  # Returns the current state of the history as a string.
+  def to_s
+    @content
+  end
+end

data/tasks/bump/links.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Manages the version comparison links at the botton of the changelog.
+#
+# Release automation needs to update links. Manually calculating git diff URLs
+# for every release is tedious and error-prone. SourceHut does not have
+# standard comparison views, complicating matters further.
+#
+# This class manages the collection of links. It parses them from the markdown.
+# It generates the correct tree links for SourceHut. It properly shifts the
+# "Unreleased" pointer.
+#
+# Use it to update the changelog during a release.
+class Links
+  PATTERN = /^(\[Unreleased\]: .*)$/m
+  UNRELEASED_PATTERN = %r{^\[Unreleased\]: (.*?/refs/)HEAD$}
+
+  # Creates a Links object from the full markdown content.
+  #
+  # [content] String. The full text of the changelog.
+  def self.from_markdown(content)
+    match = content.match(PATTERN)
+    return unless match
+
+    new(match[1].strip)
+  end
+
+  # Returns the raw text of the links.
+  attr_reader :text
+
+  # Creates a new Links object.
+  #
+  # [text] String. The raw text of the links section.
+  def initialize(text)
+    @text = text.dup
+  end
+
+  # Releases a new version.
+  #
+  # Updates the "Unreleased" link to point to the new head. Adds a new link for
+  # the just-released version pointing to its specific tag.
+  #
+  # [version] String. The new version number (e.g., <tt>"0.5.0"</tt>).
+  def release(version)
+    return unless base_url
+
+    new_unreleased = "[Unreleased]: #{base_url}HEAD" # .../HEAD
+    new_version_link = "[#{version}]: #{base_url}v#{version}" # .../v1.0.0
+
+    @text.sub!(UNRELEASED_PATTERN, "#{new_unreleased}\n#{new_version_link}")
+    self
+  end
+
+  # Returns the string representation of the links.
+  def to_s
+    @text
+  end
+
+  # The base URL for the repository's references.
+  private def base_url
+    match = @text.match(UNRELEASED_PATTERN)
+    match[1] if match
+  end
+end

data/tasks/bump/manifest.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Manifests hold a copy of the version number and should be changed manually.
+# Use Regexp lookarounds in `pattern` to match the version number.
+class Manifest < Data.define(:path, :pattern, :primary)
+  def read
+    File.read(path)
+  end
+
+  def initialize(path:, pattern:, primary: false)
+    super
+  end
+
+  def version
+    content = read
+    match = content.match(pattern)
+    raise "Version missing in manifest #{path}" unless match
+
+    SemVer.parse(match[0])
+  end
+
+  def write(version)
+    return unless File.exist?(path)
+
+    new_content = read.gsub(pattern, version.to_s)
+    File.write(path, new_content)
+  end
+end

data/tasks/bump/patch_release.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require_relative "bump_workflow"
+
+# PatchRelease performs a patch release on the current release branch.
+class PatchRelease < BumpWorkflow
+  private def prepare(segment)
+    puts "Bumping #{segment}: #{@gem.version} -> #{target}"
+  end
+
+  private def finalize
+    puts "\nCommitted. Push and run: bundle exec rake release"
+  end
+end

data/tasks/bump/release_branch.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# ReleaseBranch represents a release/X.Y branch for a version series.
+class ReleaseBranch < Data.define(:major, :minor)
+  def self.for_version(semver)
+    new(semver.major, semver.minor)
+  end
+
+  def name
+    "release/#{major}.#{minor}"
+  end
+end

data/tasks/bump/release_from_trunk.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require_relative "bump_workflow"
+require_relative "release_branch"
+
+# ReleaseFromTrunk creates a release branch, releases there, syncs trunk, returns to release branch.
+class ReleaseFromTrunk < BumpWorkflow
+  private def prepare(segment)
+    @branch = ReleaseBranch.for_version(target)
+
+    puts "Creating release branch: #{@branch.name}"
+    puts "Bumping #{segment}: #{@gem.version} -> #{target}"
+
+    @repository.create_branch(@branch.name)
+  end
+
+  private def release_on_branch
+    super
+    puts "\nCommitted on #{@branch.name}."
+
+    # Capture for trunk import
+    @released_changelog_content = File.read("CHANGELOG.md")
+  end
+
+  private def finalize
+    sync_trunk
+    return_to_release_branch
+  end
+
+  private def sync_trunk
+    @repository.checkout("trunk")
+    trunk_changelog = Changelog.new
+    trunk_changelog.import_release(target, @released_changelog_content)
+    @gem.update_version(target)
+    generate_ci_manifests
+    @repository.commit_all("chore: import v#{target} to trunk")
+    puts "Committed on trunk."
+  end
+
+  private def return_to_release_branch
+    @repository.checkout(@branch.name)
+    puts "\nBack on #{@branch.name}. Review, push both branches, then: bundle exec rake release"
+  end
+end

data/tasks/bump/repository.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require "shellwords"
+require "tmpdir"
+
+class Repository
+  TRUNK = "trunk"
+
+  def on_trunk? = current_branch == TRUNK
+
+  def current_branch
+    `git branch --show-current`.strip
+  end
+
+  def create_branch(name)
+    system("git checkout -b #{name}", exception: true)
+  end
+
+  def checkout(name)
+    system("git checkout #{name}", exception: true)
+  end
+
+  def assert_can_bump!(segment)
+    assert_pristine!
+
+    if on_trunk? && segment == :patch
+      raise ArgumentError, "Cannot bump:patch from trunk. Use a release branch."
+    end
+
+    if !on_trunk? && [:minor, :major].include?(segment)
+      raise ArgumentError, "Cannot bump:#{segment} from #{current_branch}. Switch to trunk first."
+    end
+  end
+
+  def assert_pristine!
+    return if `git status --porcelain`.strip.empty?
+
+    raise ArgumentError, "Working tree is not clean. Commit or stash changes first."
+  end
+
+  def commit_all(message)
+    msg_file = File.join(Dir.tmpdir, "ratatui_ruby_commit_msg_#{$$}.txt")
+    system("git add -A", exception: true)
+    File.write(msg_file, message)
+    system("git commit -F #{msg_file.shellescape}", exception: true)
+  ensure
+    File.delete(msg_file) if msg_file && File.exist?(msg_file)
+  end
+end

data/tasks/bump/ruby_gem.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# RubyGem knows how to update its version: manifests, lockfiles.
+class RubyGem
+  def initialize(manifests:, lockfile:)
+    raise ArgumentError, "Must have exactly one primary manifest" unless manifests.count(&:primary) == 1
+    @manifests = manifests
+    @lockfile = lockfile
+  end
+
+  def version
+    @manifests.find(&:primary).version
+  end
+
+  def update_version(target)
+    @manifests.each { |manifest| manifest.write(target) }
+    @lockfile.refresh
+    refresh_bundler_lockfile
+  end
+
+  private def refresh_bundler_lockfile
+    system("bundle install", exception: true)
+  end
+end

data/tasks/bump/sem_ver.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# See https://semver.org/spec/v2.0.0.html
+class SemVer
+  SEGMENTS = [:major, :minor, :patch].freeze
+
+  def self.parse(string)
+    require "rubygems"
+    # Extract prerelease suffix (e.g., "-beta.1", "-alpha.2", "-rc.1")
+    base, prerelease = string.split("-", 2)
+    segments = Gem::Version.new(base).segments.fill(0, 3).first(3)
+    new(segments, prerelease:)
+  end
+
+  def initialize(segments, prerelease: nil)
+    @segments = segments
+    @prerelease = prerelease
+  end
+
+  def major = @segments[0]
+  def minor = @segments[1]
+  def patch = @segments[2]
+
+  def next(segment)
+    index = SEGMENTS.index(segment)
+    raise ArgumentError, "Invalid segment: #{segment}" unless index
+
+    new_segments = @segments.dup
+    new_segments[index] += 1
+    new_segments.fill(0, (index + 1)..2)
+
+    SemVer.new(new_segments)
+  end
+
+  def to_s
+    base = @segments.join(".")
+    @prerelease ? "#{base}-#{@prerelease}" : base
+  end
+end

data/tasks/bump/unreleased_section.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require "date"
+require "rdoc"
+
+# UnreleasedSection manages the [Unreleased] section of the changelog.
+class UnreleasedSection
+  PATTERN = /^(## \[Unreleased\].*?)(?=## \[\d)/m
+
+  # Extracts the unreleased section from the given content.
+  def self.parse(content)
+    match = content.match(PATTERN)
+    new(match[1].strip) if match
+  end
+
+  # Creates a new UnreleasedSection from the given unreleased content.
+  def initialize(content)
+    @content = content.dup
+  end
+
+  # Returns the unreleased content as a versioned section.
+  def as_version(new_version)
+    date = Date.today.iso8601
+    @content.sub(/^## \[Unreleased\]/, "## [#{new_version}] - #{date}")
+  end
+
+  # Returns a fresh unreleased section.
+  def self.fresh
+    new("## [Unreleased]\n\n### Added\n\n### Changed\n\n### Fixed\n\n### Removed")
+  end
+
+  # Returns the current state of the section as a string.
+  def to_s
+    @content
+  end
+
+  def commit_body
+    formatter = Class.new { include RDoc::Text }.new
+    @content
+      .sub(/^## \[Unreleased\].*$/, "")
+      .gsub(/^### (Added|Changed|Fixed|Removed)\n*$/, "")
+      .gsub(/^- \*\*([^*]+)\*\*:/, '\1:')
+      .gsub(/`([^`]+)`/, '\1')
+      .strip
+      .lines
+      .map { |line| line.gsub(/^- /, "").strip }
+      .reject(&:empty?)
+      .map { |line| formatter.wrap(line, 72) }
+      .join("\n\n")
+  end
+
+  # Returns all changelog entry lines (lines starting with "- ")
+  def entries
+    @content.lines.select { |line| line.strip.start_with?("- ") }.map(&:strip)
+  end
+
+  # Returns a new UnreleasedSection with entries removed that appear in the given list.
+  def without_entries(entries_to_remove)
+    return self if entries_to_remove.empty?
+
+    new_lines = @content.lines.reject do |line|
+      stripped = line.strip
+      entries_to_remove.include?(stripped)
+    end
+
+    self.class.new(new_lines.join)
+  end
+end

data/tasks/bump.rake

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require "rubygems"
+
+require_relative "bump/sem_ver"
+require_relative "bump/manifest"
+require_relative "bump/cargo_lockfile"
+require_relative "bump/ruby_gem"
+require_relative "bump/release_from_trunk"
+require_relative "bump/patch_release"
+
+namespace :bump do
+  gem = RubyGem.new(
+    manifests: [
+      Manifest.new(
+        path: "lib/ratatui_ruby/version.rb",
+        pattern: /(?<=VERSION = ")[^"]+(?=")/,
+        primary: true
+      ),
+      Manifest.new(
+        path: "ext/ratatui_ruby/Cargo.toml",
+        pattern: /(?<=^version = ")[^"]+(?=")/,
+        primary: false
+      ),
+    ],
+    lockfile: CargoLockfile.new(
+      path: "ext/ratatui_ruby/Cargo.lock",
+      dir: "ext/ratatui_ruby",
+      name: "ratatui_ruby"
+    )
+  )
+
+  desc "Bump major version"
+  task :major do
+    ReleaseFromTrunk.new(gem:).call(:major)
+  end
+
+  desc "Bump minor version"
+  task :minor do
+    ReleaseFromTrunk.new(gem:).call(:minor)
+  end
+
+  desc "Bump patch version"
+  task :patch do
+    PatchRelease.new(gem:).call(:patch)
+  end
+
+  desc "Set exact version (e.g. rake bump:exact[0.1.0])"
+  task :exact, [:version] do |_, args|
+    target = SemVer.parse(args[:version])
+    changelog = Changelog.new
+    changelog.release(target)
+    gem.update_version(target)
+    Rake::Task["sourcehut"].invoke
+  end
+end