reverse_markdown 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d374ce991c236ccd344ef88d17531e3dc845bc4eb76015f5237f2646be1b3b66
-  data.tar.gz: 3bb3e85c76d512647fe7c70f983b22113775c2ab02bc7410dec85cfd06c46cb8
+  metadata.gz: df79f3321ee1b7803fbb6a3b6ab689e5dd6ca149eb1398c4fb3c40f62e33342f
+  data.tar.gz: e33b4305f00468791b28d8544fd50c94bedc2c634378f819b6fc1c17a558d23e
 SHA512:
-  metadata.gz: 1c860d94f4b07ae28cd2553e86c6538ebcaecd861a25bb695879ed2f69b6da6459c2ff9884d7c86127c18dac6217ddd3b41ee8e069eaa012e04b9d6d280cebd4
-  data.tar.gz: 1025d7a735a38f59d2e921d5e7fb29e41b007a238eca7052bba16b319316695a50dc15f1729b47f2c27887244000b0c5a2b3d386be1765ee0c37578f5be2978d
+  metadata.gz: 2bdbe152941277e1bd891080277d8bb20bb165826ac44425159126448c559aceefb05aeed1569c09423fdfc8af1d8c6d68190814036713f53c627d966b6441cb
+  data.tar.gz: f94731850ae8879b8336e11ac80f4e6ac3ba93f1b793a11ab4e8be1847d0ecec0ed58e52a03d05e0961ea4d24a8b23f4857b95f23d88aadd4c7ff2edc6f13b2f

data/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v7
 
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1

data/.gitignore

