maruku 0.2.13 → 0.3.0

data/lib/maruku.rb

@@ -18,10 +18,15 @@
 
 # Structures definition
 require 'maruku/structures'
+# Less typing
+require 'maruku/helpers'
 
 # Code for parsing whole Markdown documents
 require 'maruku/parse_doc'
 
+# Ugly things kept in a closet
+require 'maruku/string_utils'
+
 # A class for reading and sanitizing inline HTML
 require 'maruku/html_helper'
 
@@ -29,10 +34,12 @@ require 'maruku/html_helper'
 require 'maruku/parse_block'
 
 # Code for parsing Markdown span-level elements
-require 'maruku/parse_span'
+require 'maruku/parse_span_better'
+
+require 'maruku/structures_iterators'
+
+require 'maruku/errors_management'
 
-# Ugly things kept in a closet
-require 'maruku/string_utils'
 
 # Code for creating a table of contents
 require 'maruku/toc'
@@ -49,5 +56,8 @@ require 'maruku/to_latex'
 require 'maruku/to_latex_strings'
 require 'maruku/to_latex_entities'
 
+# Pretty print
+require 'maruku/to_markdown'
+
 # Exporting to text: strips all formatting (not complete)
 require 'maruku/to_s'

data/lib/maruku/errors_management.rb

@@ -0,0 +1,75 @@
+
+
+# Any method that detects formatting error calls the
+# error() method. 
+# if @meta[:on_error] == 
+#
+# - :warning   write on the standard err (or @error_stream if defined), 
+#              then do your best.
+# - :ignore    be shy and try to continue
+# - :raise     raises a MarukuException
+#
+# default is :raise
+
+class MarukuException < RuntimeError
+	
+end
+
+
+module MarukuErrors
+	Default_on_error = :warning
+	
+	def maruku_error(s,src=nil,con=nil)
+		policy = @doc ? (@doc.meta[:on_error] || Default_on_error) : :raise
+		
+		case policy
+		when :ignore 
+		when :raise
+			raise_error describe_error(s,src,con)
+		when :warning
+			tell_user describe_error(s,src,con)
+		end
+	end
+	
+	alias error maruku_error
+
+	def raise_error(s)
+		raise MarukuException, s, caller
+	end
+
+	def tell_user(s)
+		n = 75
+		(@error_stream || $stderr) <<
+		" "+"_"*n << "\n"<<
+		"| Maruku tells you (#{caller[0]})\n" << 
+		"+"+"-"*n +"\n"+
+		add_tabs(s,1,'| ') << "\n" <<
+		"+" << "-"*n << "\n" <<
+		add_tabs(caller.join("\n"),1,'!') << "\n" <<
+		"\\" << "_"*n << "\n"
+	end
+	
+	def set_error_stream(os)
+		@error_stream = os
+	end
+
+	def describe_error(s,src,con)
+		t = s
+		if src
+			t += "\n#{src.describe}\n"
+		end
+		if con
+			t += "\n#{con.describe}\n"
+		end
+		t
+	end
+	
+end
+
+class MDElement
+	include MarukuErrors
+end
+
+
+
+

data/lib/maruku/helpers.rb

