| Class | MathML::Util::SimpleLaTeX |
| In: |
lib/math_ml/util.rb
|
| Parent: | Object |
| DEFAULT | = | { :delimiter=>"\001", :math_env_list=>[ /\$((?:\\.|[^\\\$])#{MathML::LaTeX::MBEC}*?)\$/m, /\\\((#{MathML::LaTeX::MBEC}*?)\\\)/m |
# File lib/math_ml/util.rb, line 323
323: def self.decode(src, data)
324: @@default_latex.decode(src, data)
325: end
# File lib/math_ml/util.rb, line 318
318: def self.encode(src)
319: @@default_latex = self.new unless @@default_latex
320: @@default_latex.encode(src)
321: end
# File lib/math_ml/util.rb, line 91
91: def initialize(options = {})
92: @params = DEFAULT.merge(options)
93: @params[:parser] = MathML::LaTeX::Parser.new unless @params[:parser] || @params[:without_parse]
94:
95: @params[:math_envs] = collect_regexp(@params[:math_env_list])
96: @params[:dmath_envs] = collect_regexp(@params[:dmath_env_list])
97: @params[:escapes] = collect_regexp(@params[:escape_list])
98: @params[:throughs] = collect_regexp(@params[:through_list])
99: reset_encode_proc
100: reset_rescue_proc
101: reset_decode_proc
102: reset_unencode_proc
103: end
# File lib/math_ml/util.rb, line 233
233: def decode(encoded, data, without_parsed = false, &proc)
234: return nil if encoded==nil
235: proc = @decode_proc unless proc
236: encoded.gsub(/#{Regexp.escape(@params[:delimiter])}([demu])(\d+)#{Regexp.escape(@params[:delimiter])}/) do
237: i = $2.to_i
238: t, d, s =
239: case $1
240: when "d"
241: [:dmath, without_parsed ? escapeXML(data.dsrc_list[i], true) : data.dmath_list[i], data.dsrc_list[i]]
242: when "e"
243: [:escape, data.escape_list[i], data.esrc_list[i]]
244: when "m"
245: [:math, without_parsed ? escapeXML(data.msrc_list[i], true) : data.math_list[i], data.msrc_list[i]]
246: when "u"
247: [:user, data.user_list[i], data.usrc_list[i]]
248: end
249: if proc
250: proc.call(d, :type=>t, :index=>i, :src=>s) || d
251: else
252: d
253: end
254: end
255: end
# File lib/math_ml/util.rb, line 257
257: def decode_partial(type, encoded, data, &proc)
258: return nil if encoded==nil
259: head =
260: case type
261: when :math
262: "m"
263: when :dmath
264: "d"
265: when :escape
266: "e"
267: when :user
268: "u"
269: else
270: return
271: end
272: encoded.gsub(/#{Regexp.escape(@params[:delimiter])}#{head}(\d+)#{Regexp.escape(@params[:delimiter])}/) do
273: i = $1.to_i
274: t, d, s =
275: case head
276: when "d"
277: [:dmath, data.dmath_list[i], data.dsrc_list[i]]
278: when "e"
279: [:escape, data.escape_list[i], data.esrc_list[i]]
280: when "m"
281: [:math, data.math_list[i], data.msrc_list[i]]
282: when "u"
283: [:user, data.user_list[i], data.usrc_list[i]]
284: end
285: if proc
286: proc.call(d, :type=>t, :index=>i, :src=>s) || "#{@params[:delimiter]}#{head}#{i}#{@params[:delimiter]}"
287: else
288: d
289: end
290: end
291: end
# File lib/math_ml/util.rb, line 139
139: def encode(src, *proc_re, &proc)
140: if proc_re.size>0 && proc_re[0].is_a?(MathData)
141: data = proc_re.shift
142: else
143: data = MathData.new
144: end
145:
146: proc_re = proc_re.size==0 ? @encode_proc_re : collect_regexp(proc_re)
147: proc = @encode_proc unless proc
148:
149: s = StringScanner.new(src)
150: encoded = ""
151:
152: until s.eos?
153: if s.scan(/(.*?)(((((#{@params[:throughs]})|#{@params[:dmath_envs]})|#{@params[:math_envs]})|#{proc_re})|#{@params[:escapes]})/m)
154: encoded << s[1]
155: case
156: when s[6]
157: encoded << s[6]
158: when s[5], s[4]
159: env_src = s[5] || s[4]
160: if @params[:dmath_envs]=~env_src
161: encoded << "#{@params[:delimiter]}d#{data.dsrc_list.size}#{@params[:delimiter]}"
162: data.dsrc_list << env_src
163: else
164: encoded << "#{@params[:delimiter]}m#{data.msrc_list.size}#{@params[:delimiter]}"
165: data.msrc_list << env_src
166: end
167: when s[3]
168: size = s[3].size
169: s.pos = left = s.pos-size
170: if r=proc.call(s)
171: right = s.pos
172: encoded << "#{@params[:delimiter]}u#{data.user_list.size}#{@params[:delimiter]}"
173: data.user_list << r
174: data.usrc_list << s.string[left...right]
175: else
176: encoded << s.peek(size)
177: s.pos = s.pos+size
178: end
179: when s[2]
180: encoded << "#{@params[:delimiter]}e#{data.escape_list.size}#{@params[:delimiter]}"
181: @params[:escapes]=~s[2]
182: data.esrc_list << s[2]
183: data.escape_list << escapeXML($+, true)
184: end
185: else
186: encoded << s.rest
187: s.terminate
188: end
189: end
190:
191: parse(data, @params[:parser]) unless @params[:without_parse]
192:
193: return encoded, data
194: end
# File lib/math_ml/util.rb, line 196
196: def error_to_html(e)
197: "<br />\n#{escapeXML(e.message)}<br />\n<code>#{escapeXML(e.done).gsub(/\n/, "<br />\n")}<strong>#{escapeXML(e.rest).gsub(/\n/, "<br />\n")}</strong></code><br />"
198: end
# File lib/math_ml/util.rb, line 200
200: def latex_parser
201: @params[:parser] = MathML::LaTeX::Parser.new unless @params[:parser]
202: @params[:parser]
203: end
# File lib/math_ml/util.rb, line 205
205: def parse(data, parser=nil)
206: parser = latex_parser unless parser
207: (data.math_list.size...data.msrc_list.size).each do |i|
208: begin
209: @params[:math_envs]=~data.msrc_list[i]
210: data.math_list[i] = parser.parse($+)
211: rescue MathML::LaTeX::ParseError => e
212: if @rescue_proc
213: data.math_list[i] = @rescue_proc.call(e)
214: else
215: data.math_list[i] = error_to_html(e)
216: end
217: end
218: end
219: (data.dmath_list.size...data.dsrc_list.size).each do |i|
220: begin
221: @params[:dmath_envs]=~data.dsrc_list[i]
222: data.dmath_list[i] = parser.parse($+, true)
223: rescue MathML::LaTeX::ParseError => e
224: if @rescue_proc
225: data.dmath_list[i] = @rescue_proc.call(e)
226: else
227: data.dmath_list[i] = error_to_html(e)
228: end
229: end
230: end
231: end
# File lib/math_ml/util.rb, line 327
327: def parse_eqnarray(src, parser=nil)
328: src = "\\begin{array}{ccc}#{src}\\end{array}"
329: parser = latex_parser unless parser
330: begin
331: parser.parse(src, true)
332: rescue MathML::LaTeX::ParseError => e
333: e = MathML::LaTeX::ParseError.new(e.message,
334: e.rest.sub(/\\end\{array\}\z/, '\end{eqnarray}'),
335: e.done.sub(/\A\\begin\{array\}\{ccc\}/, '\begin{eqnarray}'))
336: @rescue_proc ? @rescue_proc.call(e) : error_to_html(e)
337: end
338: end
# File lib/math_ml/util.rb, line 340
340: def parse_single_command(src, parser=nil)
341: s = src[SINGLE_COMMAND_RE, 1]
342: parser = latex_parser unless parser
343: begin
344: parser.parse(s)
345: rescue MathML::LaTeX::ParseError => e
346: src[SINGLE_COMMAND_RE, 2]
347: end
348: end
# File lib/math_ml/util.rb, line 105
105: def reset_encode_proc
106: @encode_proc_re = INVALID_RE
107: @encode_proc = nil
108: end
# File lib/math_ml/util.rb, line 135
135: def reset_unencode_proc
136: @unencode_proc = nil
137: end
# File lib/math_ml/util.rb, line 127
127: def set_decode_proc(&proc)
128: @decode_proc = proc
129: end
# File lib/math_ml/util.rb, line 110
110: def set_encode_proc(*re, &proc)
111: @encode_proc_re = collect_regexp(re)
112: @encode_proc = proc
113: end
# File lib/math_ml/util.rb, line 119
119: def set_rescue_proc(&proc)
120: @rescue_proc = proc
121: end
# File lib/math_ml/util.rb, line 131
131: def set_unencode_proc(&proc)
132: @unencode_proc = proc
133: end
# File lib/math_ml/util.rb, line 293
293: def unencode(encoded, data, without_escape=false, &proc)
294: return nil if encoded==nil
295: proc = @unencode_proc unless proc
296: encoded.gsub(/#{Regexp.escape(@params[:delimiter])}([demu])(\d+)#{Regexp.escape(@params[:delimiter])}/) do
297: i = $2.to_i
298: t, s =
299: case $1
300: when "d"
301: [:dmath, data.dsrc_list[i]]
302: when "e"
303: [:escape, data.esrc_list[i]]
304: when "m"
305: [:math, data.msrc_list[i]]
306: when "u"
307: [:user, data.usrc_list[i]]
308: end
309: s = escapeXML(s, true) unless without_escape
310: if proc
311: proc.call(s, :type=>t, :index=>i) || s
312: else
313: s
314: end
315: end
316: end