maruku 0.4.1 → 0.4.2

data/lib/maruku/input/charsource.rb

@@ -41,9 +41,11 @@ CharSource = CharSourceManual     # faster! 58ms vs. 65ms
 class CharSourceManual
 	include MaRuKu::Strings
 	
-	def initialize(s)
+	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).
@@ -140,7 +142,11 @@ class CharSourceManual
 	end
 	
 	def describe
-		describe_pos(@buffer, @buffer_index)
+		s = describe_pos(@buffer, @buffer_index)
+		if @parent
+			s += "\n\n" + @parent.describe
+		end
+		s
 	end
 	include SpanLevelParser
 end

data/lib/maruku/input/parse_block.rb

@@ -24,6 +24,15 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 	include Helpers
 	include MaRuKu::Strings
 	include MaRuKu::In::Markdown::SpanLevelParser
+
+	class BlockContext < Array
+		def describe
+			n = 5
+			desc = size > n ? self[-n,n] : self
+			"Last #{n} elements: "+
+			desc.map{|x| "\n -" + x.inspect}.join
+		end
+	end
 	
 	# Splits the string and calls parse_lines_as_markdown
 	def parse_text_as_markdown(text)
@@ -32,25 +41,23 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		return parse_blocks(src)
 	end
 	
+	# Input is a LineSource
 	def parse_blocks(src)
-		output = [];
+		output = BlockContext.new
 		
 		# run state machine
 		while src.cur_line
 #  Prints detected type (useful for debugging)
-			#puts "#{src.cur_line.md_type}|#{src.cur_line}"
+#			puts "#{src.cur_line.md_type}|#{src.cur_line}"
 			case src.cur_line.md_type
 				when :empty; 
+					output.push :empty
 					src.ignore_line
 				when :ial
-					m =  /\s*\{([^\}]*)\}\s*/.match src.shift_line
-					al = read_attribute_list(CharSource.new(m[1]), context=nil, break_on=[nil])
-					if last = output.last 
-						last.al = al
-					else
-						maruku_error "An attribute list at beginning of context {#{al.to_md}}", src
-						maruku_recover "I will ignore this AL: {#{al.to_md}}", src
-					end
+					m =  InlineAttributeList.match src.shift_line
+					content = m[1] ||  "" 
+					src2 = CharSource.new(content, src)
+					interpret_extension(src2, output, [nil])
 				when :ald
 					output.push read_ald(src)
 				when :text
@@ -61,7 +68,8 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 						output.push read_header12(src)
 					elsif eventually_comes_a_def_list(src)
 					 	definition = read_definition(src)
-						if output.last && output.last.node_type == :definition_list
+						if output.last.kind_of?(MDElement) && 
+							output.last.node_type == :definition_list then
 							output.last.children << definition
 						else
 							output.push md_el(:definition_list, [definition])
@@ -79,7 +87,8 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 					list_type = src.cur_line.md_type == :ulist ? :ul : :ol
 					li = read_list_item(src)
 					# append to current list if we have one
-					if output.last && output.last.node_type == list_type
+					if output.last.kind_of?(MDElement) && 
+						output.last.node_type == list_type then
 						output.last.children << li
 					else
 						output.push md_el(list_type, [li])
@@ -91,7 +100,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				when :footnote_text;   output.push read_footnote_text(src)
 				when :ref_definition;  output.push read_ref_definition(src)
 				when :abbreviation;    output.push read_abbreviation(src)
-				when :xml_instr;       output.push read_xml_instruction(src)
+				when :xml_instr;       read_xml_instruction(src, output)
 #				# these do not produce output
 				when :metadata;        
 					maruku_error "Please use the new meta-data syntax: \n"+
@@ -104,7 +113,13 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 					src.shift_line
 			end
 		end
+
+		merge_ial(output, src, output)
+		output.delete_if {|x| x.kind_of?(MDElement) &&
+			x.node_type == :ial}
 		
+		# get rid of empty line markers
+		output.delete_if {|x| x == :empty}
 		# See for each list if we can omit the paragraphs and use li_span
 		# TODO: do this after
 		output.each do |c| 
@@ -135,7 +150,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 	def read_ald(src)
 		if (l=src.shift_line) =~ AttributeDefinitionList
 			id = $1;   al=$2;