@@ -0,0 +1,164 @@
+
+
+# A series of helper functions for creating elements
+
+module Helpers
+
+	def md_el(node_type, children=[], meta={})
+		e=MDElement.new(node_type, children, meta)
+		e.doc = self
+		e
+	end
+
+	def md_code(code)
+		md_el(:inline_code, [], {:raw_code => code})
+	end
+
+	def md_par(children, meta={})
+		md_el(:paragraph, [], meta)
+	end
+	
+	def md_html(raw_html)
+		e = md_el(:raw_html, [], {:raw_html=>raw_html})
+		begin
+			# remove newlines and whitespace at begin
+			# end end of string, or else REXML gets confused
+			raw_html = raw_html.gsub(/\A\s*</,'<').
+			                    gsub(/>[\s\n]*\Z/,'>')
+			e.instance_variable_set :@parsed_html,
+			 	REXML::Document.new(raw_html)
+		
+		rescue Exception => ex
+			tell_user "Malformed block of HTML:\n"+
+			add_tabs(raw_html,1,'|')
+#			"  #{raw_html.inspect}\n\n"+ex.inspect
+		end
+		e
+	end
+		
+	def md_link(children, ref_id)
+		md_el(:link, children, {:ref_id=>ref_id.downcase})
+	end
+	
+	def md_im_link(children, url, title=nil)
+		md_el(:link, children, {:url=>url,:title=>title})
+	end
+	
+	
+	def md_image(children, ref_id)
+		md_el(:image, children, {:ref_id=>ref_id})
+	end
+	
+	def md_im_image(children, url, title=nil)
+		md_el(:image, children, {:url=>url,:title=>title})
+	end
+
+	def md_em(children)
+		md_el(:emphasis, [children].flatten)
+	end
+
+	def md_strong(children)
+		md_el(:strong, [children].flatten)
+	end
+
+	def md_emstrong(children)
+		md_strong(md_em(children))
+	end
+
+	# <http://www.example.com/>
+	def md_url(url)
+		md_el(:immediate_link, [], {:url=>url})
+	end
+	
+	# <andrea@rubyforge.org>
+	# <mailto:andrea@rubyforge.org>
+	def md_email(email)
+		md_el(:email_address, [], {:email=>email})
+	end
+	
+	def md_entity(entity_name)
+		md_el(:entity, [], {:entity_name=>entity_name})
+	end
+	
+	# Markdown extra
+	def md_foot_ref(ref_id)
+		md_el(:footnote_reference, [], {:footnote_id=>ref_id})
+	end
+	
+	def md_par(children, meta={})
+		md_el(:paragraph, children, meta)
+	end
+
+	# [1]: http://url [properties]
+	def md_ref_def(ref_id, url, title=nil, meta={})
+		meta[:url] = url
+		meta[:ref_id] = ref_id
+		meta[:title] = title if title
+		md_el(:ref_definition, [], meta)
+	end
+end
+
+class MDElement	
+	# outputs abbreviated form 
+	def inspect2 
+		case @node_type
+		when :paragraph
+			"md_par(%s)" % children_inspect
+		when :footnote_reference
+			"md_foot_ref(%s)" % @meta[:footnote_id].inspect
+		when :entity
+			"md_entity(%s)" % @meta[:entity_name].inspect
+		when :email_address
+			"md_email(%s)" % @meta[:email].inspect
+		when :inline_code
+			"md_code(%s)" % @meta[:raw_code].inspect
+		when :raw_html
+			"md_html(%s)" % @meta[:raw_html].inspect
+		when :emphasis 
+			"md_em(%s)" % children_inspect
+		when :strong
+			"md_strong(%s)" % children_inspect
+		when :immediate_link
+			"md_url(%s)" % @meta[:url].inspect
+		when :image
+			if @meta[:ref_id]
+				"md_image(%s,%s)" % [
+					children_inspect, @meta[:ref_id].inspect]
+			else
+				"md_im_image(%s, %s %s)" % [
+					children_inspect, @meta[:url].inspect,
+					(title=@meta[:title]) ? (", "+ title.inspect) : ""
+				]
+			end
+		when :link
+			if @meta[:ref_id]
+				"md_link(%s,%s)" % [
+					children_inspect, @meta[:ref_id].inspect]
+			else
+				"md_im_link(%s, %s %s)" % [
+					children_inspect, @meta[:url].inspect,
+					(title=@meta[:title]) ? (", "+ title.inspect) : ""
+				]
+			end
+		when :ref_definition
+			"md_ref_def(%s, %s %s)" % 
+				[
+					@meta[:ref_id].inspect, 
+					@meta[:url].inspect,
+					@meta[:title] ? ","+@meta[:title].inspect : ""
+				]
+		else
+			nil
+		end
+	end
+	
+end
+
+
+
+
+
+
+
+
+

data/lib/maruku/html_helper.rb

@@ -1,16 +1,21 @@
 
 class Maruku
 
-# this class helps me read and sanitize code blocks
+# This class helps me read and sanitize HTML blocks
+
+# I tried to do this with REXML, but wasn't able to. (suggestions?)
 
 	class HTMLHelper
