patcito-maruku 0.6.0

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

@@ -0,0 +1,36 @@
+require 'maruku/ext/math/latex_fix'
+
+module MaRuKu
+  module Out
+    module Latex
+      def to_latex_inline_math
+        fix_latex("$#{self.math.strip}$")
+      end
+
+      def to_latex_equation
+        if self.label
+          fix_latex("\\begin{equation}\n#{self.math.strip}\n\\label{#{self.label}}\\end{equation}\n")
+        else
+          fix_latex("\\begin{displaymath}\n#{self.math.strip}\n\\end{displaymath}\n")
+        end
+      end
+
+      def to_latex_eqref
+        "\\eqref{#{self.eqid}}"
+      end
+
+      def to_latex_divref
+        "\\ref{#{self.refid}}"
+      end
+
+      private
+
+      def fix_latex(str)
+        return str unless self.get_setting(:html_math_engine) == 'itex2mml'
+        s = str.gsub("\\mathop{", "\\operatorname{")
+        s.gsub!(/\\begin\{svg\}.*?\\end\{svg\}/m, " ")
+        s.gsub("\\space{", "\\itexspace{")
+      end
+    end
+  end
+end

data/lib/maruku/ext/yaml.rb

@@ -0,0 +1,43 @@
+require 'YAML'
+
+module MaRuKu
+  # Utility functions for dealing with strings.
+  module Strings
+    # Parses yaml headers, returning a hash.
+    # `hash[:data]` is the message; 
+    # that is, anything past the headers.
+    #
+    # Keys are downcased and converted to symbols; 
+    # spaces become underscores.  For example:
+    #
+    # ---
+    # My key: true
+    # ---
+    #
+    # becomes:
+    #
+    # {:my_deg => true}
+    #
+    # @param s [String] the entire contents
+    # @return [Symbol => String] The header values
+    def parse_yaml_headers(s)
+      headers = {}
+      if s =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        
+        begin
+          hash = YAML.load($1)
+        rescue => e
+          puts "YAML Exception reading #{name}: #{e.message}"
+          hash = {}
+        end
+      end
+      hash.each_pair do |yamlkey,yamlval| 
+        k, v = normalize_key_and_value(yamlkey, yamlval)
+        headers[k.to_sym] = v
+      end
+        
+      headers[:data] = $' # the postmatch string
+      headers
+    end
+  end
+end

data/lib/maruku/helpers.rb

