omf_web 0.9.9 → 1.0.0

data/lib/omf-web/widget/text/maruku/input/parse_block.rb

@@ -2,17 +2,17 @@
 #   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
@@ -33,32 +33,32 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			desc.map{|x| "\n -" + x.inspect}.join
 		end
 	end
-	
+
 	# Splits the string and calls parse_lines_as_markdown
 	def parse_text_as_markdown(text)
 		lines =  split_lines(text)
 		src = LineSource.new(lines)
 		return parse_blocks(src)
 	end
-	
+
 	# Input is a LineSource
 	def parse_blocks(src)
 		output = BlockContext.new
-		
+
 		# run state machine
 		while src.cur_line
-			
+
 			next if check_block_extensions(src, output, src.cur_line)
-			
+
 #  Prints detected type (useful for debugging)
 #			puts "#{src.cur_line.md_type}|#{src.cur_line}"
 			case src.cur_line.md_type
-				when :empty; 
+				when :empty;
 					output.push :empty
 					src.ignore_line
 				when :ial
 					m =  InlineAttributeList.match src.shift_line
-					content = m[1] ||  "" 
+					content = m[1] ||  ""
 #					puts "Content: #{content.inspect}"
 					src2 = CharSource.new(content, src)
 					interpret_extension(src2, output, [nil])
@@ -77,7 +77,7 @@ 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.kind_of?(MDElement) && 
+					if output.last.kind_of?(MDElement) &&
 						output.last.node_type == list_type then
 						output.last.children << li
 					else
@@ -88,7 +88,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				when :raw_html; e = read_raw_html(src); output << e if e
 
 				when :footnote_text;   output.push read_footnote_text(src)
-				when :ref_definition;  
+				when :ref_definition
 					if src.parent && (src.cur_index == 0)
 						read_text_material(src, output)
 					else
@@ -96,7 +96,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 					end
 				when :abbreviation;    output.push read_abbreviation(src)
 				when :xml_instr;       read_xml_instruction(src, output)
-				when :metadata;        
+				when :metadata;
 					maruku_error "Please use the new meta-data syntax: \n"+
 					"  http://maruku.rubyforge.org/proposal.html\n", src
 					src.ignore_line
@@ -111,44 +111,44 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		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| 
+		output.each do |c|
 			# Remove paragraphs that we can get rid of
-			if [:ul,:ol].include? c.node_type 
+			if [:ul,:ol].include? c.node_type
 				if c.children.all? {|li| !li.want_my_paragraph} then
 					c.children.each do |d|
 						d.node_type = :li_span
-						d.children = d.children[0].children 
+						d.children = d.children[0].children
 					end
 				end
-			end 
+			end
 			if c.node_type == :definition_list
 				if c.children.all?{|defi| !defi.want_my_paragraph} then
-					c.children.each do |definition| 
+					c.children.each do |definition|
 						definition.definitions.each do |dd|
-							dd.children = dd.children[0].children 
+							dd.children = dd.children[0].children
 						end
 					end
 				end
-			end 
+			end
 		end
-		
+
 		output
 	end
-	
+
 	def read_text_material(src, output)
-		if src.cur_line =~ MightBeTableHeader and 
+		if src.cur_line =~ MightBeTableHeader and
 			(src.next_line && src.next_line =~ TableSeparator)
 			output.push read_table(src)
 		elsif [:header1,:header2].include? src.next_line.md_type
 			output.push read_header12(src)
 		elsif eventually_comes_a_def_list(src)
 		 	definition = read_definition(src)
-			if output.last.kind_of?(MDElement) && 
+			if output.last.kind_of?(MDElement) &&
 				output.last.node_type == :definition_list then
 				output.last.children << definition
 			else
@@ -158,8 +158,8 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			output.push read_paragraph(src)
 		end
 	end
-	
-	
+
+
 	def read_ald(src)
 		if (l=src.shift_line) =~ AttributeDefinitionList
 			id = $1;   al=$2;
@@ -171,7 +171,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			return nil
 		end
 	end
-		
+
 	# reads a header (with ----- or ========)
 	def read_header12(src)
 		line = src.shift_line.strip
@@ -183,12 +183,12 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			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;  
+		level = src.cur_line.md_type == :header2 ? 2 : 1;
 		src.shift_line
 		return md_header(level, text, al, src.cur_index)
 	end
 
