ratatui_ruby-devtools 0.2.1 → 0.4.0

data/lib/ratatui_ruby/devtools/tasks/bump/manifest.rb

@@ -5,6 +5,8 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
+require_relative "sem_ver"
+
 # Represents a file that contains a version number.
 #
 # Gems have version numbers in multiple places: version.rb, Cargo.toml, etc.
@@ -16,27 +18,16 @@
 #
 # [path] The file path.
 # [pattern] A regex with lookarounds to match the version string.
-# [primary] Whether this is the primary source of truth.
 #
 # === Example
 #
 #   manifest = Manifest.new(
 #     path: "lib/my_gem/version.rb",
-#     pattern: /(?<=VERSION = ")[^"]+(?=")/,
-#     primary: true
+#     pattern: /(?<=VERSION = ")[^"]+(?=")/
 #   )
 #   manifest.version.to_s  # => "1.2.3"
 #
-class Manifest < Data.define(:path, :pattern, :primary)
-  # Creates a new Manifest.
-  #
-  # [path] The file path.
-  # [pattern] A regex with lookarounds to match the version string.
-  # [primary] Whether this is the primary source of truth.
-  def initialize(path:, pattern:, primary: false)
-    super
-  end
-
+class Manifest < Data.define(:path, :pattern)
   # Reads the file content.
   def read
     File.read(path)
@@ -44,11 +35,12 @@ class Manifest < Data.define(:path, :pattern, :primary)
 
   # Returns the current version from this manifest.
   def version
-    content = read
-    match = content.match(pattern)
-    raise "Version missing in manifest #{path}" unless match
+    SemVer.parse(written)
+  end
 
-    SemVer.parse(match[0])
+  # Returns the version exactly as this manifest writes it.
+  def written
+    read[pattern] or raise "Version missing in manifest #{path}"
   end
 
   # Writes a new version to this manifest.

data/lib/ratatui_ruby/devtools/tasks/bump/no_crate.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
+#++
+
+# The Rust extension of a pure Ruby gem, which has none.
+class NoCrate # :nodoc:
+  def manifests
+    []
+  end
+
+  def refresh
+  end
+
+  def release_native_gems(version:, sha:)
+  end
+end

data/lib/ratatui_ruby/devtools/tasks/bump/no_links.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# The links of a changelog that has none yet, as the scaffold writes it.
+class NoLinks # :nodoc:
+  def release(_version)
+    self
+  end
+
+  # With no links, the history runs to the end of the changelog.
+  def start_in(content)
+    content.length
+  end
+
+  def footer
+    ""
+  end
+end

data/lib/ratatui_ruby/devtools/tasks/bump/patch_release.rb

@@ -0,0 +1,25 @@
+# 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 assert_can_bump!
+    return unless @repository.on_trunk?
+
+    raise ArgumentError, "Cannot bump:#{@task} from trunk. Use a release branch."
+  end
+
+  private def prepare
+    puts "Bumping #{@task}: #{@gem.version} -> #{target}"
+  end
+
+  private def finalize
+    puts "\nCommitted. Push and run: bundle exec rake release"
+  end
+end

data/lib/ratatui_ruby/devtools/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) # :nodoc:
+  def self.for_version(semver)
+    new(semver.major, semver.minor)
+  end
+
+  def name
+    "release/#{major}.#{minor}"
+  end
+end

data/lib/ratatui_ruby/devtools/tasks/bump/release_from_trunk.rb

