remi-maruku 0.5.9

data/lib/maruku/ext/math.rb

@@ -0,0 +1,41 @@
+
+
+require 'maruku/ext/math/elements'
+require 'maruku/ext/math/parsing'
+require 'maruku/ext/math/to_latex'
+require 'maruku/ext/math/to_html'
+
+require 'maruku/ext/math/mathml_engines/none'
+require 'maruku/ext/math/mathml_engines/ritex'
+require 'maruku/ext/math/mathml_engines/itex2mml'
+require 'maruku/ext/math/mathml_engines/blahtex'
+
+
+=begin maruku_doc
+Attribute: math_enabled
+Scope: global, document
+Summary: Enables parsing of LaTeX math 
+
+To explicitly disable the math parsing:
+
+	Maruku.new(string, {:math_enabled => false})
+	{:ruby}
+	
+=end
+
+MaRuKu::Globals[:math_enabled] = true
+
+
+=begin maruku_doc
+Attribute: math_numbered
+Scope: global, document
+Summary: Math openings which should be numerated
+
+Array containing any of `'\\['`, `'\\begin{equation}'`, `'$$'`.
+
+	MaRuKu::Globals[:math_numbered] = ['\\[']
+	
+=end
+
+
+MaRuKu::Globals[:math_numbered] = [] 

data/lib/maruku/ext/math/elements.rb

@@ -0,0 +1,27 @@
+module MaRuKu; class MDElement
+	
+	def md_inline_math(math)
+		self.md_el(:inline_math, [], meta={:math=>math})
+	end
+
+	def md_equation(math, label, numerate)
+		reglabel= /\\label\{(\w+)\}/
+		if math =~ reglabel
+			label = $1
+			math.gsub!(reglabel,'')
+		end
+#		puts "Found label = #{label} math #{math.inspect} "
+		num = nil
+		if (label || numerate) && @doc #take number
+			@doc.eqid2eq ||= {}	
+			num = @doc.eqid2eq.size + 1
+			label = "eq#{num}" if not label      # FIXME do id for document
+		end
+		e = self.md_el(:equation, [], meta={:math=>math, :label=>label,:num=>num})
+		if label && @doc #take number
+			@doc.eqid2eq[label] = e
+		end
+		e
+	end
+
+end end

data/lib/maruku/ext/math/latex_fix.rb

@@ -0,0 +1,11 @@
+class String
+	# fix some LaTeX command-name clashes
+	def fix_latex
+		if #{html_math_engine} == 'itex2mml'
+			s = self.gsub("\\mathop{", "\\operatorname{")
+			s.gsub("\\space{", "\\itexspace{")
+		else
+			self
+		end
+	end
+end

data/lib/maruku/ext/math/mathml_engines/blahtex.rb

@@ -0,0 +1,104 @@
+
+require 'tempfile'
+require 'fileutils'
+require 'digest/md5'
+require 'pstore'
+
+module MaRuKu; module Out; module HTML
+	
+	PNG = Struct.new(:src,:depth,:height)
+	
+	def convert_to_png_blahtex(kind, tex)
+		begin
+			FileUtils::mkdir_p MaRuKu::Globals[:html_png_dir]
+
+			# first, we check whether this image has already been processed
+			md5sum = Digest::MD5.hexdigest(tex+" params: ")
+			result_file = File.join(MaRuKu::Globals[:html_png_dir], md5sum+".txt")
+
+			if not File.exists?(result_file) 
+				tmp_in = Tempfile.new('maruku_blahtex')
+        f = tmp_in.open
+				f.write tex
+				f.close
+
+				resolution = get_setting(:html_png_resolution)
+
+				options = "--png --use-preview-package --shell-dvipng 'dvipng -D #{resolution}' "
+				options += ("--png-directory '%s'" % MaRuKu::Globals[:html_png_dir])
+
+				cmd = "blahtex #{options} < #{tmp_in.path} > #{result_file}"
+				$stderr.puts "$ #{cmd}"
+        system cmd
+				tmp_in.delete
+			end
+			
+      result = File.read(result_file)
+      if result.nil? || result.empty?
+        raise "Blahtex error: empty output"
+      end
+      
+			doc = Document.new(result, {:respect_whitespace =>:all})
+			png = doc.root.elements[1]
+			if png.name != 'png'
+				raise "Blahtex error: \n#{doc}"
+			end
+			depth = png.elements['depth'] || (raise "No depth element in:\n #{doc}")
+			height = png.elements['height'] || (raise "No height element in:\n #{doc}")
+			md5 = png.elements['md5'] || (raise "No md5 element in:\n #{doc}")
+			
+			depth = depth.text.to_f
+			height = height.text.to_f # XXX check != 0
+			md5 = md5.text
+			
+			dir_url = MaRuKu::Globals[:html_png_url]
+			return PNG.new("#{dir_url}#{md5}.png", depth, height)
+		rescue Exception => e
+			maruku_error "Error: #{e}"
+		end
+		nil
+	end
+
+	BlahtexCache = PStore.new("blahtex_cache.pstore")
+
+	def convert_to_mathml_blahtex(kind, tex)
+		begin
+			BlahtexCache.transaction do 
+				if BlahtexCache[tex].nil?
+					tmp_in = Tempfile.new('maruku_blahtex')
+						f = tmp_in.open
+						f.write tex
+						f.close
+					tmp_out = Tempfile.new('maruku_blahtex')
+	
+					options = "--mathml"
+					cmd = "blahtex #{options} < #{tmp_in.path} > #{tmp_out.path}"
+					$stderr.puts "$ #{cmd}"
+					system cmd
+					tmp_in.delete
+					
+					result = nil
+					File.open(tmp_out.path) do |f| result=f.read end
+						puts result
+					
+					BlahtexCache[tex] = result
+				end
+			
+				blahtex = BlahtexCache[tex]
+				doc = Document.new(blahtex, {:respect_whitespace =>:all})
+				mathml = doc.root.elements['mathml']
+				if not mathml
+					maruku_error "Blahtex error: \n#{doc}"
+					return nil
+				else
+					return mathml
+				end
+			end
+			
+		rescue Exception => e
+			maruku_error "Error: #{e}"
+		end
+		nil
+	end
+
+end end end