-			al = read_attribute_list(CharSource.new(al), context=nil, break_on=[nil])
+			al = read_attribute_list(CharSource.new(al,src), context=nil, break_on=[nil])
 			self.ald[id] = al;
 			return md_ald(id, al)
 		else
@@ -152,7 +167,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		if new_meta_data? and line =~ /^(.*)\{(.*)\}\s*$/
 			line = $1.strip
 			ial = $2
-			al  = read_attribute_list(CharSource.new(ial), context=nil, break_on=[nil])
+			al  = read_attribute_list(CharSource.new(ial,src), context=nil, break_on=[nil])
 		end
 		text = parse_lines_as_span [ line ]
 		level = src.cur_line.md_type == :header2 ? 2 : 1;  
@@ -168,14 +183,14 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		if new_meta_data? and line =~ /^(.*)\{(.*)\}\s*$/
 			line = $1.strip
 			ial = $2
-			al  = read_attribute_list(CharSource.new(ial), context=nil, break_on=[nil])
+			al  = read_attribute_list(CharSource.new(ial,src), context=nil, break_on=[nil])
 		end
 		level = num_leading_hashes(line)
 		text = parse_lines_as_span [strip_hashes(line)] 
 		return md_header(level, text, al)
 	end
 
-	def read_xml_instruction(src)
+	def read_xml_instruction(src, output)
 		m = /^\s*<\?((\w+)\s*)?(.*)$/.match src.shift_line
 		raise "BugBug" if not m
 		target = m[2] || ''
@@ -190,7 +205,18 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		end
 		code.gsub!(/\?>\s*$/, '')
 		
-		return md_xml_instr(target, code)
+		if target == 'mrk' && MaRuKu::Globals[:unsafe_features]
+			result = safe_execute_code(self, code)	
+			if result
+				if result.kind_of? String
+					raise "Not expected"
+				else
+					output.push *result
+				end
+			end
+		else
+			output.push md_xml_instr(target, code)
+		end
 	end
 	
 	def read_raw_html(src)

data/lib/maruku/input/parse_doc.rb

@@ -84,8 +84,7 @@ Conversion happens using the `iconv` library.
 		end
 	
 =begin maruku_doc
-Attribute: exec
-Scope:     document
+Variable: Maruku::Globals[:unsafe_features]
 Summary:   Enables execution of XML instructions.
 
 Disabled by default because of security concerns.
@@ -115,8 +114,10 @@ Disabled by default because of security concerns.
 						already.push v
 						expand_attribute_list(self.ald[v], result)
 					else
-						maruku_error "Circular reference: #{v} already seen\n"+
-							already.inspect
+						already.push  v
+						maruku_error "Circular reference between labels.\n\n"+
+						"Label #{v.inspect} calls itself via recursion.\nThe recursion is "+
+							(already.map{|x| x.inspect}.join(' => ')) 
 					end
 				else
 					if not result[:unresolved_references]
@@ -133,31 +134,32 @@ Disabled by default because of security concerns.
 		end
 	end
 
+	def safe_execute_code(object, code)
+		begin
+			return object.instance_eval(code)
+		rescue Exception => e
+			maruku_error "Exception while executing this:\n"+
+				add_tabs(code, 1, ">")+
+				"\nThe error was:\n"+
+				add_tabs(e.inspect+"\n"+e.caller.join("\n"), 1, "|")
+		rescue RuntimeError => e
+			maruku_error "2: Exception while executing this:\n"+
+				add_tabs(code, 1, ">")+
+				"\nThe error was:\n"+
+				add_tabs(e.inspect, 1, "|")
+		rescue SyntaxError => e
+			maruku_error "2: Exception while executing this:\n"+
+				add_tabs(code, 1, ">")+
+				"\nThe error was:\n"+
+				add_tabs(e.inspect, 1, "|")
+		end
+		nil
+	end
+	
 	def execute_code_blocks
 		self.each_element(:xml_instr) do |e|
 			if e.target == 'maruku'
