markdownator 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba67d2ba95d9e160fde97514331e9a40a72bee5219f49f422738700a799af23
-  data.tar.gz: a277a37a4de92899f4d045c9f4d4c76a1ebf72d76d014fe13887952ccf522eb0
+  metadata.gz: ef75f03777f577049069b98fee3104ee31f7ad3d4cece96f3cc78052db648f6e
+  data.tar.gz: '047778687f87ca470f627d082e7653c17999c8981f7c579512eed0c8a31cb9fa'
 SHA512:
-  metadata.gz: 2cd3f9f43a382e333b5a1fd76bba182d09b27da73a7bc47072fd0f366aa53fe01ace0eae14daa5ac6aded3d8e6d8b3f1031c27e85132f7cc7f6f13988db9f5e9
-  data.tar.gz: faa3b029ce56dc20a3e54c2ea541b2749038c36fe07c0eb3a56bf7625113219a58eb2003bd46a20564f84a21c16c03d18a7ff4a92543586f8e9464f2c092bef9
+  metadata.gz: e3ce45e8c1f63c4f374aa475a27c3a567846423005caafa8999e136531139a36695fd180d806dcd5e49d1a5414b7a372d6a448f3c1bccb49d5868c13ae2e3870
+  data.tar.gz: ef73a6ccac7125b16fd8838a88f56be01c8fa555b39887963e8a79170c34428c21f20ac7fea867af06c6aa3410114ad01619f804ed3f1333669596bd656aed2c

data/CHANGELOG.md

@@ -1,9 +1,45 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
 ## [Unreleased]
 
+## [0.1.2] - 2026-06-13
+
+### Changed
+
+- XLSX conversion now reads the workbook directly with rubyzip and Nokogiri
+  instead of `roo`, so every Office format (DOCX, XLSX, PPTX, EPUB) shares one
+  approach and the `roo` dependency is dropped.
+- Moved the HTML renderer to `Markdownator::Renderers::HtmlRenderer` (it renders
+  Markdown, it does not convert a source file).
+
+## [0.1.1] - 2026-06-13
+
+### Changed
+
+- HTML (and EPUB) conversion now renders Markdown directly from the Nokogiri
+  node tree, dropping the `reverse_markdown` dependency (it was only a thin
+  layer over Nokogiri).
+
 ## [0.1.0] - 2026-06-12
 
-- Initial release.
-- Converter-registry engine (`Markdownator.convert`) dispatching local paths, URLs, and IO streams.
-- Converters for plain text, HTML, CSV, JSON, XML, DOCX, XLSX, PPTX, PDF, EPUB, ZIP (recursive), and image metadata.
-- Optional/lazy dependency loading with helpful errors for missing format gems.
-- Pluggable LLM image captioner hook.
+### Added
+
+- Converter-registry engine (`Markdownator.convert`, `.convert_local`,
+  `.convert_stream`) dispatching local paths, URLs, and IO streams to the first
+  converter that accepts the stream.
+- Converters for plain text, HTML, CSV, JSON, XML, DOCX, XLSX, PPTX, PDF, EPUB,
+  ZIP (recursive), and image metadata.
+- Optional, lazily loaded format dependencies with a helpful
+  `MissingDependencyError` when a required gem is absent; zero hard runtime
+  dependencies.
+- Pluggable LLM image-captioner hook (off by default).
+
+[Unreleased]: https://github.com/alexrupom/markdownator/compare/v0.1.2...HEAD
+[0.1.2]: https://github.com/alexrupom/markdownator/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/alexrupom/markdownator/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/alexrupom/markdownator/releases/tag/v0.1.0

data/Gemfile

@@ -17,6 +17,4 @@ gem "rubocop", "~> 1.21"
 gem "exifr", "~> 1.3"
 gem "nokogiri", "~> 1.15"
 gem "pdf-reader", "~> 2.12"
-gem "reverse_markdown", "~> 2.1"
-gem "roo", "~> 2.10"
 gem "rubyzip", "~> 2.3"

data/README.md

@@ -13,13 +13,13 @@ libraries **lazily**, so you only install the gems for the formats you actually
 | Plain text / Markdown | `.txt`, `.md` | — (built in) |
 | CSV | `.csv` | — (built in) |
 | JSON | `.json` | — (built in) |
-| HTML | `.html`, `.htm` | `reverse_markdown` (+ `nokogiri`) |
+| HTML | `.html`, `.htm` | `nokogiri` |
 | XML | `.xml` | `nokogiri` |
 | Word | `.docx` | `rubyzip`, `nokogiri` |
-| Excel | `.xlsx` | `roo` |
+| Excel | `.xlsx` | `rubyzip`, `nokogiri` |
 | PowerPoint | `.pptx` | `rubyzip`, `nokogiri` |
 | PDF | `.pdf` | `pdf-reader` |