data/lib/maruku/ext/math/mathml_engines/itex2mml.rb

@@ -0,0 +1,29 @@
+
+module MaRuKu; module Out; module HTML
+
+	def convert_to_mathml_itex2mml(kind, tex)
+		begin
+			if not $itex2mml_parser
+				require 'itextomml'
+				$itex2mml_parser =  Itex2MML::Parser.new
+			end
+			
+			itex_method = {:equation=>:block_filter,:inline=>:inline_filter}
+			
+			mathml =  $itex2mml_parser.send(itex_method[kind], tex)
+			doc = Document.new(mathml, {:respect_whitespace =>:all}).root
+			return doc
+		rescue LoadError => e
+			maruku_error "Could not load package 'itex2mml'.\n"+ "Please install it." 			unless $already_warned_itex2mml 
+			$already_warned_itex2mml = true
+		rescue REXML::ParseException => e
+			maruku_error "Invalid MathML TeX: \n#{add_tabs(tex,1,'tex>')}"+
+				"\n\n #{e.inspect}"
+		rescue 
+			maruku_error "Could not produce MathML TeX: \n#{tex}"+
+				"\n\n #{e.inspect}"
+		end
+		nil
+	end
+
+end end end

data/lib/maruku/ext/math/mathml_engines/none.rb

@@ -0,0 +1,20 @@
+module MaRuKu; module Out; module HTML
+
+	def convert_to_mathml_none(kind, tex)
+		# You can: either return a REXML::Element
+		#    return Element.new 'div'    
+		# or return an empty array on error
+		#    return []  
+		# or have a string parsed by REXML:
+		tex = tex.gsub('&','&')
+		mathml = "<code>#{tex}</code>"
+		return Document.new(mathml).root
+	end
+
+	def convert_to_png_none(kind, tex)
+		return nil
+	end
+
+
+end end end
+

data/lib/maruku/ext/math/mathml_engines/ritex.rb

@@ -0,0 +1,24 @@
+module MaRuKu; module Out; module HTML
+
+	def convert_to_mathml_ritex(kind, tex)
+		begin
+			if not $ritex_parser
+				require 'ritex'
+			 	$ritex_parser = Ritex::Parser.new
+			end
+			
+			mathml =  $ritex_parser.parse(tex.strip)
+			doc = Document.new(mathml, {:respect_whitespace =>:all}).root
+			return doc
+		rescue LoadError => e
+			maruku_error "Could not load package 'ritex'.\n"+
+			"Please install it using:\n"+
+			"   $ gem install ritex\n\n"+e.inspect
+		rescue Racc::ParseError => e
+			maruku_error "Could not parse TeX: \n#{tex}"+
+				"\n\n #{e.inspect}"
+		end
+		nil
+	end
+	
+end end end

data/lib/maruku/ext/math/parsing.rb

