Class: RDoc::TomDoc

Inherits:
Markup::Parser show all
Defined in:
lib/rdoc/tom_doc.rb

Overview

A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)

The TomDoc specification can be found at tomdoc.org.

To choose TomDoc as your only default format see RDoc::Options@Saved+Options for instructions on setting up a .rdoc_options file to store your project default.

There are a few differences between this parser and the specification. A best-effort was made to follow the specification as closely as possible but some choices to deviate were made.

A future version of RDoc will warn when a MUST or MUST NOT is violated and may warn when a SHOULD or SHOULD NOT is violated. RDoc will always try to emit documentation even if given invalid TomDoc.

Here are some implementation choices this parser currently makes:

This parser allows rdoc-style inline markup but you should not depended on it.

This parser allows a space between the comment and the method body.

This parser does not require the default value to be described for an optional argument.

This parser does not examine the order of sections. An Examples section may precede the Arguments section.

This class is documented in TomDoc format. Since this is a subclass of the RDoc markup parser there isn’t much to see here, unfortunately.

Constant Summary

Constants inherited from Markup::Parser

Markup::Parser::LIST_TOKENS

Constants included from Text

RDoc::Text::MARKUP_FORMAT, RDoc::Text::SPACE_SEPARATED_LETTER_CLASS, RDoc::Text::TO_HTML_CHARACTERS

Instance Attribute Summary collapse

Attributes inherited from Markup::Parser

#debug

Attributes included from Text

#language

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Markup::Parser

#build_list, #get, #parse, #peek_token, #setup_scanner, #skip, tokenize, #unget

Methods included from Text

encode_fallback, #expand_tabs, #flush_left, #markup, #normalize_comment, #parse, #snippet, #strip_hashes, #strip_newlines, #strip_stars, #to_html, #wrap

Constructor Details

#initialize ⇒ TomDoc

Public: Creates a new TomDoc parser. See also RDoc::Markup::parse



124
125
126
127
128
129
 
# File 'lib/rdoc/tom_doc.rb', line 124

def initialize
  super

  @section      = nil
  @seen_returns = false
end

Instance Attribute Details

#tokens ⇒ Object (readonly)

Internal: Token accessor



40
41
42
 
# File 'lib/rdoc/tom_doc.rb', line 40

def tokens
  @tokens
end

Class Method Details

.add_post_processor ⇒ Object

Internal: Adds a post-processor which sets the RDoc section based on the comment’s status.

Returns nothing.



47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/rdoc/tom_doc.rb', line 47

def self.add_post_processor # :nodoc:
  RDoc::Markup::PreProcess.post_process do |comment, code_object|
    next unless code_object and
                RDoc::Comment === comment and comment.format == 'tomdoc'

    comment.text.gsub!(/(\A\s*# )(Public|Internal|Deprecated):\s+/) do
      section = code_object.add_section $2
      code_object.temporary_section = section

      $1
    end
  end
end

.parse(text) ⇒ Object

Public: Parses TomDoc from text

text - A String containing TomDoc-format text.

Examples

RDoc::TomDoc.parse <<-TOMDOC
This method does some things

Returns nothing.
TOMDOC
# => #<RDoc::Markup::Document:0xXXX @parts=[...], @file=nil>

Returns an RDoc::Markup::Document representing the TomDoc format.



78
79
80
81
82
83
84
85
 
# File 'lib/rdoc/tom_doc.rb', line 78

def self.parse text
  parser = new

  parser.tokenize text
  doc = RDoc::Markup::Document.new
  parser.parse doc
  doc
end

.signature(comment) ⇒ Object

Internal: Extracts the Signature section’s method signature

comment - An RDoc::Comment that will be parsed and have the signature

extracted

Returns a String containing the signature and nil if not



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/rdoc/tom_doc.rb', line 94

def self.signature comment
  return unless comment.tomdoc?

  document = comment.parse

  signature = nil
  found_heading = false
  found_signature = false

  document.parts.delete_if do |part|
    next false if found_signature

    found_heading ||=
      RDoc::Markup::Heading === part && part.text == 'Signature'

    next false unless found_heading

    next true if RDoc::Markup::BlankLine === part

    if RDoc::Markup::Verbatim === part then
      signature = part
      found_signature = true
    end
  end

  signature and signature.text
end

Instance Method Details

#build_heading(level) ⇒ Object

Internal: Builds a heading from the token stream

level - The level of heading to create

Returns an RDoc::Markup::Heading



137
138
139
140
141
142
143
 
# File 'lib/rdoc/tom_doc.rb', line 137

def build_heading level
  heading = super

  @section = heading.text

  heading
end

#build_paragraph(margin) ⇒ Object

Internal: Builds a paragraph from the token stream

margin - Unused

Returns an RDoc::Markup::Paragraph.



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/rdoc/tom_doc.rb', line 167

def build_paragraph margin
  p :paragraph_start => margin if @debug

  paragraph = RDoc::Markup::Paragraph.new

  until @tokens.empty? do
    type, data, = get

    case type
    when :TEXT then
      @section = 'Returns' if data =~ /\A(Returns|Raises)/

      paragraph << data
    when :NEWLINE then
      if :TEXT == peek_token[0] then
        # Lines beginning with 'Raises' in the Returns section should not be
        # treated as multiline text
        if 'Returns' == @section and
          peek_token[1].start_with?('Raises') then
          break
        else
          paragraph << ' '
        end
      else
        break
      end
    else
      unget
      break
    end
  end

  p :paragraph_end => margin if @debug

  paragraph
end

#build_verbatim(margin) ⇒ Object

Internal: Builds a verbatim from the token stream. A verbatim in the Examples section will be marked as in Ruby format.

margin - The indentation from the margin for lines that belong to this

verbatim section.

Returns an RDoc::Markup::Verbatim



153
154
155
156
157
158
159
 
# File 'lib/rdoc/tom_doc.rb', line 153

def build_verbatim margin
  verbatim = super

  verbatim.format = :ruby if @section == 'Examples'

  verbatim
end

#parse_text(parent, indent) ⇒ Object

Detects a section change to “Returns” and adds a heading



207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/rdoc/tom_doc.rb', line 207

def parse_text parent, indent # :nodoc:
  paragraph = build_paragraph indent

  if false == @seen_returns and 'Returns' == @section then
    @seen_returns = true
    parent << RDoc::Markup::Heading.new(3, 'Returns')
    parent << RDoc::Markup::BlankLine.new
  end

  parent << paragraph
end

#tokenize(text) ⇒ Object

Internal: Turns text into an Array of tokens

text - A String containing TomDoc-format text.

Returns self.



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/rdoc/tom_doc.rb', line 225

def tokenize text
  text = text.sub(/\A(Public|Internal|Deprecated):\s+/, '')

  setup_scanner text

  until @s.eos? do
    pos = @s.pos

    # leading spaces will be reflected by the column of the next token
    # the only thing we loose are trailing spaces at the end of the file
    next if @s.scan(/ +/)

    @tokens << case
               when @s.scan(/\r?\n/) then
                 token = [:NEWLINE, @s.matched, *pos]
                 @s.newline!
                 token
               when @s.scan(/(Examples|Signature)$/) then
                 @tokens << [:HEADER, 3, *pos]

                 [:TEXT, @s[1], *pos]
               when @s.scan(/([:\w][\w\[\]]*)[ ]+- /) then
                 [:NOTE, @s[1], *pos]
               else
                 @s.scan(/.*/)
                 [:TEXT, @s.matched.sub(/\r$/, ''), *pos]
               end
  end

  self
end