-| EPUB | `.epub` | `rubyzip`, `nokogiri`, `reverse_markdown` |
+| EPUB | `.epub` | `rubyzip`, `nokogiri` |
 | ZIP (recurses) | `.zip` | `rubyzip` |
 | Images (metadata) | `.jpg`, `.png`, `.tiff`, … | `exifr` (for EXIF) |
 
@@ -36,10 +36,8 @@ Then add the gems for the formats you need, e.g.:
 
 ```ruby
 gem "pdf-reader"      # PDF
-gem "roo"             # XLSX
-gem "rubyzip"         # DOCX, PPTX, EPUB, ZIP
-gem "nokogiri"        # HTML, XML, DOCX, PPTX, EPUB
-gem "reverse_markdown" # HTML, EPUB
+gem "rubyzip"         # DOCX, XLSX, PPTX, EPUB, ZIP
+gem "nokogiri"        # HTML, XML, DOCX, XLSX, PPTX, EPUB
 gem "exifr"           # image EXIF
 ```
 

data/lib/markdownator/converters/html.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "../renderers/html_renderer"
+
 module Markdownator
   module Converters
-    # Converts HTML into Markdown using reverse_markdown (Nokogiri-backed).
+    # Converts HTML into Markdown by walking the Nokogiri node tree.
     class Html < Base
       def accepts?(_io, stream_info)
         matches?(stream_info, extensions: %w[html htm], mimetypes: %w[text/html application/xhtml+xml])
@@ -15,8 +17,10 @@ module Markdownator
 
       # Shared so other container converters (EPUB) can reuse HTML conversion.
       def self.html_to_markdown(html)
-        Markdownator.require_optional("reverse_markdown", feature: "HTML conversion")
-        ReverseMarkdown.convert(html, unknown_tags: :bypass, github_flavored: true).strip
+        Markdownator.require_optional("nokogiri", feature: "HTML conversion")
+        doc = Nokogiri::HTML(html)
+        root = doc.at_css("body") || doc.root || doc
+        Renderers::HtmlRenderer.new.render(root)
       end
 
       def self.extract_title(html)

data/lib/markdownator/converters/xlsx.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "tempfile"
-
 module Markdownator
   module Converters
     # Converts an Excel .xlsx workbook into Markdown: one `## SheetName` heading