@@ -0,0 +1,48 @@
+# 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
+    @branch = ReleaseBranch.for_version(target)
+
+    puts "Creating release branch: #{@branch.name}"
+    puts "Bumping #{@task}: #{@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)
+    @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/lib/ratatui_ruby/devtools/tasks/bump/repository.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require "open3"
+require "rake/file_utils_ext"
+require "tmpdir"
+
+class Repository # :nodoc:
+  # Releasing shows each git command it runs, as rake tasks do.
+  include Rake::FileUtilsExt
+
+  TRUNK = "trunk"
+  STABLE = "stable"
+
+  class Author < Data.define(:name, :email) # :nodoc:
+    def to_s
+      "#{name} <#{email}>"
+    end
+  end
+
+  # The identity your next commit would carry, from git config or the
+  # GIT_AUTHOR_* variables. Without useConfigOnly, git would guess an email
+  # from the hostname, and that guess would end up in copyright headers.
+  def author
+    ident, status = Open3.capture2("git", "-c", "user.useConfigOnly=true", "var", "GIT_AUTHOR_IDENT", err: File::NULL)
+    name, email = ident.match(/\A(.+) <(.*)> \d+ [+-]\d{4}\n?\z/)&.captures
+    return Author.new(name:, email:) if status.success? && name && email
+
+    raise ArgumentError, "Git doesn't know who you are. Run: git config --global user.name \"Your Name\" " \
+      "and git config --global user.email you@example.com"
+  end
+
+  def on_trunk? = current_branch == TRUNK
+
+  def current_branch
+    git("branch", "--show-current").strip
+  end
+
+  def tracked_files(pattern)
+    git("ls-files", pattern).split("\n")
+  end
+
+  # The tracked files a syntax covers, under the given paths, or everywhere
+  # it looks by default. A path that isn't a directory is taken as it is, if
+  # it's written in the syntax. In a git pathspec * crosses directories, so
+  # dir/*.rb reaches every depth, while dir/**/*.rb would skip the files
+  # directly inside dir.
+  def tracked_files_for(paths, syntax)
+    return syntax.tracked_patterns.flat_map { |pattern| tracked_files(pattern) }.uniq if paths.empty?
+
+    paths.flat_map do |path|
+      if File.directory?(path)
+        syntax.extensions.flat_map { |extension| tracked_files("#{path}/*.#{extension}") }
+      elsif syntax.extensions.include?(File.extname(path).delete_prefix("."))
+        [path]
+      else
+        []
+      end
+    end
+  end
+
+  # Added, copied, modified, or renamed since HEAD, staged or not, plus new
+  # untracked files. The staged diff also covers a repository with no commits.
+  def changed_files
+    [
+      git("diff", "--name-only", "--diff-filter=ACMR", "HEAD"),
+      git("diff", "--name-only", "--cached", "--diff-filter=ACMR"),
+      git("ls-files", "--others", "--exclude-standard"),
+    ].flat_map { |output| output.split("\n") }.uniq
+  end
+
+  def latest_tag
+    git("describe", "--tags", "--abbrev=0").strip
+  end
+
+  # An annotated tag is an object of its own, and a branch can only point at
+  # a commit.
+  def released_commit(tag)
+    git("rev-parse", "#{tag}^{}").strip
+  end
+
+  # The file as the stable branch has it, or nil when there's no such branch
+  # or file.
+  def stable_file(path)
+    text = git("show", "#{STABLE}:#{path}")
+    text unless text.empty?
+  end
+
+  # Stable is reset to each release rather than fast-forwarded, so origin's
+  # copy is overwritten. Git can't tell that a bare name is meant as a branch
+  # when origin has none yet, as after the scaffold, so the push names it in
+  # full.
+  def move_stable(commit)
+    sh "git", "branch", "-f", STABLE, commit
+    sh "git", "push", "--force", "origin", "#{commit}:refs/heads/#{STABLE}"
+  end
+
+  # Deletes the tag here and on origin.
+  def delete_tag(name)
+    sh "git", "tag", "-d", name
+    sh "git", "push", "origin", ":refs/tags/#{name}"
+  end
+
+  # Tags HEAD here and on origin.
+  def tag_head(name)
+    sh "git", "tag", name, "HEAD"
+    sh "git", "push", "origin", name
+  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_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, exception: true)
+  ensure
+    File.delete(msg_file) if msg_file && File.exist?(msg_file)
+  end
+
+  # Runs git directly rather than through a shell, whose quoting and
+  # redirection differ on Windows, and keeps its complaints out of the
+  # output it answers with.
+  private def git(*)
+    Open3.capture2("git", *, err: File::NULL).first
+  end
+end

data/lib/ratatui_ruby/devtools/tasks/bump/ruby_gem.rb

