ratatui_ruby-devtools 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57fc1bc3e22f7db96b7434687a5ba68ebd2e791af094ca8c7b0fa93046c0c8e0
-  data.tar.gz: ce0771ddec4a189df1e9ec5de19a9bc2fad461b6265575380d1c15a8120e6939
+  metadata.gz: 7c9a5440c5c524c14e18b914b7d5666c97f0e65384aac9952e5b8051d4459b44
+  data.tar.gz: f13332c056f0fd2becec90b040fc4f57c170e692efded028f9d49390874711c0
 SHA512:
-  metadata.gz: ee73b0da8bbe0f1ae17c266f7320a6795036e7c8e9a2b9c2c0ecb2f4c125a788a319ed475a76e759e7531805fdafda9372ec6dd20baed006dc95fe95b00fc8a4
-  data.tar.gz: 14d72b6a59018d202eba6e175d4cf8716a4c42791ac759402a6367b23168fe6d6678e2199384cf34269b6d67899d7610ee19c0c8c73f6b5238b8506b28cebc72
+  metadata.gz: fec0e188fc6ff2f9386c571f942e4838d855212dbdc9d18763fc4aca146ea07f742cf1f9867c1e74d0024ab907bd4c4821d6a2d42233166b6cdf65b10943abc9
+  data.tar.gz: 5e81a6e80457bd82db93223473b0091b7746f162f6669c88a23df40c1efecd5e951818554840f7120317fec0edc2368f37b8b31142a6210ac09009b02153ce1c

data/CHANGELOG.md

@@ -21,6 +21,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [0.4.1] - 2026-10-24
+
+### Added
+
+### Changed
+
+### Fixed
+
+- **Year ranges in copyright notices were misread**: A notice with a range of years, such as `2016-2022 Jane Doe`, didn't count as a notice. A license header kept it but added a second notice for the same holder, and a snippet's renewed tags dropped it. A range now renews from its end, as in `2016-2024 Jane Doe`.
+- **Snippet tasks relicensed quoted code**: `rake license:snippets:all` rewrapped a Markdown snippet under any license but MIT-0 as yours, and relicensed an RDoc one MIT-0, though a license like MIT requires keeping the quoted authors' notices. Such snippets now keep their notices and license.
+- **Incomplete Markdown snippets lost their notices**: `rake license:snippets:md` rewrapped a Markdown snippet missing its license or copyright tag from git blame, dropping notices git can't see, such as code a contributor brought from elsewhere. It now completes the snippet's tags in place, as it already did for RDoc examples.
+- **Stray comments after renewing Markdown snippets**: Renewing a Markdown snippet whose tags share one comment with `SPDX-SnippetBegin` left a stray `<!--` above the new wrapper. A snippet with a comment for each tag was rewrapped, leaving its old copyright comment behind. Both now renew in place.
+
+### Removed
+
 ## [0.4.0] - 2026-10-23
 
 ### Added
@@ -156,6 +171,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Removed
 
 [Unreleased]: https://github.com/setdef/ratatui_ruby-devtools/tree/HEAD
+[0.4.1]: https://github.com/setdef/ratatui_ruby-devtools/releases/tag/v0.4.1
 [0.4.0]: https://github.com/setdef/ratatui_ruby-devtools/releases/tag/v0.4.0
 [0.3.0]: https://github.com/setdef/ratatui_ruby-devtools/releases/tag/v0.3.0
 [0.2.1]: https://github.com/setdef/ratatui_ruby-devtools/releases/tag/v0.2.1

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

@@ -8,7 +8,22 @@
 require "date"
 require_relative "renewal"
 
-class Copyright < Data.define(:year, :holder) # :nodoc:
+# A notice's year is its latest. A range keeps the year it starts from, which
+# is +since+.
+class Copyright < Data.define(:year, :holder, :since) # :nodoc:
+  # Non-capturing, because the syntaxes read the holder from the group after
+  # it.
+  YEARS = /\d{4}(?:\s*-\s*\d{4})?/
+
+  def initialize(year:, holder:, since: nil)
+    super
+  end
+
+  def self.parse(years, holder)
+    since, year = years.scan(/\d{4}/).map(&:to_i).minmax
+    new(year:, holder: holder.strip, since: (since if since < year))
+  end
+
   def self.of(contribution)
     new(year: contribution.year, holder: contribution.author.to_s)
   end
