maruku 0.3.0 → 0.4.0

data/lib/maruku/{parse_doc.rb → input/parse_doc.rb}

@@ -1,3 +1,4 @@
+#--
 #   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
 #
 # This file is part of Maruku.
@@ -15,34 +16,23 @@
 #   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
+#++
 
-require 'iconv'
 
-class Maruku
-	def initialize(s=nil, meta={})
-		@node_type = :document
-		@doc       = self
+require 'iconv'
 
-		@refs = {}
-		@footnotes = {}
-		@abbreviations = {}
-		@meta = meta
-		
-		parse_doc(s) if s 
-	end
+module MaRuKu; module In; module Markdown; module BlockLevelParser
 		
 	def parse_doc(s)
-		# setup initial stack
-		@stack = []
 		
 		meta2 =  parse_email_headers(s)
 		data = meta2[:data]
 		meta2.delete :data
 		
-		@meta.merge! meta2
+		self.attributes.merge! meta2
 		
-		enc = @meta[:encoding]
-		@meta.delete :encoding
+		enc = self.attributes[:encoding]
+		self.attributes.delete :encoding
 		if enc && enc.downcase != 'utf-8'
 #			puts "Converting from #{enc} to UTF-8."
 			converted = Iconv.new('utf-8', enc).iconv(data)
@@ -53,8 +43,7 @@ class Maruku
 			data = converted
 		end
 		
-		lines = Maruku.split_lines(data)
-		@children = parse_lines_as_markdown(lines)
+		@children = parse_text_as_markdown(data)
 		
 		if true #markdown_extra? 
 			self.search_abbreviations
@@ -64,26 +53,70 @@ class Maruku
 		toc = create_toc
 
 		# use title if not set
-		if not self.meta[:title] and toc.header_element
+		if not self.attributes[:title] and toc.header_element
 			title = toc.header_element.to_s
-			self.meta[:title]  = title
+			self.attributes[:title]  = title
 #			puts "Set document title to #{title}"
 		end
 		
 		# save for later use
 		self.toc = toc
 		
+		# Now do the attributes magic
+		each_element do |e|
+			# default attribute list
+			if default = self.ald[e.node_type.to_s]
+				expand_attribute_list(default, e.attributes)
+			end
+			expand_attribute_list(e.al, e.attributes)
+#			puts "#{e.node_type}: #{e.attributes.inspect}"
+		end
+		
 #		puts self.inspect
 	end
+	
+	# Expands an attribute list in an Hash
+	def expand_attribute_list(al, result)
+		al.each do |k, v|
+			case k
+			when :class
+				if not result[:class]
+					result[:class] = v
+				else
+					result[:class] += " " + v
+				end
+			when :id; result[:id] = v
+			when :ref; 
+				if self.ald[v]
+					already = (result[:expanded_references] ||= [])
+					if not already.include?(v)
+						already.push v
+						expand_attribute_list(self.ald[v], result)
+					else
+						maruku_error "Circular reference: #{v} already seen\n"+
+							already.inspect
+					end
+				else
+					if not result[:unresolved_references]
+						result[:unresolved_references] = v
+					else
+						result[:unresolved_references] << " #{v}"
+					end
+					
+					result[v.to_sym] = true
+				end
+			else
+				result[k.to_sym]=v
+			end
+		end
+	end
 
 	def search_abbreviations
-		@abbreviations.each do |abbrev, title|
+		self.abbreviations.each do |abbrev, title|
 			reg = Regexp.new(Regexp.escape(abbrev))
 			self.replace_each_string do |s|
 				if m = reg.match(s)
-					e = create_md_element(:abbreviation)
-					e.children = [abbrev.dup]
-					e.meta[:title] = title.dup if title
+					e = md_abbr(abbrev.dup, title ? title.dup : nil)
 					[m.pre_match, e, m.post_match]
 				else
 					s
@@ -111,7 +144,7 @@ class Maruku
 					e.texts.each do |original_text|
 #						puts "parse_blocks = #{parse_blocks} found = #{original_text} "
 						s = original_text.to_s.strip # XXX