-		Tag = %r{^<(/)?(\w+)([^>]*)>}m
+		include MarukuStrings
+		
+		Tag = %r{^<(/)?(\w+)\s*([^>]*)>}m
 		EverythingElse = %r{^[^<]+}m
 		CommentStart = %r{^<!--}x
 		CommentEnd = %r{^.*-->}
 		TO_SANITIZE = ['img','hr'] 
 		
-		attr_accessor :inside_comment
+#		attr_accessor :inside_comment
+		attr_reader :rest
 		
 		def initialize 
 			@rest = ""
@@ -21,8 +26,8 @@ class Maruku
 		end
 		
 		def eat_this(line)
-			@rest = line + "\n" + @rest
-			
+			@rest = line  + @rest
+			things_read = 0
 			until @rest.empty?
 				if @inside_comment
 					if @m = CommentEnd.match(@rest)
@@ -35,10 +40,12 @@ class Maruku
 					end
 				else
 					if @m = CommentStart.match(@rest)
+						things_read += 1
 						@inside_comment = true
 						@already += @m.pre_match + @m.to_s
 						@rest = @m.post_match
 					elsif @m = Tag.match(@rest)
+						things_read += 1
 						@already += @m.pre_match
 						@rest = @m.post_match
 					
@@ -53,7 +60,13 @@ class Maruku
 						end
 					
 						if TO_SANITIZE.include? tag 
-							@already +=  '<%s %s />' % [tag, attributes]
+							attributes.strip!
+					#		puts "Attributes: #{attributes.inspect}"
+							if attributes.size > 0
+								@already +=  '<%s %s />' % [tag, attributes]
+							else
+								@already +=  '<%s />' % [tag]
+							end
 						elsif is_closing
 							@already += @m.to_s
 							if @tag_stack.last != tag
@@ -73,29 +86,36 @@ class Maruku
 						@already += @m.pre_match + @m.to_s
 						@rest = @m.post_match
 					else
-#						puts "No match??? #{@rest.inspect}"
+						error "Malformed HTML: not complete: #{@rest.inspect}"
 					end
 				end # not inside comment
 				
 #				puts inspect
 #				puts "Read: #{@tag_stack.inspect}"
+				break if is_finished? and things_read>0	
 			end
 		end
 
 
 		def error(s)
-			raise "Error: #{s} "+ inspect
+			raise RuntimeError, "Error: #{s} "+ inspect, caller
 		end
 
-		def inspect; "HTML READER\n comment=#{inside_comment} "+
-			"match=#{@m.to_s.inspect}"+
-			"\n * * * BEFORE * * *\n#{@already.inspect}"+
-			"\n * * * AFTER  * * *\n#{@rest.inspect}"+
-			"\n * * * TAGS stack * * *\n#{@tag_stack.inspect}"
+		def inspect; "HTML READER\n comment=#{@inside_comment} "+
+			"match=#{@m.to_s.inspect}\n"+
+			"Tag stack = #{@tag_stack.inspect} \n"+
+			"Before:\n"+
+			add_tabs(@already,1,'|')+"\n"+
+			"After:\n"+
+			add_tabs(@rest,1,'|')+"\n"
+			
 		end
+		
+		
 		def stuff_you_read
 			@already
 		end
+		
 		def is_finished?
 			not @inside_comment and @tag_stack.empty?
 		end

data/lib/maruku/parse_block.rb

@@ -17,9 +17,11 @@
 #   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 class Maruku
+	include Helpers
+	
 	# Splits the string and calls parse_lines_as_markdown
 	def parse_text_as_markdown(text)
-		lines =  split_lines(text)
+		lines =  Maruku.split_lines(text)
 		parse_lines_as_markdown(lines)
 	end
 	
@@ -74,7 +76,7 @@ class Maruku
 
 				# these do not produce output
 				when :footnote_text; read_footnote_text
-				when :ref;           read_ref
+				when :ref_definition;  output << read_ref_definition
 				when :abbreviation;  read_abbreviation
 				when :metadata;      just_read_metadata = read_metadata
 					
@@ -82,7 +84,7 @@ class Maruku
 				else
 					node_type = cur_line_node_type
 					line = shift_line