@@ -42,6 +57,10 @@ class Copyright < Data.define(:year, :holder) # :nodoc:
   end
 
   def to_s
-    "#{year} #{holder}"
+    if since
+      "#{since}-#{year} #{holder}"
+    else
+      "#{year} #{holder}"
+    end
   end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+require_relative "snippet"
+
+# An HTML comment in a Markdown document, from the line it opens on to the
+# line it closes on, counting from 0.
+class MarkdownComment < Data.define(:first, :last, :text) # :nodoc:
+  def span
+    first..last
+  end
+
+  def holds_line?(index)
+    index.between?(first, last)
+  end
+
+  # SPDX tags that go with a wrapper's SnippetBegin, rather than opening or
+  # closing a wrapper of their own.
+  def tags?
+    text.include?("SPDX-") && !text.include?(Snippet::BEGIN_TAG) && !text.include?(Snippet::END_TAG)
+  end
+end

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

@@ -5,6 +5,8 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
+require_relative "markdown_comment"
+
 class MarkdownDocument < Data.define(:lines) # :nodoc:
   FENCE = /^(````*)\w*$/
 
@@ -12,6 +14,32 @@ class MarkdownDocument < Data.define(:lines) # :nodoc:
     lines[index].match?(FENCE)
   end
 
+  def comment_opens?(index)
+    lines.fetch(index, "").include?("<!--")
+  end
+
+  def comment_at(index)
+    last = comment_close(index)
+    MarkdownComment.new(first: index, last:, text: lines[index..last].join)
+  end
+
+  # The comment that line +index+ sits in, which can open on a line above it.
+  # A line in no comment stands alone, so prose after it stays out.
+  def comment_around(index)
+    first = index.downto(0).find { |earlier| comment_opens?(earlier) }
+    comment = first && comment_at(first)
+    if comment&.holds_line?(index)
+      comment
+    else
+      MarkdownComment.new(first: index, last: index, text: lines[index])
+    end
+  end
+
+  # The comment that opens on the line after +comment+ closes, if one does.
+  def comment_after(comment)
+    comment_at(comment.last + 1) if comment_opens?(comment.last + 1)
+  end
+
   # The line that closes the fence opening at +index+, when one does.
   def fence_end(index)
     marker = lines[index][FENCE, 1]
@@ -20,4 +48,9 @@ class MarkdownDocument < Data.define(:lines) # :nodoc:
     closing = /^#{Regexp.escape(marker)}$/
     (index + 1).upto(lines.length - 1).find { |later| lines[later].match?(closing) }
   end
+
+  # A comment that never closes runs to the end of the document.
+  private def comment_close(index)
+    index.upto(lines.length - 1).find { |later| lines[later].include?("-->") } || (lines.length - 1)
+  end
 end

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

@@ -15,7 +15,7 @@ require_relative "spdx_header"
 class MarkdownHeaderSyntax # :nodoc:
   LICENSE = "CC-BY-SA-4.0"
   # REUSE-IgnoreStart