-						el = create_md_element(:dummy,
+						el = md_el(:dummy,
 						 	parse_blocks ? parse_text_as_markdown(s) :
 						                  parse_lines_as_span([s]) )
 						el.children_to_html.each do |x|
@@ -125,5 +158,4 @@ class Maruku
 		end
 	end
 	
-
-end
+end end end end

data/lib/maruku/{parse_span_better.rb → input/parse_span_better.rb}

@@ -1,7 +1,28 @@
+#--
+#   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
+#++
+
+
 require 'set'
 
-class Maruku
-	include Helpers
+module MaRuKu; module In; module Markdown; module SpanLevelParser
+	include MaRuKu::Helpers
 	
 	EscapedCharInText = 
 		Set.new [?\\,?`,?*,?_,?{,?},?[,?],?(,?),?#,?.,?!,?|,?:,?+,?-,?>]
@@ -36,8 +57,9 @@ class Maruku
 		while true
 			c = src.cur_char
 
+			# This is only an optimization which cuts 50% of the time used.
+			# (but you can't use a-zA-z in exit_on_chars)
 			if c && ((c>=?a && c<=?z) || ((c>=?A && c<=?Z)))
-#				src.read_text_chars con.cur_string
 				con.cur_string << src.shift_char
 				next
 			end
@@ -49,7 +71,7 @@ class Maruku
 			when ?\ # it's space (32)
 				if src.cur_chars_are "  \n"
 					src.ignore_chars(3)
-					con.push_element  create_md_element(:linebreak)
+					con.push_element  md_br()
 					next
 				else
 					src.ignore_char
@@ -75,20 +97,21 @@ class Maruku
 						else 
 							con.push_char src.shift_char
 						end
-					when ??; read_server_directive
+					when ?? 
+						read_server_directive(src, con) 
 					when ?\ , ?\t 
 						con.push_char src.shift_char
-					else;  
+					else
 						if src.next_matches(/<mailto:/) or
 						   src.next_matches(/<[\w\.]+\@/)
 							read_email_el(src, con)
 						elsif src.next_matches(/<\w+:/)
 							read_url_el(src, con)
 						elsif src.next_matches(/<\w/)
-#							puts "This is HTML: #{src.cur_chars(20)}"
+							#puts "This is HTML: #{src.cur_chars(20)}"
 							read_inline_html(src, con)
 						else 
-#							puts "This is NOT HTML: #{src.cur_chars(20)}"
+							#puts "This is NOT HTML: #{src.cur_chars(20)}"
 							con.push_char src.shift_char
 						end
 				end
@@ -113,15 +136,15 @@ class Maruku
 					con.push_char src.shift_char
 				end
 			when ?&
-				if m = src.read_regexp(/&([\w\d]+);/)
+				if m = src.read_regexp(/\&([\w\d]+);/)
 					con.push_element md_entity(m[1])
 				else
 					con.push_char src.shift_char
 				end
 			when ?*
 				if not src.next_char
-					error "Opening * as last char", src, con
-					tell_user "Threating as literal"
+					maruku_error "Opening * as last char.", src, con
+					maruku_recover "Threating as literal"
 					con.push_char src.shift_char
 				else
 					follows = src.cur_chars(4)
@@ -137,8 +160,8 @@ class Maruku
 				end
 			when ?_
 				if not src.next_char
-					error "Opening _ as last char", src, con
-					tell_user "Threating as literal"
+					maruku_error "Opening _ as last char", src, con
+					maruku_recover "Threating as literal", src, con
 					con.push_char src.shift_char
 				else
 					follows = src.cur_chars(4)
@@ -152,21 +175,84 @@ class Maruku
 						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 nil
-				error ("Unclosed span (waiting for %s"+
+				maruku_error ("Unclosed span (waiting for %s"+
 				 "#{exit_on_strings.inspect})") % [
 						exit_on_chars ? "#{exit_on_chars.inspect} or" : ""],
 						src,con
 						
-				tell_user "I will boldly  go ahead."
 				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) }
+		
+		# Remove leading space
+		if (s = con.elements.first).kind_of? String
+			if s[0] == ?\ then con.elements[0] = s[1, s.size-1] end
+			con.elements.shift if s.size == 0 
+		end
+		
+		# Remove final spaces
+		if (s = con.elements.last).kind_of? String
+			s.chop! if s[-1] == ?\ 
+			con.elements.pop if s.size == 0 
+		end
+		
 		con.elements
 	end
+	
+	def read_server_directive(src, con) 
+		delim = "?>"
+		
+		src.ignore_chars delim.size
+		
+		code = 
+			read_simple(src, escaped=[], break_on_chars=[], 
+			break_on_strings=[delim])
+		
+		src.ignore_chars delim.size
+		
+		code = (code || "").strip
+		con.push_element md_server(code)
+	end
 
 	def read_url_el(src,con)
 		src.ignore_char # leading <
@@ -191,6 +277,9 @@ class Maruku
 		end
 		
 		url = read_simple(src, [], break_on)
+		if not url # empty url
+			url = ""
+		end
 		
 		if url[0] == ?< && url[-1] == ?>
 			url = url[1, url.size-2]
@@ -203,9 +292,19 @@ class Maruku
 		url
 	end
 	
+	
+	def read_quoted_or_unquoted(src, con, escaped, exit_on_chars)
+		case src.cur_char
+		when ?', ?"
+			read_quoted(src, con)
+		else
+			read_simple(src, escaped, exit_on_chars)
+		end
+	end
+	
 	# Tries to read a quoted value. If stream does not
 	# start with ' or ", returns nil.
-	def read_quoted(src,con)
+	def read_quoted(src, con)
 		case src.cur_char
 			when ?', ?"
 				quote_char = src.shift_char # opening quote
@@ -219,8 +318,10 @@ class Maruku
 	end
 	
 	# Reads a simple string (no formatting) until one of break_on_chars, 
-	# while escaping the escaped
-	def read_simple(src, escaped, exit_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) 
 		text = ""
 		while true
 #			puts "Reading simple #{text.inspect}"
@@ -229,12 +330,17 @@ class Maruku
 #				puts ("  breaking on "<<c)+" contained in "+exit_on_chars.inspect
 				break
 			end
+			
+			break if exit_on_strings && 
+				exit_on_strings.any? {|x| src.cur_chars_are x}
+			
 			case c
 			when nil
-				s= "String finished while reading (break on #{exit_on_chars.inspect})"+
+				s= "String finished while reading (break on "+
+				"#{exit_on_chars.map{|x|""<<x}.inspect})"+
 				" already read: #{text.inspect}"
-				error s, src
-				tell_user "I boldly continue"
+				maruku_error s, src
+				maruku_recover "I boldly continue", src, con
 				break
 			when ?\\
 				d = src.next_char
@@ -249,7 +355,7 @@ class Maruku
 			end
 		end
 #		puts "Read simple #{text.inspect}"
-		text
+		text.empty? ? nil : text
 	end
 	
 	def read_em(src, delim)
@@ -321,48 +427,33 @@ class Maruku
 			maruku_error "Bad html: \n" + 
 				add_tabs(e.inspect+e.backtrace.join("\n"),1,'>'),
 				src,con
-			tell_user "I will try to continue after bad HTML."
+			maruku_recover "I will try to continue after bad HTML.", src, con
 			con.push_char src.shift_char
 		end
 	end
 	
 	def read_inline_code(src, con)
+		# Count the number of ticks
 		num_ticks = 0
-		
 		while src.cur_char == ?` 
 			num_ticks += 1
 			src.ignore_char
 		end
+		# We will read until this string
+		end_string = "`"*num_ticks
 
+		code = 
+			read_simple(src, escaped=[], break_on_chars=[], 
+				break_on_strings=[end_string])
 		
-		# ignore space
-		if num_ticks > 1 && src.cur_char == SPACE
-			src.ignore_char
-		end
-
-#		puts "Ticks: #{num_ticks } next: #{src.some} "
-
-		end_string = "`"*num_ticks
+#		puts "Now I expects #{num_ticks} ticks: #{src.cur_chars(10).inspect}"
+		src.ignore_chars num_ticks
 		
-		code = ''
-		while true
-			if not src.cur_char
-				error("Ticks not finished: read #{code.inspect}"+
-				      " and waiting for #{end_string.inspect} num=#{num_ticks}",
-						src,con)
-				tell_user "Read invalid code block: #{code.inspect}"
-				break
-			end
-			
-			if src.cur_chars(num_ticks) ==end_string # bah
-#				puts "Breaking on #{src.some}  (end:#{end_string.inspect})"
-				src.ignore_chars num_ticks
-				break
-			end
-			
-			code << src.shift_char
+		# Ignore at most one space
+		if num_ticks > 1 && code[0] == SPACE
+			code = code[1, code.size-1]
 		end
-
+		
 		# drop last space 
 		if num_ticks > 1 && code[-1] == SPACE
 			code = code[0,code.size-1]
@@ -371,17 +462,6 @@ class Maruku
 #		puts "Read `` code: #{code.inspect}; after: #{src.cur_chars(10).inspect} "
 		con.push_element md_code(code)
 	end
-
-	
-	
-	def read_server_directive
-		# match = gimme(/^(.*)\?>/)
-		# if not match
-		# 	error "Server directive not closed"
-		# end
-		# server = match[1]
-		# con.found_object create_md_element(:server, server)
-	end
 	
 	def read_link(src, con)
 		# we read the string and see what happens
@@ -405,14 +485,31 @@ class Maruku
 			src.consume_whitespace
 			title = nil
 			if src.cur_char != ?) # we have a title
+				quote_char = src.cur_char
 				title = read_quoted(src,con)
+				
+				if not title
+					maruku_error 'Must quote title',src,con
+				else
+					# Tries to read a title with quotes: ![a](url "ti"tle")
+					# this is the most ugly thing in Markdown
+					if not src.next_matches(/\s*\)/)
+						# if there is not a closing par ), then read
+						# the rest and guess it's title with quotes
+						rest = read_simple(src, escaped=[], break_on_chars=[?)], 
+							break_on_strings=[])
+						# chop the closing char
+						rest.chop!
+						title << quote_char << rest
+					end
+				end
 			end
 			src.consume_whitespace
 			closing = src.shift_char # closing )
 			if closing != ?)
