maiku 0.6.1.maiku

data/lib/maruku/ext/div.rb

@@ -0,0 +1,133 @@
+
+
+#+-----------------------------------{.warning}------
+#| this is the last warning!
+#|
+#| please, go away!
+#|
+#| +------------------------------------- {.menace} --
+#| | or else terrible things will happen
+#| +--------------------------------------------------
+#+---------------------------------------------------
+
+OpenDiv = /^[ ]{0,3}\+\-\-+\s*(\{([^{}]*|".*"|'.*')*\})?\s*\-*\s*$/
+CloseDiv = /^[ ]{0,3}\=\-\-+\s*(\{([^{}]*|".*"|'.*')*\})?\s*\-*\s*$/
+# note these are not enough for parsing the above example:
+#OpenDiv = /^[ ]{0,3}\+\-\-+\s*(.*)$/
+#CloseDiv = /^[ ]{0,3}\=\-\-+\s*(.*)$/
+StartPipe = /^[ ]{0,3}\|(.*)$/ # $1 is rest of line
+DecorativeClosing = OpenDiv
+
+MaRuKu::In::Markdown::register_block_extension(
+	:regexp  => OpenDiv,
+	:handler => lambda { |doc, src, context|
+		# return false if not doc.is_math_enabled?
+		first = src.shift_line
+		first =~ OpenDiv
+		ial_at_beginning = $1
+		ial_at_end = nil
+		
+		lines = []
+		# if second line starts with "|"
+		if src.cur_line =~ StartPipe
+			# then we read until no more "|"
+			while src.cur_line && (src.cur_line =~ StartPipe)
+				content = $1
+				lines.push content
+				src.shift_line
+			end
+			if src.cur_line =~ DecorativeClosing
+				ial_at_end = $1
+				src.shift_line 
+			end
+		else
+			# else we read until CloseDiv
+			divs_open = 1
+			while src.cur_line && (divs_open>0)
+				if src.cur_line =~ CloseDiv
+					divs_open -= 1
+					if divs_open == 0
+						ial_at_end = $1
+						src.shift_line
+						break
+					else
+						lines.push src.shift_line
+					end
+				else
+					if src.cur_line =~ OpenDiv
+						divs_open += 1 
+					end
+					lines.push src.shift_line
+				end
+			end
+			
+			if divs_open > 0
+				e = "At end of input, I still have #{divs_open} DIVs open."
+				doc.maruku_error(e, src, context)
+				return true
+			end
+		end
+		
+		ial_at_beginning = nil unless 
+			(ial_at_beginning&&ial_at_beginning.size > 0)
+		ial_at_end = nil unless (ial_at_end && ial_at_end.size > 0)
+
+		if ial_at_beginning && ial_at_end
+			e = "Found two conflicting IALs: #{ial_at_beginning.inspect} and #{ial_at_end.inspect}"
+			doc.maruku_error(e, src, context)
+		end
+		
+		al_string = ial_at_beginning || ial_at_end
+		al = nil
+		
+		if al_string =~ /^\{(.*)\}\s*$/
+			inside = $1
+		cs = MaRuKu::In::Markdown::SpanLevelParser::CharSource
+		al = al_string &&
+			doc.read_attribute_list(cs.new(inside), its_context=nil, break_on=[nil])
+		end
+		
+		src = MaRuKu::In::Markdown::BlockLevelParser::LineSource.new(lines)
+		children = doc.parse_blocks(src)
+
+		context.push doc.md_div(children, al)
+		true
+	})
+	
+
+module MaRuKu; class MDElement
+
+	def md_div(children, al=nil)
+		type = label = num = nil
+		doc.refid2ref ||= {}
+		if al
+			al.each do |k, v|
+				case k
+				when :class
+					type = $1 if v =~ /^num_(\w*)/
+        	                when :id
+					label = v
+				end
+			end
+		end
+		if type
+			doc.refid2ref[type] ||= {}
+			num = doc.refid2ref[type].length + 1 || 1
+		end
+		e = self.md_el(:div, children, meta={:label => label, :type => type, :num => num}, al)
+		if type && label
+			doc.refid2ref[type].update({label => e})
+		end
+		e
+	end
+	
+end end
+
+
+module MaRuKu; module Out; module HTML
+
+	def to_html_div
+		add_ws  wrap_as_element('div')
+	end
+	
+end end end

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,12 @@
+class String
+	# fix some LaTeX command-name clashes
+	def fix_latex
+		if #{html_math_engine} == 'itex2mml'
+			s = self.gsub("\\mathop{", "\\operatorname{")
+			s.gsub!(/\\begin\{svg\}.*?\\end\{svg\}/m, " ")
+			s.gsub("\\space{", "\\itexspace{")
+		else
+			self
+		end
+	end
+end

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

@@ -0,0 +1,107 @@
+
+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 get_setting(:html_png_dir)
+
+			# first, we check whether this image has already been processed
+			md5sum = Digest::MD5.hexdigest(tex+" params: ")
+			result_file = File.join(get_setting(: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 += "--displaymath " if kind == :equation
+				options += ("--temp-directory '%s' " % get_setting(:html_png_dir))
+				options += ("--png-directory '%s'" % get_setting(: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 = get_setting(:html_png_url)
+			return PNG.new("#{dir_url}#{md5}.png", depth, height)
+		rescue Exception => e
+			maruku_error "Error: #{e}"
+		end
+		nil
+	end
+
+  
+	def convert_to_mathml_blahtex(kind, tex)
+    @@BlahtexCache = PStore.new(get_setting(:latex_cache_file))
+    
+		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,119 @@
+module MaRuKu
+	
+	class MDDocument
+		# Hash equation id (String) to equation element (MDElement)
+		safe_attr_accessor :eqid2eq, Hash
+		
+		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 
+		}
+	)
+
+	# This adds support for \ref
+	RegRef = /\\ref\{(\w*)\}/
+        MaRuKu::In::Markdown::register_span_extension(
+                :chars => [?\\, ?(], 
+                :regexp => RegRef,
+                :handler => lambda { |doc, src, con|
+                        return false if not doc.is_math_enabled?
+                        refid = src.read_regexp(RegRef).captures.compact.first
+                        r = doc.md_el(:divref, [], meta={:refid=>refid})
+                        con.push r
+                        true 
+                }
+        )