maruku 0.6.1 → 0.7.0.beta1

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

@@ -1,20 +1,12 @@
-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
+module MaRuKu::Out::HTML
+  def convert_to_mathml_none(kind, tex)
+    code = xelem('code')
+    tex_node = xtext(tex)
+    code << tex_node
+  end
+
+  def convert_to_png_none(kind, tex)
+    nil
+  end
+end
 

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

@@ -1,5 +1,4 @@
-module MaRuKu; module Out; module HTML
-
+module MaRuKu::Out::HTML
 	def convert_to_mathml_ritex(kind, tex)
 		begin
 			if not $ritex_parser
@@ -20,5 +19,4 @@ module MaRuKu; module Out; module HTML
 		end
 		nil
 	end
-	
-end end end
+end

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

@@ -1,119 +1,113 @@
 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
+  class MDDocument
+    # A hash of equation ids to equation elements
+    #
+    # @return [String => MDElement]
+    attr_accessor :eqid2eq
+
+    def is_math_enabled?
+      get_setting :math_enabled
+    end
+  end
 end
 
+# TODO: Properly scope all these regexps
+# Everything goes; takes care of escaping the "\$" inside the expression
+RegInlineMath = /\${1}((?:[^\$]|\\\$)+)\$/
+
+MaRuKu::In::Markdown.register_span_extension(
+  :chars => '$',
+  :regexp => RegInlineMath,
+  :handler => lambda do |doc, src, con|
+    next false unless doc.is_math_enabled?
+    next false unless m = src.read_regexp(RegInlineMath)
+    math = m.captures.compact.first
+    con.push doc.md_inline_math(math)
+    true
+  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 do |doc, src, con|
+    next false unless 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)
+      next true
+    end
+
+    opening, tex = first.scan(EquationStart).first
+    # ensure newline at end of first line of equation isn't swallowed
+    tex << "\n"
+    numerate = doc.get_setting(:math_numbered).include?(opening)
+    label = nil
+    loop do
+      unless src.cur_line
+        doc.maruku_error(
+          "Stream finished while reading equation\n\n" + tex.gsub(/^/, '$> '),
+          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
+      end
+
+      tex << line << "\n"
+    end
+    con.push doc.md_equation(tex, label, numerate)
+    true
+  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*$/
+# This adds support for \eqref
+RegEqrefLatex = /\\eqref\{(\w+?)\}/
+RegEqPar = /\(eq:(\w+?)\)/
+RegEqref = Regexp.union(RegEqrefLatex, RegEqPar)
 
-	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 
-		}
-	)
+MaRuKu::In::Markdown.register_span_extension(
+  :chars => ["\\", '('],
+  :regexp => RegEqref,
+  :handler => lambda do |doc, src, con|
+    return false unless doc.is_math_enabled?
+    eqid = src.read_regexp(RegEqref).captures.compact.first
+    con.push doc.md_el(:eqref, [], :eqid => eqid)
+    true
+  end)
 
-	# 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 
-                }
-        )
+# This adds support for \ref
+RegRef = /\\ref\{(\w*?)\}/
+MaRuKu::In::Markdown.register_span_extension(
+  :chars => ["\\", '('],
+  :regexp => RegRef,
+  :handler => lambda do |doc, src, con|
+    return false unless doc.is_math_enabled?
+    refid = src.read_regexp(RegRef).captures.compact.first
+    con.push doc.md_el(:divref, [], :refid => refid)
+    true
+  end)

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

