ratatui_ruby 0.8.0 → 0.9.0

data/tasks/license/headers_md.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Script to ensure markdown files have correct SPDX file headers (CC-BY-SA-4.0).
+#
+# Usage: ruby tasks/license/headers_md.rb [path...]
+#
+# If no paths are given, processes all .md files via git ls-files.
+#
+# Rules:
+# - Ensures file has CC-BY-SA-4.0 license header with YOUR copyright
+# - Updates years for EXISTING contributors based on git blame + Co-Authored-By
+# - Does NOT add new contributors from git history - only updates existing ones
+# - Uses non-code-block lines for year calculation
+# - Adds header with YOUR copyright if missing
+
+require_relative "license_utils"
+
+YOUR_NAME = "Kerrick Long"
+YOUR_EMAIL = "me@kerricklong.com"
+YOUR_IDENTIFIERS = [YOUR_NAME, YOUR_EMAIL].freeze
+YOUR_COPYRIGHT = "#{YOUR_NAME} <#{YOUR_EMAIL}>"
+LICENSE = "CC-BY-SA-4.0"
+
+def find_code_blocks(lines)
+  blocks = []
+  i = 0
+
+  while i < lines.length
+    line = lines[i]
+
+    if line =~ /^(````*)(\w*)$/
+      fence_marker = $1
+      fence_start = i
+      re_end = /^#{Regexp.escape(fence_marker)}$/
+
+      j = i + 1
+      while j < lines.length
+        if lines[j] =~ re_end
+          blocks << { start: fence_start, end: j }
+          i = j
+          break
+        end
+        j += 1
+      end
+    end
+
+    i += 1
+  end
+
+  blocks
+end
+
+def get_non_code_line_ranges(lines)
+  header_end = 0
+  if lines[0]&.include?("<!--")
+    (0...(lines.length)).each do |i|
+      if lines[i].include?("-->")
+        header_end = i + 1
+        break
+      end
+    end
+  end
+
+  code_blocks = find_code_blocks(lines)
+  non_code_ranges = []
+  current_line = header_end
+
+  code_blocks.each do |block|
+    if current_line < block[:start]
+      non_code_ranges << [current_line + 1, block[:start]]
+    end
+    current_line = block[:end] + 1
+  end
+
+  if current_line < lines.length
+    non_code_ranges << [current_line + 1, lines.length]
+  end
+
+  non_code_ranges
+end
+
+def parse_existing_header(lines)
+  return nil unless lines[0]&.include?("<!--")
+
+  header_end = nil
+  copyrights = []
+  license = nil
+
+  (0...(lines.length)).each do |i|
+    line = lines[i]
+
+    if line =~ /SPDX-FileCopyrightText:\s*(\d{4})\s+(.+)$/
+      copyrights << { year: $1.to_i, holder: $2.strip }
+    # REUSE-IgnoreStart
+    elsif line =~ /SPDX-License-Identifier:\s*(.+)$/
+      # REUSE-IgnoreEnd
+      license = $1.strip
+    end
+
+    if line.include?("-->")
+      header_end = i
+      break
+    end
+  end
+
+  return nil if header_end.nil?
+  return nil if copyrights.empty? && license.nil?
+
+  { end_line: header_end, copyrights:, license: }
+end
+
+def process_file(filepath)
+  content = File.read(filepath)
+  lines = content.lines
+
+  non_code_ranges = get_non_code_line_ranges(lines)
+
+  # Get contributors from non-code lines for year lookups
+  all_contributors = {}
+  non_code_ranges.each do |start_line, end_line|
+    range_contributors = LicenseUtils.get_contributors_for_lines(filepath, start_line, end_line)
+    range_contributors.each do |contributor, year|
+      all_contributors[contributor] = [all_contributors[contributor] || 0, year].max
+    end
+  end
+
+  your_year = nil
+  all_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
+
+  existing = parse_existing_header(lines)
+
+  if existing
+    # Only update years for EXISTING contributors
+    needs_update = false
+    updated_copyrights = []
+
+    existing[:copyrights].each do |c|
+      git_year = nil
+      all_contributors.each do |contributor, year|
+        if c[:holder].split.any? { |word| contributor.include?(word) }
+          git_year = [git_year || 0, year].max
+        end
+      end
+
+      if git_year && git_year != c[:year]
+        puts "  Updated #{c[:holder].split.first}'s copyright year: #{c[:year]} -> #{git_year}"
+        updated_copyrights << { year: git_year, holder: c[:holder] }
+        needs_update = true
+      else
+        updated_copyrights << c
+      end
+    end
+
+    # Check if YOUR year needs updating
+    your_existing = updated_copyrights.find { |c| YOUR_IDENTIFIERS.any? { |id| c[:holder].include?(id) } }
+    if your_existing.nil?
+      puts "  Adding your copyright"
+      updated_copyrights << { year: your_year, holder: YOUR_COPYRIGHT }
+      needs_update = true
+    end
+
+    if existing[:license] != LICENSE
+      puts "  Fixing license: #{existing[:license]} -> #{LICENSE}"
+      needs_update = true
+    end
+
+    if needs_update
+      # REUSE-IgnoreStart
+      header_lines = ["<!--\n"]
+      updated_copyrights.each do |c|
+        header_lines << "  SPDX-FileCopyrightText: #{c[:year]} #{c[:holder]}\n"
+      end
+      header_lines << "  SPDX-License-Identifier: #{LICENSE}\n"
+      header_lines << "-->\n"
+      # REUSE-IgnoreEnd
+
+      remaining = lines[(existing[:end_line] + 1)..]
+      File.write(filepath, header_lines.join + remaining.join)
+      puts "Updated: #{filepath}"
+    end
+  else
+    # No header - add one with YOUR copyright only
+    # REUSE-IgnoreStart
+    header = "<!--\n  SPDX-FileCopyrightText: #{your_year} #{YOUR_COPYRIGHT}\n  SPDX-License-Identifier: #{LICENSE}\n-->\n"
+    # REUSE-IgnoreEnd
+
+    File.write(filepath, header + content)
+    puts "Added header: #{filepath}"
+  end
+end
+
+def find_md_files(paths)
+  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/headers_rb.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Script to ensure Ruby files have correct SPDX file headers.
+#
+# Usage: ruby tasks/license/headers_rb.rb [path...]
+#
+# If no paths are given, processes lib/, ext/, test/, examples/, tasks/, bin/.
+#
+# License selection by directory:
+# - lib/, ext/, test/ → LGPL-3.0-or-later
+# - examples/widget_*, examples/verify_* → MIT-0
+# - examples/app_*, tasks/, bin/ → AGPL-3.0-or-later
+
+require_relative "license_utils"
+
+YOUR_NAME = "Kerrick Long"
+YOUR_EMAIL = "me@kerricklong.com"
+YOUR_IDENTIFIERS = [YOUR_NAME, YOUR_EMAIL].freeze
+YOUR_COPYRIGHT = "#{YOUR_NAME} <#{YOUR_EMAIL}>"
+
+def license_for_file(filepath)
+  case filepath
+  when %r{^(lib|sig/ratatui_ruby|ext|test)/}
+    "LGPL-3.0-or-later"
+  when %r{^(examples|sig/examples)/(widget_|verify_)}
+    "MIT-0"
+  else
+    "AGPL-3.0-or-later"
+  end
+end
+
+def parse_existing_header(lines)
+  # Returns { end_line:, copyrights: [{year:, holder:}], license: }
+  # REUSE-IgnoreStart
+  # Ruby files typically have:
+  #   # frozen_string_literal: true
+  #   (blank line)
+  #   #--
+  #   # SPDX-FileCopyrightText: YYYY Name
+  #   # SPDX-License-Identifier: LICENSE
+  #   #++
+  # REUSE-IgnoreEnd
+
+  copyrights = []
+  license = nil
+  header_end = nil
+  found_spdx = false
+
+  lines.each_with_index do |line, i|
+    if line =~ /^#\s*SPDX-FileCopyrightText:\s*(\d{4})\s+(.+)$/
+      copyrights << { year: $1.to_i, holder: $2.strip }
+      found_spdx = true
+    # REUSE-IgnoreStart
+    elsif line =~ /^#\s*SPDX-License-Identifier:\s*(.+)$/
+      # REUSE-IgnoreEnd
+      license = $1.strip
+      found_spdx = true
+    elsif line =~ /^#\+\+\s*$/ && found_spdx
+      header_end = i
+      break
+    end
+  end
+
+  return nil if copyrights.empty? && license.nil?
+
+  { end_line: header_end || 0, copyrights:, license: }
+end
+
+def process_file(filepath)
+  content = File.read(filepath)
+  lines = content.lines
+
+  target_license = license_for_file(filepath)
+
+  # Get contributors from git for year lookups
+  all_contributors = LicenseUtils.get_contributors_for_lines(filepath)
+  your_year = LicenseUtils.get_your_latest_year(filepath, YOUR_IDENTIFIERS)
+
+  existing = parse_existing_header(lines)
+
+  if existing
+    # File has existing header - only update years for EXISTING contributors
+    needs_update = false
+    updated_copyrights = []
+
+    existing[:copyrights].each do |c|
+      # Find this contributor's latest year from git
+      git_year = nil
+      all_contributors.each do |contributor, year|
+        if c[:holder].split.any? { |word| contributor.include?(word) }
+          git_year = [git_year || 0, year].max
+        end
+      end
+
+      if git_year && git_year != c[:year]
+        puts "  Updated #{c[:holder].split.first}'s copyright year: #{c[:year]} -> #{git_year}"
+        updated_copyrights << { year: git_year, holder: c[:holder] }
+        needs_update = true
+      else
+        updated_copyrights << c
+      end
+    end
+
+    # Check if YOUR year needs updating (if you're a contributor)
+    your_existing = updated_copyrights.find { |c| YOUR_IDENTIFIERS.any? { |id| c[:holder].include?(id) } }
+    if your_existing.nil?
+      puts "  Adding your copyright"
+      updated_copyrights << { year: your_year, holder: YOUR_COPYRIGHT }
+      needs_update = true
+    end
+
+    # Check license
+    if existing[:license] != target_license
+      puts "  Fixing license: #{existing[:license]} -> #{target_license}"
+      needs_update = true
+    end
+
+    if needs_update
+      frozen_string = lines[0].include?("frozen_string_literal") ? lines[0] : nil
+
+      header_lines = []
+      header_lines << "# frozen_string_literal: true\n" unless frozen_string
+      header_lines << "\n" if frozen_string.nil? && !lines[0].strip.empty?
+      header_lines << "#--\n"
+
+      # REUSE-IgnoreStart
+      updated_copyrights.each do |c|
+        header_lines << "# SPDX-FileCopyrightText: #{c[:year]} #{c[:holder]}\n"
+      end
+      header_lines << "# SPDX-License-Identifier: #{target_license}\n"
+      # REUSE-IgnoreEnd
+      header_lines << "#++\n"
+
+      content_start = existing[:end_line] + 1
+      while content_start < lines.length && lines[content_start].strip.empty?
+        content_start += 1
+      end
+
+      remaining = lines[content_start..]
+
+      new_content = if frozen_string
+        "#{frozen_string}\n#{header_lines.join}\n#{remaining.join}"
+      else
+        "#{header_lines.join}\n#{remaining.join}"
+      end
+
+      File.write(filepath, new_content)
+      puts "Updated: #{filepath}"
+    end
+  else
+    # No header - add one with YOUR copyright only
+    frozen_line = lines[0]&.include?("frozen_string_literal") ? lines.shift : nil
+
+    header = []
+    header << "# frozen_string_literal: true\n\n" unless frozen_line
+    header << "#--\n"
+    # REUSE-IgnoreStart
+    header << "# SPDX-FileCopyrightText: #{your_year} #{YOUR_COPYRIGHT}\n"
+    header << "# SPDX-License-Identifier: #{target_license}\n"
+    # REUSE-IgnoreEnd
+    header << "#++\n\n"
+
+    if frozen_line
+      File.write(filepath, "#{frozen_line}\n#{header.join}#{lines.join}")
+    else
+      File.write(filepath, header.join + lines.join)
+    end
+    puts "Added header: #{filepath}"
+  end
+end
+
+def find_rb_files(paths)
+  if paths.empty?
+    # Process all relevant directories
+    dirs = %w[lib ext test examples tasks bin sig]
+    files = dirs.flat_map do |dir|
+      # Include both root files and subdirectory files, for both .rb and .rbs
+      %w[rb rbs].flat_map do |ext|
+        root_files = `git ls-files '#{dir}/*.#{ext}' 2>/dev/null`.split("\n")
+        sub_files = `git ls-files '#{dir}/**/*.#{ext}' 2>/dev/null`.split("\n")
+        root_files + sub_files
+      end
+    end
+    files.uniq
+  else
+    paths.flat_map do |path|
+      if File.directory?(path)
+        rb_files = `git ls-files '#{path}/**/*.rb'`.split("\n")
+        rbs_files = `git ls-files '#{path}/**/*.rbs'`.split("\n")
+        rb_files + rbs_files
+      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/license_utils.rb

@@ -0,0 +1,130 @@
+# 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