ratatui_ruby-devtools 0.2.1 → 0.4.0

data/lib/ratatui_ruby/devtools/tasks/license/headers_md.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#++
-
-# Ensures markdown files have correct SPDX headers.
-#
-# Open source projects need license headers in every file. REUSE compliance
-# requires SPDX format. Adding and updating these headers by hand is tedious.
-# Years drift. Contributors are forgotten.
-#
-# This script processes markdown files. It adds CC-BY-SA-4.0 headers where
-# missing. It updates copyright years based on git history. It preserves
-# existing contributors.
-#
-# Run it as part of license:headers:md rake task.
-#
-# === Example
-#
-#   ruby tasks/license/headers_md.rb README.md
-#   ruby tasks/license/headers_md.rb doc/
-#   ruby tasks/license/headers_md.rb  # all .md 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 for copyright headers.
-YOUR_NAME = "Kerrick Long"
-
-# Your email for copyright headers.
-YOUR_EMAIL = "me@kerricklong.com"
-
-# Identifiers used to match your contributions in git history.
-YOUR_IDENTIFIERS = [YOUR_NAME, YOUR_EMAIL].freeze
-
-# Full copyright string for headers.
-YOUR_COPYRIGHT = "#{YOUR_NAME} <#{YOUR_EMAIL}>"
-
-# The SPDX license identifier for markdown documentation.
-LICENSE = "CC-BY-SA-4.0"
-
-# Identifies fenced code blocks in markdown content.
-#
-# Copyright years come from git blame. Code blocks contain pasted content,
-# not original prose. Blaming code block lines produces wrong contributors.
-# Exclude these ranges when calculating copyright years.
-#
-# [lines] Array of line strings from the file.
-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
-
-# Calculates line ranges outside code blocks.
-#
-# Copyright years come from git blame. Blaming the entire file includes code
-# blocks. This function returns only prose ranges for accurate year lookup.
-#
-# [lines] Array of line strings from the file.
-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
-
-# Extracts existing SPDX header from markdown content.
-#
-# Files may already have headers. Updating requires parsing existing copyright
-# holders and years. This extracts them for comparison and update.
-#
-# [lines] Array of line strings from the file.
-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
-
-# Updates or adds SPDX headers for a single markdown file.
-#
-# Each file needs correct CC-BY-SA-4.0 headers with accurate copyright years.
-# Processing involves reading, parsing, querying git, and rewriting. This
-# function orchestrates that workflow.
-#
-# [filepath] Path to the markdown file.
-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
-
-# Finds markdown files to process.
-#
-# License automation runs on file sets. Users may specify paths or want all
-# files. This handles both cases using git ls-files for tracking.
-#
-# [paths] Explicit paths to process, or empty for all tracked .md files.
-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/lib/ratatui_ruby/devtools/tasks/license/headers_rb.rb

@@ -1,236 +0,0 @@
-# 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}>"
-
-# Selects the appropriate license based on file location.
-#
-# Different parts of the codebase have different licenses. Library code is
-# LGPL. Examples are MIT-0 or AGPL. This function routes files to their
-# correct license by path pattern.
-#
-# [filepath] Path to the Ruby file.
-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
-
-# Extracts existing SPDX header from Ruby file content.
-#
-# Files may already have headers. Updating requires parsing existing copyright
-# holders and years. This extracts them for comparison and update.
-#
-# [lines] Array of line strings from the file.
-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
-
-# Updates or adds SPDX headers for a single Ruby file.
-#
-# Each file needs correct license headers with accurate copyright years.
-# Processing involves reading, parsing, querying git, and rewriting. This
-# function orchestrates that workflow.
-#
-# [filepath] Path to the Ruby file.
-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
-
-# Finds Ruby files to process.
-#
-# License automation runs on file sets. Users may specify paths or want all
-# lib/ext/test files. This handles both cases using git ls-files for tracking.
-#
-# [paths] Explicit paths to process, or empty for default directories.
-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/lib/ratatui_ruby/devtools/tasks/license/license_utils.rb

@@ -1,143 +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"
-
-# Extracts contributor information from git history.
-#
-# License headers need accurate copyright years and contributor names. Git
-# blame provides line-level authorship. Commit messages contain Co-Authored-By
-# trailers. Combining these sources manually is tedious.
-#
-# This module queries git blame and parses commit messages. It returns
-# contributor names with their latest modification years. Use it when
-# generating or updating SPDX headers.
-module LicenseUtils
-  # A contributor with their latest modification year.
-  #
-  # [name] The contributor's display name.
-  # [email] The contributor's email address.
-  # [year] The most recent year they modified the file.
-  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