Class: RDoc::Markup::Formatter

Inherits:
Object
  • Object
show all
Defined in:
lib/rdoc/markup/formatter.rb

Defined Under Namespace

Classes: InlineTag

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options, markup = nil) ⇒ Formatter

Creates a new Formatter



51
52
53
54
55
56
57
 
# File 'lib/rdoc/markup/formatter.rb', line 51

def initialize(options, markup = nil)
  @options = options

  @markup = markup || RDoc::Markup.new

  @from_path = '.'
end

Class Method Details

.gen_relative_url(path, target) ⇒ Object

Converts a target url to one that is relative to a given path



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/rdoc/markup/formatter.rb', line 27

def self.gen_relative_url(path, target)
  from        = File.dirname path
  to, to_file = File.split target

  from = from.split "/"
  to   = to.split "/"

  from.delete '.'
  to.delete '.'

  while from.size > 0 and to.size > 0 and from[0] == to[0] do
    from.shift
    to.shift
  end

  from.fill ".."
  from.concat to
  from << to_file
  File.join(*from)
end

Instance Method Details

#accept_document(document) ⇒ Object

Adds document to the output



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/rdoc/markup/formatter.rb', line 62

def accept_document(document)
  document.parts.each do |item|
    case item
    when RDoc::Markup::Document then # HACK
      accept_document item
    else
      item.accept self
    end
  end
end

#add_regexp_handling_RDOCLINK ⇒ Object

Adds a regexp handling for links of the form rdoc-…:



76
77
78
 
# File 'lib/rdoc/markup/formatter.rb', line 76

def add_regexp_handling_RDOCLINK
  @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
end

#annotate(tag) ⇒ Object

Allows tag to be decorated with additional information.



83
84
85
 
# File 'lib/rdoc/markup/formatter.rb', line 83

def annotate(tag)
  tag
end

#apply_regexp_handling(text) ⇒ Object

Applies regexp handling to text and returns an array of [text, converted?] pairs.



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
121
122
123
 
# File 'lib/rdoc/markup/formatter.rb', line 96

def apply_regexp_handling(text)
  output = []
  start = 0
  loop do
    pos = text.size
    matched_name = matched_text = nil
    @markup.regexp_handlings.each do |pattern, name|
      m = text.match(pattern, start)
      next unless m
      idx = m[1] ? 1 : 0
      if m.begin(idx) < pos
        pos = m.begin(idx)
        matched_text = m[idx]
        matched_name = name
      end
    end
    output << [text[start...pos], false] if pos > start
    if matched_name
      handled = public_send(:"handle_regexp_#{matched_name}", matched_text)
      output << [handled, true]
      start = pos + matched_text.size
    else
      start = pos
    end
    break if pos == text.size
  end
  output
end

#convert(content) ⇒ Object

Marks up content



90
91
92
 
# File 'lib/rdoc/markup/formatter.rb', line 90

def convert(content)
  @markup.convert content, self
end

#convert_string(string) ⇒ Object

Converts a string to be fancier if desired



243
244
245
 
# File 'lib/rdoc/markup/formatter.rb', line 243

def convert_string(string)
  string
end

#handle_BOLD(nodes) ⇒ Object

Called when processing bold nodes while traversing inline nodes from handle_inline. Traverse the children nodes and dispatch to the appropriate handlers.



158
159
160
 
# File 'lib/rdoc/markup/formatter.rb', line 158

def handle_BOLD(nodes)
  traverse_inline_nodes(nodes)
end

#handle_BOLD_WORD(word) ⇒ Object

Called when processing bold word nodes while traversing inline nodes from handle_inline. word may need proper escaping.



172
173
174
 
# File 'lib/rdoc/markup/formatter.rb', line 172

def handle_BOLD_WORD(word)
  handle_PLAIN_TEXT(word)
end

#handle_EM(nodes) ⇒ Object

Called when processing emphasis nodes while traversing inline nodes from handle_inline. Traverse the children nodes and dispatch to the appropriate handlers.



165
166
167
 
# File 'lib/rdoc/markup/formatter.rb', line 165

def handle_EM(nodes)
  traverse_inline_nodes(nodes)
end

#handle_EM_WORD(word) ⇒ Object

Called when processing emphasis word nodes while traversing inline nodes from handle_inline. word may need proper escaping.



179
180
181
 
# File 'lib/rdoc/markup/formatter.rb', line 179

def handle_EM_WORD(word)
  handle_PLAIN_TEXT(word)
end

#handle_HARD_BREAK ⇒ Object

Called when processing a hard break while traversing inline nodes from handle_inline.



152
153
 
# File 'lib/rdoc/markup/formatter.rb', line 152

def handle_HARD_BREAK
end

#handle_inline(text) ⇒ Object

