patcito-maruku 0.6.0

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

@@ -0,0 +1,39 @@
+module MaRuKu
+  module Out
+    module HTML
+      def convert_to_mathml_itex2mml(kind, tex)
+        return if $already_warned_itex2mml
+        begin
+          require 'itextomml'
+        rescue LoadError => e
+          maruku_error "Could not load package 'itex2mml'.\nPlease install it." unless $already_warned_itex2mml
+          $already_warned_itex2mml = true
+          return nil
+        end
+        begin
+          require 'instiki_stringsupport'
+        rescue LoadError
+          require 'itex_stringsupport'
+        end
+
+        parser = Itex2MML::Parser.new
+        mathml =
+          case kind
+          when :equation; parser.block_filter(tex)
+          when :inline; parser.inline_filter(tex)
+          else
+            maruku_error "Unknown itex2mml kind: #{kind}"
+            return
+          end
+
+        return Document.new(mathml.to_utf8, :respect_whitespace => :all).root
+      rescue REXML::ParseException => e
+        maruku_error "Invalid MathML TeX: \n#{tex.gsub(/^/, 'tex>')}\n\n #{e.inspect}"
+        nil
+      rescue
+        maruku_error "Could not produce MathML TeX: \n#{tex}\n\n #{e.inspect}"
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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:
+		mathml = "<code>#{tex.gsub( /&/, "&amp;" ).
+		  gsub( /</, "&lt;" ).gsub( />/, "&gt;"  ).
+		  gsub(/'/, "&#39;" ).gsub(/"/, "&quot;" )}</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,125 @@
+module MaRuKu
+  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*$/
+MultiLineEquation = /^[ ]{0,3}(#{EquationOpen})(.*?)(#{EquationClose})\s*?#{EqLabel}?\s*?$/m
+
+if MaRuKu::Globals[:html_math_output_span_equations]
+  MaRuKu::In::Markdown.register_span_extension(
+    :chars   => ?\\,
+    :regexp  => EquationStart,
+    :handler => lambda do |doc, src, con|
+      next false unless doc.is_math_enabled?
+      next false unless m = src.read_regexp(MultiLineEquation)
+      opening, tex, closing, label = $1, $2, $3, $4
+      numerate = doc.get_setting(:math_numbered).include?(opening)
+      con.push doc.md_equation(tex, label, numerate)
+      true
+    end)
+else
+  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
+      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)
+end
+
+# 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 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 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

@@ -0,0 +1,237 @@
+=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 [REXML::Document]
+      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."
+        return 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."
+        return nil
+      end
+      
+      # Renders a MathJax block of out this node's TeX code.
+      #
+      # @return [REXML::Document]
+      def render_mathjax(kind,tex)
+        if kind == :equation
+          # using the script that works with Instapaper
+          # see http://www.leancrew.com/all-this/2010/11/mathjax-markdown-and-instapaper/
+          # <span class="MathJax_Preview"><code>[math]</code></span>
+          # <script type="math/tex; mode=display">\int f(x) = F(x)</script>
+			
+          equation = create_html_element 'span'
+          
+          span = create_html_element 'span'
+          add_class_to(span,'MathJax_Preview')
+          code = convert_to_mathml_none(:equation, tex.strip)	
+          span << code
+			
+          script = create_html_element 'script'
+          script.attributes['type'] = 'math/tex; mode=display'
+          script << Text.new("#{tex.strip}")
+			
+          equation << span 
+          equation << script
+			
+          return equation
+        else
+          script = create_html_element 'script'
+          script.attributes['type'] = 'math/tex'
+          script << Text.new("#{tex.strip}")
+          return script
+        end
+      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 = 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)
+        mathjax = get_setting(:html_math_output_mathjax) && render_mathjax(: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, true)
+          add_class_to(img, 'maruku-png')
+          span << img
+        end
+        
+        if mathjax
+          span << mathjax
+        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)
+        mathjax = get_setting(:html_math_output_mathjax) && render_mathjax(:equation, self.math)
+        
+        if mathjax
+          span = create_html_element 'span'
+          add_class_to(span, 'maruku-equation')
+			
+          span << mathjax
+			
+          # mathjax handles equation numbering
+          return span
+        end
+
+        div = create_html_element 'div'
+        add_class_to(div, 'maruku-equation')
+        if mathml
+          if self.label  # then numerate
+            span = Element.new 'span'
+            span.attributes['class'] = 'maruku-eq-number'
+            span << Text.new("(#{self.num})")
+            div << span
+            div.attributes['id'] = "eq:#{self.label}"
+          end	
+          add_class_to(mathml, 'maruku-mathml')
+          div << mathml
+        end
+
+        if png
+          img = adjust_png(png, false)
+          add_class_to(img, 'maruku-png')
+          div << img
+          if self.label  # then numerate
+            span = Element.new 'span'
+            span.attributes['class'] = 'maruku-eq-number'
+            span << Text.new("(#{self.num})")
+            div << span
+            div.attributes['id'] = "eq:#{self.label}"
+          end	
+        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
+
+        div
+      end
+
+      def to_html_eqref
+        unless eq = self.doc.eqid2eq[self.eqid]
+          maruku_error "Cannot find equation #{self.eqid.inspect}"
+          return Text.new("(eq:#{self.eqid})")
+        end
+
+        a = Element.new 'a'
+        a.attributes['class'] = 'maruku-eqref'
+        a.attributes['href'] = "#eq:#{self.eqid}"
+        a << Text.new("(#{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 Text.new("\\ref{#{self.refid}}")
+        end
+        ref= hash[self.refid]
+
+        a = Element.new 'a'
+        a.attributes['class'] = 'maruku-ref'
+        a.attributes['href'] = "#" + self.refid
+        a << Text.new(ref.num.to_s)
+        a
+      end
+    end
+  end
+end