remi-maruku 0.5.9

data/lib/maruku/attributes.rb

@@ -0,0 +1,227 @@
+#--
+#   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
+#++
+
+
+class String
+	def quote_if_needed
+		if /[\s\'\"]/.match self
+			inspect
+		else
+			self
+		end
+	end
+end
+
+module MaRuKu; 
+	MagicChar = ':'
+	
+	class AttributeList < Array
+		
+		# An attribute list becomes 
+		# {#id .cl key="val" ref}
+		# [ [:id, 'id'], [:class, 'id'], ['key', 'val'], [ :ref, 'ref' ]]
+
+		private :push
+		
+		def push_key_val(key, val); 
+			raise "Bad #{key.inspect}=#{val.inspect}" if not key and val
+			push [key, val] 
+		end
+		def push_ref(ref_id);       
+			
+			raise "Bad :ref #{ref_id.inspect}" if not ref_id
+			push [:ref, ref_id+""] 
+
+#			p "Now ", self ########################################
+		end
+		def push_class(val);        
+			raise "Bad :id #{val.inspect}" if not val
+			push [:class,  val] 
+		end
+		def push_id(val);           
+			raise "Bad :id #{val.inspect}" if not val
+			push [:id,  val] 
+		end
+		
+		def to_s
+			map do |k,v|
+				case k
+				when :id;    "#" + v.quote_if_needed
+				when :class; "." + v.quote_if_needed
+				when :ref;    v.quote_if_needed
+				else k.quote_if_needed + "=" + v.quote_if_needed
+				end
+			end . join(' ')
+		end
+		alias to_md to_s 
+	end
+	
+end
+
+module MaRuKu; module In; module Markdown; module SpanLevelParser
+	
+	def unit_tests_for_attribute_lists
+		[
+			[ "",     [], "Empty lists are allowed" ], 
+			[ "=",    :throw, "Bad char to begin a list with." ], 
+			[ "a =b", :throw, "No whitespace before `=`." ], 
+			[ "a= b", :throw, "No whitespace after `=`." ], 
+
+			[ "a b", [[:ref, 'a'],[:ref, 'b']], "More than one ref" ], 
+			[ "a b c", [[:ref, 'a'],[:ref, 'b'],[:ref, 'c']], "More than one ref" ], 
+			[ "hello notfound", [[:ref, 'hello'],[:ref, 'notfound']]], 
+
+			[ "'a'",  [[:ref, 'a']], "Quoted value." ], 
+			[ '"a"'   ], 
+
+			[ "a=b",  [['a','b']], "Simple key/val" ], 
+			[ "'a'=b"   ], 
+			[ "'a'='b'" ], 
+			[ "a='b'"   ], 
+
+			[ 'a="b\'"',  [['a',"b\'"]], "Key/val with quotes" ],
+			[ 'a=b\''],
+			[ 'a="\\\'b\'"',  [['a',"\'b\'"]], "Key/val with quotes" ], 
+			
+			['"', :throw, "Unclosed quotes"],
+			["'"],
+			["'a "],
+			['"a '],
+			
+			[ "#a",  [[:id, 'a']], "Simple ID" ], 
+			[ "#'a'" ], 
+			[ '#"a"' ], 
+
+			[ "#",  :throw, "Unfinished '#'." ], 
+			[ ".",  :throw, "Unfinished '.'." ], 
+			[ "# a",  :throw, "No white-space after '#'." ], 
+			[ ". a",  :throw, "No white-space after '.' ." ], 
+			
+			[ "a=b c=d",  [['a','b'],['c','d']], "Tabbing" ], 
+			[ " \ta=b \tc='d' "],
+			[ "\t a=b\t c='d'\t\t"],
+			
+			[ ".\"a'",  :throw, "Mixing quotes is bad." ], 
+			
+		].map { |s, expected, comment| 
+			@expected = (expected ||= @expected)
+			@comment  = (comment  ||= (last=@comment) )
+			(comment == last && (comment += (@count+=1).to_s)) || @count = 1
+			expected = [md_ial(expected)] if expected.kind_of? Array
+			["{#{MagicChar}#{s}}", expected, "Attributes: #{comment}"]
+		}
+	end
+	
+	def md_al(s=[]); AttributeList.new(s) end
+
+	# returns nil or an AttributeList
+	def read_attribute_list(src, con, break_on_chars)
+		
+		separators = break_on_chars + [?=,?\ ,?\t]
+		escaped = Maruku::EscapedCharInQuotes
+			
+		al = AttributeList.new
+		while true
+			src.consume_whitespace
+			break if break_on_chars.include? src.cur_char
+	
+			case src.cur_char
+			when nil 
+				maruku_error "Attribute list terminated by EOF:\n "+
+				             "#{al.inspect}" , src, con
+				tell_user "I try to continue and return partial attribute list:\n"+
+					al.inspect
+				break
+			when ?=     # error
+				maruku_error "In attribute lists, cannot start identifier with `=`."
+				tell_user "I try to continue"
+				src.ignore_char
+			when ?#     # id definition
+				src.ignore_char
+				if id = read_quoted_or_unquoted(src, con, escaped, separators)
+					al.push_id id
+				else
+					maruku_error 'Could not read `id` attribute.', src, con
+					tell_user 'Trying to ignore bad `id` attribute.'
+				end
+			when ?.     # class definition
+				src.ignore_char
+				if klass = read_quoted_or_unquoted(src, con, escaped, separators)
+					al.push_class klass
+				else
+					maruku_error 'Could not read `class` attribute.', src, con
+					tell_user 'Trying to ignore bad `class` attribute.'
+				end
+			else
+				if key = read_quoted_or_unquoted(src, con, escaped, separators)
+					if src.cur_char == ?=
+						src.ignore_char # skip the =
+						if val = read_quoted_or_unquoted(src, con, escaped, separators)
+							al.push_key_val(key, val)
+						else
+							maruku_error "Could not read value for key #{key.inspect}.",
+								src, con
+							tell_user "Ignoring key #{key.inspect}."
+						end
+					else
+						al.push_ref key
+					end
+				else
+					maruku_error 'Could not read key or reference.'
+				end
+			end # case
+		end # while true
+		al
+	end
+	
+	
+	# We need a helper
+	def is_ial(e); e.kind_of? MDElement and e.node_type == :ial end
+
+	def merge_ial(elements, src, con)	
+
+		# Apply each IAL to the element before
+		elements.each_with_index do |e, i| 
+		if is_ial(e) && i>= 1 then
+			before = elements[i-1]
+			after = elements[i+1]
+			if before.kind_of? MDElement
+				before.al = e.ial
+			elsif after.kind_of? MDElement
+				after.al = e.ial
+			else
+				maruku_error "It is not clear to me what element this IAL {:#{e.ial.to_md}} \n"+
+				"is referring to. The element before is a #{before.class.to_s}, \n"+
+				"the element after is a #{after.class.to_s}.\n"+
+				"\n before: #{before.inspect}"+
+				"\n after: #{after.inspect}",
+				src, con
+				# xxx dire se c'è empty vicino
+			end
+		end 
+		end
+		
+		if not Globals[:debug_keep_ials]
+			elements.delete_if {|x| is_ial(x) unless x == elements.first} 
+		end
+	end
+		
+end end end end 
+#module MaRuKu; module In; module Markdown; module SpanLevelParser

data/lib/maruku/defaults.rb

@@ -0,0 +1,70 @@
+#--
+#   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
+	
+Globals = {
+	:unsafe_features => false,
+	:on_error => :warning,
+	
+	
+	:use_numbered_headers => false,
+	
+	:maruku_signature => false,
+	:code_background_color => '#fef',
+	:code_show_spaces => false,
+	
+	:filter_html => false,
+	
+	:html_math_output_mathml => true, # also set :html_math_engine
+	:html_math_engine => 'none', #ritex, itex2mml
+	
+	:html_math_output_png => false, 	
+	:html_png_engine => 'none',
+	:html_png_dir => 'pngs',
+	:html_png_url => 'pngs/',
+	:html_png_resolution => 200,
+	
+	:html_use_syntax => false,
+	
+	:latex_use_listings => false,
+	:latex_cjk => false,
+	
+	:debug_keep_ials => false,
+	:doc_prefix => ''
+}
+
+class MDElement
+	def get_setting(sym)
+		if self.attributes.has_key?(sym) then
+			return self.attributes[sym]
+		elsif self.doc && self.doc.attributes.has_key?(sym) then
+			return self.doc.attributes[sym]
+		elsif MaRuKu::Globals.has_key?(sym)
+			return MaRuKu::Globals[sym]
+		else
+			$stderr.puts "Bug: no default for #{sym.inspect}"
+			nil
+		end
+	end
+end
+
+end

data/lib/maruku/errors_management.rb

@@ -0,0 +1,92 @@
+#--
+#   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
+#++
+
+
+
+#m  Any method that detects formatting error calls the
+#m  maruku_error() method. 
+#m  if @meta[:on_error] == 
+#m
+#m  - :warning   write on the standard err (or @error_stream if defined), 
+#m              then do your best.
+#m  - :ignore    be shy and try to continue
+#m  - :raise     raises a MarukuException
+#m
+#m  default is :raise
+
+module MaRuKu
+	
+	class Exception < RuntimeError
+	end
+	
+module Errors
+	
+	def maruku_error(s,src=nil,con=nil)
+		policy = get_setting(:on_error)
+		
+		case policy
+		when :ignore 
+		when :raise
+			raise_error create_frame(describe_error(s,src,con))
+		when :warning
+			tell_user create_frame(describe_error(s,src,con))
+		else
+			raise "BugBug: policy = #{policy.inspect}"
+		end
+	end
+	
+	def maruku_recover(s,src=nil,con=nil)
+		tell_user create_frame(describe_error(s,src,con))
+	end
+	
+	alias error maruku_error
+
+	def raise_error(s)
+		raise MaRuKu::Exception, s, caller
+	end
+
+	def tell_user(s)
+		error_stream = self.attributes[:error_stream] || $stderr
+		error_stream << s 
+	end
+	
+	def create_frame(s)
+		n = 75
+		"\n" +
+		" "+"_"*n + "\n"+
+		"| Maruku tells you:\n" +
+		"+" + ("-"*n) +"\n"+
+		add_tabs(s,1,'| ') + "\n" +
+		"+" + ("-"*n) + "\n" +
+		add_tabs(caller[0, 5].join("\n"),1,'!') + "\n" +
+		"\\" + ("_"*n) + "\n"
+	end
+
+	def describe_error(s,src,con)
+		t = s
+		src && (t += "\n#{src.describe}\n")
+		con && (t += "\n#{con.describe}\n")
+		t
+	end
+	
+end # Errors
+end # MaRuKu
+
+

data/lib/maruku/ext/div.rb

@@ -0,0 +1,100 @@
+
+
+OpenDiv = /^[ ]{0,3}\+\-\-+\s*([^\s-]*)\s*\-*\s*$/
+CloseDiv = /^[ ]{0,3}\=\-\-+\s*([^\s-]*)\s*\-*\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 =~ /^\{(.*)\}$/
+			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, a=nil)
+		self.md_el(:div, children, meta={}, a)
+	end
+	
+end end
+
+
+module MaRuKu; module Out; module HTML
+
+	def to_html_div
+		add_ws  wrap_as_element('div')
+	end
+	
+end end end