-#					$stderr.puts "Ignoring line '#{line}' type = #{node_type}"
+					tell_user "Ignoring line '#{line}' type = #{node_type}"
 			end
 			
 			if current_metadata and output.last
@@ -122,10 +124,8 @@ class Maruku
 		output
 	end
 		 
-	def create_md_element(node_type, children=[])
-		e = MDElement.new
-		e.node_type = node_type
-		e.children = children
+	def create_md_element(node_type, children=[], meta = {})
+		e = MDElement.new(node_type, children, meta)
 		e.doc = self
 		e
 	end
@@ -134,7 +134,8 @@ class Maruku
 	def cur_line_node_type; line_node_type top.first  end
 	def cur_line; top.empty? ? nil : top.first end
 	def next_line; top.empty? ? nil : top[1] end
-	def next_line_node_type; (top.size >= 2) ? line_node_type(top[1]) : nil end
+	def next_line_node_type
+		(top.size >= 2) ? line_node_type(top[1]) : nil end
 	def shift_line; top.shift; end
 		
 	# reads a header (with ----- or ========)
@@ -191,41 +192,33 @@ class Maruku
 			while cur_line and not h.is_finished? 
 				l=shift_line
 #				puts "html -> #{l.inspect}"
-				h.eat_this l
+				h.eat_this "\n"+l
 			end
 		rescue Exception => e
-			puts e.inspect
+			tell_user e.inspect + e.backtrace.join("\n")
 #			puts h.inspect
 		end
 		
 		raw_html = h.stuff_you_read
 		
-		e = create_md_element(:raw_html)
-
-		begin
-			# remove newlines and whitespace at begin
-			# end end of string, or else REXML gets confused
-			raw_html = raw_html.gsub(/\A\s*</,'<').
-			                    gsub(/>[\s\n]*\Z/,'>')
-			e.meta[:parsed_html] = Document.new(raw_html)
-		rescue 
-			#$stderr.puts "Malformed block of HTML:\n#{raw_html}"
-			#puts h.inspect
-		end
-		
-		e.meta[:raw_html] = raw_html
-		e
+		md_html(raw_html)
 	end
 	
 	def read_paragraph
 		lines = []
-		while cur_line && cur_line_node_type == :text
+		while cur_line 
+			break if [:quote,:header3,:empty,:raw_html,:ref_definition].include?(
+				cur_line_node_type)
+			break if cur_line.strip.size == 0
+			
+			break if [:header1,:header2].include? next_line_node_type
+			
 			lines << shift_line
 		end
 #		dbg_describe_ary(lines, 'PAR')
 		children = parse_lines_as_span(lines)
 
-		e = create_md_element(:paragraph, children)
+		md_par(children)
 	end
 	
 	
@@ -291,56 +284,56 @@ class Maruku
 	# This is the only ugly function in the code base.
 	# It is used to read list items, descriptions, footnote text
 	def read_indented_content(indentation, break_list, item_type)
-			lines =[]
-			# collect all indented lines
-			saw_empty = false; saw_anything_after = false
-			while cur_line 
-				if cur_line_node_type == :empty
-					saw_empty = true
-					lines << shift_line
-					next
-				end
-			
-				# after a white line
-				if saw_empty
-					# we expect things to be properly aligned
-					if number_of_leading_spaces(cur_line) < indentation
+		lines =[]
+		# collect all indented lines
+		saw_empty = false; saw_anything_after = false
+		while cur_line 
+			if cur_line_node_type == :empty
+				saw_empty = true
+				lines << shift_line
+				next
+			end
+		
+			# after a white line
+			if saw_empty
+				# we expect things to be properly aligned
+				if number_of_leading_spaces(cur_line) < indentation
 #						debug "breaking for spaces: #{cur_line}"
-						break
-					end
-					saw_anything_after = true
-				else
-					break if break_list.include? cur_line_node_type
-	#				break if cur_line_node_type != :text
-				end
-			
-	#			debug "Accepted '#{cur_line}'"
-
-				stripped = strip_indent(shift_line, indentation)
-				lines << stripped
-			
-				# You are only required to indent the first line of 
-				# a child paragraph.
-				if line_node_type(stripped) == :text
-					while cur_line && (cur_line_node_type == :text)
-						lines << strip_indent(shift_line, indentation)
-					end
+					break
 				end
