turndown 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e872e69c4203945c84b806f145774f108be74a01347ed147b8ca8c54a5411db
+  data.tar.gz: c48f4355527c6b2a15b2a336d4370931c509403f558c36c5e8fb619425572240
+SHA512:
+  metadata.gz: 38b924e0043afed737117111f801d1b65a90d8ea20ef0e41fbdf661af9b3ebc92c38c502d702cd9851f0e739a9f37cba03ce7a7a46fb3740433ceb9bf31b1324
+  data.tar.gz: f274c12fb369b06dc52327b0e3a31121b5c3b4d3236953351808db44ad4a45bbdf8399a2866a31ecb5b59c94bac5e16ac652ebe8bf19524bcb22295a6014905a

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+# 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]
+
+## [1.0.0] - 2026-08-08
+
+Initial public release.
+
+Requires Ruby >= 3.3. The floor tracks Ruby's own maintained branches rather
+than a fixed version, so expect it to move as branches reach end of life.
+
+### Added
+
+- `Turndown::Converter` — a Nokogiri-backed HTML to Markdown converter ported
+  from [Turndown](https://github.com/mixmark-io/turndown) `7.2.2`.
+- Accepts HTML strings, Nokogiri element nodes, documents, and document
+  fragments as input.
+- Converter API: `#convert`, `#use`, `#add_rule`, `#keep`, `#remove`, `#escape`.
+- Options with symbol keys in snake_case: `heading_style`, `hr`,
+  `bullet_list_marker`, `code_block_style`, `fence`, `em_delimiter`,
+  `strong_delimiter`, `link_style`, `link_reference_style`, `br`,
+  `preformatted_code`, `blank_replacement`, `keep_replacement`,
+  `default_replacement`.
+- `Turndown::Plugins::GFM`, ported from
+  [turndown-plugin-gfm](https://github.com/mixmark-io/turndown-plugin-gfm),
+  with `Strikethrough`, `Tables`, `TaskListItems`, and `HighlightedCodeBlock`
+  available individually.
+- Custom rule and plugin support via any Ruby callable.
+- Parity test suite running the upstream fixture corpus: 149 core fixtures and
+  18 GFM fixtures.
+
+[Unreleased]: https://github.com/bavmind/turndown/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/bavmind/turndown/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,81 @@
+MIT License
+
+Copyright (c) 2026 Devran Cosmo Uenal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+
+This project is a Ruby port of Turndown and turndown-plugin-gfm. Its conversion
+rules, behavior, and test fixture corpus are derived from those projects, which
+are distributed under the MIT License:
+
+    Turndown             https://github.com/mixmark-io/turndown
+    turndown-plugin-gfm  https://github.com/mixmark-io/turndown-plugin-gfm
+
+The MIT License (MIT)
+
+Copyright (c) 2017 Dom Christie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+
+The whitespace collapsing logic in lib/turndown/collapse_whitespace.rb is
+adapted, by way of Turndown, from collapse-whitespace by Luc Thevenard:
+
+    collapse-whitespace  https://github.com/lucthev/collapse-whitespace
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Luc Thevenard <lucthevenard@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,264 @@
+# Turndown
+
+[![Gem Version](https://img.shields.io/gem/v/turndown.svg)](https://rubygems.org/gems/turndown)
+[![CI](https://github.com/bavmind/turndown/actions/workflows/ci.yml/badge.svg)](https://github.com/bavmind/turndown/actions/workflows/ci.yml)
+
+Convert HTML to Markdown in Ruby.
+
+```ruby
+Turndown::Converter.new.convert("<h1>Hello world</h1>")
+# => "Hello world\n==========="
+```
+
+> **This is a Ruby port of [Turndown](https://github.com/mixmark-io/turndown) by Dom Christie.**
+> It is an unofficial port, not affiliated with or endorsed by the upstream
+> JavaScript project. Conversion behavior, rule semantics, and the test fixture
+> corpus are derived from upstream Turndown `7.2.2` and
+> [turndown-plugin-gfm](https://github.com/mixmark-io/turndown-plugin-gfm).
+> See [Credits](#credits).
+
+## Requirements
+
+- Ruby >= 3.3 (tracks Ruby's own maintained branches)
+- Nokogiri >= 1.16
+
+## Installation
+
+Add it to your Gemfile:
+
+```ruby
+gem "turndown"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install turndown
+```
+
+## Usage
+
+### Convert an HTML string
+
+```ruby
+require "turndown"
+
+converter = Turndown::Converter.new
+markdown = converter.convert("<h1>Hello world</h1>")
+
+puts markdown
+# Hello world
+# ===========
+```
+
+### Convert a Nokogiri node or fragment
+
+```ruby
+require "nokogiri"
+require "turndown"
+
+fragment = Nokogiri::HTML5::DocumentFragment.parse("<p>Hello</p><p>world</p>")
+converter = Turndown::Converter.new
+
+puts converter.convert(fragment)
+# Hello
+#
+# world
+```
+
+Accepted inputs:
+
+- HTML `String`
+- `Nokogiri` element nodes
+- `Nokogiri` documents
+- `Nokogiri` document fragments
+
+## API
+
+- `Turndown::Converter.new(options = {})`
+- `converter.convert(input)`
+- `converter.use(plugin_or_plugins)`
+- `converter.add_rule(name, filter:, replacement:, append: nil)`
+- `converter.keep(filter)`
+- `converter.remove(filter)`
+- `converter.escape(string)`
+
+Every method except `convert` and `escape` returns the converter, so calls chain.
+
+## Options
+
+Options use symbol keys and snake_case names.
+
+| Option | Default | Notes |
+| :-- | :-- | :-- |
+| `heading_style` | `"setext"` | or `"atx"` |
+| `hr` | `"* * *"` | |
+| `bullet_list_marker` | `"*"` | or `"-"`, `"+"` |
+| `code_block_style` | `"indented"` | or `"fenced"` |
+| `fence` | ` "```" ` | or `"~~~"` |
+| `em_delimiter` | `"_"` | or `"*"` |
+| `strong_delimiter` | `"**"` | or `"__"` |
+| `link_style` | `"inlined"` | or `"referenced"` |
+| `link_reference_style` | `"full"` | or `"collapsed"`, `"shortcut"` |
+| `br` | `"  "` | |
+| `preformatted_code` | `false` | |
+| `blank_replacement` | proc | |
+| `keep_replacement` | proc | |
+| `default_replacement` | proc | |
+
+```ruby
+converter = Turndown::Converter.new(
+  heading_style: "atx",
+  code_block_style: "fenced",
+  fence: "~~~",
+  bullet_list_marker: "-"
+)
+```
+
+## Plugins
+
+GFM support ships in the same gem under `Turndown::Plugins::GFM`.
+
+```ruby
+require "turndown"
+
+converter = Turndown::Converter.new
+converter.use(Turndown::Plugins::GFM)
+
+puts converter.convert("<strike>Hello</strike>")
+# ~Hello~
+```
+
+Individual plugins can be used on their own:
+
+- `Turndown::Plugins::GFM` — all of the below
+- `Turndown::Plugins::GFM::Strikethrough`
+- `Turndown::Plugins::GFM::Tables`
+- `Turndown::Plugins::GFM::TaskListItems`
+- `Turndown::Plugins::GFM::HighlightedCodeBlock`
+
+## Custom rules
+
+Rules stay close to upstream Turndown, but use Ruby callables.
+
+### Add a rule
+
+```ruby
+converter = Turndown::Converter.new
+
+converter.add_rule(
+  :strikethrough,
+  filter: %w[del s strike],
+  replacement: ->(content, _node, _options) { "~~#{content}~~" }
+)
+```
+
+`filter` may be:
+
+- a tag name string
+- a tag name symbol
+- an array of tag names
+- a `Proc` receiving `(node, options)`
+
+### Keep raw HTML
+
+```ruby
+converter.keep(%w[del ins])
+```
+
+### Remove nodes
+
+```ruby
+converter.remove("script")
+```
+
+### Write a plugin
+
+Plugins are callables that receive the converter instance:
+
+```ruby
+MyPlugin = lambda do |converter|
+  converter.add_rule(
+    :callout,
+    filter: "aside",
+    replacement: ->(content, _node, _options) { "\n\n> #{content}\n\n" }
+  )
+end
+
+converter.use(MyPlugin)
+```
+
+## Escaping
+
+`converter.escape` exposes the Markdown escaping behavior used internally:
+
+```ruby
+converter = Turndown::Converter.new
+converter.escape("`not code`")
+# => "\\`not code\\`"
+```
+
+## Differences from the JavaScript version
+
+- The API is Ruby-first. There is no `TurndownService#turndown` alias — use
+  `Turndown::Converter#convert`.
+- Options are symbol keys in snake_case (`heading_style`), not camelCase
+  (`headingStyle`).
+- Rules and plugins are Ruby callables (`Proc`, `lambda`, or anything responding
+  to `#call`) rather than JavaScript functions.
+- Nokogiri is the only supported parser backend.
+
+## Parity with upstream
+
+The suite runs the upstream fixture corpus directly:
+
+- 149 upstream Turndown core fixtures
+- 18 upstream turndown-plugin-gfm fixtures
+- 10 Ruby-specific tests for Nokogiri inputs, rule registration, plugins, and
+  option handling
+
+The vendored fixture files live under `test/fixtures/upstream/`.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome at
+<https://github.com/bavmind/turndown>. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+Because this is a port, behavior changes should generally track upstream
+Turndown. If you find a case where this gem and upstream Turndown disagree,
+that is a bug — please include the HTML input and both outputs.
+
+## Credits
+
+This gem exists because of the work of others:
+
+- **[Turndown](https://github.com/mixmark-io/turndown)** by
+  **[Dom Christie](https://github.com/domchristie)** — the original project this
+  gem ports. Its conversion rules, behavior, and fixture corpus are the
+  reference implementation here.
+- **[turndown-plugin-gfm](https://github.com/mixmark-io/turndown-plugin-gfm)**,
+  also by Dom Christie, is the source of the bundled GFM plugin behavior.
+- **[collapse-whitespace](https://github.com/lucthev/collapse-whitespace)** by
+  **[Luc Thevenard](https://github.com/lucthev)** — Turndown's whitespace
+  collapsing logic is adapted from it, and this port follows that behavior.
+
+All three are MIT licensed. Their copyright notices are retained in
+[LICENSE](LICENSE).
+
+## License
+
+MIT © 2026 Devran Cosmo Uenal. Portions © 2017 Dom Christie and
+© 2014 Luc Thevenard. See [LICENSE](LICENSE).

data/lib/turndown/collapse_whitespace.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Adapted, by way of Turndown, from collapse-whitespace by Luc Thevenard.
+#
+# Copyright (c) 2014 Luc Thevenard <lucthevenard@gmail.com>
+# Released under the MIT License. See LICENSE for the full notice.
+
+module Turndown
+  module CollapseWhitespace
+    module_function
+
+    def call(element:, is_block:, is_void:, is_pre: nil)
+      is_pre ||= ->(node) { node.element? && node.name.casecmp("pre").zero? }
+      return if element.children.empty?
+      return if is_pre.call(element)
+
+      prev_text = nil
+      keep_leading_ws = false
+
+      prev = nil
+      node = next_node(prev, element, is_pre)
+
+      until node == element
+        if node.text? || node.cdata?
+          text = node.content.gsub(/[ \r\n\t]+/, " ")
+
+          if (!prev_text || prev_text.content.end_with?(" ")) &&
+             !keep_leading_ws &&
+             text.start_with?(" ")
+            text = text[1..] || ""
+          end
+
+          if text.empty?
+            node = remove(node)
+            next
+          end
+
+          node.content = text
+          prev_text = node
+        elsif node.element?
+          if is_block.call(Node.new(node, {})) || node.name.casecmp("br").zero?
+            prev_text.content = prev_text.content.sub(/ $/, "") if prev_text
+            prev_text = nil
+            keep_leading_ws = false
+          elsif is_void.call(Node.new(node, {})) || is_pre.call(node)
+            prev_text = nil
+            keep_leading_ws = true
+          elsif prev_text
+            keep_leading_ws = false
+          end
+        else
+          node = remove(node)
+          next
+        end
+
+        next_candidate = next_node(prev, node, is_pre)
+        prev = node
+        node = next_candidate
+      end
+
+      if prev_text
+        prev_text.content = prev_text.content.sub(/ $/, "")
+        prev_text.remove if prev_text.content.empty?
+      end
+    end
+
+    def remove(node)
+      next_node = node.next_sibling || node.parent
+      node.remove
+      next_node
+    end
+
+    def next_node(prev, current, is_pre)
+      if (prev && prev.parent == current) || is_pre.call(current)
+        current.next_sibling || current.parent
+      else
+        current.children.first || current.next_sibling || current.parent
+      end
+    end
+  end
+end

data/lib/turndown/commonmark_rules.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Turndown
+  class ReferenceLinkRule < Rule
+    def initialize
+      super(
+        filter: lambda do |node, options|
+          options[:link_style] == "referenced" &&
+            node.node_name == "A" &&
+            node.get_attribute("href")
+        end,
+        replacement: method(:replace),
+        append: method(:append_references)
+      )
+      @references = []
+    end
+
+    private
+
+    def replace(content, node, options)
+      href = CommonMarkRules.escape_link_destination(node.get_attribute("href"))
+      title = CommonMarkRules.clean_attribute(node.get_attribute("title"))
+      title = %( "#{CommonMarkRules.escape_link_title(title)}") unless title.empty?
+
+      case options[:link_reference_style]
+      when "collapsed"
+        replacement = "[#{content}][]"
+        reference = "[#{content}]: #{href}#{title}"
+      when "shortcut"
+        replacement = "[#{content}]"
+        reference = "[#{content}]: #{href}#{title}"
+      else
+        id = @references.length + 1
+        replacement = "[#{content}][#{id}]"
+        reference = "[#{id}]: #{href}#{title}"
+      end
+
+      @references << reference
+      replacement
+    end
+
+    def append_references(_options)
+      return "" if @references.empty?
+
+      output = "\n\n#{@references.join("\n")}\n\n"
+      @references = []
+      output
+    end
+  end
+
+  module CommonMarkRules
+    module_function
+
+    def build
+      {
+        paragraph: Rule.new(
+          filter: "p",
+          replacement: ->(content, _node, _options) { "\n\n#{content}\n\n" }
+        ),
+        line_break: Rule.new(
+          filter: "br",
+          replacement: ->(_content, _node, options) { "#{options[:br]}\n" }
+        ),
+        heading: Rule.new(
+          filter: %w[h1 h2 h3 h4 h5 h6],
+          replacement: lambda do |content, node, options|
+            h_level = node.node_name_downcase[1].to_i
+
+            if options[:heading_style] == "setext" && h_level < 3
+              underline = Utilities.repeat(h_level == 1 ? "=" : "-", content.length)
+              "\n\n#{content}\n#{underline}\n\n"
+            else
+              "\n\n#{Utilities.repeat('#', h_level)} #{content}\n\n"
+            end
+          end
+        ),
+        blockquote: Rule.new(
+          filter: "blockquote",
+          replacement: lambda do |content, _node, _options|
+            content = Utilities.trim_newlines(content).gsub(/^/, "> ")
+            "\n\n#{content}\n\n"
+          end
+        ),
+        list: Rule.new(
+          filter: %w[ul ol],
+          replacement: lambda do |content, node, _options|
+            parent = node.parent_node
+            if parent&.node_name == "LI" && parent.last_element_child&.same_node?(node)
+              "\n#{content}"
+            else
+              "\n\n#{content}\n\n"
+            end
+          end
+        ),
+        list_item: Rule.new(
+          filter: "li",
+          replacement: lambda do |content, node, options|
+            prefix = "#{options[:bullet_list_marker]}   "
+            parent = node.parent_node
+
+            if parent&.node_name == "OL"
+              start = parent.get_attribute("start")
+              index = parent.children.find_index { |child| child.same_node?(node) } || 0
+              prefix = "#{start ? start.to_i + index : index + 1}.  "
+            end
+
+            paragraph = content.end_with?("\n")
+            content = Utilities.trim_newlines(content)
+            content += "\n" if paragraph
+            content = content.gsub(/\n/, "\n#{' ' * prefix.length}")
+            "#{prefix}#{content}#{node.next_sibling ? "\n" : ""}"
+          end
+        ),
+        indented_code_block: Rule.new(
+          filter: lambda do |node, options|
+            options[:code_block_style] == "indented" &&
+              node.node_name == "PRE" &&
+              node.first_child &&
+              node.first_child.node_name == "CODE"
+          end,
+          replacement: lambda do |_content, node, _options|
+            code = node.first_child.text_content.gsub("\n", "\n    ")
+            "\n\n    #{code}\n\n"
+          end
+        ),
+        fenced_code_block: Rule.new(
+          filter: lambda do |node, options|
+            options[:code_block_style] == "fenced" &&
+              node.node_name == "PRE" &&
+              node.first_child &&
+              node.first_child.node_name == "CODE"
+          end,
+          replacement: lambda do |_content, node, options|
+            class_name = node.first_child.get_attribute("class").to_s
+            language = class_name[/language-(\S+)/, 1].to_s
+            code = node.first_child.text_content
+            fence_char = options[:fence][0]
+            fence_size = 3
+
+            code.scan(/^#{Regexp.escape(fence_char)}{3,}/).each do |match|
+              fence_size = match.length + 1 if match.length >= fence_size
+            end
+
+            fence = Utilities.repeat(fence_char, fence_size)
+            "\n\n#{fence}#{language}\n#{code.sub(/\n\z/, '')}\n#{fence}\n\n"
+          end
+        ),
+        horizontal_rule: Rule.new(
+          filter: "hr",
+          replacement: ->(_content, _node, options) { "\n\n#{options[:hr]}\n\n" }
+        ),
+        inline_link: Rule.new(
+          filter: lambda do |node, options|
+            options[:link_style] == "inlined" &&
+              node.node_name == "A" &&
+              node.get_attribute("href")
+          end,
+          replacement: lambda do |content, node, _options|
+            href = escape_link_destination(node.get_attribute("href"))
+            title = escape_link_title(clean_attribute(node.get_attribute("title")))
+            title_part = title.empty? ? "" : %( "#{title}")
+            "[#{content}](#{href}#{title_part})"
+          end
+        ),
+        reference_link: ReferenceLinkRule.new,
+        emphasis: Rule.new(
+          filter: %w[em i],
+          replacement: lambda do |content, _node, options|
+            next "" if content.strip.empty?
+
+            "#{options[:em_delimiter]}#{content}#{options[:em_delimiter]}"
+          end
+        ),
+        strong: Rule.new(
+          filter: %w[strong b],
+          replacement: lambda do |content, _node, options|
+            next "" if content.strip.empty?
+
+            "#{options[:strong_delimiter]}#{content}#{options[:strong_delimiter]}"
+          end
+        ),
+        code: Rule.new(
+          filter: lambda do |node, _options|
+            has_siblings = node.previous_sibling || node.next_sibling
+            is_code_block = node.parent_node&.node_name == "PRE" && !has_siblings
+            node.node_name == "CODE" && !is_code_block
+          end,
+          replacement: lambda do |content, _node, _options|
+            next "" if content.empty?
+
+            content = content.gsub(/\r?\n|\r/, " ")
+            extra_space =
+              if content.match?(/\A`/) || content.match?(/\A .*?[^ ].* \z/) || content.match?(/`\z/)
+                " "
+              else
+                ""
+              end
+
+            delimiter = "`"
+            matches = content.scan(/`+/)
+            delimiter += "`" while matches.include?(delimiter)
+
+            "#{delimiter}#{extra_space}#{content}#{extra_space}#{delimiter}"
+          end
+        ),
+        image: Rule.new(
+          filter: "img",
+          replacement: lambda do |_content, node, _options|
+            alt = Utilities.escape_markdown(clean_attribute(node.get_attribute("alt")))
+            src = escape_link_destination(node.get_attribute("src").to_s)
+            title = clean_attribute(node.get_attribute("title"))
+            title_part = title.empty? ? "" : %( "#{escape_link_title(title)}")
+            src.empty? ? "" : "![#{alt}](#{src}#{title_part})"
+          end
+        )
+      }
+    end
+
+    def clean_attribute(attribute)
+      attribute.to_s.gsub(/(\n+\s*)+/, "\n")
+    end
+
+    def escape_link_destination(destination)
+      escaped = destination.to_s.gsub(/([<>()])/, '\\\\\1')
+      escaped.include?(" ") ? "<#{escaped}>" : escaped
+    end
+
+    def escape_link_title(title)
+      title.to_s.gsub('"', '\"')
+    end
+  end
+end