Parses inline text, traverse the resulting nodes, and calls the appropriate handler methods.



208
209
210
211
 
# File 'lib/rdoc/markup/formatter.rb', line 208

def handle_inline(text)
  nodes = RDoc::Markup::InlineParser.new(text).parse
  traverse_inline_nodes(nodes)
end

#handle_PLAIN_TEXT(text) ⇒ Object

Called when processing plain text while traversing inline nodes from handle_inline. text may need proper escaping.



128
129
 
# File 'lib/rdoc/markup/formatter.rb', line 128

def handle_PLAIN_TEXT(text)
end

#handle_REGEXP_HANDLING_TEXT(text) ⇒ Object

Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline. text may contain markup tags.



134
135
 
# File 'lib/rdoc/markup/formatter.rb', line 134

def handle_REGEXP_HANDLING_TEXT(text)
end

#handle_STRIKE(nodes) ⇒ Object

Called when processing strike nodes while traversing inline nodes from handle_inline. Traverse the children nodes and dispatch to the appropriate handlers.



193
194
195
 
# File 'lib/rdoc/markup/formatter.rb', line 193

def handle_STRIKE(nodes)
  traverse_inline_nodes(nodes)
end

#handle_TEXT(text) ⇒ Object

Called when processing text node while traversing inline nodes from handle_inline. Apply regexp handling and dispatch to the appropriate handler: handle_REGEXP_HANDLING_TEXT or handle_PLAIN_TEXT.



140
141
142
143
144
145
146
147
148
 
# File 'lib/rdoc/markup/formatter.rb', line 140

def handle_TEXT(text)
  apply_regexp_handling(text).each do |part, converted|
    if converted
      handle_REGEXP_HANDLING_TEXT(part)
    else
      handle_PLAIN_TEXT(part)
    end
  end
end

#handle_TIDYLINK(label_part, url) ⇒ Object

Called when processing tidylink nodes while traversing inline nodes from handle_inline. label_part is an array of strings or nodes representing the link label. url is the link URL. Traverse the label_part nodes and dispatch to the appropriate handlers.



202
203
204
 
# File 'lib/rdoc/markup/formatter.rb', line 202

def handle_TIDYLINK(label_part, url)
  traverse_inline_nodes(label_part)
end

#handle_TT(code) ⇒ Object

Called when processing tt nodes while traversing inline nodes from handle_inline. code may need proper escaping.



186
187
188
 
# File 'lib/rdoc/markup/formatter.rb', line 186

def handle_TT(code)
  handle_PLAIN_TEXT(code)
end

#ignore(*node) ⇒ Object

Use ignore in your subclass to ignore the content of a node.

##
# We don't support raw nodes in ToNoRaw

alias accept_raw ignore



255
256
 
# File 'lib/rdoc/markup/formatter.rb', line 255

def ignore *node
end

#parse_url(url) ⇒ Object

Extracts and a scheme, url and an anchor id from url and returns them.



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/rdoc/markup/formatter.rb', line 261

def parse_url(url)
  case url
  when /^rdoc-label:([^:]*)(?::(.*))?/ then
    scheme = 'link'
    path   = "##{$1}"
    id     = " id=\"#{$2}\"" if $2
  when /([A-Za-z]+):(.*)/ then
    scheme = $1.downcase
    path   = $2
  when /^#/ then
  else
    scheme = 'http'
    path   = url
    url    = url
  end

  if scheme == 'link' then
    url = if path[0, 1] == '#' then # is this meaningful?
            path
          else
            self.class.gen_relative_url @from_path, path
          end
  end

  [scheme, url, id]
end

#traverse_inline_nodes(nodes) ⇒ Object

Traverses nodes and calls the appropriate handler methods Nodes formats are described in RDoc::Markup::InlineParser#parse



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/rdoc/markup/formatter.rb', line 216

def traverse_inline_nodes(nodes)
  nodes.each do |node|
    next handle_TEXT(node) if String === node
    case node[:type]
    when :TIDYLINK
      handle_TIDYLINK(node[:children], node[:url])
    when :HARD_BREAK
      handle_HARD_BREAK
    when :BOLD
      handle_BOLD(node[:children])
    when :BOLD_WORD
      handle_BOLD_WORD(node[:children][0] || '')
    when :EM
      handle_EM(node[:children])
    when :EM_WORD
      handle_EM_WORD(node[:children][0] || '')
    when :TT
      handle_TT(node[:children][0] || '')
    when :STRIKE
      handle_STRIKE(node[:children])
    end
  end
end

#tt?(tag) ⇒ Boolean

Is tag a tt tag?

Returns:

  • (Boolean) 


291
292
293
 
# File 'lib/rdoc/markup/formatter.rb', line 291

def tt?(tag)
  tag.bit == @tt_bit
end