ratatui_ruby 1.2.0 → 1.2.2

data/tasks/license/license_utils.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#++
-
-# Shared utility for detecting contributors from git blame and Co-Authored-By trailers.
-#
-# This module provides methods to:
-# - Get all contributors (authors and co-authors) who touched specific lines
-# - Track the latest year each contributor touched those lines
-# - Parse Co-Authored-By trailers from commit messages
-
-require "open3"
-require "date"
-
-module LicenseUtils
-  # Represents a contributor with their latest year of contribution
-  Contributor = Data.define(:name, :email, :year)
-
-  class << self
-    # Get all contributors who touched lines in a file (or range of lines).
-    # Returns a Hash of { "Name <email>" => year } mapping each contributor to their latest year.
-    #
-    # This considers both the commit author AND any Co-Authored-By trailers in commit messages.
-    def get_contributors_for_lines(filepath, start_line = nil, end_line = nil)
-      blame_cmd = if start_line && end_line
-        %W[git blame -L #{start_line},#{end_line} --porcelain -- #{filepath}]
-      else
-        %W[git blame --porcelain -- #{filepath}]
-      end
-
-      output, _status = Open3.capture2(*blame_cmd)
-
-      contributors = {}  # "Name <email>" => year
-      commit_cache = {}  # commit_hash => { year:, author:, co_authors: [] }
-
-      current_commit = nil
-
-      output.each_line do |line|
-        if line =~ /^([a-f0-9]{40})/
-          current_commit = $1
-        elsif line =~ /^author (.+)$/
-          commit_cache[current_commit] ||= {}
-          commit_cache[current_commit][:author_name] = $1
-        elsif line =~ /^author-mail <(.+)>$/
-          commit_cache[current_commit] ||= {}
-          commit_cache[current_commit][:author_email] = $1
-        elsif line =~ /^author-time (\d+)$/
-          commit_cache[current_commit] ||= {}
-          timestamp = $1.to_i
-          commit_cache[current_commit][:year] = Time.at(timestamp).year
-        end
-      end
-
-      # Now fetch co-authors for each unique commit
-      commit_cache.each do |commit_hash, data|
-        next if commit_hash == "0" * 40 # Skip uncommitted lines
-
-        # Get commit message for Co-Authored-By parsing
-        msg_output, _status = Open3.capture2("git", "log", "-1", "--format=%B", commit_hash)
-        co_authors = parse_co_authors(msg_output)
-        data[:co_authors] = co_authors
-
-        # Add author
-        if data[:author_name] && data[:author_email]
-          key = "#{data[:author_name]} <#{data[:author_email]}>"
-          year = data[:year] || Date.today.year
-          contributors[key] = [contributors[key] || 0, year].max
-        end
-
-        # Add co-authors with same year as commit
-        co_authors.each do |ca|
-          key = "#{ca[:name]} <#{ca[:email]}>"
-          year = data[:year] || Date.today.year
-          contributors[key] = [contributors[key] || 0, year].max
-        end
-      end
-
-      contributors
-    end
-
-    # Get YOUR latest year contribution to the file/lines.
-    # your_identifiers should be an array of strings that identify you (name, email fragments).
-    def get_your_latest_year(filepath, your_identifiers, start_line = nil, end_line = nil)
-      contributors = get_contributors_for_lines(filepath, start_line, end_line)
-
-      your_year = nil
-      contributors.each do |contributor, year|
-        if your_identifiers.any? { |id| contributor.include?(id) }
-          your_year = [your_year || 0, year].max
-        end
-      end
-
-      your_year || Date.today.year
-    end
-
-    # Get all contributors EXCEPT you, with their latest years.
-    # Returns array of { name:, email:, year: }
-    def get_other_contributors(filepath, your_identifiers, start_line = nil, end_line = nil)
-      contributors = get_contributors_for_lines(filepath, start_line, end_line)
-
-      others = []
-      contributors.each do |contributor, year|
-        next if your_identifiers.any? { |id| contributor.include?(id) }
-
-        # Parse "Name <email>" format
-        if contributor =~ /^(.+?)\s*<(.+)>$/
-          others << { name: $1.strip, email: $2.strip, year: }
-        end
-      end
-
-      others
-    end
-
-    private def parse_co_authors(message)
-      co_authors = []
-
-      message.each_line do |line|
-        # Match "Co-Authored-By: Name <email>" (case insensitive)
-        if line =~ /^Co-Authored-By:\s*(.+?)\s*<(.+?)>\s*$/i
-          co_authors << { name: $1.strip, email: $2.strip }
-        end
-      end
-
-      co_authors
-    end
-  end
-end

data/tasks/license/snippets_md.rb

@@ -1,315 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#++
-
-# Script to add SPDX snippet headers to fenced code blocks in markdown files.
-#
-# Usage: ruby tasks/license/snippets_md.rb [path...]
-#
-# If no paths are given, processes all .md files via git ls-files.
-#
-# Rules:
-# - Wraps all fenced code blocks (``` or ````) with SPDX snippet headers (MIT-0)
-# - For SYNC:START/SYNC:END blocks, wraps AROUND the sync markers (not inside)
-# - Uses git blame to determine the latest edit year for the code lines
-# - Skips blocks that are already properly wrapped with MIT-0 and Kerrick Long
-# - Removes malformed existing SPDX-Snippet blocks and replaces with correct ones
-
-require "open3"
-require "date"
-
-COPYRIGHT_HOLDER = "Kerrick Long"
-LICENSE = "MIT-0"
-
-# Files to skip entirely (relative paths from repo root)
-EXCLUDED_FILES = [
-  "doc/contributors/v1.0.0_blockers.md",
-  "doc/contributors/upstream_requests/tab_rects.md",
-  "doc/contributors/upstream_requests/title_rects.md",
-].freeze
-
-def get_latest_git_year(file, start_line, end_line)
-  cmd = %W[git blame -L #{start_line},#{end_line} --date=short -- #{file}]
-  output, _status = Open3.capture2(*cmd)
-  years = output.scan(/(\d{4})-\d{2}-\d{2}/).flatten.map(&:to_i)
-  years.empty? ? Date.today.year : years.max
-end
-
-def is_our_snippet_header?(lines, idx)
-  # Check if the current SPDX-SnippetBegin block already has our copyright/license
-  i = idx + 1
-  has_our_copyright = false
-  has_mit0 = false
-
-  while i < lines.length && !lines[i].include?("-->")
-    line = lines[i]
-    has_our_copyright = true if line.include?(COPYRIGHT_HOLDER) && line.include?("SPDX-FileCopyrightText")
-    has_mit0 = true if line.include?("MIT-0") && line.include?("SPDX-License-Identifier")
-    i += 1
-  end
-
-  has_our_copyright && has_mit0
-end
-
-def find_snippet_end(lines, start_idx)
-  i = start_idx
-  while i < lines.length
-    return i if lines[i].include?("SPDX-SnippetEnd")
-    i += 1
-  end
-  nil
-end
-
-def process_file(filepath)
-  # Skip excluded files
-  return if EXCLUDED_FILES.any? { |excluded| filepath.end_with?(excluded) }
-
-  content = File.read(filepath)
-  lines = content.lines
-
-  # Track code block ranges (to exclude from file header year calculation)
-  code_block_ranges = []
-  changes = []
-  removals = [] # existing malformed SPDX snippet blocks to remove
-  i = 0
-
-  while i < lines.length
-    line = lines[i]
-
-    # Check if we're at an existing SPDX-SnippetBegin
-    if line.include?("SPDX-SnippetBegin")
-      snippet_start = i
-      snippet_end = find_snippet_end(lines, i)
-
-      if snippet_end
-        # Check if this is already our proper snippet
-        if is_our_snippet_header?(lines, i)
-          # Skip this block entirely - it's already correct
-          i = snippet_end + 1
-          next
-        else
-          # Mark for removal - we'll re-wrap the inner content
-          removals << { start: snippet_start, end: snippet_end }
-          i = snippet_end + 1
-          next
-        end
-      end
-    end
-
-    # Check for SYNC:START pattern
-    if line =~ /<!--\s*SYNC:START/
-      sync_start_line = i
-      j = i + 1
-      code_start = nil
-      code_end = nil
-      sync_end_line = nil
-
-      while j < lines.length
-        if lines[j] =~ /^(````*)(\w*)$/
-          if code_start.nil?
-            code_start = j
-          else
-            code_end = j
-          end
-        elsif lines[j] =~ /<!--\s*SYNC:END/
-          sync_end_line = j
-          break
-        end
-        j += 1
-      end
-
-      if code_start && code_end && sync_end_line
-        year = get_latest_git_year(filepath, code_start + 1, code_end + 1)
-        changes << {
-          type: :sync_block,
-          start: sync_start_line,
-          end: sync_end_line,
-          year:,
-        }
-        code_block_ranges << (code_start..code_end)
-        i = sync_end_line + 1
-        next
-      end
-    end
-
-    # Check for standalone fenced code block
-    if line =~ /^(````*)(\w*)$/
-      fence_marker = $1
-      fence_start = i
-      re_end = /^#{Regexp.escape(fence_marker)}$/
-
-      j = i + 1
-      fence_end = nil
-      while j < lines.length
-        if lines[j] =~ re_end
-          fence_end = j
-          break
-        end
-        j += 1
-      end
-
-      if fence_end
-        year = get_latest_git_year(filepath, fence_start + 1, fence_end + 1)
-        changes << {
-          type: :code_block,
-          start: fence_start,
-          end: fence_end,
-          year:,
-        }
-        code_block_ranges << (fence_start..fence_end)
-        i = fence_end + 1
-        next
-      end
-    end
-
-    i += 1
-  end
-
-  # Handle removals and additions
-  has_changes = !changes.empty? || !removals.empty?
-
-  # Remove existing malformed SPDX blocks (in reverse order)
-  removals.sort_by { |r| -r[:start] }.each do |removal|
-    # Remove the SnippetEnd line
-    lines.delete_at(removal[:end])
-    # Remove lines from SnippetBegin through the --> closing the comment
-    close_idx = removal[:start]
-    while close_idx < lines.length && !lines[close_idx].include?("-->")
-      close_idx += 1
-    end
-    # Remove from start to close_idx inclusive
-    (close_idx - removal[:start] + 1).times { lines.delete_at(removal[:start]) }
-  end
-
-  # Recalculate content after removals
-  content = lines.join
-  lines = content.lines
-
-  # Re-scan for code blocks that need wrapping
-  changes = []
-  i = 0
-
-  while i < lines.length
-    line = lines[i]
-
-    # Skip if already inside an SPDX-SnippetBegin block
-    if line.include?("SPDX-SnippetBegin")
-      while i < lines.length && !lines[i].include?("SPDX-SnippetEnd")
-        i += 1
-      end
-      i += 1
-      next
-    end
-
-    # Check for SYNC:START pattern
-    if line =~ /<!--\s*SYNC:START/
-      sync_start_line = i
-      j = i + 1
-      code_start = nil
-      code_end = nil
-      sync_end_line = nil
-
-      while j < lines.length
-        if lines[j] =~ /^(````*)(\w*)$/
-          if code_start.nil?
-            code_start = j
-          else
-            code_end = j
-          end
-        elsif lines[j] =~ /<!--\s*SYNC:END/
-          sync_end_line = j
-          break
-        end
-        j += 1
-      end
-
-      if code_start && code_end && sync_end_line
-        year = get_latest_git_year(filepath, code_start + 1, code_end + 1)
-        changes << {
-          type: :sync_block,
-          start: sync_start_line,
-          end: sync_end_line,
-          year:,
-        }
-        i = sync_end_line + 1
-        next
-      end
-    end
-
-    # Check for standalone fenced code block
-    if line =~ /^(````*)(\w*)$/
-      fence_marker = $1
-      fence_start = i
-      re_end = /^#{Regexp.escape(fence_marker)}$/
-
-      j = i + 1
-      fence_end = nil
-      while j < lines.length
-        if lines[j] =~ re_end
-          fence_end = j
-          break
-        end
-        j += 1
-      end
-
-      if fence_end
-        year = get_latest_git_year(filepath, fence_start + 1, fence_end + 1)
-        changes << {
-          type: :code_block,
-          start: fence_start,
-          end: fence_end,
-          year:,
-        }
-        i = fence_end + 1
-        next
-      end
-    end
-
-    i += 1
-  end
-
-  return if changes.empty? && !has_changes
-
-  # Apply changes in reverse order to preserve line numbers
-  changes.sort_by { |c| -c[:start] }.each do |change|
-    # REUSE-IgnoreStart
-    snippet_begin = "<!-- SPDX-SnippetBegin -->\n<!--\n  SPDX-FileCopyrightText: #{change[:year]} #{COPYRIGHT_HOLDER}\n  SPDX-License-Identifier: #{LICENSE}\n-->\n"
-    snippet_end = "<!-- SPDX-SnippetEnd -->\n"
-    # REUSE-IgnoreEnd
-
-    # Insert end marker after the block
-    lines.insert(change[:end] + 1, snippet_end)
-    # Insert begin marker before the block
-    lines.insert(change[:start], snippet_begin)
-  end
-
-  File.write(filepath, lines.join)
-  puts "Updated: #{filepath} (#{changes.length} code block(s))"
-end
-
-def find_md_files(paths)
-  # Use git ls-files to respect .gitignore
-  if paths.empty?
-    `git ls-files '*.md'`.split("\n")
-  else
-    paths.flat_map do |path|
-      if File.directory?(path)
-        `git ls-files '#{path}/**/*.md'`.split("\n")
-      else
-        path
-      end
-    end
-  end
-end
-
-if __FILE__ == $0
-  paths = ARGV.empty? ? [] : ARGV
-  files = find_md_files(paths)
-
-  files.each do |file|
-    process_file(file)
-  end
-end

data/tasks/license/snippets_rdoc.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#++
-
-# Script to add SPDX snippet headers to RDoc code examples in Ruby files.
-#
-# Usage: ruby scripts/add_spdx_rdoc_snippets.rb [path...]
-#
-# If no paths are given, processes all .rb files via git ls-files.
-#
-# Rules:
-# - Wraps RDoc code examples (indented comment lines) with SPDX snippet headers
-# - Uses #-- and #++ to hide the SPDX headers from RDoc rendering
-# - Uses git blame to determine the latest edit year for the code lines
-# - Skips blocks that are already wrapped with SPDX-SnippetBegin
-
-require "open3"
-require "date"
-
-COPYRIGHT_HOLDER = "Kerrick Long"
-LICENSE = "MIT-0"
-
-def get_latest_git_year(file, start_line, end_line)
-  cmd = %W[git blame -L #{start_line},#{end_line} --date=short -- #{file}]
-  output, _status = Open3.capture2(*cmd)
-  years = output.scan(/(\d{4})-\d{2}-\d{2}/).flatten.map(&:to_i)
-  years.empty? ? Date.today.year : years.max
-end
-
-def find_rdoc_code_blocks(lines)
-  # Find all RDoc code blocks (indented comment lines)
-  # Returns array of {start:, end:, indent:} where indent is the comment prefix
-  blocks = []
-  i = 0
-
-  while i < lines.length
-    line = lines[i]
-
-    # Check if this is an indented code line in a comment
-    # Pattern: optional leading whitespace, #, then 3+ spaces (RDoc code indent)
-    if line =~ /^(\s*)#(   +)(\S.*)$/
-      prefix = $1 # leading whitespace before #
-      block_start = i
-
-      # Find the extent of this code block
-      j = i
-      while j < lines.length
-        current = lines[j]
-        # Code block continues if line is indented code OR empty comment line
-        if current =~ /^#{Regexp.escape(prefix)}#(   +|\s*$)/
-          j += 1
-        else
-          break
-        end
-      end
-
-      block_end = j - 1
-
-      # Only count as a block if it has actual code (not just empty lines)
-      has_code = (block_start..block_end).any? { |k| lines[k] =~ /^#{Regexp.escape(prefix)}#   +\S/ }
-
-      if has_code && block_end > block_start
-        blocks << { start: block_start, end: block_end, prefix: }
-      end
-
-      i = j
-    else
-      i += 1
-    end
-  end
-
-  blocks
-end
-
-def is_already_wrapped?(lines, block_start, prefix)
-  # Check if the line before the block is #++ (meaning it's already wrapped)
-  return false if block_start < 1
-
-  prev_line = lines[block_start - 1]
-  prev_line =~ /^#{Regexp.escape(prefix)}#\+\+\s*$/
-end
-
-def process_file(filepath)
-  content = File.read(filepath)
-  lines = content.lines
-
-  blocks = find_rdoc_code_blocks(lines)
-
-  # Filter out already-wrapped blocks
-  blocks.reject! { |b| is_already_wrapped?(lines, b[:start], b[:prefix]) }
-
-  return if blocks.empty?
-
-  # Apply changes in reverse order to preserve line numbers
-  blocks.sort_by { |b| -b[:start] }.each do |block|
-    year = get_latest_git_year(filepath, block[:start] + 1, block[:end] + 1)
-    prefix = block[:prefix]
-
-    # Build the wrapper lines
-    # REUSE-IgnoreStart
-    begin_wrapper = [
-      "#{prefix}#--\n",
-      "#{prefix}# SPDX-SnippetBegin\n",
-      "#{prefix}# SPDX-FileCopyrightText: #{year} #{COPYRIGHT_HOLDER}\n",
-      "#{prefix}# SPDX-License-Identifier: #{LICENSE}\n",
-      "#{prefix}#++\n",
-    ]
-
-    end_wrapper = [
-      "#{prefix}#--\n",
-      "#{prefix}# SPDX-SnippetEnd\n",
-      "#{prefix}#++\n",
-    ]
-    # REUSE-IgnoreEnd
-
-    # Insert end wrapper after the block
-    lines.insert(block[:end] + 1, *end_wrapper)
-    # Insert begin wrapper before the block
-    lines.insert(block[:start], *begin_wrapper)
-  end
-
-  File.write(filepath, lines.join)
-  puts "Updated: #{filepath} (#{blocks.length} code block(s))"
-end
-
-def find_rb_files(paths)
-  if paths.empty?
-    `git ls-files '*.rb'`.split("\n")
-  else
-    paths.flat_map do |path|
-      if File.directory?(path)
-        `git ls-files '#{path}/**/*.rb'`.split("\n")
-      else
-        path
-      end
-    end
-  end
-end
-
-if __FILE__ == $0
-  paths = ARGV.empty? ? [] : ARGV
-  files = find_rb_files(paths)
-
-  files.each do |file|
-    process_file(file)
-  end
-end

data/tasks/license.rake

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#++
-
-namespace :license do
-  namespace :headers do
-    desc "Ensure markdown files have correct CC-BY-SA-4.0 headers"
-    task :md, [:files] do |_t, args|
-      files = args[:files] || ""
-      ruby "tasks/license/headers_md.rb #{files}"
-    end
-
-    desc "Ensure Ruby files have correct AGPL-3.0-or-later headers"
-    task :rb, [:files] do |_t, args|
-      files = args[:files] || ""
-      ruby "tasks/license/headers_rb.rb #{files}"
-    end
-
-    desc "Ensure all files have correct license headers"
-    task :all do
-      Rake::Task["license:headers:md"].invoke
-      Rake::Task["license:headers:rb"].invoke
-    end
-  end
-
-  namespace :snippets do
-    desc "Add MIT-0 SPDX snippet headers to markdown fenced code blocks"
-    task :md, [:files] do |_t, args|
-      files = args[:files] || ""
-      ruby "tasks/license/snippets_md.rb #{files}"
-    end
-
-    desc "Add MIT-0 SPDX snippet headers to RDoc code examples in Ruby files"
-    task :rdoc, [:files] do |_t, args|
-      files = args[:files] || "lib/"
-      ruby "tasks/license/snippets_rdoc.rb #{files}"
-    end
-
-    desc "Add MIT-0 SPDX snippet headers to all code examples"
-    task :all do
-      Rake::Task["license:snippets:md"].invoke
-      Rake::Task["license:snippets:rdoc"].invoke
-    end
-  end
-
-  desc "Run all license tasks (headers + snippets)"
-  task all: ["headers:all", "snippets:all"]
-
-  desc "Run license tasks on changed files only (staged + unstaged)"
-  task :new do
-    # Get changed .md and .rb files (staged and unstaged)
-    changed_md = `git diff --name-only --diff-filter=ACMR HEAD -- '*.md' 2>/dev/null`.split("\n")
-    staged_md = `git diff --name-only --cached --diff-filter=ACMR -- '*.md' 2>/dev/null`.split("\n")
-    changed_rb = `git diff --name-only --diff-filter=ACMR HEAD -- '*.rb' 2>/dev/null`.split("\n")
-    staged_rb = `git diff --name-only --cached --diff-filter=ACMR -- '*.rb' 2>/dev/null`.split("\n")
-
-    # Also get untracked new files
-    untracked = `git ls-files --others --exclude-standard`.split("\n")
-    untracked_md = untracked.select { |f| f.end_with?(".md") }
-    untracked_rb = untracked.select { |f| f.end_with?(".rb") }
-
-    md_files = (changed_md + staged_md + untracked_md).uniq.join(" ")
-    rb_files = (changed_rb + staged_rb + untracked_rb).uniq
-
-    # Filter rb files to only lib/
-    lib_rb_files = rb_files.select { |f| f.start_with?("lib/") }.join(" ")
-
-    if md_files.empty? && lib_rb_files.empty?
-      puts "No changed .md or lib/*.rb files to process"
-    else
-      unless md_files.empty?
-        puts "Processing #{md_files.split.count} changed .md file(s)..."
-        Rake::Task["license:headers:md"].invoke(md_files)
-        Rake::Task["license:headers:md"].reenable
-        Rake::Task["license:snippets:md"].invoke(md_files)
-        Rake::Task["license:snippets:md"].reenable
-      end
-
-      unless lib_rb_files.empty?
-        puts "Processing #{lib_rb_files.split.count} changed lib/*.rb file(s)..."
-        Rake::Task["license:headers:rb"].invoke(lib_rb_files)
-        Rake::Task["license:headers:rb"].reenable
-        Rake::Task["license:snippets:rdoc"].invoke(lib_rb_files)
-        Rake::Task["license:snippets:rdoc"].reenable
-      end
-    end
-  end
-end