Class: RDoc::Markup::ToMarkdown

### Home Classes Methods

### In Files

- lib/rdoc/markup/to_markdown.rb

### Parent

RDoc::Markup::ToRdoc

### Methods

- ::new
- #accept_list_end
- #accept_list_item_end
- #accept_list_item_start
- #accept_list_start
- #accept_rule
- #accept_verbatim
- #gen_url
- #handle_rdoc_link
- #handle_special_HARD_BREAK
- #handle_special_RDOCLINK
- #handle_special_TIDYLINK
- #init_tags

### Files

- CVE-2013-0256.rdoc
- DEVELOPERS.rdoc
- LICENSE.rdoc
- Manifest.txt
- README.rdoc
- RI.rdoc
- Rakefile
- TODO.rdoc

### Class/Module Index

Quicksearch

- RDoc
- RDoc::Alias
- RDoc::AnonClass
- RDoc::AnyMethod
- RDoc::Attr
- RDoc::ClassModule
- RDoc::CodeObject
- RDoc::Comment
- RDoc::Constant
- RDoc::Context
- RDoc::Context::Section
- RDoc::CrossReference
- RDoc::ERBIO
- RDoc::ERBPartial
- RDoc::Encoding
- RDoc::Error
- RDoc::Extend
- RDoc::Gauntlet
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::RI
- RDoc::GhostMethod
- RDoc::Include
- RDoc::Markdown
- RDoc::Markdown::Literals
- RDoc::Markup
- RDoc::Markup::AttrChanger
- RDoc::Markup::AttrSpan
- RDoc::Markup::AttributeManager
- RDoc::Markup::Attributes
- RDoc::Markup::BlankLine
- RDoc::Markup::BlockQuote
- RDoc::Markup::Document
- RDoc::Markup::Formatter
- RDoc::Markup::FormatterTestCase
- RDoc::Markup::HardBreak
- RDoc::Markup::Include
- RDoc::Markup::IndentedParagraph
- RDoc::Markup::List
- RDoc::Markup::ListItem
- RDoc::Markup::Paragraph
- RDoc::Markup::Parser
- RDoc::Markup::Parser::Error
- RDoc::Markup::Parser::ParseError
- RDoc::Markup::PreProcess
- RDoc::Markup::Raw
- RDoc::Markup::Rule
- RDoc::Markup::Special
- RDoc::Markup::TextFormatterTestCase
- RDoc::Markup::ToAnsi
- RDoc::Markup::ToBs
- RDoc::Markup::ToHtml
- RDoc::Markup::ToHtmlCrossref
- RDoc::Markup::ToHtmlSnippet
- RDoc::Markup::ToJoinedParagraph
- RDoc::Markup::ToLabel
- RDoc::Markup::ToMarkdown
- RDoc::Markup::ToRdoc
- RDoc::Markup::ToTableOfContents
- RDoc::Markup::ToTest
- RDoc::Markup::ToTtOnly
- RDoc::Markup::Verbatim
- RDoc::MetaMethod
- RDoc::MethodAttr
- RDoc::NormalClass
- RDoc::NormalModule
- RDoc::Options
- RDoc::Parser
- RDoc::Parser::C
- RDoc::Parser::ChangeLog
- RDoc::Parser::Markdown
- RDoc::Parser::RD
- RDoc::Parser::Ruby
- RDoc::Parser::RubyTools
- RDoc::Parser::Simple
- RDoc::Parser::Text
- RDoc::RD
- RDoc::RD::BlockParser
- RDoc::RD::Inline
- RDoc::RD::InlineParser
- RDoc::RDoc
- RDoc::RI
- RDoc::RI::Driver
- RDoc::RI::Driver::Error
- RDoc::RI::Driver::NotFoundError
- RDoc::RI::Error
- RDoc::RI::Paths
- RDoc::Require
- RDoc::RubyLex
- RDoc::RubyLex::Error
- RDoc::RubyToken
- RDoc::RubygemsHook
- RDoc::Servlet
- RDoc::SingleClass
- RDoc::Stats
- RDoc::Stats::Normal
- RDoc::Stats::Quiet
- RDoc::Stats::Verbose
- RDoc::Store
- RDoc::Store::Error
- RDoc::Store::MissingFileError
- RDoc::Task
- RDoc::Task
- RDoc::TestCase
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- Object

No matching classes.

# RDoc::Markup::ToMarkdown

Outputs parsed markup as Markdown

### Public Class Methods

new(markup = nil) click to toggle source

Creates a new formatter that will output Markdown format text

    # File lib/rdoc/markup/to_markdown.rb, line 11
    def initialize markup = nil
      super

      @headings[1] = ['# ',      '']
      @headings[2] = ['## ',     '']
      @headings[3] = ['### ',    '']
      @headings[4] = ['#### ',   '']
      @headings[5] = ['##### ',  '']
      @headings[6] = ['###### ', '']

      add_special_RDOCLINK
      add_special_TIDYLINK

      @hard_break = "  \n"
    end