@@ -0,0 +1,214 @@
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+#
+#   Maruku is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   Maruku is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module MaRuKu
+  # A collection of helper functions for creating Markdown elements.
+  # They hide the particular internal representations.
+  #
+  # Always use these rather than creating an {MDElement} directly.
+  module Helpers
+    # @param children [Array<MDElement, String>]
+    #   The child nodes.
+    #   If the first child is a \{#md\_ial}, it's merged with `al`
+    def md_el(node_type, children = [], meta = {}, al = nil)
+      first = children.first
+      if first.is_a?(MDElement) && first.node_type == :ial
+        if al
+          al += first.ial
+        else
+          al = first.ial
+        end
+        children.shift
+      end
+
+      e = MDElement.new(node_type, children, meta, al)
+      e.doc = @doc
+      e
+    end
+
+    def md_header(level, children, al = nil)
+      md_el(:header, children, {:level => level}, al)
+    end
+
+    # Inline code
+    def md_code(code, al = nil)
+      md_el(:inline_code, [], {:raw_code => code}, al)
+    end
+
+    # Code block
+    def md_codeblock(source, al = nil)
+      md_el(:code, [], {:raw_code => source}, al)
+    end
+
+    def md_quote(children, al = nil)
+      md_el(:quote, children, {}, al)
+    end
+
+    def md_li(children, want_my_par, al = nil)
+      md_el(:li, children, {:want_my_paragraph => want_my_par}, al)
+    end
+
+    def md_footnote(footnote_id, children, al = nil)
+      md_el(:footnote, children, {:footnote_id => footnote_id}, al)
+    end
+
+    def md_abbr_def(abbr, text, al = nil)
+      md_el(:abbr_def, [], {:abbr => abbr, :text => text}, al)
+    end
+
+    def md_abbr(abbr, title)
+      md_el(:abbr, [abbr], :title => title)
+    end
+
+    def md_html(raw_html, al = nil)
+      e = md_el(:raw_html, [], :raw_html => raw_html)
+      begin
+        e.instance_variable_set("@parsed_html",
+          REXML::Document.new("<marukuwrap>#{raw_html.strip}</marukuwrap>"))
+      rescue REXML::ParseException => ex
+        e.instance_variable_set "@parsed_html", nil
+        maruku_recover <<ERR
+REXML cannot parse this block of HTML/XML:
+#{raw_html.gsub(/^/, '|').rstrip}
+#{ex.inspect}
+ERR
+      end
+      e
+    end
+
+    def md_link(children, ref_id, al = nil)
+      md_el(:link, children, {:ref_id => ref_id.downcase}, al)
+    end
+
+    def md_im_link(children, url, title = nil, al = nil)
+      md_el(:im_link, children, {:url => url, :title => title}, al)
+    end
+
+    def md_image(children, ref_id, al = nil)
+      md_el(:image, children, {:ref_id => ref_id}, al)
+    end
+
+    def md_im_image(children, url, title = nil, al = nil)
+      md_el(:im_image, children, {:url => url, :title => title}, al)
+    end
+
+    def md_em(children, al = nil)
+      md_el(:emphasis, [children].flatten, {}, al)
+    end
+
+    def md_br
+      md_el(:linebreak, [], {}, nil)
+    end
+
+    def md_hrule
+      md_el(:hrule, [], {}, nil)
+    end
+
+    def md_strong(children, al = nil)
+      md_el(:strong, [children].flatten, {}, al)
+    end
+
+    def md_emstrong(children, al = nil)
+      md_strong(md_em(children), al)
+    end
+
+    # A URL to be linkified (e.g. `<http://www.example.com/>`).
+    def md_url(url, al = nil)
+      md_el(:immediate_link, [], {:url => url}, al)
+    end
+
+    # An email to be linkified
+    # (e.g. `<andrea@rubyforge.org>` or `<mailto:andrea@rubyforge.org>`).
+    def md_email(email, al = nil)
+      md_el(:email_address, [], {:email => email}, al)
+    end
+
+    def md_entity(entity_name, al = nil)
+      md_el(:entity, [], {:entity_name => entity_name}, al)
+    end
+
+    # Markdown extra
+    def md_foot_ref(ref_id, al = nil)
+      md_el(:footnote_reference, [], {:footnote_id => ref_id}, al)
+    end
+
+    def md_par(children, al = nil)
+      md_el(:paragraph, children, meta = {}, al)
+    end
+
+    # A definition of a reference (e.g. `[1]: http://url [properties]`).
+    def md_ref_def(ref_id, url, title = nil, meta = {}, al = nil)
+      meta[:url] = url
+      meta[:ref_id] = ref_id
+      meta[:title] = title if title
+      md_el(:ref_definition, [], meta, al)
+    end
+
+    # inline attribute list
+    def md_ial(al)
+      al = Maruku::AttributeList.new(al) unless al.is_a?(Maruku::AttributeList)
+      md_el(:ial, [], :ial => al)
+    end
+
+    # Attribute list definition
+    def md_ald(id, al)
+      md_el(:ald, [], :ald_id => id, :ald => al)
+    end
+
+    # A server directive (e.g. `<?target code... ?>`)
+    def md_xml_instr(target, code)
+      md_el(:xml_instr, [], :target => target, :code => code)
+    end
+  end
+
+  class MDElement
+    INSPECT2_FORMS = {
+      :paragraph          => ["par",      :children],
+      :footnote_reference => ["foot_ref", :footnote_id],
+      :entity             => ["entity",   :entity_name],
+      :email_address      => ["email",    :email],
+      :inline_code        => ["code",     :raw_code],
+      :raw_html           => ["html",     :raw_html],
+      :emphasis           => ["em",       :children],
+      :strong             => ["strong",   :children],
+      :immediate_link     => ["url",      :url],
+      :image              => ["image",    :children, :ref_id],
+      :im_image           => ["im_image", :children, :url, :title],
+      :link               => ["link",     :children, :ref_id],
+      :im_link            => ["im_link",  :children, :url, :title],
+      :ref_definition     => ["ref_def",  :ref_id, :url, :title],
+      :ial                => ["ial",      :ial]
+    }
+
+    # Outputs the abbreviated form of an element
+    # (this should be `eval`-able to get a copy of the original element).
+    def inspect2
+      name, *params = INSPECT2_FORMS[@node_type]
+      return nil unless name
+
+      params = params.map do |p|
+        next children_inspect if p == :children
+        send(p).inspect
+      end
+      params << @al.inspect if @al && !@al.empty?
+
+      "md_#{name}(#{params.join(', ')})"
+    end
+  end
+end