@@ -1,187 +1,184 @@
-
-=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'] = "$#{self.math.strip}$"
-		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')
-				return 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 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_span = Element.new 'span'
-			add_class_to(source_span, 'maruku-eq-tex')
-			code = convert_to_mathml_none(:equation, self.math.strip)	
-			code.attributes['style'] = 'display: none'
-			source_span << code
-			div << source_span
-
-			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
-		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
-
-	def to_html_divref
-		ref= nil
-		self.doc.refid2ref.each_value { |h|
-			ref = h[self.refid] if h.has_key?(self.refid)			
-		}
-		if ref
-			num = ref.num
-                        a = Element.new 'a'
-                        a.attributes['class'] = 'maruku-ref'
-                        a.attributes['href'] = "#" + self.refid
-                        a << Text.new(num.to_s)
-                        a
-                else
-                        maruku_error "Cannot find div #{self.refid.inspect}"
-                        Text.new "\\ref{#{self.refid}}"
-                end
-	end
-	
-end end end
-
-
+#=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 this node's TeX code.
+      #
+      # @return [MaRuKu::Out::HTML::HTMLElement]
+      def render_mathml(kind, tex)
+        engine = get_setting(:html_math_engine)
+        method = "convert_to_mathml_#{engine}"
+        if self.respond_to? method
+          mathml = self.send(method, kind, tex)
+          return mathml || convert_to_mathml_none(kind, tex)
+        end
+
+        # TODO: Warn here
+        puts "A method called #{method} should be defined."
+        convert_to_mathml_none(kind, tex)
+      end
+
+      # Renders a PNG image of this node's TeX code.
+      # Returns
+      #
+      # @return [MaRuKu::Out::HTML::PNG, nil]
+      #   A struct describing the location and size of the image,
+      #   or nil if no library is loaded that can render PNGs.
+      def render_png(kind, tex)
+        engine = get_setting(:html_png_engine)
+        method = "convert_to_png_#{engine}".to_sym
+        return self.send(method, kind, tex) if self.respond_to? method
+
+        puts "A method called #{method} should be defined."
+        nil
+      end
+
+      def pixels_per_ex
+        $pixels_per_ex ||= render_png(:inline, "x").height
+      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 = xelem('img')
+        img['src'] = src
+        img['style'] = style
+        img['alt'] = "$#{self.math.strip}$"
+        img['class'] = 'maruku-png'
+        img
+      end
+
+      def to_html_inline_math
+        mathml = get_setting(:html_math_output_mathml) && render_mathml(:inline, self.math)
+        if mathml
+          mathml.add_class('maruku-mathml')
+          return mathml.to_html
+        end
+
+        png = get_setting(:html_math_output_png) && render_png(:inline, self.math)
+
+        HTMLElement.new 'span', 'class' => 'maruku-inline' do
+          # TODO: It seems weird that we output an empty span if there's no PNG
+          if png
+            adjust_png(png, true)
+          end
+        end
+      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 = xelem('div')
+        div['class'] = 'maruku-equation'
+        if mathml
+          if self.label  # then numerate
+            span = xelem('span')
+            span['class'] = 'maruku-eq-number'
+            span << xtext("(#{self.num})")
+            div << span
+            div['id'] = "eq:#{self.label}"
+          end
+          mathml.add_class('maruku-mathml')
+          div << mathml.to_html
+        end
+
+        if png
+          img = adjust_png(png, false)
+          div << img
+          if self.label  # then numerate
+            span = xelem('span')
+            span['class'] = 'maruku-eq-number'
+            span << xtext("(#{self.num})")
+            div << span
+            div['id'] = "eq:#{self.label}"
+          end
+        end
+
+        source_span = xelem('span')
+        add_class_to(source_span, 'maruku-eq-tex')
+        code = convert_to_mathml_none(:equation, self.math.strip)
+        code['style'] = 'display: none'
+        source_span << code
+        div << source_span
+
+        div
+      end
+
+      def to_html_eqref
+        unless eq = self.doc.eqid2eq[self.eqid]
+          maruku_error "Cannot find equation #{self.eqid.inspect}"
+          return xtext("(eq:#{self.eqid})")
+        end
+
+        a = xelem('a')
+        a['class'] = 'maruku-eqref'
+        a['href'] = "#eq:#{self.eqid}"
+        a << xtext("(#{eq.num})")
+        a
+      end
+
+      def to_html_divref
+        unless hash = self.doc.refid2ref.values.find {|h| h.has_key?(self.refid)}
+          maruku_error "Cannot find div #{self.refid.inspect}"
+          return xtext("\\ref{#{self.refid}}")
+        end
+        ref= hash[self.refid]
+
+        a = xelem('a')
+        a['class'] = 'maruku-ref'
+        a['href'] = "#" + self.refid
+        a << xtext(ref.num.to_s)
+        a
+      end
+    end
+  end
+end