markdownator 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba67d2ba95d9e160fde97514331e9a40a72bee5219f49f422738700a799af23
-  data.tar.gz: a277a37a4de92899f4d045c9f4d4c76a1ebf72d76d014fe13887952ccf522eb0
+  metadata.gz: 4799d3266ce18fa6adff8a3264b255a8bcaa2974888e260542adacd709566f2a
+  data.tar.gz: 50f573d19ff4b5407220fe4e8d2b50ebbc481c7d983183e24032ed6a8e4671f4
 SHA512:
-  metadata.gz: 2cd3f9f43a382e333b5a1fd76bba182d09b27da73a7bc47072fd0f366aa53fe01ace0eae14daa5ac6aded3d8e6d8b3f1031c27e85132f7cc7f6f13988db9f5e9
-  data.tar.gz: faa3b029ce56dc20a3e54c2ea541b2749038c36fe07c0eb3a56bf7625113219a58eb2003bd46a20564f84a21c16c03d18a7ff4a92543586f8e9464f2c092bef9
+  metadata.gz: 71873a123d242b1ff45147fc28eb50300c2dfb82d92dd5939be352dbeb05bbf9ae97c1c7003c5edf606e918176f5fa2dcb53b3f2ef2b0c3e9437a3fdb3faad81
+  data.tar.gz: 2c7aaf6871850fa39e323e32f7da9fe3870e06159fda18e4f04e268231214efd717c88f0cd41d291a07964b705e653cac677459a1921a1258545a68e72fd273e

data/CHANGELOG.md

@@ -1,9 +1,34 @@
+# 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.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.1...HEAD
+[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,5 @@ 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` |
 | 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) |
 
@@ -39,7 +39,6 @@ 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 "exifr"           # image EXIF
 ```
 

data/lib/markdownator/converters/html.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "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
+        HtmlRenderer.new.render(root)
       end
 
       def self.extract_title(html)

data/lib/markdownator/converters/html_renderer.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Markdownator
+  module Converters
+    # 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.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markdownator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - alexrupom
@@ -33,6 +33,7 @@ files:
 - lib/markdownator/converters/docx.rb
 - lib/markdownator/converters/epub.rb
 - lib/markdownator/converters/html.rb
+- lib/markdownator/converters/html_renderer.rb
 - lib/markdownator/converters/image.rb
 - lib/markdownator/converters/json.rb
 - lib/markdownator/converters/pdf.rb