-				puts e.attributes.inspect
-				code = e.code
-				result = nil
-				begin
-					 e.instance_eval(code)
-				rescue Exception => e
-					maruku_error "Exception while executing this:\n"+
-						add_tabs(code, 1, ">")+
-						"\nThe error was:\n"+
-						add_tabs(e.inspect+"\n"+e.caller.join("\n"), 1, "|")
-					next
-				rescue RuntimeError => e
-					maruku_error "2: Exception while executing this:\n"+
-						add_tabs(code, 1, ">")+
-						"\nThe error was:\n"+
-						add_tabs(e.inspect, 1, "|")
-				rescue SyntaxError => e
-					maruku_error "2: Exception while executing this:\n"+
-						add_tabs(code, 1, ">")+
-						"\nThe error was:\n"+
-						add_tabs(e.inspect, 1, "|")
-				end
+				result = safe_execute_code(e, e.code)
 				if result.kind_of?(String)
 					puts "Result is : #{result.inspect}"
 				end

data/lib/maruku/input/parse_span_better.rb

@@ -186,54 +186,26 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 						con.push_char src.shift_char
 					end
 				end
-			when ?{ # inline attribute list
-				if new_meta_data?
-					src.ignore_char # opening {
-					ial = md_ial(al=read_attribute_list(src, con, [?}]))
-					src.ignore_char # closing }
-
-				 	con.push_element ial
-				else # normal text
-					con.push_char src.shift_char
-				end
+			when ?{ # extension
+				src.ignore_char # {
+				interpret_extension(src, con, [?}])
+				src.ignore_char # }
+				
 			when nil
 				maruku_error ("Unclosed span (waiting for %s"+
 				 "#{exit_on_strings.inspect})") % [
 						exit_on_chars ? "#{exit_on_chars.inspect} or" : ""],
 						src,con
-						
 				break
 			else # normal text
 				con.push_char src.shift_char
 			end # end case
 		end # end while true
 		con.push_string_if_present 
-		
-		# Now we handle the IAL stuff
-			# We need a helper
-			def is_ial(e); e.kind_of? MDElement and e.node_type == :ial end
-		# A IAL at the beginning is strange and we ignore it
-		if false && is_ial(e=con.elements[0]) 
-			"Attribute list at the beginning of span {#{e.to_md}}"
-			tell_user "Ignoring {#{e.to_md}}"
-			con.elements.shift
-		end
-		# Apply each IAL to the element before
-		con.elements.each_with_index do |e, i| if is_ial(e) && i>= 1 then
-			before = con.elements[i-1]
-			if before.kind_of? MDElement
-				#puts "Assigning #{e.ial} to #{before}"
-				before.al = e.ial
-			else
-				maruku_error "This IAL: {#{e.ial.to_md}} seems to"+
-					" refer to a string:\n"+
-					before.inspect, src, con
-				maruku_recover "Ignoring IAL: {#{e.ial.to_md}}", src, con
-			end
-		end end
 
-		# Remove all IAL
-		# con.elements.delete_if { |e| is_ial(e) }
+		# Assign IAL to elements
+		merge_ial(con.elements, src, con)
+		
 		
 		# Remove leading space
 		if (s = con.elements.first).kind_of? String
@@ -251,7 +223,8 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 
 		educated
 	end
-	
+
+
 	def read_xml_instr_span(src, con) 
 		src.ignore_chars(2) # starting <?
 
@@ -274,6 +247,46 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 		con.push_element md_xml_instr(target, code)
 	end
 
+	# Start: cursor on character **after** '{'
+	# End: curson on '}' or EOF
+	def interpret_extension(src, con, break_on_chars)
+		case src.cur_char
+		when ?:
+			src.ignore_char # :
+			extension_meta(src, con, break_on_chars)
+		when ?#, ?.
+			extension_meta(src, con, break_on_chars)
+		else
+			stuff = read_simple(src, escaped=[?}], break_on_chars, [])
+			if stuff =~ /^(\w+\s|[^\w])/
+				extension_id = $1.strip
+				if false
+				else
+					maruku_recover "I don't know what to do with extension '#{extension_id}'\n"+
+						"I will threat this:\n\t{#{stuff}} \n as meta-data.\n", src, con
+					extension_meta(src, con, break_on_chars)
+				end
+			else 
+				maruku_recover "I will threat this:\n\t{#{stuff}} \n as meta-data.\n", src, con
+				extension_meta(src, con, break_on_chars)
+			end
+		end
+	end
+
+	def extension_meta(src, con, break_on_chars)
+		if m = src.read_regexp(/(\w)+\:/)
+			name = m[1]
+			content = m[2]
+			al = read_attribute_list(src, con, break_on_chars)
+			self.doc.ald[name] = al
+		 	con.push md_ald(name, al)
+		else
+			al = read_attribute_list(src, con, break_on_chars)
+			self.doc.ald[name] = al
+			con.push md_ial(al)
+		end
+	end	
+
 	def read_url_el(src,con)
 		src.ignore_char # leading <
 		url = read_simple(src, [], [?>])