@@ -8,3 +8,5 @@ Gemfile.lock
 pkg/*
 coverage/*
 TODO
+.claude/
+CLAUDE.md

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 3.1.0 - November 2026
+- Preserve spaces, blank lines and Markdown characters inside code, thanks @skatkov, see #116
+- Convert Nokogiri document fragments to Markdown, thanks @skatkov, see #116
+- `treat_children` returns placeholder text for code; custom converters that need the code read `node.text`, see #116
+- Keep nested lists and later paragraphs in list items that start with a paragraph, thanks @skatkov, see #117
+- Indent nested lists by the width of the parent marker, e.g. 3 spaces under `1.`, see #117
+
+## 3.0.3 - September 2026
+- Make whitespace cleanup linear instead of quadratic, thanks @skatkov, see #114
+- Only force encoding on raw string input, thanks @FoboCasteR, see #112
+- Remove simplecov deprecation warnings and refresh dev dependencies, thanks @skatkov, see #115
+
 ## 3.0.2 - January 2026
 - Add support for ruby 4.0
 - Some cleanup of test cases, thanks @joelhawksley, see #107

data/README.md

@@ -39,6 +39,7 @@ gem 'reverse_markdown'
 - Module based - if you miss a tag, just add it
 - Can deal with nested lists
 - Inline and block code is supported
+- Prose cleanup does not collapse spaces, tabs, or blank lines inside code
 - Supports blockquote
 
 

data/lib/reverse_markdown/cleaner.rb

@@ -18,11 +18,13 @@ module ReverseMarkdown
     end
 
     def remove_inner_whitespaces(string)
-      string.each_line.inject("") do |memo, line|
-        memo + preserve_border_whitespaces(line) do
+      result = String.new(encoding: Encoding::UTF_8)
+      string.each_line do |line|
+        result << preserve_border_whitespaces(line) do
           line.strip.gsub(/[ \t]{2,}/, ' ')
         end
       end
+      result
     end
 
     # Find non-asterisk content that is enclosed by two or

data/lib/reverse_markdown/converters/base.rb

@@ -43,6 +43,13 @@ module ReverseMarkdown
       def extract_src(node)
         node['src'].to_s.empty? ? '' : node['src'].to_s
       end
+
+      private
+
+      def preserve_literal(content, state)
+        literals = state[:literal_content]
+        literals ? literals.protect(content) : content
+      end
     end
   end
 end

data/lib/reverse_markdown/converters/bypass.rb

@@ -7,6 +7,7 @@ module ReverseMarkdown
     end
 
     register :document, Bypass.new
+    register :'#document-fragment', Bypass.new
     register :html,     Bypass.new
     register :body,     Bypass.new
     register :span,     Bypass.new

data/lib/reverse_markdown/converters/code.rb

@@ -2,7 +2,7 @@ module ReverseMarkdown
   module Converters
     class Code < Base
       def convert(node, state = {})
-        "`#{node.text}`"
+        preserve_literal("`#{node.text}`", state)
       end
     end
 

data/lib/reverse_markdown/converters/li.rb

@@ -3,12 +3,16 @@ module ReverseMarkdown
     class Li < Base
       def convert(node, state = {})
         contains_child_paragraph = node.first_element_child ? node.first_element_child.name == 'p' : false
-        content_node             = contains_child_paragraph ? node.first_element_child : node
-        content                  = treat_children(content_node, state)
-        indentation              = indentation_from(state)
+        content                  = treat_children(node, state)
+        content                  = content.sub(/\A[ \t]*\n\n/, '') if contains_child_paragraph
         prefix                   = prefix_for(node)
+        # Kramdown requires four-space continuation indentation after an empty marker line.
+        continuation_indentation = content.match?(/\A[ \t]*\n/) ? '    ' : ' ' * prefix.length
+        content                  = content.lines.map.with_index do |line, index|
+          index.zero? || line.strip.empty? ? line : "#{continuation_indentation}#{line}"
+        end.join
 
-        "#{indentation}#{prefix}#{content.chomp}\n" +
+        "#{prefix}#{content.chomp}\n" +
           (contains_child_paragraph ? "\n" : '')
       end
 
@@ -20,11 +24,6 @@ module ReverseMarkdown
           '- '
         end
       end
-
-      def indentation_from(state)
-        length = state.fetch(:ol_count, 0)
-        '  ' * [length - 1, 0].max
-      end
     end
 
     register :li, Li.new

data/lib/reverse_markdown/converters/ol.rb

@@ -2,8 +2,7 @@ module ReverseMarkdown
   module Converters
     class Ol < Base
       def convert(node, state = {})
-        ol_count = state.fetch(:ol_count, 0) + 1
-        +"\n" << treat_children(node, state.merge(ol_count: ol_count)) << "\n"
+        +"\n" << treat_children(node, state) << "\n"
       end
     end
 

data/lib/reverse_markdown/converters/pre.rb

@@ -2,25 +2,27 @@ module ReverseMarkdown
   module Converters
     class Pre < Base
       def convert(node, state = {})
-        content = treat_children(node, state)
+        content = treat_children(node, state).strip
         if ReverseMarkdown.config.github_flavored
-          +"\n```#{language(node)}\n" << content.strip << "\n```\n"
+          code = "```#{language(node)}\n#{content}\n```"
+          "\n#{preserve_literal(code, state)}\n"
         else
-          +"\n\n    " << content.lines.to_a.join("    ") << "\n\n"
+          code = "    #{content.lines.to_a.join('    ')}"
+          "\n\n#{preserve_literal(code, state)}\n\n"
         end
       end
 
       private
 
-      # Override #treat as proposed in https://github.com/xijo/reverse_markdown/pull/69
+      # Highlighting wrappers are not prose: recurse without normalizing or
+      # escaping their text, while preserving explicit HTML line breaks.
       def treat(node, state)
-        case node.name
-        when 'code', 'text'
-          node.text.strip
-        when 'br'
+        if node.text? || node.cdata?
+          node.text
+        elsif node.name == 'br'
           "\n"
         else
-          super
+          treat_children(node, state)
         end
       end
 

data/lib/reverse_markdown/literal_content.rb

@@ -0,0 +1,29 @@
+module ReverseMarkdown
+  # Conversion-local storage for code that must bypass prose cleanup. Capture
+  # each line separately so container converters can still indent and quote it.
+  class LiteralContent
+    # NUL is not valid HTML text. Letter guards keep internal markers
+    # intact when surrounding converters strip whitespace from their output.
+    MARKER = /RMC\0(\d+)\0END/
+
+    def initialize
+      @values = []
+    end
+
+    def protect(content)
+      content.lines("\n").map do |line|
+        marker = "RMC\0#{@values.length}\0END"
+        @values << line.delete_suffix("\n")
+        line.end_with?("\n") ? "#{marker}\n" : marker
+      end.join
+    end
+
+    def restore(markdown)
+      return markdown if @values.empty?
+
+      markdown.gsub(MARKER) { @values.fetch(Regexp.last_match(1).to_i) }
+    end
+  end
+
+  private_constant :LiteralContent
+end

data/lib/reverse_markdown/version.rb

@@ -1,3 +1,3 @@
 module ReverseMarkdown
-  VERSION = '3.0.2'
+  VERSION = '3.1.0'
 end

data/lib/reverse_markdown.rb

@@ -3,6 +3,7 @@ require 'reverse_markdown/version'
 require 'reverse_markdown/errors'
 require 'reverse_markdown/cleaner'
 require 'reverse_markdown/config'
+require 'reverse_markdown/literal_content'
 require 'reverse_markdown/converters'
 require 'reverse_markdown/converters/base'
 require 'reverse_markdown/converters/a'
@@ -37,18 +38,17 @@ module ReverseMarkdown
 
   def self.convert(input, options = {})
     config.with(options) do
-      input = cleaner.force_encoding(input.to_s)
-
       root = case input
-        when String                  then Nokogiri::HTML(input).root
+        when String                  then Nokogiri::HTML(cleaner.force_encoding(input.to_s)).root
         when Nokogiri::XML::Document then input.root
         when Nokogiri::XML::Node     then input
       end
 
       root or return ''
 
-      result = ReverseMarkdown::Converters.lookup(root.name).convert(root)
-      cleaner.tidy(result)
+      literals = LiteralContent.new
+      result = ReverseMarkdown::Converters.lookup(root.name).convert(root, literal_content: literals)
+      literals.restore(cleaner.tidy(result))
     end
   end
 

data/reverse_markdown.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'kramdown'
+  s.add_development_dependency 'ostruct'
   s.add_development_dependency 'debug' unless RUBY_ENGINE == 'jruby'
 end

data/spec/components/html_fragment_spec.rb

@@ -6,4 +6,12 @@ describe ReverseMarkdown do
   subject { ReverseMarkdown.convert(input) }
 
   it { is_expected.to eq("naked text 1\n\nparagraph text\n\nnaked text 2") }
+
+  it 'converts a Nokogiri document fragment through its child converters' do
+    fragment = Nokogiri::HTML.fragment('<h1>Title</h1><p>Some <strong>text</strong>.</p>')
+    original = fragment.to_html
+
+    expect(ReverseMarkdown.convert(fragment)).to eq ReverseMarkdown.convert(original)
+    expect(fragment.to_html).to eq original
+  end
 end

data/spec/components/lists_spec.rb

@@ -11,8 +11,8 @@ describe ReverseMarkdown do
   it { is_expected.to match /\n1. ordered list entry\n/ }
   it { is_expected.to match /\n2. ordered list entry 2\n/ }
   it { is_expected.to match /\n1. list entry 1st hierarchy\n/ }
-  it { is_expected.to match /\n {2}- nested unsorted list entry\n/ }
-  it { is_expected.to match /\n {4}1. deep nested list entry\n/ }
+  it { is_expected.to match /\n {4}- nested unsorted list entry\n/ }
+  it { is_expected.to match /\n {8}1. deep nested list entry\n/ }
 
   context "nested list with no whitespace" do
     it { is_expected.to match /\n- item a\n/ }
@@ -40,18 +40,61 @@ describe ReverseMarkdown do
   end
 
   context "list item containing multiple <p> tags" do
-    xit { is_expected.to match /\n- li 1, p 1\n\n- li 1, p 2\n/ }
+    it { is_expected.to include "- li 1, p 1\n\n  li 1, p 2\n\n- li 2, p 1\n" }
+  end
+
+  context "paragraphs followed by nested lists" do
+    let(:input) do
+      '<ul><li><p>Source:</p><ul><li><p>Readable path.</p></li>' \
+        '<li><p>Readable IO.</p></li></ul><p>More details.</p></li>' \
+        '<li><p>Destination:</p><ul><li><p>Writable path.</p></li></ul></li></ul>'
+    end
+
+    it "preserves every paragraph and nested item" do
+      is_expected.to eq "- Source:\n\n  - Readable path.\n\n  - Readable IO.\n\n" \
+        "  More details.\n\n- Destination:\n\n  - Writable path.\n\n"
+    end
+  end
+
+  context "paragraphs followed by nested ordered lists" do
+    let(:input) do
+      '<ol><li><p>First:</p><ol><li><p>Child one.</p></li>' \
+        '<li><p>Child two.</p></li></ol></li><li><p>Second.</p></li></ol>'
+    end
+
+    it "indents nested items past the parent marker" do
+      is_expected.to eq "1. First:\n\n   1. Child one.\n\n   2. Child two.\n\n2. Second.\n\n"
+    end
+  end
+
+  context "an empty paragraph followed by a nested list" do
+    let(:input) { '<ul><li><p></p><ul><li>Child.</li></ul></li></ul>' }
+
+    it "keeps the child list below the empty parent marker" do
+      is_expected.to eq "- \n\n    - Child.\n\n"
+    end
+  end
+
+  context "nested lists after a two-digit marker" do
+    let(:input) do
+      '<ol>' + '<li>Item.</li>' * 9 +
+        '<li><p>Tenth:</p><ul><li><p>Child.</p></li></ul></li></ol>'
+    end
+
+    it "accounts for the full marker width" do
+      is_expected.to include "10. Tenth:\n\n    - Child.\n"
+    end
   end
 
   context 'it produces correct numbering' do
     it { is_expected.to include "1. one" }
-    it { is_expected.to include "  1. one one" }
-    it { is_expected.to include "  2. one two" }
+    it { is_expected.to include "\n   1. one one" }
+    it { is_expected.to include "\n   2. one two" }
     it { is_expected.to include "2. two" }
-    it { is_expected.to include "  1. two one" }
-    it { is_expected.to include "    1. two one one" }
-    it { is_expected.to include "    2. two one two" }
-    it { is_expected.to include "  2. two two" }
+    it { is_expected.to include "\n   1. two one" }
+    it { is_expected.to include "\n      1. two one one" }
+    it { is_expected.to include "\n      2. two one two" }
+    it { is_expected.to include "\n   2. two two" }
     it { is_expected.to include "3. three" }
   end
 

data/spec/components/literal_code_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'kramdown'
+
+describe ReverseMarkdown, 'literal code content' do
+  def pre_html(content)
+    escaped = content.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+    "<pre>#{escaped}</pre>"
+  end
+
+  it 'preserves spaces, tabs, and Markdown-looking text in inline code' do
+    code = "two  spaces\tand __underscores__ **.** [ spaced ]"
+
+    result = ReverseMarkdown.convert("<p>Copy <code>#{code}</code>.</p>")
+
+    expect(result).to include "Copy `#{code}`."
+  end
+
+  it 'preserves empty code without leaving internal markers in the output' do
+    result = ReverseMarkdown.convert('<p><code></code></p><pre></pre>', github_flavored: true)
+
+    expect(result).to include '``'
+    expect(result).to include "```\n\n```"
+    expect(result).not_to include "\0"
+  end
+
+  it 'preserves literal HTML, ERB, and entity strings in code blocks' do
+    code = "template = '<b><%= name %></b> &lt;tag&gt; &amp;'"
+
+    result = ReverseMarkdown.convert(pre_html(code), github_flavored: true)
+
+    expect(result).to include "```\n#{code}\n```"
+  end
+
+  it 'preserves inline code through list converter state changes' do
+    html = '<ol><li>Copy <code>two  spaces [ spaced ]</code></li>' \
+      '<li><code>second  value</code></li></ol>'
+
+    result = ReverseMarkdown.convert(html)
+
+    expect(result).to include '1. Copy `two  spaces [ spaced ]`'
+    expect(result).to include '2. `second  value`'
+  end
+
+  [false, true].each do |github_flavored|
+    context "with github_flavored: #{github_flavored}" do
+      it 'preserves spaces and tabs inside code while still cleaning prose' do
+        code = "puts 'two  spaces'\nvalue = 'a\tb'\nputs '__name__ **.** [ spaced ]'"
+        html = "<p>before  prose</p>#{pre_html(code)}<p>after  prose</p>"
+
+        result = ReverseMarkdown.convert(html, github_flavored: github_flavored)
+        expected = github_flavored ? "```\n#{code}\n```" : code.lines.map { |line| "    #{line}" }.join
+
+        expect(result).to include expected
+        expect(result).to include 'before prose'
+        expect(result).to include 'after prose'
+      end
+
+      it 'preserves repeated blank lines in code blocks' do
+        code = "puts :before\n\n\n\nputs :after"
+
+        result = ReverseMarkdown.convert(pre_html(code), github_flavored: github_flavored)
+        expected = github_flavored ? "```\n#{code}\n```" : code.lines.map { |line| "    #{line}" }.join
+
+        expect(result).to include expected
+      end
+
+      it 'preserves code in nested blockquotes through container cleanup' do
+        code = "marker = '```'\nputs 'two  spaces'\n\n\nputs '__name__ [ spaced ]'"
+        html = "<blockquote><blockquote>#{pre_html(code)}</blockquote></blockquote>"
+
+        result = ReverseMarkdown.convert(html, github_flavored: github_flavored)
+        expected = github_flavored ? "```\n#{code}\n```" : code.lines.map { |line| "    #{line}" }.join
+
+        expect(result).to include expected.lines.map { |line| "> > #{line}" }.join
+      end
+    end
+  end
+
+  it 'preserves highlighted code as literal text, including nested line breaks' do
+    html = '<pre><code><span class="name">value</span> = ' \
+      '<span class="string">\'two  spaces &amp;lt;tag&amp;gt;\'</span>' \
+      '<br><span class="name">puts</span> value</code></pre>'
+
+    result = ReverseMarkdown.convert(html, github_flavored: true)
+
+    expect(result).to include "```\nvalue = 'two  spaces &lt;tag&gt;'\nputs value\n```"
+  end
+
+  it 'does not confuse prose joined across inline elements with literal content' do
+    html = '<p><span>RMC</span><span>0END</span> X0End XX0End</p>' \
+      '<pre>puts :literal</pre>'
+
+    result = ReverseMarkdown.convert(html, github_flavored: true)
+
+    expect(result).to include 'RMC0END X0End XX0End'
+    expect(result).to include "```\nputs :literal\n```"
+    expect(result).not_to include "\0"
+  end
+
+  it 'does not treat invalid HTML NUL references as internal markers' do
+    html = '<p>RMC&#0;0&#0;END</p><pre>puts :literal</pre>'
+    prose = Nokogiri::HTML.fragment(html).at_css('p').text
+
+    result = ReverseMarkdown.convert(html, github_flavored: true)
+
+    expect(result).to include prose
+    expect(result).to include "```\nputs :literal\n```"
+    expect(result).not_to include "\0"
+  end
+
+  it 'preserves literal CDATA content from an XML document' do
+    code = "value = 'a  b <tag> &amp;'"
+    document = Nokogiri::XML("<pre><![CDATA[#{code}]]></pre>")
+
+    result = ReverseMarkdown.convert(document, github_flavored: true)
+
+    expect(result).to include "```\n#{code}\n```"
+  end
+
+  it 'preserves Unicode code without changing its encoding' do
+    code = "puts 'café  世界'"
+
+    result = ReverseMarkdown.convert(pre_html(code), github_flavored: true)
+
+    expect(result).to include "```\n#{code}\n```"
+    expect(result.encoding).to eq Encoding::UTF_8
+  end
+
+  it 'keeps indented code valid when Markdown inside blockquotes is rendered' do
+    code = "puts 'two  spaces'\n\n\nputs '[ spaced ] __name__'"
+    html = "<blockquote><blockquote>#{pre_html(code)}</blockquote></blockquote>"
+    markdown = ReverseMarkdown.convert(html)
+
+    rendered = Nokogiri::HTML.fragment(Kramdown::Document.new(markdown).to_html)
+
+    expect(rendered.at_css('blockquote blockquote pre code').text).to eq "#{code}\n"
+  end
+
+  it 'restores distinct values throughout a long code block' do
+    code = Array.new(180) { |index| "puts 'line #{index}  value'" }.join("\n")
+
+    result = ReverseMarkdown.convert(pre_html(code), github_flavored: true)
+
+    expect(result).to include "```\n#{code}\n```"
+  end
+
+  it 'preserves code without modifying a Nokogiri input node' do
+    node = node_for(pre_html("puts 'two  spaces'\n\n\nputs :done"))
+    original = node.to_html
+
+    result = ReverseMarkdown.convert(node, github_flavored: true)
+
+    expect(result).to include "```\nputs 'two  spaces'\n\n\nputs :done\n```"
+    expect(node.to_html).to eq original
+  end
+
+  it 'preserves code in a native Nokogiri document fragment' do
+    fragment = Nokogiri::HTML.fragment("<p>Copy this:</p>#{pre_html("puts 'two  spaces'\n\n\nputs :done")}")
+    original = fragment.to_html
+
+    result = ReverseMarkdown.convert(fragment, github_flavored: true)
+
+    expect(result).to include "```\nputs 'two  spaces'\n\n\nputs :done\n```"
+    expect(fragment.to_html).to eq original
+  end
+
+  it 'keeps literal content isolated between conversions' do
+    first = ReverseMarkdown.convert(pre_html("puts 'first  value'"), github_flavored: true)
+    second = ReverseMarkdown.convert(pre_html("puts 'second  value'"), github_flavored: true)
+
+    expect(first).to include "puts 'first  value'"
+    expect(second).to include "puts 'second  value'"
+    expect(second).not_to include 'first'
+  end
+end

data/spec/html_to_markdown_to_html_spec.rb

@@ -62,6 +62,33 @@ describe 'Round trip: HTML to markdown (via reverse_markdown) to HTML (via redca
       ")
   end
 
+  it "should preserve paragraphs before and after nested lists" do
+    roundtrip_should_preserve(
+      '<ul><li><p>Source:</p><ul><li><p>Readable path.</p></li>' \
+        '<li><p>Readable IO.</p></li></ul><p>More details.</p></li>' \
+        '<li><p>Destination:</p><ul><li><p>Writable path.</p></li>' \
+        '<li><p>Writable IO.</p></li></ul></li></ul>'
+    )
+  end
+
+  it "should preserve mixed nested lists and their numbering" do
+    roundtrip_should_preserve(
+      '<ol><li><p>First:</p><ul><li><p>Child:</p><ol>' \
+        '<li><p>Grandchild one.</p></li><li><p>Grandchild two.</p></li></ol></li></ul></li>' \
+        '<li><p>Second.</p></li></ol>'
+    )
+  end
+
+  %w[ul ol].each do |tag|
+    it "should keep child lists nested below empty #{tag} items" do
+      input = "<#{tag}><li><p></p><ul><li>Child.</li></ul></li></#{tag}>"
+      output = html2markdown2html(input)
+      expected = "<#{tag}><li><ul><li>Child.</li></ul></li></#{tag}>"
+
+      expect(normalize_html(output)).to eq expected
+    end
+  end
+
   it "should preserve <hr> tags" do
     roundtrip_should_preserve("<hr />")
   end

data/spec/lib/reverse_markdown/cleaner_spec.rb

@@ -50,6 +50,14 @@ describe ReverseMarkdown::Cleaner do
       result = cleaner.remove_inner_whitespaces("foo \nbar \n \n  \nfoo")
       expect(result).to eq "foo \nbar \n \n  \nfoo"
     end
+
+    it 'preserves multiline content and its frozen input' do
+      input = "  third  item  \n\n \t \n[first  link](path  here)\n\tsecond   item\t\n".freeze
+
+      result = cleaner.remove_inner_whitespaces(input)
+
+      expect(result).to eq "  third item  \n\n \t \n[first link](path here)\n\tsecond item\t\n"
+    end
   end
 
   describe '#clean_punctuation_characters' do

data/spec/spec_helper.rb

@@ -2,9 +2,15 @@ require 'simplecov'
 require 'debug' unless RUBY_ENGINE == 'jruby'
 
 SimpleCov.profiles.define 'gem' do
-  add_filter '/spec/'
-  add_filter '/autotest/'
-  add_group 'Libraries', '/lib/'
+  if SimpleCov.respond_to?(:skip)
+    skip '/spec/'
+    skip '/autotest/'
+    group 'Libraries', '/lib/'
+  else
+    add_filter '/spec/'
+    add_filter '/autotest/'
+    add_group 'Libraries', '/lib/'
+  end
 end
 SimpleCov.start 'gem'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reverse_markdown
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Johannes Opper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-20 00:00:00.000000000 Z
+date: 2026-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +160,7 @@ files:
 - lib/reverse_markdown/converters/text.rb
 - lib/reverse_markdown/converters/tr.rb
 - lib/reverse_markdown/errors.rb
+- lib/reverse_markdown/literal_content.rb
 - lib/reverse_markdown/version.rb
 - reverse_markdown.gemspec
 - spec/assets/anchors.html
@@ -170,6 +185,7 @@ files:
 - spec/components/html_fragment_spec.rb
 - spec/components/iframe_spec.rb
 - spec/components/lists_spec.rb
+- spec/components/literal_code_spec.rb
 - spec/components/paragraphs_spec.rb
 - spec/components/quotation_spec.rb
 - spec/components/tables_spec.rb
@@ -237,6 +253,7 @@ test_files:
 - spec/components/html_fragment_spec.rb
 - spec/components/iframe_spec.rb
 - spec/components/lists_spec.rb
+- spec/components/literal_code_spec.rb
 - spec/components/paragraphs_spec.rb
 - spec/components/quotation_spec.rb
 - spec/components/tables_spec.rb