-				error 'Unclosed link',src,con
-				tell_user "No closing ): I will not create"+
-				" the link for #{children.inspect}"
+				maruku_error 'Unclosed link',src,con
+				maruku_recover "No closing ): I will not create"+
+				" the link for #{children.inspect}", src, con
 				con.push_elements children
 				return
 			end
@@ -423,7 +520,8 @@ class Maruku
 				con.push_element md_link(children, ref_id)
 			else 
 				maruku_error "Could not read ref_id", src, con
-				tell_user "I will not create the link for #{children.inspect}"
+				maruku_recover "I will not create the link for "+
+					"#{children.inspect}", src, con
 				con.push_elements children
 				return
 			end
@@ -453,8 +551,23 @@ class Maruku
 			src.consume_whitespace
 			title = nil
 			if src.cur_char != ?) # we have a title
+				quote_char = src.cur_char
 				title = read_quoted(src,con)
-				error 'Must quote title',src,con if not title
+				if not title
+					maruku_error 'Must quote title',src,con
+				else				
+					# Tries to read a title with quotes: ![a](url "ti"tle")
+					# this is the most ugly thing in Markdown
+					if not src.next_matches(/\s*\)/)
+						# if there is not a closing par ), then read
+						# the rest and guess it's title with quotes
+						rest = read_simple(src, escaped=[], break_on_chars=[?)], 
+							break_on_strings=[])
+						# chop the closing char
+						rest.chop!
+						title << quote_char << rest
+					end
+				end
 			end
 			src.consume_whitespace
 			closing = src.shift_char # closing )