-	# reads a header like '#### header ####'	
+	# reads a header like '#### header ####'
 	def read_header3(src)
 #          puts "READ_H3: #{src.inspect}"
 		line = src.shift_line.strip
@@ -200,7 +200,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			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)] 
+		text = parse_lines_as_span [strip_hashes(line)]
 		return md_header(level, text, al, src.cur_index)
 	end
 
@@ -218,9 +218,9 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				add_tabs(code, 1, '|'), src
 		end
 		code.gsub!(/\?>\s*$/, '')
-		
+
 		if target == 'mrk' && MaRuKu::Globals[:unsafe_features]
-			result = safe_execute_code(self, code)	
+			result = safe_execute_code(self, code)
 			if result
 				if result.kind_of? String
 					raise "Not expected"
@@ -232,13 +232,13 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			output.push md_xml_instr(target, code)
 		end
 	end
-	
+
 	def read_raw_html(src)
 		h = HTMLHelper.new
-		begin 
+		begin
 			h.eat_this(l=src.shift_line)
 #			puts "\nBLOCK:\nhtml -> #{l.inspect}"
-			while src.cur_line and not h.is_finished? 
+			while src.cur_line and not h.is_finished?
 				l=src.shift_line
 #				puts "html -> #{l.inspect}"
 				h.eat_this "\n"+l
@@ -252,13 +252,13 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				"I see that #{h.rest.inspect} is left after the raw HTML.", src
 		end
 		raw_html = h.stuff_you_read
-		
+
 		return md_html(raw_html)
 	end
-	
+
 	def read_paragraph(src)
 		lines = [src.shift_line]
-		while src.cur_line 
+		while src.cur_line
 			# :olist does not break
 			case t = src.cur_line.md_type
 				when :quote,:header3,:empty,:ref_definition,:ial #,:xml_instr,:raw_html
@@ -266,10 +266,10 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				when :olist,:ulist
 					break if src.next_line.md_type == t
 			end
-			break if src.cur_line.strip.size == 0			
+			break if src.cur_line.strip.size == 0
 			break if [:header1,:header2].include? src.next_line.md_type
-			break if any_matching_block_extension?(src.cur_line) 
-			
+			break if any_matching_block_extension?(src.cur_line)
+
 			lines << src.shift_line
 		end
 #		dbg_describe_ary(lines, 'PAR')
@@ -277,11 +277,11 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 
 		return md_par(children, nil, src.cur_index)
 	end
-	
+
 	# Reads one list item, either ordered or unordered.
 	def read_list_item(src)
 		parent_offset = src.cur_index
-		
+
 		item_type = src.cur_line.md_type
 		first = src.shift_line
 
@@ -289,20 +289,20 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		al = read_attribute_list(CharSource.new(ial,src), context=nil, break_on=[nil]) if ial
 		break_list = [:ulist, :olist, :ial]
 		# Ugly things going on inside `read_indented_content`
-		lines, want_my_paragraph = 
+		lines, want_my_paragraph =
 			read_indented_content(src,indentation, break_list, item_type)
 
 		# add first line
 			# Strip first '*', '-', '+' from first line
 			stripped = first[indentation, first.size-1]
 		lines.unshift stripped
-		
+
 		# dbg_describe_ary(lines, 'LIST ITEM ')
 
 		src2 = LineSource.new(lines, src, parent_offset)
 		children = parse_blocks(src2)
 		with_par = want_my_paragraph || (children.size>1)
-		
+
 		return md_li(children, with_par, al)
 	end
 
@@ -310,48 +310,48 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		if not (l=src.shift_line) =~ Abbreviation
 			maruku_error "Bug: it's Andrea's fault. Tell him.\n#{l.inspect}"
 		end
-		
+
 		abbr = $1
 		desc = $2
-		
+
 		if (not abbr) or (abbr.size==0)
 			maruku_error "Bad abbrev. abbr=#{abbr.inspect} desc=#{desc.inspect}"
 		end
-		
+
 		self.abbreviations[abbr] = desc
-		
+
 		return md_abbr_def(abbr, desc)
 	end
-	
+
 	def read_footnote_text(src)
 		parent_offset = src.cur_index