@@ -5,73 +5,79 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
-# Coordinates version bumping across multiple manifests.
-#
-# Ruby gems have versions in multiple files: version.rb, Cargo.toml, lockfiles.
-# Bumping manually leads to mismatches. Forgetting the changelog produces
-# incomplete releases.
-#
-# This class orchestrates the bump. It updates all manifests, refreshes
-# lockfiles, and updates the changelog. One command. Consistent versions.
-#
-# Use it in rake tasks to bump major, minor, or patch versions.
-class RubyGem
-  # Creates a new RubyGem coordinator.
-  #
-  # [manifests] Array of Manifest objects. Exactly one must be primary.
-  # [lockfile] A lockfile object that responds to <tt>refresh</tt>.
-  # [changelog] A Changelog object for updating release notes.
-  def initialize(manifests:, lockfile:, changelog:)
-    raise ArgumentError, "Must have exactly one primary manifest" unless manifests.count(&:primary) == 1
-    @manifests = manifests
-    @lockfile = lockfile
-    @changelog = changelog
+require "rubygems"
+require_relative "manifest"
+require_relative "rust_crate"
+
+# A gem, found from its files wherever you haven't said otherwise.
+class RubyGem < Data.define(:name, :gemspec_file, :version_file) # :nodoc:
+  VERSION = /(?<=VERSION = ")[^"]+(?=")/
+
+  def self.found(gemspec_file: nil, name: nil, version_file: nil)
+    gemspec_file ||= only_gemspec
+    name ||= File.basename(gemspec_file, ".gemspec")
+    new(name:, gemspec_file:, version_file: version_file || version_file_of(name))
+  end
+
+  def self.only_gemspec
+    gemspecs = Dir.glob("*.gemspec")
+    raise RatatuiRuby::Devtools::Error, "No *.gemspec found in #{Dir.pwd}" if gemspecs.empty?
+    raise RatatuiRuby::Devtools::Error, "Multiple gemspecs found: #{gemspecs.join(', ')}" if gemspecs.size > 1
+
+    gemspecs.first
+  end
+
+  # A gem named my_gem-kit keeps its version in lib/my_gem/kit/.
+  def self.version_file_of(name)
+    path = "lib/#{name.tr('-', '/')}/version.rb"
+    return path if File.exist?(path)
+
+    Dir.glob("lib/**/version.rb").first || path
+  end
+
+  # RubyGems caches a gemspec by the path it was loaded from, so a relative
+  # path would return another gem's spec loaded from another directory.
+  def spec
+    Gem::Specification.load(File.expand_path(gemspec_file))
+  end
+
+  def crate
+    RustCrate.of(name)
   end
 
-  # Returns the current version from the primary manifest.
   def version
-    @manifests.find(&:primary).version
+    manifest.version
+  end
+
+  # Bundler tags a release with the version as written, and the release
+  # tasks look for its SemVer tag. A bump reads 1.2 as 1.2.0 because it
+  # rewrites the file, but a release tags the file as it stands.
+  def release_version
+    written = manifest.written
+    version.tap do |full|
+      raise ArgumentError, "#{version_file} says #{written}. Write it as #{full} before releasing." if full.to_s != written
+    end
+  end
+
+  # What the stable branch released, or nil before the first release. Stable
+  # can still hold a version from before the gem used SemVer, which only
+  # RubyGems reads.
+  def stable_version(repository)
+    written = repository.stable_file(version_file)&.[](VERSION)
+    Gem::Version.new(written) if written
   end
 
-  # Bumps the version by the given segment.
-  #
-  # Updates all manifests, refreshes lockfiles, and updates the changelog.
-  # Prints a suggested commit message.
-  #
-  # [segment] One of <tt>:major</tt>, <tt>:minor</tt>, or <tt>:patch</tt>.
-  def bump(segment)
-    target = version.next(segment)
-    commit_message = @changelog.commit_message(target)
-
-    puts "Bumping #{segment}: #{version} -> #{target}"
-    @changelog.release(target)
-    @manifests.each { |manifest| manifest.write(target) }
-    @lockfile.refresh
-
-    puts_commit_message(commit_message)
+  def update_version(target)
+    [manifest, *crate.manifests].each { |manifest| manifest.write(target) }
+    crate.refresh
+    refresh_bundler_lockfile
   end
 
-  # Sets the version to an exact value.
-  #
-  # Updates all manifests, refreshes lockfiles, and updates the changelog.
-  # Prints a suggested commit message.
-  #
-  # [version_string] A version string like <tt>"1.2.3"</tt>.
-  def set(version_string)
-    target = SemVer.parse(version_string)
-    commit_message = @changelog.commit_message(target)
-
-    puts "Setting version: #{version} -> #{target}"
-    @changelog.release(target)
-    @manifests.each { |manifest| manifest.write(target) }
-    @lockfile.refresh
-
-    puts_commit_message(commit_message)
+  private def manifest
+    Manifest.new(path: version_file, pattern: VERSION)
   end
 
-  private def puts_commit_message(message)
-    puts "=" * 80
-    puts message
-    puts "=" * 80
+  private def refresh_bundler_lockfile
+    system("bundle install", exception: true)
   end
 end

data/lib/ratatui_ruby/devtools/tasks/bump/rust_crate.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require_relative "cargo_lockfile"
+require_relative "manifest"
+require_relative "no_crate"
+require_relative "../release/native_gem_version"
+
+# A gem's Rust extension. The scaffold names its directory and package after
+# the gem with underscores, as Cargo wants; older gems used the gem's name.
+class RustCrate < Data.define(:dir) # :nodoc:
+  VERSION = /(?<=^version = ")[^"]+(?=")/
+
+  def self.of(gem_name)
+    dir = [gem_name.tr("-", "_"), gem_name].map { |name| "ext/#{name}" }.find { |path| File.exist?("#{path}/Cargo.toml") }
+    dir ? new(dir:) : NoCrate.new
+  end
+
+  def manifests
+    [Manifest.new(path: "#{dir}/Cargo.toml", pattern: VERSION)]
+  end
+
+  def refresh
+    lockfile.refresh
+  end
+
+  def lockfile
+    CargoLockfile.new(path: "#{dir}/Cargo.lock", dir:, name: package)
+  end
+
+  def release_native_gems(version:, sha:)
+    NativeGemVersion.new(version:, sha:).release
+  end
+
+  private def package
+    File.read("#{dir}/Cargo.toml")[/^name = "([^"]+)"/, 1]
+  end
+end