@@ -471,211 +584,68 @@ class Maruku
 		end
 	end # read link
 
-end
-
 
-class SpanContext 
-	include MarukuStrings
+	class SpanContext 
+		include MaRuKu::Strings
 	
-	# Read elements
-	attr_accessor :elements
-	attr_accessor :cur_string
-	
-	def initialize
-		@elements = []
-		@cur_string = ""
-	end
+		# Read elements
+		attr_accessor :elements
+		attr_accessor :cur_string
 	
-	def push_element(e)
-		raise "Only MDElement and String, please. You pushed #{e.class}: #{e.inspect} " if
-		 not (e.kind_of?(String) or e.kind_of?(MDElement))
-		
-		push_string_if_present
-		@elements << e
-		nil
-	end
-
-	def push_elements(a)
-		for e in a 
-			if e.kind_of? String
-				e.each_byte do |b| push_char b end
-			else
-				push_element e
-			end
-		end
-	end
-	def push_string_if_present
-		if @cur_string.size > 0
-			@elements << @cur_string
+		def initialize
+			@elements = []
 			@cur_string = ""
 		end
-		nil
-	end
-	
-	def push_char(c)
-		@cur_string << c 
-		nil
-	end
-	
-	# push space into current string if
-	# there isn't one
-	def push_space
-		last = @cur_string[@cur_string.size-1]
-		@cur_string << ?\  if last != ?\ 
-	end
 	