### Public Instance Methods

accept_list_end(list) click to toggle source

Finishes consumption of `list`

    # File lib/rdoc/markup/to_markdown.rb, line 46
    def accept_list_end list
      @res << "\n"

      super
    end

accept_list_item_end(list_item) click to toggle source

Finishes consumption of `list_item`

    # File lib/rdoc/markup/to_markdown.rb, line 55
    def accept_list_item_end list_item
      width = case @list_type.last
              when :BULLET then
                4
              when :NOTE, :LABEL then
                use_prefix

                4
              else
                @list_index[-1] = @list_index.last.succ
                4
              end

      @indent -= width
    end

accept_list_item_start(list_item) click to toggle source

Prepares the visitor for consuming `list_item`

    # File lib/rdoc/markup/to_markdown.rb, line 74
    def accept_list_item_start list_item
      type = @list_type.last

      case type
      when :NOTE, :LABEL then
        bullets = Array(list_item.label).map do |label|
          attributes(label).strip
        end.join "\n"

        bullets << "\n:"

        @prefix = ' ' * @indent
        @indent += 4
        @prefix << bullets + (' ' * (@indent - 1))
      else
        bullet = type == :BULLET ? '*' : @list_index.last.to_s + '.'
        @prefix = (' ' * @indent) + bullet.ljust(4)

        @indent += 4
      end
    end

accept_list_start(list) click to toggle source

Prepares the visitor for consuming `list`

    # File lib/rdoc/markup/to_markdown.rb, line 99
    def accept_list_start list
      case list.type
      when :BULLET, :LABEL, :NOTE then
        @list_index << nil
      when :LALPHA, :NUMBER, :UALPHA then
        @list_index << 1
      else
        raise RDoc::Error, "invalid list type #{list.type}"
      end

      @list_width << 4
      @list_type << list.type
    end

accept_rule(rule) click to toggle source

Adds `rule` to the output

    # File lib/rdoc/markup/to_markdown.rb, line 116
    def accept_rule rule
      use_prefix or @res << ' ' * @indent
      @res << '-' * 3
      @res << "\n"
    end

accept_verbatim(verbatim) click to toggle source

Outputs `verbatim` indented 4 columns

    # File lib/rdoc/markup/to_markdown.rb, line 125
    def accept_verbatim verbatim
      indent = ' ' * (@indent + 4)

      verbatim.parts.each do |part|
        @res << indent unless part == "\n"
        @res << part
      end

      @res << "\n" unless @res =~ /\n\z/
    end

gen_url(url, text) click to toggle source

Creates a Markdown-style URL from `url` with `text`.

    # File lib/rdoc/markup/to_markdown.rb, line 139
    def gen_url url, text
      scheme, url, = parse_url url

      "[#{text.sub(%r{^#{scheme}:/*}i, '')}](#{url})"
    end

handle_rdoc_link(url) click to toggle source

Handles `rdoc-` type links for footnotes.

    # File lib/rdoc/markup/to_markdown.rb, line 148
    def handle_rdoc_link url
      case url
      when /\Ardoc-ref:/ then
        $'
      when /\Ardoc-label:footmark-(\d+)/ then
        "[^#{$1}]:"
      when /\Ardoc-label:foottext-(\d+)/ then
        "[^#{$1}]"
      when /\Ardoc-label:label-/ then
        gen_url url, $'
      when /\Ardoc-[a-z]+:/ then
        $'
      end
    end

handle_special_HARD_BREAK(special) click to toggle source

Adds a newline to the output

    # File lib/rdoc/markup/to_markdown.rb, line 39
    def handle_special_HARD_BREAK special
      "  \n"
    end

handle_special_RDOCLINK(special) click to toggle source

Converts the rdoc-...: links into a Markdown.style links.

    # File lib/rdoc/markup/to_markdown.rb, line 184
    def handle_special_RDOCLINK special
      handle_rdoc_link special.text
    end

handle_special_TIDYLINK(special) click to toggle source

Converts the RDoc markup tidylink into a Markdown.style link.

    # File lib/rdoc/markup/to_markdown.rb, line 166
    def handle_special_TIDYLINK special
      text = special.text

      return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/

      label = $1
      url   = $2

      if url =~ /^rdoc-label:foot/ then
        handle_rdoc_link url
      else
        gen_url url, label
      end
    end

init_tags() click to toggle source

Maps attributes to HTML sequences

    # File lib/rdoc/markup/to_markdown.rb, line 30
    def init_tags
      add_tag :BOLD, '**', '**'
      add_tag :EM,   '*',  '*'
      add_tag :TT,   '`',  '`'
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.