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.



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

def initialize block_parser
  @block_parser = block_parser
end

Instance Method Details

#_reduce_101(val, _values, result) ⇒ Object

reduce 100 omitted



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

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 



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

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



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

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

#_reduce_111(val, _values, result) ⇒ Object

reduce 110 omitted



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

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

    result
end

#_reduce_113(val, _values, result) ⇒ Object

reduce 112 omitted



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

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

#_reduce_114(val, _values, result) ⇒ Object 



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

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

#_reduce_115(val, _values, result) ⇒ Object 



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

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

#_reduce_13(val, _values, result) ⇒ Object

reduce 12 omitted



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

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



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

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

#_reduce_14(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_15(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_16(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_17(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_19(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_20(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_21(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_22(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_23(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_24(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_25(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_26(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_27(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_3(val, _values, result) ⇒ Object 



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

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

#_reduce_30(val, _values, result) ⇒ Object 



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

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

#_reduce_31(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_32(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_33(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_34(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_36(val, _values, result) ⇒ Object

reduce 35 omitted



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

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

#_reduce_37(val, _values, result) ⇒ Object 



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

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

#_reduce_38(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_39(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_40(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_41(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_43(val, _values, result) ⇒ Object

reduce 42 omitted



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

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

    result
end

#_reduce_44(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_45(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_46(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



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

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

    result
end

#_reduce_58(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_59(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_60(val, _values, result) ⇒ Object 



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

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

#_reduce_62(val, _values, result) ⇒ Object

reduce 61 omitted



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

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

    result
end

#_reduce_64(val, _values, result) ⇒ Object

reduce 63 omitted



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

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

    result
end

#_reduce_78(val, _values, result) ⇒ Object

reduce 77 omitted



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

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

#_reduce_none(val, _values, result) ⇒ Object

reduce 137 omitted



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

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



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

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

#next_token ⇒ Object

Returns the next token from the inline text



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

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



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

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) 


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

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.



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

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

#prev_words_on_error(ev) ⇒ Object

Returns words before the error



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

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