data/lib/maruku/input/charsource.rb

@@ -0,0 +1,326 @@
+#--
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+# 
+#   Maruku is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+# 
+#   Maruku is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+# 
+#   You should have received a copy of the GNU General Public License
+#   along with Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+
+module MaRuKu; module In; module Markdown; module SpanLevelParser
+
+# a string scanner coded by me
+class CharSourceManual; end
+
+# a wrapper around StringScanner
+class CharSourceStrscan; end
+
+# A debug scanner that checks the correctness of both
+# by comparing their output
+class CharSourceDebug; end
+
+# Choose!
+
+CharSource = CharSourceManual     # faster! 58ms vs. 65ms
+#CharSource = CharSourceStrscan
+#CharSource = CharSourceDebug
+
+
+class CharSourceManual
+	include MaRuKu::Strings
+	
+	def initialize(s, parent=nil)
+		raise "Passed #{s.class}" if not s.kind_of? String
+		@buffer = s
+		@buffer_index = 0
+		@parent = parent
+	end
+	
+	# Return current char as a FixNum (or nil).
+	def cur_char; @buffer[@buffer_index]   end
+
+	# Return the next n chars as a String.
+	def cur_chars(n); @buffer[@buffer_index,n]  end
+	
+	# Return the char after current char as a FixNum (or nil).
+	def next_char; @buffer[@buffer_index+1] end
+	
+	def shift_char
+		c = @buffer[@buffer_index]
+		@buffer_index+=1
+		c
+	end
+	
+	def ignore_char
+		@buffer_index+=1
+		nil
+	end
+	
+	def ignore_chars(n)
+		@buffer_index+=n
+		nil
+	end
+	
+	def current_remaining_buffer
+		@buffer[@buffer_index, @buffer.size-@buffer_index]
+	end
+	
+	def cur_chars_are(string)
+		# There is a bug here
+		if false
+			r2 = /^.{#{@buffer_index}}#{Regexp.escape string}/m
+			@buffer =~ r2
+		else
+			cur_chars(string.size) == string
+		end
+	end
+
+	def next_matches(r)
+		r2 = /^.{#{@buffer_index}}#{r}/m
+		md = r2.match @buffer
+		return !!md
+	end
+	
+	def read_regexp3(r)
+		r2 = /^.{#{@buffer_index}}#{r}/m
+		m = r2.match @buffer
+		if m
+			consumed = m.to_s.size - @buffer_index
+#			puts "Consumed #{consumed} chars (entire is #{m.to_s.inspect})"
+			ignore_chars consumed
+		else
+#			puts "Could not read regexp #{r2.inspect} from buffer "+
+#			" index=#{@buffer_index}"
+#			puts "Cur chars = #{cur_chars(20).inspect}"
+#			puts "Matches? = #{cur_chars(20) =~ r}"
+		end
+		m
+	end
+
+		def read_regexp(r)
+			r2 = /^#{r}/
+			rest = current_remaining_buffer
+			m = r2.match(rest)
+			if m
+				@buffer_index += m.to_s.size
+#				puts "#{r} matched #{rest.inspect}: #{m.to_s.inspect}"
+			end
+			return m
+		end
+	
+	def consume_whitespace
+		while c = cur_char 
+		  if (c == ?\s || c == ?\t)
+#				puts "ignoring #{c}"
+				ignore_char
+			else
+#				puts "#{c} is not ws: "<<c
+				break
+			end
+		end
+	end
+
+	def read_text_chars(out)
+		s = @buffer.size; c=nil
+		while @buffer_index < s && (c=@buffer[@buffer_index]) &&
+			 ((c>=?a && c<=?z) || (c>=?A && c<=?Z))
+				out << c
+				@buffer_index += 1
+		end
+	end
+	
+	def describe
+		s = describe_pos(@buffer, @buffer_index)
+		if @parent
+			s += "\n\n" + @parent.describe
+		end
+		s
+	end
+	include SpanLevelParser
+end
+
+def describe_pos(buffer, buffer_index)
+	len = 75
+	num_before = [len/2, buffer_index].min
+	num_after = [len/2, buffer.size-buffer_index].min
+	num_before_max = buffer_index
+	num_after_max = buffer.size-buffer_index
+	
+#		puts "num #{num_before} #{num_after}"
+	num_before = [num_before_max, len-num_after].min
+	num_after  = [num_after_max, len-num_before].min
+#		puts "num #{num_before} #{num_after}"
+	
+	index_start = [buffer_index - num_before, 0].max
+	index_end   = [buffer_index + num_after, buffer.size].min
+	
+	size = index_end- index_start
+	
+#		puts "- #{index_start} #{size}"
+
+	str = buffer[index_start, size]
+	str.gsub!("\n",'N')
+	str.gsub!("\t",'T')
+	
+	if index_end == buffer.size 
+		str += "EOF"
+	end
+		
+	pre_s = buffer_index-index_start
+	pre_s = [pre_s, 0].max
+	pre_s2 = [len-pre_s,0].max
+#		puts "pre_S = #{pre_s}"
+	pre =" "*(pre_s) 
+	
+	"-"*len+"\n"+
+	str + "\n" +
+	"-"*pre_s + "|" + "-"*(pre_s2)+"\n"+
+#		pre + "|\n"+
+	pre + "+--- Byte #{buffer_index}\n"+
+	
+	"Shown bytes [#{index_start} to #{size}] of #{buffer.size}:\n"+
+	buffer.gsub(/^/, ">")
+	
+#		"CharSource: At character #{@buffer_index} of block "+
+#		" beginning with:\n    #{@buffer[0,50].inspect} ...\n"+
+#		" before: \n     ... #{cur_chars(50).inspect} ... "
+end
+
+
+require 'strscan'
+
+class CharSourceStrscan
+	include SpanLevelParser
+	include MaRuKu::Strings
+	
+	def initialize(s, parent=nil)
+		@s = StringScanner.new(s)
+		@parent = parent
+	end
+	
+	# Return current char as a FixNum (or nil).
+	def cur_char
+		 @s.peek(1)[0]
+	end
+
+	# Return the next n chars as a String.
+	def cur_chars(n); 
+		@s.peek(n)
+	end
+	
+	# Return the char after current char as a FixNum (or nil).
+	def next_char; 
+		@s.peek(2)[1]
+	end
+	
+	def shift_char
+		(@s.get_byte)[0]
+	end
+	
+	def ignore_char
+		@s.get_byte
+		nil
+	end
+	
+	def ignore_chars(n)
+		n.times do @s.get_byte end
+		nil
+	end
+	
+	def current_remaining_buffer
+		@s.rest #nil #@buffer[@buffer_index, @buffer.size-@buffer_index]
+	end
+	
+	def cur_chars_are(string)
+		cur_chars(string.size) == string
+	end
+
+	def next_matches(r)
+		len = @s.match?(r)
+		return !!len
+	end
+	
+	def read_regexp(r)
+		string = @s.scan(r)
+		if string
+			return r.match(string)
+		else
+			return nil
+		end
+	end
+	
+	def consume_whitespace
+		@s.scan(/\s+/)
+		nil
+	end
+	
+	def describe
+		describe_pos(@s.string, @s.pos)
+	end
+	
+end
+
+
+class CharSourceDebug
+	def initialize(s, parent)
+		@a = CharSourceManual.new(s, parent)
+		@b = CharSourceStrscan.new(s, parent)
+	end
+	
+	def method_missing(methodname, *args)
+		a_bef = @a.describe
+		b_bef = @b.describe
+		
+		a = @a.send(methodname, *args)
+		b = @b.send(methodname, *args)
+		
+#		if methodname == :describe
+#			return a
+#		end
+		
+		if a.kind_of? MatchData
+			if a.to_a != b.to_a
+				puts "called: #{methodname}(#{args})"
+				puts "Matchdata:\na = #{a.to_a.inspect}\nb = #{b.to_a.inspect}"
+				puts "AFTER: "+@a.describe
+				puts "AFTER: "+@b.describe
+				puts "BEFORE: "+a_bef
+				puts "BEFORE: "+b_bef
+				puts caller.join("\n")
+				exit
+			end
+		else
+			if a!=b
+				puts "called: #{methodname}(#{args})"
+				puts "Attenzione!\na = #{a.inspect}\nb = #{b.inspect}"
+				puts ""+@a.describe
+				puts ""+@b.describe
+				puts caller.join("\n")
+				exit
+			end
+		end
+		
+		if @a.cur_char != @b.cur_char
+			puts "Fuori sincronia dopo #{methodname}(#{args})"
+			puts ""+@a.describe
+			puts ""+@b.describe
+			exit
+		end
+		
+		return a
+	end
+end
+
+end end end end