Class: RDoc::RD::InlineParser

Inherits:
Racc::Parser
  • Object
show all
Defined in:
lib/rdoc/rd/inline_parser.rb

Overview

RD format parser for inline markup such as emphasis, links, footnotes, etc.

Constant Summary collapse

EM_OPEN =

:stopdoc:

'((*'
EM_OPEN_RE = 
/\A#{Regexp.quote(EM_OPEN)}/
EM_CLOSE = 
'*))'
EM_CLOSE_RE = 
/\A#{Regexp.quote(EM_CLOSE)}/
CODE_OPEN = 
'(({'
CODE_OPEN_RE = 
/\A#{Regexp.quote(CODE_OPEN)}/
CODE_CLOSE = 
'}))'
CODE_CLOSE_RE = 
/\A#{Regexp.quote(CODE_CLOSE)}/
VAR_OPEN = 
'((|'
VAR_OPEN_RE = 
/\A#{Regexp.quote(VAR_OPEN)}/
VAR_CLOSE = 
'|))'
VAR_CLOSE_RE = 
/\A#{Regexp.quote(VAR_CLOSE)}/
KBD_OPEN = 
'((%'
KBD_OPEN_RE = 
/\A#{Regexp.quote(KBD_OPEN)}/
KBD_CLOSE = 
'%))'
KBD_CLOSE_RE = 
/\A#{Regexp.quote(KBD_CLOSE)}/
INDEX_OPEN = 
'((:'
INDEX_OPEN_RE = 
/\A#{Regexp.quote(INDEX_OPEN)}/
INDEX_CLOSE = 
':))'
INDEX_CLOSE_RE = 
/\A#{Regexp.quote(INDEX_CLOSE)}/
REF_OPEN = 
'((<'
REF_OPEN_RE = 
/\A#{Regexp.quote(REF_OPEN)}/
REF_CLOSE = 
'>))'
REF_CLOSE_RE = 
/\A#{Regexp.quote(REF_CLOSE)}/
FOOTNOTE_OPEN = 
'((-'
FOOTNOTE_OPEN_RE = 
/\A#{Regexp.quote(FOOTNOTE_OPEN)}/
FOOTNOTE_CLOSE = 
'-))'
FOOTNOTE_CLOSE_RE = 
/\A#{Regexp.quote(FOOTNOTE_CLOSE)}/
VERB_OPEN = 
"(('"
VERB_OPEN_RE = 
/\A#{Regexp.quote(VERB_OPEN)}/
VERB_CLOSE = 
"'))"
VERB_CLOSE_RE = 
/\A#{Regexp.quote(VERB_CLOSE)}/
BAR = 
"|"
BAR_RE = 
/\A#{Regexp.quote(BAR)}/
QUOTE = 
'"'
QUOTE_RE = 
/\A#{Regexp.quote(QUOTE)}/
SLASH = 
"/"
SLASH_RE = 
/\A#{Regexp.quote(SLASH)}/
BACK_SLASH = 
"\\"
BACK_SLASH_RE = 
/\A#{Regexp.quote(BACK_SLASH)}/
URL = 
"URL:"
URL_RE = 
/\A#{Regexp.quote(URL)}/
OTHER_RE = 
Regexp.new(
  "\\A.+?(?=#{Regexp.quote(EM_OPEN)}|#{Regexp.quote(EM_CLOSE)}|
#{Regexp.quote(CODE_OPEN)}|#{Regexp.quote(CODE_CLOSE)}|
#{Regexp.quote(VAR_OPEN)}|#{Regexp.quote(VAR_CLOSE)}|
#{Regexp.quote(KBD_OPEN)}|#{Regexp.quote(KBD_CLOSE)}|
#{Regexp.quote(INDEX_OPEN)}|#{Regexp.quote(INDEX_CLOSE)}|
#{Regexp.quote(REF_OPEN)}|#{Regexp.quote(REF_CLOSE)}|
            #{Regexp.quote(FOOTNOTE_OPEN)}|#{Regexp.quote(FOOTNOTE_CLOSE)}|
#{Regexp.quote(VERB_OPEN)}|#{Regexp.quote(VERB_CLOSE)}|
#{Regexp.quote(BAR)}|
#{Regexp.quote(QUOTE)}|
#{Regexp.quote(SLASH)}|
#{Regexp.quote(BACK_SLASH)}|
#{Regexp.quote(URL)})", other_re_mode)
Racc_arg = 
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = 
[
"$end",
"error",
"EX_LOW",
"QUOTE",
"BAR",
"SLASH",
"BACK_SLASH",
"URL",
"OTHER",
"REF_OPEN",
"FOOTNOTE_OPEN",
"FOOTNOTE_CLOSE",
"EX_HIGH",
"EM_OPEN",
"EM_CLOSE",
"CODE_OPEN",
"CODE_CLOSE",
"VAR_OPEN",
"VAR_CLOSE",
"KBD_OPEN",
"KBD_CLOSE",
"INDEX_OPEN",
"INDEX_CLOSE",
"REF_CLOSE",
"VERB_OPEN",
"VERB_CLOSE",
"$start",
"content",
"elements",
"element",
"emphasis",
"code",
"var",
"keyboard",
"index",
"reference",
"footnote",
"verb",
"normal_str_ele",
"substitute",
"ref_label",
"ref_label2",
"ref_url_strings",
"filename",
"element_label",
"element_label2",
"ref_subst_content",
"ref_subst_content_q",
"ref_subst_strings_q",
"ref_subst_strings_first",
"ref_subst_ele2",
"ref_subst_eles",
"ref_subst_str_ele_first",
"ref_subst_eles_q",
"ref_subst_ele",
"ref_subst_ele_q",
"ref_subst_str_ele",
"ref_subst_str_ele_q",
"ref_subst_strings",
"ref_subst_string3",
"ref_subst_string",
"ref_subst_string_q",
"ref_subst_string2",
"ref_url_string",
"verb_strings",
"normal_string",
"normal_strings",
"verb_string",
"verb_normal_string" ]
Racc_debug_parser = 
false

Instance Method Summary collapse

Constructor Details

#initialize(block_parser) ⇒ InlineParser

Creates a new parser for inline markup in the rd format. The block_parser is used to for footnotes and labels in the inline text.



90
91
92
 
# File 'lib/rdoc/rd/inline_parser.rb', line 90

def initialize block_parser
  @block_parser = block_parser
end

Instance Method Details

#_reduce_101(val, _values, result) ⇒ Object

reduce 100 omitted



1100
1101
1102
1103
1104
1105
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1100

def _reduce_101(val, _values, result)
      index = @block_parser.add_footnote val[1].rdoc
      result = "{*#{index}}[rdoc-label:foottext-#{index}:footmark-#{index}]"

    result
end

#_reduce_102(val, _values, result) ⇒ Object 



1107
1108
1109
1110
1111
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1107

def _reduce_102(val, _values, result)
      result = inline "<tt>#{val[1]}</tt>", val[1]

    result
end

#_reduce_109(val, _values, result) ⇒ Object

reduce 108 omitted



1125
1126
1127
1128
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1125

def _reduce_109(val, _values, result)
 result << val[1]
    result
end

#_reduce_111(val, _values, result) ⇒ Object

reduce 110 omitted



1132
1133
1134
1135
1136
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1132

def _reduce_111(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_113(val, _values, result) ⇒ Object

reduce 112 omitted



1140
1141
1142
1143
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1140

def _reduce_113(val, _values, result)
 result = val[1]
    result
end

#_reduce_114(val, _values, result) ⇒ Object 



1145
1146
1147
1148
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1145

def _reduce_114(val, _values, result)
 result = val[1]
    result
end

#_reduce_115(val, _values, result) ⇒ Object 



1150
1151
1152
1153
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1150

def _reduce_115(val, _values, result)
 result = val[1]
    result
end

#_reduce_13(val, _values, result) ⇒ Object

reduce 12 omitted



763
764
765
766
767
768
 
# File 'lib/rdoc/rd/inline_parser.rb', line 763

def _reduce_13(val, _values, result)
      content = val[1]
      result = inline "<em>#{content}</em>", content

    result
end

#_reduce_136(val, _values, result) ⇒ Object

reduce 135 omitted



1195
1196
1197
1198
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1195

def _reduce_136(val, _values, result)
 result << val[1]
    result
end

#_reduce_14(val, _values, result) ⇒ Object 



770
771
772
773
774
775
 
# File 'lib/rdoc/rd/inline_parser.rb', line 770

def _reduce_14(val, _values, result)
      content = val[1]
      result = inline "<code>#{content}</code>", content

    result
end

#_reduce_15(val, _values, result) ⇒ Object 



777
778
779
780
781
782
 
# File 'lib/rdoc/rd/inline_parser.rb', line 777

def _reduce_15(val, _values, result)
      content = val[1]
      result = inline "+#{content}+", content

    result
end

#_reduce_16(val, _values, result) ⇒ Object 



784
785
786
787
788
789
 
# File 'lib/rdoc/rd/inline_parser.rb', line 784

def _reduce_16(val, _values, result)
      content = val[1]
      result = inline "<tt>#{content}</tt>", content

    result
end

#_reduce_17(val, _values, result) ⇒ Object 



791
792
793
794
795
796
797
 
# File 'lib/rdoc/rd/inline_parser.rb', line 791

def _reduce_17(val, _values, result)
      label = val[1]
      @block_parser.add_label label.reference
      result = "<span id=\"label-#{label}\">#{label}</span>"

    result
end

#_reduce_18(val, _values, result) ⇒ Object 



799
800
801
802
803
 
# File 'lib/rdoc/rd/inline_parser.rb', line 799

def _reduce_18(val, _values, result)
      result = "{#{val[1]}}[#{val[2].join}]"

    result
end

#_reduce_19(val, _values, result) ⇒ Object 



805
806
807
808
809
810
811
 
# File 'lib/rdoc/rd/inline_parser.rb', line 805

def _reduce_19(val, _values, result)
      scheme, inline = val[1]

      result = "{#{inline}}[#{scheme}#{inline.reference}]"

    result
end

#_reduce_2(val, _values, result) ⇒ Object

reduce 1 omitted



735
736
737
738
 
# File 'lib/rdoc/rd/inline_parser.rb', line 735

def _reduce_2(val, _values, result)
 result.append val[1]
    result
end

#_reduce_20(val, _values, result) ⇒ Object 



813
814
815
816
817
 
# File 'lib/rdoc/rd/inline_parser.rb', line 813

def _reduce_20(val, _values, result)
      result = [nil, inline(val[1])]

    result
end

#_reduce_21(val, _values, result) ⇒ Object 



819
820
821
822
823
824
825
826
 
# File 'lib/rdoc/rd/inline_parser.rb', line 819

def _reduce_21(val, _values, result)
      result = [
        'rdoc-label:',
        inline("#{val[0].reference}/#{val[1].reference}")
      ]

    result
end

#_reduce_22(val, _values, result) ⇒ Object 



828
829
830
831
832
 
# File 'lib/rdoc/rd/inline_parser.rb', line 828

def _reduce_22(val, _values, result)
      result = ['rdoc-label:', val[0].reference]

    result
end

#_reduce_23(val, _values, result) ⇒ Object 



834
835
836
837
838
 
# File 'lib/rdoc/rd/inline_parser.rb', line 834

def _reduce_23(val, _values, result)
      result = ['rdoc-label:', "#{val[0].reference}/"]

    result
end

#_reduce_24(val, _values, result) ⇒ Object 



840
841
842
843
844
 
# File 'lib/rdoc/rd/inline_parser.rb', line 840

def _reduce_24(val, _values, result)
      result = [nil, inline(val[1])]

    result
end

#_reduce_25(val, _values, result) ⇒ Object 



846
847
848
849
850
851
852
853
 
# File 'lib/rdoc/rd/inline_parser.rb', line 846

def _reduce_25(val, _values, result)
      result = [
        'rdoc-label:',
        inline("#{val[0].reference}/#{val[1].reference}")
      ]

    result
end

#_reduce_26(val, _values, result) ⇒ Object 



855
856
857
858
859
 
# File 'lib/rdoc/rd/inline_parser.rb', line 855

def _reduce_26(val, _values, result)
      result = ['rdoc-label:', val[0]]

    result
end

#_reduce_27(val, _values, result) ⇒ Object 



861
862
863
864
865
866
 
# File 'lib/rdoc/rd/inline_parser.rb', line 861

def _reduce_27(val, _values, result)
      ref = val[0].reference
      result = ['rdoc-label:', inline(ref, "#{ref}/")]

    result
end

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted



870
871
872
873
 
# File 'lib/rdoc/rd/inline_parser.rb', line 870

def _reduce_29(val, _values, result)
 result = val[1]
    result
end

#_reduce_3(val, _values, result) ⇒ Object 



740
741
742
743
 
# File 'lib/rdoc/rd/inline_parser.rb', line 740

def _reduce_3(val, _values, result)
 result = val[0]
    result
end

#_reduce_30(val, _values, result) ⇒ Object 



875
876
877
878
 
# File 'lib/rdoc/rd/inline_parser.rb', line 875

def _reduce_30(val, _values, result)
 result = val[1]
    result
end

#_reduce_31(val, _values, result) ⇒ Object 



880
881
882
883
884
 
# File 'lib/rdoc/rd/inline_parser.rb', line 880

def _reduce_31(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_32(val, _values, result) ⇒ Object 



886
887
888
889
890
 
# File 'lib/rdoc/rd/inline_parser.rb', line 886

def _reduce_32(val, _values, result)
      result = inline "\"#{val[1]}\""

    result
end

#_reduce_33(val, _values, result) ⇒ Object 



892
893
894
895
896
 
# File 'lib/rdoc/rd/inline_parser.rb', line 892

def _reduce_33(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_34(val, _values, result) ⇒ Object 



898
899
900
901
902
 
# File 'lib/rdoc/rd/inline_parser.rb', line 898

def _reduce_34(val, _values, result)
      result = inline "\"#{val[1]}\""

    result
end

#_reduce_36(val, _values, result) ⇒ Object

reduce 35 omitted



906
907
908
909
 
# File 'lib/rdoc/rd/inline_parser.rb', line 906

def _reduce_36(val, _values, result)
 result = val[1]
    result
end

#_reduce_37(val, _values, result) ⇒ Object 



911
912
913
914
 
# File 'lib/rdoc/rd/inline_parser.rb', line 911

def _reduce_37(val, _values, result)
 result = inline val[1]
    result
end

#_reduce_38(val, _values, result) ⇒ Object 



916
917
918
919
920
 
# File 'lib/rdoc/rd/inline_parser.rb', line 916

def _reduce_38(val, _values, result)
      result = val[0].append val[1]

    result
end

#_reduce_39(val, _values, result) ⇒ Object 



922
923
924
925
926
 
# File 'lib/rdoc/rd/inline_parser.rb', line 922

def _reduce_39(val, _values, result)
      result = val[0].append val[1]

    result
end

#_reduce_40(val, _values, result) ⇒ Object 



928
929
930
931
932
 
# File 'lib/rdoc/rd/inline_parser.rb', line 928

def _reduce_40(val, _values, result)
      result = val[0]

    result
end

#_reduce_41(val, _values, result) ⇒ Object 



934
935
936
937
938
 
# File 'lib/rdoc/rd/inline_parser.rb', line 934

def _reduce_41(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_43(val, _values, result) ⇒ Object

reduce 42 omitted



942
943
944
945
946
 
# File 'lib/rdoc/rd/inline_parser.rb', line 942

def _reduce_43(val, _values, result)
      result = val[0].append val[1]

    result
end

#_reduce_44(val, _values, result) ⇒ Object 



948
949
950
951
952
 
# File 'lib/rdoc/rd/inline_parser.rb', line 948

def _reduce_44(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_45(val, _values, result) ⇒ Object 



954
955
956
957
958
 
# File 'lib/rdoc/rd/inline_parser.rb', line 954

def _reduce_45(val, _values, result)
      result = val[0].append val[1]

    result
end

#_reduce_46(val, _values, result) ⇒ Object 



960
961
962
963
964
 
# File 'lib/rdoc/rd/inline_parser.rb', line 960

def _reduce_46(val, _values, result)
      result = val[0]

    result
end

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



986
987
988
989
990
 
# File 'lib/rdoc/rd/inline_parser.rb', line 986

def _reduce_57(val, _values, result)
      result = val[0]

    result
end

#_reduce_58(val, _values, result) ⇒ Object 



992
993
994
995
996
 
# File 'lib/rdoc/rd/inline_parser.rb', line 992

def _reduce_58(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_59(val, _values, result) ⇒ Object 



998
999
1000
1001
1002
 
# File 'lib/rdoc/rd/inline_parser.rb', line 998

def _reduce_59(val, _values, result)
      result = inline val[0]

    result
end

#_reduce_60(val, _values, result) ⇒ Object 



1004
1005
1006
1007
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1004

def _reduce_60(val, _values, result)
 result << val[1]
    result
end

#_reduce_62(val, _values, result) ⇒ Object

reduce 61 omitted



1011
1012
1013
1014
1015
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1011

def _reduce_62(val, _values, result)
      result << val[1]

    result
end

#_reduce_64(val, _values, result) ⇒ Object

reduce 63 omitted



1019
1020
1021
1022
1023
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1019

def _reduce_64(val, _values, result)
      result << val[1]

    result
end

#_reduce_78(val, _values, result) ⇒ Object

reduce 77 omitted



1051
1052
1053
1054
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1051

def _reduce_78(val, _values, result)
 result << val[1]
    result
end

#_reduce_none(val, _values, result) ⇒ Object

reduce 137 omitted



1202
1203
1204
 
# File 'lib/rdoc/rd/inline_parser.rb', line 1202

def _reduce_none(val, _values, result)
  val[0]
end

#inline(rdoc, reference = rdoc) ⇒ Object

Creates a new RDoc::RD::Inline for the rdoc markup and the raw reference



239
240
241
 
# File 'lib/rdoc/rd/inline_parser.rb', line 239

def inline rdoc, reference = rdoc
  RDoc::RD::Inline.new rdoc, reference
end

#next_token ⇒ Object

Returns the next token from the inline text



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
 
# File 'lib/rdoc/rd/inline_parser.rb', line 108

def next_token
  return [false, false] if @src.eos?
#  p @src.rest if @yydebug
  if ret = @src.scan(EM_OPEN_RE)
    @pre << ret
    [:EM_OPEN, ret]
  elsif ret = @src.scan(EM_CLOSE_RE)
    @pre << ret
    [:EM_CLOSE, ret]
  elsif ret = @src.scan(CODE_OPEN_RE)
    @pre << ret
    [:CODE_OPEN, ret]
  elsif ret = @src.scan(CODE_CLOSE_RE)
    @pre << ret
    [:CODE_CLOSE, ret]
  elsif ret = @src.scan(VAR_OPEN_RE)
    @pre << ret
    [:VAR_OPEN, ret]
  elsif ret = @src.scan(VAR_CLOSE_RE)
    @pre << ret
    [:VAR_CLOSE, ret]
  elsif ret = @src.scan(KBD_OPEN_RE)
    @pre << ret
    [:KBD_OPEN, ret]
  elsif ret = @src.scan(KBD_CLOSE_RE)
    @pre << ret
    [:KBD_CLOSE, ret]
  elsif ret = @src.scan(INDEX_OPEN_RE)
    @pre << ret
    [:INDEX_OPEN, ret]
  elsif ret = @src.scan(INDEX_CLOSE_RE)
    @pre << ret
    [:INDEX_CLOSE, ret]
  elsif ret = @src.scan(REF_OPEN_RE)
    @pre << ret
    [:REF_OPEN, ret]
  elsif ret = @src.scan(REF_CLOSE_RE)
    @pre << ret
    [:REF_CLOSE, ret]
  elsif ret = @src.scan(FOOTNOTE_OPEN_RE)
    @pre << ret
    [:FOOTNOTE_OPEN, ret]
  elsif ret = @src.scan(FOOTNOTE_CLOSE_RE)
    @pre << ret
    [:FOOTNOTE_CLOSE, ret]
  elsif ret = @src.scan(VERB_OPEN_RE)
    @pre << ret
    [:VERB_OPEN, ret]
  elsif ret = @src.scan(VERB_CLOSE_RE)
    @pre << ret
    [:VERB_CLOSE, ret]
  elsif ret = @src.scan(BAR_RE)
    @pre << ret
    [:BAR, ret]
  elsif ret = @src.scan(QUOTE_RE)
    @pre << ret
    [:QUOTE, ret]
  elsif ret = @src.scan(SLASH_RE)
    @pre << ret
    [:SLASH, ret]
  elsif ret = @src.scan(BACK_SLASH_RE)
    @pre << ret
    [:BACK_SLASH, ret]
  elsif ret = @src.scan(URL_RE)
    @pre << ret
    [:URL, ret]
  elsif ret = @src.scan(OTHER_RE)
    @pre << ret
    [:OTHER, ret]
  else
    ret = @src.rest
    @pre << ret
    @src.terminate
    [:OTHER, ret]
  end
end

#next_words_on_error ⇒ Object

Returns words following an error



228
229
230
231
232
233
234
 
# File 'lib/rdoc/rd/inline_parser.rb', line 228

def next_words_on_error
  if n = @src.rest.index("\n")
    @src.rest[0 .. (n-1)]
  else
    @src.rest
  end
end

#on_error(et, ev, values) ⇒ Object

Raises a ParseError when invalid formatting is found

Raises:

  • (ParseError) 


188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/rdoc/rd/inline_parser.rb', line 188

def on_error(et, ev, values)
  lines_of_rest = @src.rest.lines.to_a.length
  prev_words = prev_words_on_error(ev)
  at = 4 + prev_words.length

  message = <<-MSG
RD syntax error: line #{@block_parser.line_index - lines_of_rest}:
...#{prev_words} #{(ev||'')} #{next_words_on_error()} ...
  MSG

  message << " " * at + "^" * (ev ? ev.length : 0) + "\n"
  raise ParseError, message
end

#parse(inline) ⇒ Object

Parses the inline text from RD format into RDoc format.



97
98
99
100
101
102
103
 
# File 'lib/rdoc/rd/inline_parser.rb', line 97

def parse inline
  @inline = inline
  @src = StringScanner.new inline
  @pre = "".dup
  @yydebug = true
  do_parse.to_s
end

#prev_words_on_error(ev) ⇒ Object

Returns words before the error



205
206
207
208
209
210
211
 
# File 'lib/rdoc/rd/inline_parser.rb', line 205

def prev_words_on_error(ev)
  pre = @pre
  if ev and /#{Regexp.quote(ev)}$/ =~ pre
    pre = $`
  end
  last_line(pre)
end