+				saw_anything_after = true
+			else
+				break if break_list.include? cur_line_node_type
+#				break if cur_line_node_type != :text
 			end
-
-			want_my_paragraph = saw_anything_after || 
-				(saw_empty && (cur_line  && (cur_line_node_type == item_type))) 
 		
-	#		dbg_describe_ary(lines, 'LI')
-			# create a new context 
+#			debug "Accepted '#{cur_line}'"
+
+			stripped = strip_indent(shift_line, indentation)
+			lines << stripped
 		
-			while lines.last && (line_node_type(lines.last) == :empty)
-				lines.pop
+			# You are only required to indent the first line of 
+			# a child paragraph.
+			if line_node_type(stripped) == :text
+				while cur_line && (cur_line_node_type == :text)
+					lines << strip_indent(shift_line, indentation)
+				end
 			end
-			
-			return lines, want_my_paragraph
 		end
 
+		want_my_paragraph = saw_anything_after || 
+			(saw_empty && (cur_line  && (cur_line_node_type == item_type))) 
+	
+#		dbg_describe_ary(lines, 'LI')
+		# create a new context 
+	
+		while lines.last && (line_node_type(lines.last) == :empty)
+			lines.pop
+		end
+		
+		return lines, want_my_paragraph
+	end
+
 	
 	def read_quote
 		lines = []
@@ -413,40 +406,42 @@ class Maruku
 	
 
 	
-	def read_ref
+	def read_ref_definition
 		line = shift_line
 		
 		# if link is incomplete, shift next line
-		while cur_line && (cur_line_node_type != :ref) && 
+		if cur_line && (cur_line_node_type != :ref_definition) && 
 			([1,2,3].include? number_of_leading_spaces(cur_line) )
 			line += " "+ shift_line
 		end
 		
 #		puts "total= #{line}"
 		
-		if match = LinkRegex.match(line)
-			id = match[1]; url = match[2]; title = match[3]; 
-			id = id.strip.downcase
-			
-			hash = self.refs[id] = {:url=>url,:title=>title}
-			
-			stuff=match[4]
-			
-			if stuff
-				stuff.split.each do |couple|
+		match = LinkRegex.match(line)
+		if not match
+			error "Link does not respect format: '#{line}'"
+		end
+		
+		id = match[1]; url = match[2]; title = match[3]; 
+		id = id.strip.downcase
+		
+		hash = self.refs[id] = {:url=>url,:title=>title}
+		
+		stuff=match[4]
+		
+		if stuff
+			stuff.split.each do |couple|
 #					puts "found #{couple}"
-					k, v = couple.split('=')
-					v ||= ""
-					if v[0,1]=='"' then v = v[1, v.size-2] end
+				k, v = couple.split('=')
+				v ||= ""
+				if v[0,1]=='"' then v = v[1, v.size-2] end
 #					puts "key:_#{k}_ value=_#{v}_"
-					hash[k.to_sym] = v
-				end
+				hash[k.to_sym] = v
 			end
-#			puts hash.inspect
-			
-		else
-			raise "Link does not respect format: '#{line}'"
 		end
+#			puts hash.inspect
+		
+		md_ref_def(id, url, meta={:title=>title})
 	end
 	
 	def read_table
@@ -466,7 +461,8 @@ class Maruku
 		num_columns = align.size
 		
 		if head.size != num_columns
-			$stderr.puts "Head does not have #{num_columns} columns: \n#{head.inspect}"
+			error "Head does not have #{num_columns} columns: \n#{head.inspect}"
+			# XXX try to recover
 			return create_md_element(:linebreak)
 		end
 				
@@ -476,7 +472,8 @@ class Maruku
 			row = split_cells(shift_line).map{|s|
 				create_md_element(:cell, parse_lines_as_span([s]))}
 			if head.size != num_columns
-				$stderr.puts "Row does not have #{num_columns} columns: \n#{row.inspect}"
+				error  "Row does not have #{num_columns} columns: \n#{row.inspect}"
+				# XXX try to recover
 				return create_md_element(:linebreak)
 			end
 			rows << row