-			
+
 		first = src.shift_line
-		
-		if not first =~ FootnoteText 
+
+		if not first =~ FootnoteText
 			maruku_error "Bug (it's Andrea's fault)"
 		end
-		
+
 		id = $1
 		text = $2
 
 		# Ugly things going on inside `read_indented_content`
 		indentation = 4 #first.size-text.size
-		
+
 #		puts "id =_#{id}_; text=_#{text}_ indent=#{indentation}"
-		
+
 		break_list = [:footnote_text, :ref_definition, :definition, :abbreviation]
 		item_type = :footnote_text
-		lines, want_my_paragraph = 
+		lines, want_my_paragraph =
 			read_indented_content(src,indentation, break_list, item_type)
 
 		# add first line
 		if text && text.strip != "" then lines.unshift text end
-		
+
 #		dbg_describe_ary(lines, 'FOOTNOTE')
 		src2 = LineSource.new(lines, src, parent_offset)
 		children = parse_blocks(src2)
-		
+
 		e = md_footnote(id, children)
 		self.footnotes[id] = e
 		return e
@@ -364,7 +364,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		lines =[]
 		# collect all indented lines
 		saw_empty = false; saw_anything_after = false
-		while src.cur_line 
+		while src.cur_line
 #			puts "Reading indent = #{indentation} #{src.cur_line.inspect}"
 			#puts "#{src.cur_line.md_type} #{src.cur_line.inspect}"
 			if src.cur_line.md_type == :empty
@@ -372,7 +372,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				lines << src.shift_line
 				next
 			end
-		
+
 			# after a white line
 			if saw_empty
 				# we expect things to be properly aligned
@@ -382,19 +382,19 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				end
 				saw_anything_after = true
 			else
-#				if src.cur_line[0] != ?\ 
+#				if src.cur_line[0] != ?\
 					break if break_list.include? src.cur_line.md_type
 #				end
 #				break if src.cur_line.md_type != :text
 			end
-		
+
 
 			stripped = strip_indent(src.shift_line, indentation)
 			lines << stripped
 
 			#puts "Accepted as #{stripped.inspect}"
-		
-			# You are only required to indent the first line of 
+
+			# You are only required to indent the first line of
 			# a child paragraph.
 			if stripped.md_type == :text
 				while src.cur_line && (src.cur_line.md_type == :text)
@@ -403,23 +403,23 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			end
 		end
 
-		want_my_paragraph = saw_anything_after || 
-			(saw_empty && (src.cur_line  && (src.cur_line.md_type == item_type))) 
-	
+		want_my_paragraph = saw_anything_after ||
+			(saw_empty && (src.cur_line  && (src.cur_line.md_type == item_type)))
+
 #		dbg_describe_ary(lines, 'LI')
-		# create a new context 
-	
+		# create a new context
+
 		while lines.last && (lines.last.md_type == :empty)
 			lines.pop
 		end
-		
+
 		return lines, want_my_paragraph
 	end
 
-	
+
 	def read_quote(src)
 		parent_offset = src.cur_index
-			
+
 		lines = []
 		# collect all indented lines
 		while src.cur_line && src.cur_line.md_type == :quote
@@ -438,20 +438,20 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		while src.cur_line && ([:code, :empty].include? src.cur_line.md_type)
 			lines << strip_indent(src.shift_line, 4)
 		end
-		
+
 		#while lines.last && (lines.last.md_type == :empty )
 		while lines.last && lines.last.strip.size == 0
-			lines.pop 
+			lines.pop
 		end
 
 		while lines.first && lines.first.strip.size == 0
-			lines.shift 
+			lines.shift
 		end
-		
+
 		return nil if lines.empty?
 
 		source = lines.join("\n")
-		
+
 #		dbg_describe_ary(lines, 'CODE')
 
 		return md_codeblock(source)
@@ -460,7 +460,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 	# Reads a series of metadata lines with empty lines in between
 	def read_metadata(src)
 		hash = {}
-		while src.cur_line 
+		while src.cur_line
 			case src.cur_line.md_type
 				when :empty;  src.shift_line
 				when :metadata; hash.merge! parse_metadata(src.shift_line)
@@ -469,33 +469,33 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		end
 		hash
 	end
