Module: MaRuKu::In::Markdown::SpanLevelParser
- Includes:
- Helpers
- Included in:
- BlockLevelParser, MDDocument
- Defined in:
- lib/maruku.rb,
lib/maruku/attributes.rb,
lib/maruku/input/rubypants.rb,
lib/maruku/input/charsource.rb,
lib/maruku/input/parse_span.rb,
lib/maruku/input/html_helper.rb
Defined Under Namespace
Classes: CaptureRule, CharSourceDebug, CharSourceManual, CharSourceStrscan, HTMLHelper, ReplaceRule, Rule, SpanContext
Constant Summary collapse
- Punct_class =
'[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
- Close_class =
"[^\ \t\r\n\\[\{\(\-]"
- Rules =
All the rules that will be applied (in order) to smarten the document.
[ ['---', :mdash ], ['--', :ndash ], ['...', :hellip ], ['. . .', :hellip ], ["``", :ldquo ], ["''", :rdquo ], [/<<\s/, [:laquo, :nbsp] ], [/\s>>/, [:nbsp, :raquo] ], ['<<', :laquo ], ['>>', :raquo ], # Special case if the very first character is a quote followed by # punctuation at a non-word-break. Close the quotes by brute # force: [/\A'(?=#{Punct_class}\B)/, :rsquo], [/\A"(?=#{Punct_class}\B)/, :rdquo], # Special case for double sets of quotes, e.g.: # <p>He said, "'Quoted' words in a larger quote."</p> [/"'(?=\w)/, [:ldquo, :lsquo] ], [/'"(?=\w)/, [:lsquo, :ldquo] ], # Special case for decade abbreviations (the '80s): [/'(?=\d\ds)/, :rsquo ], # Get most opening single quotes: [/(\s)'(?=\w)/, [:one, :lsquo] ], # Single closing quotes: [/(#{Close_class})'/, [:one, :rsquo]], [/'(\s|s\b|$)/, [:rsquo, :one]], # Any remaining single quotes should be opening ones: ["'", :lsquo], # Get most opening double quotes: [/(\s)"(?=\w)/, [:one, :ldquo]], # Double closing quotes: [/(#{Close_class})"/, [:one, :rdquo]], [/"(\s|s\b|$)/, [:rdquo, :one]], # Any remaining quotes should be opening ones: ['"', :ldquo] ]. map do |reg, subst| # People should do the thinking, machines should do the work. captures = false subst = Array(subst).map do |s| if s == :one captures = true s else MaRuKu::MDElement.new(:entity, [], { :entity_name => s.to_s.freeze }, nil) end end.freeze if captures CaptureRule.new reg, subst else ReplaceRule.new reg, subst end end
- CharSource =
Choose!
CharSourceManual
- EscapedCharInText =
'\\`*_{}[]()#.!|:+->'.split(//)
- EscapedCharInQuotes =
EscapedCharInText + ["'", '"']
- EscapedCharInInlineCode =
['\\', '`']
- IgnoreWikiLinks =
Instance Method Summary collapse
-
#apply_one_rule!(rule, input) ⇒ Object
Fully apply a single rule to an entire array of elements.
-
#educate(elements) ⇒ Object
Transform elements to have SmartyPants punctuation.
- #extension_meta(src, con, break_on_chars = nil) ⇒ Object
-
#interpret_extension(src, con, break_on_chars = nil) ⇒ Object
Start: cursor on character after ‘End: curson on ‘’ or EOF.
- #md_al(s = []) ⇒ Object
- #merge_ial(elements, src, con) ⇒ Object
- #parse_span(string, parent = nil) ⇒ Object
- #read_attribute_list(src, con = nil, break_on_chars = nil) ⇒ AttributeList?
- #read_em(src, delim) ⇒ Object
- #read_email_el(src, con) ⇒ Object
- #read_emstrong(src, delim) ⇒ Object
- #read_footnote_ref(src, con) ⇒ Object
-
#read_image(src, con) ⇒ Object
read link.
- #read_inline_code(src, con) ⇒ Object
- #read_inline_html(src, con) ⇒ Object
- #read_link(src, con) ⇒ Object
-
#read_quoted(src, con) ⇒ Object
Tries to read a quoted value.
- #read_quoted_or_unquoted(src, con, escaped, exit_on_chars) ⇒ Object
-
#read_ref_id(src, con) ⇒ Object
Reads a bracketed id “[refid]”.
-
#read_simple(src, escaped, exit_on_chars = nil, exit_on_strings = nil, warn = true) ⇒ Object
Reads a simple string (no formatting) until one of break_on_chars, while escaping the escaped.
-
#read_span(src, escaped, exit_on_chars = nil, exit_on_strings = nil) ⇒ Object
This is the main loop for reading span elements.
- #read_strong(src, delim) ⇒ Object
- #read_url(src, break_on) ⇒ Object
- #read_url_el(src, con) ⇒ Object
- #read_xml_instr_span(src, con) ⇒ Object
Methods included from Helpers
#md_abbr, #md_abbr_def, #md_ald, #md_br, #md_code, #md_codeblock, #md_el, #md_em, #md_email, #md_emstrong, #md_entity, #md_foot_ref, #md_footnote, #md_header, #md_hrule, #md_html, #md_ial, #md_im_image, #md_im_link, #md_image, #md_li, #md_link, #md_par, #md_quote, #md_ref_def, #md_strong, #md_url, #md_xml_instr
Instance Method Details
#apply_one_rule!(rule, input) ⇒ Object
Fully apply a single rule to an entire array of elements. note: input will be modified in place
278 279 280 281 282 283 284 285 286 287 288 289 |
# File 'lib/maruku/input/rubypants.rb', line 278 def apply_one_rule!(rule, input) output = [] while first = input.shift if first.kind_of?(String) rule.doc = @doc rule.apply(first, input, output) else output << first end end output end |
#educate(elements) ⇒ Object
Transform elements to have SmartyPants punctuation.
292 293 294 295 296 |
# File 'lib/maruku/input/rubypants.rb', line 292 def educate(elements) Rules.inject(elements) do |elems, rule| apply_one_rule!(rule, elems) end end |
#extension_meta(src, con, break_on_chars = nil) ⇒ Object
270 271 272 273 274 275 276 277 278 279 280 |
# File 'lib/maruku/input/parse_span.rb', line 270 def (src, con, break_on_chars=nil) if m = src.read_regexp(/([^\s\:\"\'}]+?):/) name = m[1] al = read_attribute_list(src, con, break_on_chars) self.doc.ald[name] = al con.push md_ald(name, al) else al = read_attribute_list(src, con, break_on_chars) con.push md_ial(al) end end |
#interpret_extension(src, con, break_on_chars = nil) ⇒ Object
Start: cursor on character after ‘End: curson on ‘’ or EOF
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 |
# File 'lib/maruku/input/parse_span.rb', line 249 def interpret_extension(src, con, break_on_chars=nil) case src.cur_char when ':' src.ignore_char # : (src, con, break_on_chars) when '#', '.' (src, con, break_on_chars) else stuff = read_simple(src, '}', break_on_chars) if stuff =~ /^(\w+\s|[^\w])/ extension_id = $1.strip maruku_recover "I don't know what to do with extension '#{extension_id}'\n" + "I will treat this:\n\t{#{stuff}} \n as meta-data.\n", src, con else maruku_recover "I will treat this:\n\t{#{stuff}} \n as meta-data.\n", src, con end (src, con, break_on_chars) end end |
#md_al(s = []) ⇒ Object
28 29 30 |
# File 'lib/maruku/attributes.rb', line 28 def md_al(s = []) AttributeList.new(s) end |
#merge_ial(elements, src, con) ⇒ Object
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 |
# File 'lib/maruku/attributes.rb', line 91 def merge_ial(elements, src, con) # Apply each IAL to the element before (elements + [nil]).each_cons(3) do |before, e, after| next unless ial?(e) if before.kind_of? MDElement before.al = e.ial elsif after.kind_of? MDElement after.al = e.ial else maruku_error <<ERR, src, con It's unclear which element the attribute list {:#{e.ial.to_s}} is referring to. The element before is a #{before.class}, the element after is a #{after.class}. before: #{before.inspect} after: #{after.inspect} ERR end end unless Globals[:debug_keep_ials] elements.delete_if {|x| ial?(x) && x != elements.first} end end |
#parse_span(string, parent = nil) ⇒ Object
11 12 13 14 15 |
# File 'lib/maruku/input/parse_span.rb', line 11 def parse_span(string, parent=nil) string = Array(string).join("\n") unless string.kind_of? String src = MaRuKu::In::Markdown::SpanLevelParser::CharSource.new(string, parent) read_span(src, EscapedCharInText, [nil]) end |
#read_attribute_list(src, con = nil, break_on_chars = nil) ⇒ AttributeList?
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
# File 'lib/maruku/attributes.rb', line 33 def read_attribute_list(src, con=nil, break_on_chars=nil) break_on_chars = Array(break_on_chars) separators = break_on_chars + ['=', ' ', "\t"] escaped = Maruku::EscapedCharInQuotes al = AttributeList.new loop do src.consume_whitespace break if break_on_chars.include? src.cur_char case src.cur_char when ':' src.ignore_char when nil break # we're done here. when '=' # error src.ignore_char maruku_error "In attribute lists, cannot start identifier with `=`." tell_user "Ignoring and continuing." when '#' # id definition src.ignore_char if id = read_quoted_or_unquoted(src, con, escaped, separators) al << [:id, id] else maruku_error 'Could not read `id` attribute.', src, con tell_user 'Ignoring bad `id` attribute.' end when '.' # class definition src.ignore_char if klass = read_quoted_or_unquoted(src, con, escaped, separators) al << [:class, klass] else maruku_error 'Could not read `class` attribute.', src, con tell_user 'Ignoring bad `class` attribute.' end else unless key = read_quoted_or_unquoted(src, con, escaped, separators) maruku_error 'Could not read key or reference.' next end if src.cur_char != '=' && key.length > 0 al << [:ref, key] next end src.ignore_char # skip the = if val = read_quoted_or_unquoted(src, con, escaped, separators) al << [key, val] else maruku_error "Could not read value for key #{key.inspect}.", src, con tell_user "Ignoring key #{key.inspect}" end end end al end |
#read_em(src, delim) ⇒ Object
378 379 380 381 382 383 |
# File 'lib/maruku/input/parse_span.rb', line 378 def read_em(src, delim) src.ignore_char children = read_span(src, EscapedCharInText, nil, delim) src.ignore_char md_em(children) end |
#read_email_el(src, con) ⇒ Object
290 291 292 293 294 295 296 297 |
# File 'lib/maruku/input/parse_span.rb', line 290 def read_email_el(src,con) src.ignore_char # leading < mail = read_simple(src, nil, '>') src.ignore_char # closing > address = mail.gsub(/^mailto:/, '') con.push_element md_email(address) end |
#read_emstrong(src, delim) ⇒ Object
392 393 394 395 396 397 |
# File 'lib/maruku/input/parse_span.rb', line 392 def read_emstrong(src, delim) src.ignore_chars(3) children = read_span(src, EscapedCharInText, nil, delim) src.ignore_chars(3) md_emstrong(children) end |
#read_footnote_ref(src, con) ⇒ Object
409 410 411 412 |
# File 'lib/maruku/input/parse_span.rb', line 409 def read_footnote_ref(src,con) ref = read_ref_id(src,con) con.push_element md_foot_ref(ref) end |
#read_image(src, con) ⇒ Object
read link
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 |
# File 'lib/maruku/input/parse_span.rb', line 542 def read_image(src, con) src.ignore_chars(2) # opening "![" alt_text = read_span(src, EscapedCharInText, ']') src.ignore_char # closing bracket # ignore space if src.cur_char == ' ' && ['[', '('].include?(src.next_char) src.ignore_char end case src.cur_char when '(' src.ignore_char # opening ( src.consume_whitespace url = read_url(src, [' ', "\t", ')']) unless url maruku_error "Could not read url from #{src.cur_chars(10).inspect}", src, con end src.consume_whitespace title = nil if src.cur_char != ')' # we have a title quote_char = src.cur_char title = read_quoted(src, con) if !title maruku_error 'Must quote title', src, con else # Tries to read a title with quotes: ![a](url "ti"tle") # this is the most ugly thing in Markdown if !src.next_matches(/\s*\)/) # if there is not a closing par ), then read # the rest and guess it's title with quotes rest = read_simple(src, nil, ')', nil) # chop the closing char rest.chop! title << quote_char << rest end end end src.consume_whitespace closing = src.shift_char # closing ) if closing != ')' maruku_error "Unclosed link: '#{closing}'" + " Read url=#{url.inspect} title=#{title.inspect}", src, con end con.push_element md_im_image(alt_text, url, title) when '[' # link ref ref_id = read_ref_id(src, con) if !ref_id # TODO: check around maruku_error 'Reference not closed.', src, con ref_id = "" end con.push_element md_image(alt_text, ref_id) else # no stuff ref_id = alt_text.join con.push_element md_image(alt_text, ref_id) end end |
#read_inline_code(src, con) ⇒ Object
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 |
# File 'lib/maruku/input/parse_span.rb', line 440 def read_inline_code(src, con) # Count the number of ticks num_ticks = 0 while src.cur_char == '`' num_ticks += 1 src.ignore_char end # We will read until this string end_string = "`" * num_ticks code = read_simple(src, nil, nil, end_string) # We didn't find a closing batch! if !code || src.cur_char != '`' con.push_element(end_string + (code || '')) and return end # We didn't find a closing batch! if !code || src.cur_char != '`' con.push_element(end_string + (code || '')) return end # puts "Now I expects #{num_ticks} ticks: #{src.cur_chars(10).inspect}" src.ignore_chars num_ticks # Ignore at most one space if num_ticks > 1 && code[0, 1] == ' ' code = code[1..-1] end # drop last space if num_ticks > 1 && code[-1, 1] == ' ' code = code[0..-2] end # puts "Read `` code: #{code.inspect}; after: #{src.cur_chars(10).inspect} " con.push_element md_code(code) end |
#read_inline_html(src, con) ⇒ Object
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 |
# File 'lib/maruku/input/parse_span.rb', line 414 def read_inline_html(src, con) h = HTMLHelper.new begin # This is our current buffer in the context next_stuff = src.current_remaining_buffer consumed = 0 while true if consumed >= next_stuff.size maruku_error "Malformed HTML starting at #{next_stuff.inspect}", src, con break end h.eat_this next_stuff[consumed].chr consumed += 1 break if h.is_finished? end src.ignore_chars(consumed) con.push_element md_html(h.stuff_you_read) rescue => e maruku_error "Bad html: \n" + e.inspect.gsub(/^/, '>'), src, con, "I will try to continue after bad HTML." con.push_char src.shift_char end end |
#read_link(src, con) ⇒ Object
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 |
# File 'lib/maruku/input/parse_span.rb', line 480 def read_link(src, con) # we read the string and see what happens src.ignore_char # opening bracket children = read_span(src, EscapedCharInText, ']') src.ignore_char # closing bracket # ignore space if src.cur_char == ' ' && ['[', '('].include?(src.next_char) src.shift_char end case src.cur_char when '(' src.ignore_char # opening ( src.consume_whitespace url = read_url(src, [' ', "\t", ")"]) || '' src.consume_whitespace title = nil if src.cur_char != ')' # we have a title quote_char = src.cur_char title = read_quoted(src, con) if not title maruku_error 'Must quote title', src, con else # Tries to read a title with quotes: ![a](url "ti"tle") # this is the most ugly thing in Markdown unless src.next_matches(/\s*\)/) # if there is not a closing par ), then read # the rest and guess it's title with quotes rest = read_simple(src, nil, ')', nil) # chop the closing char rest.chop! title << quote_char << rest end end end src.consume_whitespace closing = src.shift_char # closing ) if closing != ')' maruku_error 'Unclosed link', src, con, "No closing ): I will not create" + " the link for #{children.inspect}" con.push_elements children return end con.push_element md_im_link(children, url, title) when '[' # link ref ref_id = read_ref_id(src, con) if ref_id con.push_element md_link(children, ref_id) else maruku_error "Could not read ref_id", src, con, "I will not create the link for " + "#{children.inspect}" con.push_elements children return end else # empty [link] con.push_element md_link(children, nil) end end |
#read_quoted(src, con) ⇒ Object
Tries to read a quoted value. If stream does not start with ‘ or “, returns nil.
326 327 328 329 330 331 332 333 334 335 336 |
# File 'lib/maruku/input/parse_span.rb', line 326 def read_quoted(src, con) case src.cur_char when "'", '"' quote_char = src.shift_char # opening quote string = read_simple(src, EscapedCharInQuotes, quote_char) src.ignore_char # closing quote string else nil end end |
#read_quoted_or_unquoted(src, con, escaped, exit_on_chars) ⇒ Object
315 316 317 318 319 320 321 322 |
# File 'lib/maruku/input/parse_span.rb', line 315 def read_quoted_or_unquoted(src, con, escaped, exit_on_chars) case src.cur_char when "'", '"' read_quoted(src, con) else read_simple(src, escaped, exit_on_chars, nil, false) end end |
#read_ref_id(src, con) ⇒ Object
Reads a bracketed id “[refid]”. Consumes also both brackets.
400 401 402 403 404 405 406 407 |
# File 'lib/maruku/input/parse_span.rb', line 400 def read_ref_id(src, con) src.ignore_char # [ if m = src.read_regexp(/([^\]]*?)\]/) m[1] else nil end end |
#read_simple(src, escaped, exit_on_chars = nil, exit_on_strings = nil, warn = true) ⇒ Object
Reads a simple string (no formatting) until one of break_on_chars, while escaping the escaped. If the string is empty, it returns nil. By default, raises on error if the string terminates unexpectedly. This can be by setting the last argument to false.
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 |
# File 'lib/maruku/input/parse_span.rb', line 343 def read_simple(src, escaped, exit_on_chars=nil, exit_on_strings=nil, warn=true) text = "" escaped = Array(escaped) exit_on_chars = Array(exit_on_chars) exit_on_strings = Array(exit_on_strings) while true c = src.cur_char break if exit_on_chars.include?(c) break if exit_on_strings.any? {|x| src.cur_chars_are x } case c when nil if warn maruku_error "String finished while reading (break on " + "#{exit_on_chars.inspect})" + " already read: #{text.inspect}", src end break when "\\" d = src.next_char if escaped.include? d src.ignore_chars(2) text << d else text << src.shift_char end else text << src.shift_char end end text.empty? ? nil : text end |
#read_span(src, escaped, exit_on_chars = nil, exit_on_strings = nil) ⇒ Object
This is the main loop for reading span elements
It’s long, but not complex or difficult to understand.
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 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 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 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 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 |
# File 'lib/maruku/input/parse_span.rb', line 22 def read_span(src, escaped, exit_on_chars=nil, exit_on_strings=nil) escaped = Array(escaped) con = SpanContext.new c = d = nil while true c = src.cur_char # This is only an optimization which cuts 50% of the time used. # (but you can't use a-zA-z in exit_on_chars) if c && c =~ /a-zA-Z0-9/ con.push_char src.shift_char next end break if Array(exit_on_chars).include?(c) if Array(exit_on_strings).any? {|x| src.cur_chars_are x } # Special case: bold nested in italic break unless !(['*', '_'] & Array(exit_on_strings)).empty? && ['**', '__'].include?(src.cur_chars(2)) && !['***', '___'].include?(src.cur_chars(3)) end # check if there are extensions next if check_span_extensions(src, con) case c = src.cur_char when ' ' if src.cur_chars_are " \n" src.ignore_chars(3) con.push_element md_br next else src.ignore_char con.push_space end when "\n", "\t" src.ignore_char con.push_space when '`' read_inline_code(src, con) when '<' # It could be: # 1) HTML "<div ..." # 2) HTML "<!-- ..." # 3) url "<http:// ", "<ftp:// ..." # 4) email "<andrea@... ", "<mailto:andrea@..." # 5) on itself! "a < b " # 6) Start of <<guillemettes>> case d = src.next_char when '<' # guillemettes src.ignore_chars(2) con.push_char '<' con.push_char '<' when '!' if src.cur_chars_are '<!--' read_inline_html(src, con) else con.push_char src.shift_char end when '?' read_xml_instr_span(src, con) when ' ', "\t" con.push_char src.shift_char else if src.next_matches(/<mailto:/) || src.next_matches(/<[\w\.]+\@/) read_email_el(src, con) elsif src.next_matches(/<\w+:/) read_url_el(src, con) elsif src.next_matches(/<\w/) #puts "This is HTML: #{src.cur_chars(20)}" read_inline_html(src, con) else #puts "This is NOT HTML: #{src.cur_chars(20)}" con.push_char src.shift_char end end when "\\" d = src.next_char if d == "'" src.ignore_chars(2) con.push_element md_entity('apos') elsif d == '"' src.ignore_chars(2) con.push_element md_entity('quot') elsif escaped.include? d src.ignore_chars(2) con.push_char d else con.push_char src.shift_char end when '[' if markdown_extra? && src.next_char == '^' read_footnote_ref(src,con) elsif IgnoreWikiLinks && src.next_char == '[' con.push_char src.shift_char con.push_char src.shift_char else read_link(src, con) end when '!' if src.next_char == '[' read_image(src, con) else con.push_char src.shift_char end when '&' # named references if m = src.read_regexp(/\&(\w+);/) con.push_element md_entity(m[1]) # numeric elsif m = src.read_regexp(/\&\#(x)?(\w+);/) num = m[1] ? m[2].hex : m[2].to_i con.push_element md_entity(num) else con.push_char src.shift_char end when '*' if !src.next_char maruku_error "Opening * as last char.", src, con, 'Treating as literal' con.push_char src.shift_char else follows = src.cur_chars(4) if follows =~ /^\*\*\*[^\s\*]/ con.push_element read_emstrong(src, '***') elsif follows =~ /^\*\*[^\s\*]/ con.push_element read_strong(src, '**') elsif follows =~ /^\*[^\s\*]/ con.push_element read_em(src, '*') else # * is just a normal char con.push_char src.shift_char end end when '_' if !src.next_char maruku_error "Opening _ as last char", src, con, 'Treating as literal' con.push_char src.shift_char else # we don't want "mod_ruby" to start an emphasis # so we start one only if # 1) there's nothing else in the span (first char) # or 2) the last char was a space # or 3) the current string is empty #if con.elements.empty? || if con.is_end? # also, we check the next characters follows = src.cur_chars(4) if follows =~ /^\_\_\_[^\s\_]/ con.push_element read_emstrong(src, '___') elsif follows =~ /^\_\_[^\s\_]/ con.push_element read_strong(src, '__') elsif follows =~ /^\_[^\s\_]/ con.push_element read_em(src, '_') else # _ is just a normal char con.push_char src.shift_char end else # _ is just a normal char con.push_char src.shift_char end end when '{' # extension if ['#', '.', ':'].include? src.next_char src.ignore_char # { interpret_extension(src, con, '}') src.ignore_char # } else con.push_char src.shift_char end when nil maruku_error( ("Unclosed span (waiting for %s" + "#{exit_on_strings.inspect})") % [ exit_on_chars ? "#{exit_on_chars.inspect} or" : "" ], src, con) break else # normal text con.push_char src.shift_char end # end case end # end while true con.push_string_if_present # Assign IAL to elements merge_ial(con.elements, src, con) # Remove leading space if (s = con.elements.first).kind_of? String if s[0, 1] == ' ' con.elements[0] = s[1..-1] end con.elements.shift if s.empty? end # Remove final spaces if (s = con.elements.last).kind_of? String s.chop! if s[-1, 1] == ' ' con.elements.pop if s.empty? end educate(con.elements) end |
#read_strong(src, delim) ⇒ Object
385 386 387 388 389 390 |
# File 'lib/maruku/input/parse_span.rb', line 385 def read_strong(src, delim) src.ignore_chars(2) children = read_span(src, EscapedCharInText, nil, delim) src.ignore_chars(2) md_strong(children) end |
#read_url(src, break_on) ⇒ Object
299 300 301 302 303 304 305 306 307 308 309 310 311 312 |
# File 'lib/maruku/input/parse_span.rb', line 299 def read_url(src, break_on) if ["'", '"'].include? src.cur_char maruku_error 'Invalid char for url', src end url = read_simple(src, nil, break_on) || '' if url[0, 1] == '<' && url[-1, 1] == '>' url = url[1, url.size-2] end return nil if url.empty? url end |
#read_url_el(src, con) ⇒ Object
282 283 284 285 286 287 288 |
# File 'lib/maruku/input/parse_span.rb', line 282 def read_url_el(src,con) src.ignore_char # leading < url = read_simple(src, nil, '>') src.ignore_char # closing > con.push_element md_url(url) end |
#read_xml_instr_span(src, con) ⇒ Object
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 |
# File 'lib/maruku/input/parse_span.rb', line 226 def read_xml_instr_span(src, con) src.ignore_chars(2) # starting <? # read target <?target code... ?> target = if m = src.read_regexp(/^(\w+)/) m[1] else # XML instructions are invalid without a target '' end delim = "?>" code = read_simple(src, nil, nil, delim) src.ignore_chars delim.size code = (code || "").strip con.push_element md_xml_instr(target, code) end |