-  COPYRIGHT = /SPDX-FileCopyrightText:\s*(\d{4})\s+(.+)$/
+  COPYRIGHT = /SPDX-FileCopyrightText:\s*(#{Copyright::YEARS})\s+(.+)$/
   LICENSE_LINE = /SPDX-License-Identifier:\s*(.+)$/
   # REUSE-IgnoreEnd
 
@@ -46,7 +46,7 @@ class MarkdownHeaderSyntax # :nodoc:
     return MissingHeader.new unless closing
 
     comment = lines[..closing]
-    copyrights = comment.grep(COPYRIGHT) { Copyright.new(year: $1.to_i, holder: $2.strip) }
+    copyrights = comment.grep(COPYRIGHT) { Copyright.parse($1, $2) }
     license = comment.grep(LICENSE_LINE) { $1.strip }.last
     return MissingHeader.new unless copyrights.any? || license
 

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

@@ -29,31 +29,37 @@ class MarkdownSnippetSyntax # :nodoc:
     LICENSE
   end
 
-  # Without the wrappers that don't license their code MIT-0, so the code they
-  # held can be wrapped again, and with the copyright notices of the rest
-  # under the snippet tag.
-  def cleaned(lines)
-    _, removals = scan(lines, first_pass: true)
-    lines = lines.dup
-    removals.sort_by { |first, _| -first }.each do |first, last|
-      lines.delete_at(last)
-      (opening_end(lines, first) - first + 1).times { lines.delete_at(first) }
-    end
-    lines.each_index.select { |index| lines[index].include?("SPDX-SnippetBegin") }.each do |first|
-      first.upto(opening_end(lines, first)) { |index| lines[index] = Snippet.tag(lines[index]) }
-    end
-    lines
-  end
-
+  # A wrapper with no end leaves the rest of the document alone.
   def snippets_in(lines)
-    regions, = scan(lines, first_pass: false)
-    regions
+    document = MarkdownDocument.new(lines)
+    snippets = []
+    index = 0
+    while index < lines.length
+      if lines[index].include?(Snippet::BEGIN_TAG)
+        finish = index.upto(lines.length - 1).find { |later| lines[later].include?(Snippet::END_TAG) }
+        return snippets unless finish
+
+        closing = document.comment_around(finish).span
+        snippets.concat(wrapped_at(lines, document, document.comment_around(index).first, closing))
+        index = closing.last + 1
+        next
+      end
+
+      region = sync_region(lines, document, index) || fence_region(document, index)
+      if region
+        snippets << region
+        index = region.last + 1
+      else
+        index += 1
+      end
+    end
+    snippets
   end
 
   def opening(_snippet, copyrights)
     # REUSE-IgnoreStart
     [
-      "<!-- SPDX-SnippetBegin -->\n",
+      "<!-- #{Snippet::BEGIN_TAG} -->\n",
       "<!--\n",
       *copyrights.map { |copyright| "  #{Snippet::COPYRIGHT_TAG}: #{copyright}\n" },
       "  SPDX-License-Identifier: #{LICENSE}\n",
@@ -63,64 +69,26 @@ class MarkdownSnippetSyntax # :nodoc:
   end
 
   def closing(_snippet)
-    # REUSE-IgnoreStart
-    ["<!-- SPDX-SnippetEnd -->\n"]
-    # REUSE-IgnoreEnd
+    ["<!-- #{Snippet::END_TAG} -->\n"]
   end
 
-  # The last line of the opening wrapper at +first+. A SnippetBegin comment
-  # that closes on its own line is followed by the comment holding the SPDX
-  # tags, which goes with it.
-  private def opening_end(lines, first)
-    start = tags_follow?(lines, first) ? first + 1 : first
-    start.upto(lines.length - 1).find { |index| lines[index].include?("-->") } || (lines.length - 1)
-  end
-
-  private def tags_follow?(lines, first)
-    lines[first].include?("-->") && lines[first + 1]&.include?("<!--")
-  end
-
-  # A wrapper from its SnippetBegin to its SnippetEnd, with the code between
-  # its opening tags and its end.
-  private def wrapped_region(lines, first, finish)
-    opening = SnippetOpening.in(lines, first, opening_end(lines, first))
-    return if opening.last + 1 > finish - 1
-
-    WrappedSnippet.new(snippet: Snippet.around(first, finish, code: [opening.last + 1, finish - 1]), opening:)
+  # The last line of the opening at +first+: the comment holding its
+  # SnippetBegin, then each comment after it holding tags, whether one holds
+  # them all or each tag has its own.
+  private def opening_end(document, first)
+    comment = document.comment_at(first)
+    while (tags = document.comment_after(comment))&.tags?
+      comment = tags
+    end
+    comment.last
   end
 
-  # The first pass leaves MIT-0 wrappers alone and marks the rest for
-  # removal. The second, after removal, reports the wrappers left with their
-  # openings.
-  private def scan(lines, first_pass:)
-    document = MarkdownDocument.new(lines)
-    regions = []
-    removals = []
-    index = 0
-    while index < lines.length
-      if lines[index].include?("SPDX-SnippetBegin")
-        finish = index.upto(lines.length - 1).find { |later| lines[later].include?("SPDX-SnippetEnd") }
-        if !first_pass
-          wrapped = wrapped_region(lines, index, finish) if finish
-          regions << wrapped if wrapped
-          index = (finish || lines.length) + 1
-          next
-        elsif finish
-          removals << [index, finish] unless licensed?(lines, index)
-          index = finish + 1
-          next
-        end
-      end
-
-      region = sync_region(lines, document, index) || fence_region(document, index)
-      if region
-        regions << region
-        index = region.last + 1
-      else
-        index += 1
-      end
-    end
-    [regions, removals]
+  # The wrapper opening at +first+ and closing on the lines of +closing+. One
+  # around nothing has no code to credit, so it stays as it is.
+  private def wrapped_at(lines, document, first, closing)
+    opening = SnippetOpening.in(lines, first, opening_end(document, first))
+    snippet = Snippet.around(opening.last + 1, closing.first - 1)
+    snippet.empty? ? [] : [WrappedSnippet.found(snippet:, opening:, closing:, license: LICENSE)]
   end
 
   private def sync_region(lines, document, start)
@@ -146,14 +114,4 @@ class MarkdownSnippetSyntax # :nodoc:
     finish = document.fence_end(start)
     Snippet.around(start, finish) if finish
   end
-
-  # A wrapper that already credits someone under MIT-0 stays, whoever it
-  # credits.
-  private def licensed?(lines, begin_line)
-    tags = lines[(begin_line + 1)..].take_while { |line| !line.include?("-->") }
-    # REUSE-IgnoreStart
-    tags.any? { |line| line.include?(Snippet::COPYRIGHT_TAG) || line.include?(Snippet::FILE_COPYRIGHT_TAG) } &&
-      tags.any? { |line| line.include?(LICENSE) && line.include?("SPDX-License-Identifier") }
-    # REUSE-IgnoreEnd
-  end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Code quoted from elsewhere under its own license, such as MIT, which
+# requires keeping its notices as they are, whatever the code looks like.
+class QuotedSnippet < Data.define(:snippet, :opening) # :nodoc:
+  def first
+    snippet.first
+  end
+
+  def covers?(other)
+    snippet.covers?(other)
+  end
+
+  def around_prose(_contents)
+    self
+  end
+
+  def revise(revision)
+    revision.retag(opening)
+  end
+end

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

@@ -23,30 +23,16 @@ class RdocSnippetSyntax # :nodoc:
     ["*.rb"]
   end
 
-  # Existing wrappers with their copyright notices under the snippet tag,
-  # without the blank lines that once followed their code inside them, and
-  # only around text RDoc shows as code.
-  def cleaned(lines)
-    in_tags = false
-    tagged = lines.map do |line|
-      in_tags = true if line.match?(/^\s*# SPDX-SnippetBegin\s*$/)
-      cleaned_line = in_tags ? Snippet.tag(line) : line
-      in_tags = false if line.match?(/^\s*#\+\+\s*$/)
-      cleaned_line
-    end
-    without_wrappers_around_prose(blanks_after_wrappers(tagged))
-  end
-
   def license
     LICENSE
   end
 
-  # A wrapper marks its own snippet, whatever RDoc makes of the code inside
-  # it. RDoc finds the examples that have no wrapper yet.
+  # RDoc finds the examples, and the ones no wrapper covers are bare.
   def snippets_in(lines)
-    wrapped = wrapped_in(lines)
-    bare = examples(lines).reject { |example| wrapped.any? { |snippet| snippet.covers?(example) } }
-    (wrapped + bare).sort_by(&:first)
+    examples = examples(lines)
+    wrappers = wrapped_in(lines)
+    bare = examples.reject { |example| wrappers.any? { |wrapper| wrapper.covers?(example) } }
+    (wrappers.map { |wrapper| as_read(wrapper, examples) } + bare).sort_by(&:first)
   end
 
   def opening(snippet, copyrights)
@@ -54,7 +40,7 @@ class RdocSnippetSyntax # :nodoc:
     # REUSE-IgnoreStart
     [
       "#{prefix}#--\n",
-      "#{prefix}# SPDX-SnippetBegin\n",
+      "#{prefix}# #{Snippet::BEGIN_TAG}\n",
       *copyrights.map { |copyright| "#{prefix}# #{Snippet::COPYRIGHT_TAG}: #{copyright}\n" },
       "#{prefix}# SPDX-License-Identifier: #{LICENSE}\n",
       "#{prefix}#++\n",
@@ -64,56 +50,50 @@ class RdocSnippetSyntax # :nodoc:
 
   def closing(snippet)
     prefix = snippet.prefix
-    # REUSE-IgnoreStart
     [
       "#{prefix}#--\n",
-      "#{prefix}# SPDX-SnippetEnd\n",
+      "#{prefix}# #{Snippet::END_TAG}\n",
       "#{prefix}#++\n",
     ]
-    # REUSE-IgnoreEnd
   end
 
   private def examples(lines)
     RdocComment.all_in(lines).flat_map(&:examples)
   end
 
-  # The code between each SnippetBegin's #++ and its SnippetEnd's #--.
+  # The wrapper from each SnippetBegin to its SnippetEnd. Its code runs from
+  # the #++ to the last line before the SnippetEnd that isn't a blank comment,
+  # since RDoc ends an example there.
   private def wrapped_in(lines)
     lines.each_index.filter_map do |index|
-      next unless lines[index].match?(/^\s*# SPDX-SnippetBegin\s*$/)
+      next unless lines[index].match?(/^\s*# #{Regexp.escape(Snippet::BEGIN_TAG)}\s*$/)
 
       prefix = lines[index][/\A\s*/]
       opened = (index + 1).upto(lines.length - 1).find { |line| lines[line].match?(/^#{Regexp.escape(prefix)}#\+\+\s*$/) }
-      ended = opened && (opened + 1).upto(lines.length - 1).find { |line| lines[line].match?(/^\s*# SPDX-SnippetEnd\s*$/) }
-      next unless ended && ended - 2 > opened
-
-      snippet = Snippet.around(opened + 1, ended - 2, prefix:)
-      WrappedSnippet.new(snippet:, opening: SnippetOpening.in(lines, index - 1, opened))
+      ended = opened && (opened + 1).upto(lines.length - 1).find { |line| lines[line].match?(/^\s*# #{Regexp.escape(Snippet::END_TAG)}\s*$/) }
+      next unless ended
+
+      code_end = ended - 2
+      code_end -= 1 while code_end > opened && lines[code_end].match?(/^\s*#\s*$/)
+      next unless code_end > opened
+
+      WrappedSnippet.found(
+        snippet: Snippet.around(opened + 1, code_end, prefix:),
+        opening: SnippetOpening.in(lines, index - 1, opened),
+        closing: (ended - 1)..(ended + 1),
+        license: LICENSE
+      )
     end
   end
 
-  # Wrappers once went around every indented comment, list items' text
-  # included. A wrapper whose lines RDoc shows as prose comes off.
-  private def without_wrappers_around_prose(lines)
-    code = examples(lines).map(&:first)
-    prose = wrapped_in(lines).reject { |wrapped| code.include?(wrapped.first) }
-    prose.reverse_each.with_object(lines.dup) do |wrapped, unwrapped|
-      ended = wrapped.snippet.last + 1
-      unwrapped.slice!(ended..(ended + 2))
-      unwrapped.slice!(wrapped.opening.span)
-    end
-  end
-
-  # Blank comment lines after an example aren't part of it, as RDoc reads it.
-  private def blanks_after_wrappers(lines)
-    lines = lines.dup
-    lines.each_index do |index|
-      next unless lines[index].match?(/^\s*#--\s*$/) && lines[index + 1]&.match?(/^\s*# SPDX-SnippetEnd\s*$/)
-
-      first_blank = index
-      first_blank -= 1 while first_blank.positive? && lines[first_blank - 1].match?(/^\s*#\s*$/)
-      lines.insert(first_blank + 3, *lines.slice!(first_blank...index)) if first_blank < index
+  # The wrapper as RDoc reads it. Wrappers once went around every indented
+  # comment, list items' text included, so one that doesn't start at an
+  # example wraps prose.
+  private def as_read(wrapper, examples)
+    if examples.any? { |example| example.first == wrapper.first }
+      wrapper
+    else
+      wrapper.around_prose(examples.select { |example| wrapper.covers?(example) })
     end
-    lines
   end
 end

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

@@ -14,7 +14,7 @@ require_relative "spdx_header"
 # #++ that keep a Ruby header out of the docs.
 module RubyCommentHeader # :nodoc:
   # REUSE-IgnoreStart
-  COPYRIGHT = /^#\s*SPDX-FileCopyrightText:\s*(\d{4})\s+(.+)$/
+  COPYRIGHT = /^#\s*SPDX-FileCopyrightText:\s*(#{Copyright::YEARS})\s+(.+)$/
   LICENSE = /^#\s*SPDX-License-Identifier:\s*(.+)$/
   # REUSE-IgnoreEnd
 
@@ -27,7 +27,7 @@ module RubyCommentHeader # :nodoc:
     lines.each_with_index do |line, index|
       case line
       when COPYRIGHT
-        copyrights << Copyright.new(year: $1.to_i, holder: $2.strip)
+        copyrights << Copyright.parse($1, $2)
         last_tag = index
       when LICENSE
         license = $1.strip

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

@@ -15,7 +15,7 @@ class RustHeaderSyntax # :nodoc:
   include DirectoryLicensing
 
   # REUSE-IgnoreStart
-  COPYRIGHT = %r{^//\s*SPDX-FileCopyrightText:\s*(\d{4})\s+(.+)$}
+  COPYRIGHT = %r{^//\s*SPDX-FileCopyrightText:\s*(#{Copyright::YEARS})\s+(.+)$}
   LICENSE = %r{^//\s*SPDX-License-Identifier:\s*(.+)$}
   # REUSE-IgnoreEnd
 
@@ -34,7 +34,7 @@ class RustHeaderSyntax # :nodoc:
     lines.each_with_index do |line, index|
       case line
       when COPYRIGHT
-        copyrights << Copyright.new(year: $1.to_i, holder: $2.strip)
+        copyrights << Copyright.parse($1, $2)
         last_tag = index
       when LICENSE
         license = $1.strip

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

@@ -9,9 +9,12 @@
 # counting from 0, behind the given comment prefix. Its year comes from the
 # code lines alone, which can sit inside markers the wrapper goes around.
 class Snippet < Data.define(:first, :last, :prefix, :code) # :nodoc:
+  # REUSE-IgnoreStart
+  BEGIN_TAG = "SPDX-SnippetBegin"
+  END_TAG = "SPDX-SnippetEnd"
+
   # REUSE 3.3 requires copyright notices inside a snippet to use the snippet
   # tag. Earlier wrappers used the file tag.
-  # REUSE-IgnoreStart
   COPYRIGHT_TAG = "SPDX-SnippetCopyrightText"
   FILE_COPYRIGHT_TAG = "SPDX-FileCopyrightText"
   # REUSE-IgnoreEnd
@@ -30,12 +33,16 @@ class Snippet < Data.define(:first, :last, :prefix, :code) # :nodoc:
     code.map { |line| line + 1 }
   end
 
-  def lines_in(file_lines)
-    file_lines[first..last]
+  def empty?
+    last < first
   end
 
-  def bare?
-    true
+  def covers?(other)
+    other.first.between?(first, last)
+  end
+
+  def lines_in(file_lines)
+    file_lines[first..last]
   end
 
   def revise(revision)

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

@@ -13,17 +13,22 @@ require_relative "spdx_header"
 # line counting from 0, with the notices they hold.
 class SnippetOpening < Data.define(:first, :last, :header) # :nodoc:
   # REUSE-IgnoreStart
-  COPYRIGHT = /SPDX-(?:Snippet|File)CopyrightText:\s*(\d{4})\s+(.+)$/
+  COPYRIGHT = /SPDX-(?:Snippet|File)CopyrightText:\s*(#{Copyright::YEARS})\s+(.+?)\s*(?:-->)?\s*$/
   LICENSE = /SPDX-License-Identifier:\s*(\S+)/
   # REUSE-IgnoreEnd
 
   def self.in(lines, first, last)
     tags = lines[first..last]
-    copyrights = tags.grep(COPYRIGHT) { Copyright.new(year: $1.to_i, holder: $2.strip) }
+    copyrights = tags.grep(COPYRIGHT) { Copyright.parse($1, $2) }
     license = tags.grep(LICENSE) { $1 }.last
     new(first:, last:, header: SpdxHeader.new(copyrights:, license:))
   end
 
+  # Tags under a license other than +license+ quote someone else's code.
+  def quotes?(license)
+    !header.license.nil? && header.license != license
+  end
+
   def span
     first..last
   end

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

@@ -7,22 +7,22 @@
 
 require_relative "blame"
 require_relative "copyright"
+require_relative "snippet"
 
 # One file's snippets brought up to date: each bare snippet asks to be
-# wrapped, and each wrapped one whose notices have moved on asks to be
-# reopened.
+# wrapped, each wrapped one to be tidied and reopened, and each wrapper that
+# comes off to be removed.
 class SnippetRevision # :nodoc:
   def initialize(path:, text:, syntax:, author:)
     @path = path
     @original = text
     @syntax = syntax
     @author = author
-    @lines = syntax.cleaned(text.lines)
+    @lines = text.lines
     @snippets = syntax.snippets_in(@lines)
     @notices = []
-    # Blame reads the cleaned lines the snippets were found in, not the file
-    # on disk.
-    @blame = Blame.new(path:, contents: @lines.join)
+    @wrapped = 0
+    @blame = Blame.new(path:, contents: text)
   end
 
   # Revises from the last snippet back, so the earlier ones stay on the lines
@@ -44,11 +44,10 @@ class SnippetRevision # :nodoc:
   def messages
     return [] unless changed?
 
-    wrapped = @snippets.count(&:bare?)
-    summary = if wrapped.zero?
+    summary = if @wrapped.zero?
       "Updated: #{@path}"
     else
-      "Updated: #{@path} (#{wrapped} code block(s))"
+      "Updated: #{@path} (#{@wrapped} code block(s))"
     end
     [*@notices.map { |notice| "  #{notice}" }, summary]
   end
@@ -65,6 +64,7 @@ class SnippetRevision # :nodoc:
     copyrights = contributions(snippet).map { |contribution| Copyright.of(contribution) }.sort_by(&:holder)
     @lines.insert(snippet.last + 1, *@syntax.closing(snippet))
     @lines.insert(snippet.first, *@syntax.opening(snippet, copyrights))
+    @wrapped += 1
   end
 
   def reopen(snippet, renewal)
@@ -72,4 +72,21 @@ class SnippetRevision # :nodoc:
     @lines[opening.span] = @syntax.opening(snippet, opening.copyrights)
     @notices.concat(renewal.notices)
   end
+
+  # A wrapper ends right after its code, so blank lines between them move
+  # below it.
+  def close(snippet, closing)
+    after = snippet.last + 1
+    between = @lines[after, closing.first - after]
+    @lines[after, closing.last + 1 - after] = @lines[closing] + between
+  end
+
+  # REUSE 3.3 wants the snippet tag where older wrappers used the file tag.
+  def retag(opening)
+    @lines[opening.span] = @lines[opening.span].map { |line| Snippet.tag(line) }
+  end
+
+  def remove(span)
+    @lines[span] = []
+  end
 end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# A wrapper that comes off, with the snippets it held, which are revised on
+# their own.
+class Unwrapping < Data.define(:opening, :closing, :contents) # :nodoc:
+  def first
+    opening.first
+  end
+
+  def revise(revision)
+    revision.remove(closing)
+    contents.reverse_each { |snippet| snippet.revise(revision) }
+    revision.remove(opening)
+  end
+end

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

@@ -5,25 +5,41 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
-# A Snippet that already has its wrapper, opened by its SnippetOpening.
-class WrappedSnippet < Data.define(:snippet, :opening) # :nodoc:
+require_relative "quoted_snippet"
+require_relative "unwrapping"
+
+# A Snippet that already has its wrapper, opened by its SnippetOpening and
+# closed on the lines of +closing+.
+class WrappedSnippet < Data.define(:snippet, :opening, :closing) # :nodoc:
+  # Quoted code keeps its notices; the rest is ours to renew.
+  def self.found(snippet:, opening:, closing:, license:)
+    if opening.quotes?(license)
+      QuotedSnippet.new(snippet:, opening:)
+    else
+      new(snippet:, opening:, closing:)
+    end
+  end
+
   def first
     snippet.first
   end
 
   def covers?(other)
-    other.first.between?(snippet.first, snippet.last)
+    snippet.covers?(other)
   end
 
   def blame_range
     snippet.blame_range
   end
 
-  def bare?
-    false
+  # One of ours around prose comes off, with the examples it held.
+  def around_prose(contents)
+    Unwrapping.new(opening: opening.span, closing:, contents:)
   end
 
   def revise(revision)
+    revision.close(snippet, closing)
+    revision.retag(opening)
     renewal = opening.renewal(revision.contributions(self), revision.license)
     revision.reopen(snippet, renewal) if renewal.changed?
   end

data/lib/ratatui_ruby/devtools/version.rb

@@ -8,6 +8,6 @@
 module RatatuiRuby
   module Devtools
     # Current version of the ratatui_ruby-devtools gem.
-    VERSION = "0.4.0"
+    VERSION = "0.4.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratatui_ruby-devtools
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Kerrick Long
@@ -220,11 +220,13 @@ files:
 - lib/ratatui_ruby/devtools/tasks/license/header_revision.rb
 - lib/ratatui_ruby/devtools/tasks/license/licensed_file.rb
 - lib/ratatui_ruby/devtools/tasks/license/licensing.rb
+- lib/ratatui_ruby/devtools/tasks/license/markdown_comment.rb
 - lib/ratatui_ruby/devtools/tasks/license/markdown_document.rb
 - lib/ratatui_ruby/devtools/tasks/license/markdown_files.rb
 - lib/ratatui_ruby/devtools/tasks/license/markdown_header_syntax.rb
 - lib/ratatui_ruby/devtools/tasks/license/markdown_snippet_syntax.rb
 - lib/ratatui_ruby/devtools/tasks/license/missing_header.rb
+- lib/ratatui_ruby/devtools/tasks/license/quoted_snippet.rb
 - lib/ratatui_ruby/devtools/tasks/license/rbs_files.rb
 - lib/ratatui_ruby/devtools/tasks/license/rbs_header_syntax.rb
 - lib/ratatui_ruby/devtools/tasks/license/rdoc_comment.rb
@@ -245,6 +247,7 @@ files:
 - lib/ratatui_ruby/devtools/tasks/license/spdx_header.rb
 - lib/ratatui_ruby/devtools/tasks/license/unknown_file.rb
 - lib/ratatui_ruby/devtools/tasks/license/unlicensed_files.rb
+- lib/ratatui_ruby/devtools/tasks/license/unwrapping.rb
 - lib/ratatui_ruby/devtools/tasks/license/wrapped_snippet.rb
 - lib/ratatui_ruby/devtools/tasks/license_tasks.rb
 - lib/ratatui_ruby/devtools/tasks/lint/gem_lockfile.rb