-	
-		
-	def read_ref_definition(src, out)	
+
+
+	def read_ref_definition(src, out)
 		line = src.shift_line
-		
-		
+
+
 		# if link is incomplete, shift next line
-		if src.cur_line && !([:footnote_text, :ref_definition, :definition, :abbreviation].include? src.cur_line.md_type) && 
-			([1,2,3].include? number_of_leading_spaces(src.cur_line) ) 
+		if src.cur_line && !([:footnote_text, :ref_definition, :definition, :abbreviation].include? src.cur_line.md_type) &&
+			([1,2,3].include? number_of_leading_spaces(src.cur_line) )
 			line += " "+ src.shift_line
 		end
-		
+
 #		puts "total= #{line}"
-		
+
 		match = LinkRegex.match(line)
 		if not match
 			maruku_error "Link does not respect format: '#{line}'"
 			return
 		end
-		
-		id = match[1]; url = match[2]; title = match[3]; 
+
+		id = match[1]; url = match[2]; title = match[3];
 		id = sanitize_ref_id(id)
-		
+
 		hash = self.refs[id] = {:url=>url,:title=>title}
-		
+
 		stuff=match[4]
-		
+
 		if stuff
 			stuff.split.each do |couple|
 #					puts "found #{couple}"
@@ -507,10 +507,10 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			end
 		end
 #			puts hash.inspect
-		
+
 		out.push md_ref_def(id, url, meta={:title=>title})
 	end
-	
+
 	def split_cells(s)
 #		s.strip.split('|').select{|x|x.strip.size>0}.map{|x|x.strip}
 # changed to allow empty cells
@@ -519,23 +519,23 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 
 	def read_table(src)
 		head = split_cells(src.shift_line).map{|s| md_el(:head_cell, parse_lines_as_span([s])) }
-			
+
 		separator=split_cells(src.shift_line)
 
 		align = separator.map { |s|  s =~ Sep
 			if $1 and $2 then :center elsif $2 then :right else :left end }
-				
+
 		num_columns = align.size
-		
+
 		if head.size != num_columns
 			maruku_error "Table head does not have #{num_columns} columns: \n#{head.inspect}"
 			tell_user "I will ignore this table."
 			# XXX try to recover
 			return md_br()
 		end
-				
+
 		rows = []
-		
+
 		while src.cur_line && src.cur_line =~ /\|/
 			row = split_cells(src.shift_line).map{|s|
 				md_el(:cell, parse_lines_as_span([s]))}
@@ -551,18 +551,18 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		children = (head+rows).flatten
 		return md_el(:table, children, {:align => align})
 	end
-	
+
 	# If current line is text, a definition list is coming
 	# if 1) text,empty,[text,empty]*,definition
-	
+
 	def eventually_comes_a_def_list(src)
 		future = src.tell_me_the_future
 		ok = future =~ %r{^t+e?d}x
 #		puts "future: #{future} - #{ok}"
 		ok
 	end
-	
-		
+
+
 	def read_definition(src)
 		# Read one or more terms
 		terms = []
@@ -580,35 +580,35 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 			want_my_paragraph = true
 			src.shift_line
 		end
-		
+
 		raise "Chunky Bacon!" if src.cur_line.md_type != :definition
-		
+
 		# Read one or more definitions
 		definitions = []
 		while src.cur_line && src.cur_line.md_type == :definition
 			parent_offset = src.cur_index
-				
+
 			first = src.shift_line
 			first =~ Definition
 			first = $1
-			
+
 			# I know, it's ugly!!!
 
-			lines, w_m_p = 
+			lines, w_m_p =
 				read_indented_content(src,4, [:definition], :definition)
 			want_my_paragraph ||= w_m_p
-		
+
 			lines.unshift first
-			
+
 #			dbg_describe_ary(lines, 'DD')
 			src2 = LineSource.new(lines, src, parent_offset)
 			children = parse_blocks(src2)
 			definitions << md_el(:definition_data, children)
 		end
-		
-		return md_el(:definition, terms+definitions, { 	
-			:terms => terms, 
-			:definitions => definitions, 
+
+		return md_el(:definition, terms+definitions, {
+			:terms => terms,
+			:definitions => definitions,
 			:want_my_paragraph => want_my_paragraph})
 	end
 end # BlockLevelParser