@@ -340,14 +353,16 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 	# Reads a simple string (no formatting) until one of break_on_chars, 
 	# while escaping the escaped.
 	# If the string is empty, it returns nil.
-	# Raises on error.
-	def read_simple(src, escaped, exit_on_chars, exit_on_strings=nil) 
+	# Raises on error if the string terminates unexpectedly.
+#	# If eat_delim is true, and if the delim is not the EOF, then the delim
+#	# gets eaten from the stream.
+	def read_simple(src, escaped, exit_on_chars, exit_on_strings=nil)
 		text = ""
 		while true
 #			puts "Reading simple #{text.inspect}"
 			c = src.cur_char
 			if exit_on_chars && exit_on_chars.include?(c)
-#				puts ("  breaking on "<<c)+" contained in "+exit_on_chars.inspect
+#				src.ignore_char if eat_delim
 				break
 			end
 			
@@ -625,7 +640,8 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 			@elements << e
 			nil
 		end
-
+		alias push push_element
+		
 		def push_elements(a)
 			for e in a 
 				if e.kind_of? String

data/lib/maruku/input/type_detection.rb

@@ -62,14 +62,15 @@ module MaRuKu; module Strings
 		return :metadata if l =~ /^@/
 #		if @@new_meta_data?
 			return :ald   if l =~ AttributeDefinitionList
-			return :ial   if l =~ /^\s{0,3}\{.*\}/
+			return :ial   if l =~ InlineAttributeList
 #		end
 		return :text # else, it's just text
 	end
 
 	# $1 = id   $2 = attribute list
 	AttributeDefinitionList = /^\s{0,3}\{([\w\d\s]+)\}:\s*(.*)\s*$/
-
+	# 
+	InlineAttributeList = /^\s{0,3}\{(.*)\}\s*$/
 	# Example:
 	#     ^:blah blah
 	#     ^: blah blah

data/lib/maruku/output/to_html.rb

@@ -346,7 +346,7 @@ module MaRuKu; module Out; module HTML
 	end
 	
 	def to_html_code_using_pre(source)
-		pre = Element.new 'pre'
+		pre = create_html_element  'pre'
 		code = Element.new 'code', pre
 		s = source
 		
@@ -368,7 +368,7 @@ module MaRuKu; module Out; module HTML
 	end
 
 	def to_html_inline_code; 
-		pre = Element.new 'code'
+		pre =  create_html_element 'code'
 			source = self.raw_code
 			pre << source2html(source) 
 			
@@ -381,7 +381,7 @@ module MaRuKu; module Out; module HTML
 	end
 
 	def to_html_immediate_link
-		a = Element.new 'a'
+		a =  create_html_element 'a'
 		url = self.url
 		text = url.gsub(/^mailto:/,'') # don't show mailto
 		a << Text.new(text)
@@ -439,7 +439,7 @@ module MaRuKu; module Out; module HTML
 	
 	def to_html_email_address
 		email = self.email
-		a = Element.new 'a'
+		a = create_html_element 'a'
 			#a.attributes['href'] = Text.new("mailto:"+obfuscate(email),false,nil,true)
 			#a.attributes.add Attribute.new('href',Text.new(
 			#"mailto:"+obfuscate(email),false,nil,true))
@@ -453,7 +453,7 @@ module MaRuKu; module Out; module HTML
 ##### Images
 
 	def to_html_image
-		a =  Element.new 'img'
+		a =  create_html_element 'img'
 		id = self.ref_id
 		if ref = @doc.refs[id]
 			url = ref[:url]
@@ -478,7 +478,7 @@ module MaRuKu; module Out; module HTML
 			return wrap_as_element('span')
 		end
 		title = self.title
-		a =  Element.new 'img'
+		a =  create_html_element 'img'
 			a.attributes['src'] = url
 			a.attributes['title'] = title if title
 		return a