-	def describe
-		lines = @elements.map{|x| x.inspect}.join("\n")
-		s = "Elements read in span: \n" +
-		add_tabs(lines,1, ' -')+"\n"
+		def push_element(e)
+			raise "Only MDElement and String, please. You pushed #{e.class}: #{e.inspect} " if
+			 not (e.kind_of?(String) or e.kind_of?(MDElement))
 		
-		if @cur_string.size > 0
-		s += "Current string: \n  #{@cur_string.inspect}\n" 
+			push_string_if_present
+			@elements << e
+			nil
 		end
-		s
-	end
-	
-end
-
-class CharSource
-	include MarukuStrings
-	
-	def initialize(s)
-		@elements = []
-		@cur_string = ""
-		@buffer = s
-		@buffer_index = 0
-	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
-	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)
-		r2 = /^.{#{@buffer_index}}#{Regexp.escape string}/m
-		@buffer =~ r2
-	end
-
-	def next_matches(r)
-		r2 = /^.{#{@buffer_index}}#{r}/m
-		r2.match @buffer
-	end
-	
-	def read_regexp(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}"
+		def push_elements(a)
+			for e in a 
+				if e.kind_of? String
+					e.each_byte do |b| push_char b end
+				else
+					push_element e
+				end
+			end
 		end
-		m
-	end
-	
-	def consume_whitespace
-		while c = cur_char 
-			if (c == 32 || c == ?\t)
-#				puts "ignoring #{c}"
-				ignore_char
-			else
-#				puts "#{c} is not ws: "<<c
-				break
+		def push_string_if_present
+			if @cur_string.size > 0
+				@elements << @cur_string
+				@cur_string = ""
 			end
+			nil
 		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
+	
+		def push_char(c)
+			@cur_string << c 
+			nil
 		end
-	end
 	
-	def describe
-		
-		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"
+		# push space into current string if
+		# there isn't one
+		def push_space
+			last = @cur_string[@cur_string.size-1]
+			@cur_string << ?\  if last != ?\ 
 		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"+
-		add_tabs(@buffer,1,">")
+	
+		def describe
+			lines = @elements.map{|x| x.inspect}.join("\n")
+			s = "Elements read in span: \n" +
+			add_tabs(lines,1, ' -')+"\n"
 		
-#		"CharSource: At character #{@buffer_index} of block "+
-#		" beginning with:\n    #{@buffer[0,50].inspect} ...\n"+
-#		" before: \n     ... #{cur_chars(50).inspect} ... "
-	end
+			if @cur_string.size > 0
+			s += "Current string: \n  #{@cur_string.inspect}\n" 
+			end
+			s
+		end
+	end # SpanContext
 	
-	def some
-		cur_chars(15).inspect
-	end
-end
-
-
-
+end end end end # module MaRuKu; module In; module Markdown; module SpanLevelParser