-    # and a Markdown table per sheet, using the `roo` gem.
+    # and a Markdown table per sheet.
+    #
+    # Reads the OOXML zip directly with rubyzip and Nokogiri, the same approach
+    # used by the DOCX, PPTX, and EPUB converters.
     class Xlsx < Base
       def accepts?(_io, stream_info)
         matches?(
@@ -16,12 +17,16 @@ module Markdownator
       end
 
       def convert(io, _stream_info, **_options)
-        Markdownator.require_optional("roo", feature: "XLSX conversion")
+        Markdownator.require_optional("zip", feature: "XLSX conversion")
+        Markdownator.require_optional("nokogiri", feature: "XLSX conversion")
 
-        with_tempfile(io) do |path|
-          workbook = Roo::Excelx.new(path)
-          sections = workbook.sheets.map { |name| render_sheet(workbook, name) }
-          Result.new(markdown: sections.compact.join("\n\n"))
+        ::Zip::File.open_buffer(io) do |zip|
+          shared = shared_strings(zip)
+          sections = sheets(zip).filter_map do |name, path|
+            table = markdown_table(parse_sheet(read(zip, path), shared))
+            "## #{name}\n\n#{table}" unless table.empty?
+          end
+          return Result.new(markdown: sections.join("\n\n"))
         end
       rescue StandardError => e
         raise FileConversionError, "Could not read XLSX: #{e.message}"
@@ -29,23 +34,85 @@ module Markdownator
 
       private
 
-      def render_sheet(workbook, name)
-        sheet = workbook.sheet(name)
-        rows = (1..sheet.last_row.to_i).map do |r|
-          (1..sheet.last_column.to_i).map { |c| sheet.cell(r, c) }
+      def read(zip, path)
+        zip.find_entry(path)&.get_input_stream&.read
+      end
+
+      # Ordered [[sheet_name, worksheet_path], ...] resolved via the workbook
+      # relationships.
+      def sheets(zip)
+        workbook = parse(read(zip, "xl/workbook.xml"))
+        return [] if workbook.nil?
+
+        rels = relationships(zip)
+        workbook.xpath("//sheets/sheet").filter_map do |sheet|
+          path = resolve_target(rels[sheet["id"]])
+          [sheet["name"].to_s, path] if path
         end
-        table = markdown_table(rows)
-        table.empty? ? nil : "## #{name}\n\n#{table}"
       end
 
-      def with_tempfile(io)
-        Tempfile.create(["markdownator", ".xlsx"]) do |file|
-          file.binmode
-          file.write(io.read)
-          file.flush
-          yield file.path
+      def relationships(zip)
+        doc = parse(read(zip, "xl/_rels/workbook.xml.rels"))
+        return {} if doc.nil?
+
+        doc.xpath("//Relationship").to_h { |rel| [rel["Id"], rel["Target"]] }
+      end
+
+      def resolve_target(target)
+        return nil if target.nil? || target.empty?
+
+        target = target.delete_prefix("/")
+        target.start_with?("xl/") ? target : "xl/#{target}"
+      end
+
+      # The shared string table: index -> text.
+      def shared_strings(zip)
+        doc = parse(read(zip, "xl/sharedStrings.xml"))
+        return [] if doc.nil?
+
+        doc.xpath("//si").map { |si| si.xpath(".//t").map(&:text).join }
+      end
+
+      def parse_sheet(xml, shared)
+        doc = parse(xml)
+        return [] if doc.nil?
+
+        doc.xpath("//sheetData/row").map do |row|
+          values = {}
+          width = 0
+          row.xpath("./c").each_with_index do |cell, position|
+            column = column_index(cell["r"]) || (position + 1)
+            width = column if column > width
+            values[column] = cell_value(cell, shared)
+          end
+          (1..width).map { |i| values[i] || "" }
+        end
+      end
+
+      def cell_value(cell, shared)
+        case cell["t"]
+        when "s" then shared[cell.at_xpath("./v")&.text.to_i].to_s
+        when "inlineStr" then cell.xpath("./is//t").map(&:text).join
+        when "b" then cell.at_xpath("./v")&.text == "1" ? "TRUE" : "FALSE"
+        else cell.at_xpath("./v")&.text.to_s
         end
       end
+
+      # Converts a cell reference like "B2" into a 1-based column index (2).
+      def column_index(ref)
+        letters = ref.to_s[/\A[A-Z]+/i]
+        return nil if letters.nil?
+
+        letters.upcase.each_char.reduce(0) { |acc, char| (acc * 26) + (char.ord - 64) }
+      end
+
+      def parse(xml)
+        return nil if xml.nil?
+
+        doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+        doc
+      end
     end
   end
 end

data/lib/markdownator/renderers/html_renderer.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Markdownator
+  module Renderers
+    # Walks a Nokogiri HTML node tree and renders Markdown. A focused,
+    # dependency-free replacement for reverse_markdown: HTML conversion needs
+    # only Nokogiri (which reverse_markdown depended on anyway).
+    class HtmlRenderer
+      # Elements that introduce their own block (line-separated) content.
+      BLOCK_TAGS = %w[
+        address article aside blockquote details div dl figcaption figure
+        footer form h1 h2 h3 h4 h5 h6 header hr main nav ol p pre section
+        table ul
+      ].freeze
+
+      # Elements whose contents are dropped entirely.
+      SKIP_TAGS = %w[script style head title noscript template].freeze
+
+      def render(node)
+        blocks_to_string(render_blocks(node))
+      end
+
+      private
+
+      # Renders the children of +node+ into an array of block strings, grouping
+      # consecutive inline content into paragraphs.
+      def render_blocks(node)
+        blocks = []
+        buffer = +""
+
+        node.children.each do |child|
+          if block?(child)
+            push_paragraph(blocks, buffer)
+            buffer = +""
+            block = render_block(child)
+            blocks << block unless block.nil? || block.empty?
+          elsif !skip?(child)
+            buffer << render_inline(child)
+          end
+        end
+        push_paragraph(blocks, buffer)
+        blocks
+      end
+
+      def render_block(node)
+        case node.name
+        when /\Ah([1-6])\z/ then "#{"#" * Regexp.last_match(1).to_i} #{inline_of(node)}"
+        when "ul" then render_list(node, ordered: false)
+        when "ol" then render_list(node, ordered: true)
+        when "pre" then render_pre(node)
+        when "blockquote" then render_blockquote(node)
+        when "table" then render_table(node)
+        when "dl" then render_definition_list(node)
+        when "hr" then "---"
+        else blocks_to_string(render_blocks(node)) # div, section, p, unknown blocks
+        end
+      end
+
+      def render_inline(node)
+        return normalize(node.text) if node.text?
+        return "" if node.comment? || skip?(node)
+
+        case node.name
+        when "strong", "b" then emphasis(node, "**")
+        when "em", "i" then emphasis(node, "_")
+        when "del", "s", "strike" then emphasis(node, "~~")
+        when "code" then inline_code(node)
+        when "a" then render_link(node)
+        when "img" then render_image(node)
+        when "br" then "\n"
+        else inline_of(node)
+        end
+      end
+
+      def render_link(node)
+        href = node["href"].to_s.strip
+        text = inline_of(node)
+        text = href if text.empty?
+        href.empty? ? text : "[#{text}](#{href})"
+      end
+
+      def render_image(node)
+        "![#{node["alt"].to_s.strip}](#{node["src"].to_s.strip})"
+      end
+
+      def render_list(node, ordered:)
+        index = 0
+        list_items(node).map do |li|
+          index += 1
+          marker = ordered ? "#{index}." : "-"
+          indent = " " * (marker.length + 1)
+          lines = blocks_to_string(render_blocks(li)).split("\n")
+          first = lines.shift.to_s
+          rest = lines.map { |line| line.empty? ? "" : "#{indent}#{line}" }
+          (["#{marker} #{first}"] + rest).join("\n")
+        end.join("\n")
+      end
+
+      def render_pre(node)
+        code = node.at_css("code") || node
+        language = code["class"].to_s[/(?:language|lang)-(\w+)/, 1].to_s
+        "```#{language}\n#{code.text.chomp}\n```"
+      end
+
+      def render_blockquote(node)
+        blocks_to_string(render_blocks(node)).split("\n").map do |line|
+          line.empty? ? ">" : "> #{line}"
+        end.join("\n")
+      end
+
+      def render_table(node)
+        rows = node.css("tr").map do |tr|
+          tr.css("th, td").map { |cell| inline_of(cell).gsub("|", "\\|") }
+        end
+        rows.reject!(&:empty?)
+        return "" if rows.empty?
+
+        width = rows.map(&:length).max
+        rows.each { |row| row.fill("", row.length...width) }
+        header, *body = rows
+        lines = ["| #{header.join(" | ")} |", "| #{Array.new(width, "---").join(" | ")} |"]
+        body.each { |row| lines << "| #{row.join(" | ")} |" }
+        lines.join("\n")
+      end
+
+      def render_definition_list(node)
+        node.element_children.map do |child|
+          text = inline_of(child)
+          next if text.empty?
+
+          child.name == "dt" ? "**#{text}**" : ": #{text}"
+        end.compact.join("\n")
+      end
+
+      # --- helpers ---------------------------------------------------------
+
+      def inline_code(node)
+        text = node.text
+        fence = text.include?("`") ? "`` " : "`"
+        close = text.include?("`") ? " ``" : "`"
+        "#{fence}#{text}#{close}"
+      end
+
+      def emphasis(node, marker)
+        inner = inline_of(node)
+        inner.empty? ? "" : "#{marker}#{inner}#{marker}"
+      end
+
+      # Inline content of a node, with surrounding whitespace collapsed.
+      def inline_of(node)
+        clean_inline(node.children.map { |child| render_inline(child) }.join)
+      end
+
+      def list_items(node)
+        node.element_children.select { |child| child.name == "li" }
+      end
+
+      def push_paragraph(blocks, buffer)
+        text = clean_block(buffer)
+        blocks << text unless text.empty?
+      end
+
+      def blocks_to_string(blocks)
+        blocks.reject(&:empty?).join("\n\n")
+      end
+
+      # Collapses source whitespace (including newlines) to single spaces, so
+      # only explicit <br> newlines survive.
+      def normalize(text)
+        text.gsub(/\s+/, " ")
+      end
+
+      def clean_inline(text)
+        text.gsub(/[ \t]{2,}/, " ").strip
+      end
+
+      def clean_block(text)
+        text.gsub(/ *\n */, "\n").gsub(/[ \t]{2,}/, " ").gsub(/\n{3,}/, "\n\n").strip
+      end
+
+      def block?(node)
+        node.element? && BLOCK_TAGS.include?(node.name)
+      end
+
+      def skip?(node)
+        node.element? && SKIP_TAGS.include?(node.name)
+      end
+    end
+  end
+end

data/lib/markdownator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markdownator
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdownator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - alexrupom
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 2026-06-13 00:00:00.000000000 Z
 dependencies: []
 description: Markdownator converts PDF, Word, Excel, PowerPoint, EPUB, HTML, CSV,
   JSON, XML, ZIP archives and images into clean Markdown suitable for large language
@@ -43,6 +43,7 @@ files:
 - lib/markdownator/converters/zip.rb
 - lib/markdownator/engine.rb
 - lib/markdownator/errors.rb
+- lib/markdownator/renderers/html_renderer.rb
 - lib/markdownator/result.rb
 - lib/markdownator/stream_info.rb
 - lib/markdownator/version.rb