@@ -0,0 +1,105 @@
+module MaRuKu
+	
+	class MDDocument
+		# Hash equation id (String) to equation element (MDElement)
+		attr_accessor :eqid2eq
+		
+		def is_math_enabled? 
+			get_setting :math_enabled
+		end
+	end
+end
+
+
+	# Everything goes; takes care of escaping the "\$" inside the expression
+	RegInlineMath = /\${1}((?:[^\$]|\\\$)+)\$/
+	
+	MaRuKu::In::Markdown::register_span_extension(
+		:chars => ?$, 
+		:regexp => RegInlineMath, 
+		:handler => lambda { |doc, src, con|
+			return false if not doc.is_math_enabled?
+		
+			if m = src.read_regexp(RegInlineMath)
+				math = m.captures.compact.first
+				con.push doc.md_inline_math(math)
+				true
+			else
+				#puts "not math: #{src.cur_chars 10}"
+				false
+			end
+		}
+	)
+	
+	
+	MathOpen1 = Regexp.escape('\\begin{equation}')
+	MathClose1 = Regexp.escape('\\end{equation}')
+	MathOpen2 = Regexp.escape('\\[')
+	MathClose2 = Regexp.escape('\\]')
+	MathOpen3 = Regexp.escape('$$')
+	MathClose3 = Regexp.escape('$$')
+	
+	EqLabel = /(?:\((\w+)\))/
+	EquationOpen = /#{MathOpen1}|#{MathOpen2}|#{MathOpen3}/
+	EquationClose = /#{MathClose1}|#{MathClose2}|#{MathClose3}/
+	
+	# $1 is opening, $2 is tex
+	EquationStart = /^[ ]{0,3}(#{EquationOpen})(.*)$/
+	# $1 is tex, $2 is closing, $3 is tex
+	EquationEnd = /^(.*)(#{EquationClose})\s*#{EqLabel}?\s*$/
+	# $1 is opening, $2 is tex, $3 is closing, $4 is label
+	OneLineEquation = /^[ ]{0,3}(#{EquationOpen})(.*)(#{EquationClose})\s*#{EqLabel}?\s*$/
+
+	MaRuKu::In::Markdown::register_block_extension(
+		:regexp  => EquationStart,
+		:handler => lambda { |doc, src, con|
+			return false if not doc.is_math_enabled?
+			first = src.shift_line
+			if first =~ OneLineEquation
+				opening, tex, closing, label = $1, $2, $3, $4
+				numerate = doc.get_setting(:math_numbered).include?(opening)
+				con.push doc.md_equation(tex, label, numerate)
+			else
+				first =~ EquationStart
+				opening, tex = $1, $2
+				
+				numerate = doc.get_setting(:math_numbered).include?(opening)
+				label = nil
+				while true
+					if not src.cur_line
+						doc.maruku_error("Stream finished while reading equation\n\n"+
+							doc.add_tabs(tex,1,'$> '), src, con)
+						break
+					end
+					line = src.shift_line
+					if line =~ EquationEnd
+						tex_line, closing = $1, $2
+						label = $3 if $3
+						tex += tex_line + "\n"
+						break
+					else
+						tex += line + "\n"
+					end
+				end
+				con.push doc.md_equation(tex, label, numerate)
+			end
+			true
+		})
+		
+		
+	# This adds support for \eqref
+	RegEqrefLatex = /\\eqref\{(\w+)\}/
+	RegEqPar = /\(eq:(\w+)\)/
+	RegEqref = Regexp::union(RegEqrefLatex, RegEqPar)
+	
+	MaRuKu::In::Markdown::register_span_extension(
+		:chars => [?\\, ?(], 
+		:regexp => RegEqref,
+		:handler => lambda { |doc, src, con|
+			return false if not doc.is_math_enabled?
+			eqid = src.read_regexp(RegEqref).captures.compact.first
+			r = doc.md_el(:eqref, [], meta={:eqid=>eqid})
+			con.push r
+	 		true 
+		}
+	)

data/lib/maruku/ext/math/to_html.rb

@@ -0,0 +1,170 @@
+
+=begin maruku_doc
+Extension: math
+Attribute: html_math_engine
+Scope: document, element
+Output: html
+Summary: Select the rendering engine for MathML.
+Default: <?mrk Globals[:html_math_engine].to_s ?>
+
+Select the rendering engine for math.
+
+If you want to use your custom engine `foo`, then set:
+
+	HTML math engine: foo
+{:lang=markdown}
+
+and then implement two functions:
+
+	def convert_to_mathml_foo(kind, tex)
+		...
+	end
+=end
+
+=begin maruku_doc
+Extension: math
+Attribute: html_png_engine
+Scope: document, element
+Output: html
+Summary: Select the rendering engine for math.
+Default: <?mrk Globals[:html_math_engine].to_s ?>
+
+Same thing as `html_math_engine`, only for PNG output.
+
+	def convert_to_png_foo(kind, tex)
+		# same thing
+		...
+	end
+{:lang=ruby}
+
+=end
+
+module MaRuKu; module Out; module HTML
+
+
+	
+	# Creates an xml Mathml document of self.math
+	def render_mathml(kind, tex)
+		engine = get_setting(:html_math_engine)
+		method = "convert_to_mathml_#{engine}".to_sym
+		if self.respond_to? method
+			mathml = self.send(method, kind, tex) 
+			return mathml || convert_to_mathml_none(kind, tex)
+		else 
+			puts "A method called #{method} should be defined."
+			return convert_to_mathml_none(kind, tex)
+		end
+	end
+
+	# Creates an xml Mathml document of self.math
+	def render_png(kind, tex)
+		engine = get_setting(:html_png_engine)
+		method = "convert_to_png_#{engine}".to_sym
+		if self.respond_to? method
+			return self.send(method, kind, tex) 
+		else 
+			puts "A method called #{method} should be defined."
+			return nil
+		end
+	end
+	
+	def pixels_per_ex
+		if not $pixels_per_ex 
+			x = render_png(:inline, "x")
+			$pixels_per_ex  = x.height # + x.depth
+		end
+		$pixels_per_ex
+	end
+		
+	def adjust_png(png, use_depth)
+		src = png.src
+		
+		height_in_px = png.height
+		depth_in_px = png.depth
+		height_in_ex = height_in_px / pixels_per_ex
+		depth_in_ex = depth_in_px / pixels_per_ex
+		total_height_in_ex = height_in_ex + depth_in_ex
+		style = "" 
+		style += "vertical-align: -#{depth_in_ex}ex;" if use_depth
+		style += "height: #{total_height_in_ex}ex;"
+		img = Element.new 'img'
+		img.attributes['src'] = src
+		img.attributes['style'] = style
+		img.attributes['alt'] = "equation"
+		img
+	end
+	
+	def to_html_inline_math
+		mathml  = get_setting(:html_math_output_mathml) && render_mathml(:inline, self.math)
+		png = get_setting(:html_math_output_png) &&  render_png(:inline, self.math)
+
+		span = create_html_element 'span'
+		add_class_to(span, 'maruku-inline')
+			
+			if mathml
+				add_class_to(mathml, 'maruku-mathml')
+				span << mathml 
+			end
+	
+			if png
+				img = adjust_png(png, use_depth=true)
+				add_class_to(img, 'maruku-png')
+				span << img
+			end
+		span
+		
+	end
+
+	def to_html_equation
+		mathml  = get_setting(:html_math_output_mathml) && render_mathml(:equation, self.math)
+		png     = get_setting(:html_math_output_png)    && render_png(:equation, self.math)
+		
+		div = create_html_element 'div'
+		add_class_to(div, 'maruku-equation')
+			if self.label  # then numerate
+				span = Element.new 'span'
+				span.attributes['class'] = 'maruku-eq-number'
+				num = self.num
+				span << Text.new("(#{num})")
+				div << span
+				div.attributes['id'] = "eq:#{self.label}"
+			end
+			
+			if mathml
+				add_class_to(mathml, 'maruku-mathml')
+				div << mathml 
+			end
+			
+			if png
+				img = adjust_png(png, use_depth=false)
+				add_class_to(img, 'maruku-png')
+				div << img
+			end
+			
+			source_div = Element.new 'div'
+				add_class_to(source_div, 'maruku-eq-tex')
+				code = convert_to_mathml_none(:equation, self.math)	
+				code.attributes['style'] = 'display: none'
+			source_div << code
+			div << source_div
+		div
+	end
+	
+	def to_html_eqref
+		if eq = self.doc.eqid2eq[self.eqid]
+			num = eq.num
+			a = Element.new 'a'
+			a.attributes['class'] = 'maruku-eqref'
+			a.attributes['href'] = "#eq:#{self.eqid}"
+			a << Text.new("(#{num})")
+			a
+		else
+			maruku_error "Cannot find equation #{self.eqid.inspect}"
+			Text.new "(eq:#{self.eqid})"
+		end
+	end
+
+	
+end end end
+
+