maruku 0.3.0 → 0.4.0

data/lib/maruku/errors_management.rb

@@ -1,75 +1,91 @@
-
-
-# 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
+#--
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
 #
-# default is :raise
+# 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 MarukuException < RuntimeError
-	
-end
 
+#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 MarukuErrors
+module MaRuKu
+	
+	class Exception < RuntimeError
+	end
+	
+module Errors
 	Default_on_error = :warning
 	
 	def maruku_error(s,src=nil,con=nil)
-		policy = @doc ? (@doc.meta[:on_error] || Default_on_error) : :raise
+		policy = @doc ? (@doc.attributes[:on_error] || Default_on_error) : :raise
 		
 		case policy
 		when :ignore 
 		when :raise
-			raise_error describe_error(s,src,con)
+			raise_error create_frame(describe_error(s,src,con))
 		when :warning
-			tell_user describe_error(s,src,con)
+			tell_user create_frame(describe_error(s,src,con))
 		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 MarukuException, s, caller
+		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
-		(@error_stream || $stderr) <<
+		"\n" +
 		" "+"_"*n << "\n"<<
-		"| Maruku tells you (#{caller[0]})\n" << 
+		"| Maruku tells you:\n" << 
 		"+"+"-"*n +"\n"+
 		add_tabs(s,1,'| ') << "\n" <<
 		"+" << "-"*n << "\n" <<
-		add_tabs(caller.join("\n"),1,'!') << "\n" <<
+		add_tabs(caller[0, 5].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
+		src && (t += "\n#{src.describe}\n")
+		con && (t += "\n#{con.describe}\n")
 		t
 	end
 	
-end
-
-class MDElement
-	include MarukuErrors
-end
-
-
+end # Errors
+end # MaRuKu
 
 

data/lib/maruku/helpers.rb

@@ -1,160 +1,244 @@
+#--
+#   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
+#++
+
+
+
+
+# A series of helper functions for creating elements: they hide the 
+# particular internal representation.
+#
+# Please, always use these instead of creating MDElement.
+#
+
+module MaRuKu
+module Helpers
 
+	def md_el(node_type, children=[], meta={}, al=nil)
+		e = MDElement.new(node_type, children, meta, al)
+		e.doc = self
+		return e
+	end
 
-# A series of helper functions for creating elements
+	def md_header(level, children, al=nil)
+		md_el(:header, children, {:level => level}, al)
+	end
+	
+	# Inline code
+	def md_code(code, al=nil)
+		md_el(:inline_code, [], {:raw_code => code}, al)
+	end
 
-module Helpers
+	# Code block
+	def md_codeblock(source, al=nil)
+		md_el(:code, [], {:raw_code => source}, al)
+	end
 
-	def md_el(node_type, children=[], meta={})
-		e=MDElement.new(node_type, children, meta)
-		e.doc = self
-		e
+	def md_quote(children, al=nil)
+		md_el(:quote, children, {}, al)
+	end
+
+	def md_li(children, want_my_par, al=nil)
+		md_el(:li, children, {:want_my_paragraph=>want_my_par}, al)
 	end
 
-	def md_code(code)
-		md_el(:inline_code, [], {:raw_code => code})
+	def md_footnote(footnote_id, children, al=nil)
+		md_el(:footnote, children, {:footnote_id=>footnote_id}, al)
 	end
 
-	def md_par(children, meta={})
-		md_el(:paragraph, [], meta)
+	def md_abbr_def(abbr, text, al=nil)
+		md_el(:abbr_def, [], {:abbr=>abbr, :text=>text}, al)
+	end
+
+	def md_abbr(abbr, title)
+		md_el(:abbr, [abbr], {:title=>title})
 	end
 	
-	def md_html(raw_html)
+	def md_html(raw_html, al=nil)
 		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/,'>')
+			
+			raw_html = "<marukuwrap>#{raw_html}</marukuwrap>"
 			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,'|')
+		rescue 
+#			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})
+	def md_link(children, ref_id, al=nil)
+		md_el(:link, children, {:ref_id=>ref_id.downcase}, al)
 	end
 	
-	def md_im_link(children, url, title=nil)
-		md_el(:link, children, {:url=>url,:title=>title})
+	def md_im_link(children, url, title=nil, al=nil)
+		md_el(:im_link, children, {:url=>url,:title=>title}, al)
 	end
 	
-	
-	def md_image(children, ref_id)
-		md_el(:image, children, {:ref_id=>ref_id})
+	def md_image(children, ref_id, al=nil)
+		md_el(:image, children, {:ref_id=>ref_id}, al)
 	end
 	
-	def md_im_image(children, url, title=nil)
-		md_el(:image, children, {:url=>url,:title=>title})
+	def md_im_image(children, url, title=nil, al=nil)
+		md_el(:im_image, children, {:url=>url,:title=>title},al)
 	end
 
-	def md_em(children)
-		md_el(:emphasis, [children].flatten)
+	def md_em(children, al=nil)
+		md_el(:emphasis, [children].flatten, {}, al)
 	end
 
-	def md_strong(children)
-		md_el(:strong, [children].flatten)
+	def md_br()
+		md_el(:linebreak, [], {}, nil)
 	end
 
-	def md_emstrong(children)
-		md_strong(md_em(children))
+	def md_hrule()
+		md_el(:hrule, [], {}, nil)
+	end
+
+	def md_strong(children, al=nil)
+		md_el(:strong, [children].flatten, {}, al)
+	end
+
+	def md_emstrong(children, al=nil)
+		md_strong(md_em(children), al)
 	end
 
 	# <http://www.example.com/>
-	def md_url(url)
-		md_el(:immediate_link, [], {:url=>url})
+	def md_url(url, al=nil)
+		md_el(:immediate_link, [], {:url=>url}, al)
 	end
 	
 	# <andrea@rubyforge.org>
 	# <mailto:andrea@rubyforge.org>
-	def md_email(email)
-		md_el(:email_address, [], {:email=>email})
+	def md_email(email, al=nil)
+		md_el(:email_address, [], {:email=>email}, al)
 	end
 	
-	def md_entity(entity_name)
-		md_el(:entity, [], {:entity_name=>entity_name})
+	def md_entity(entity_name, al=nil)
+		md_el(:entity, [], {:entity_name=>entity_name}, al)
 	end
 	
 	# Markdown extra
-	def md_foot_ref(ref_id)
-		md_el(:footnote_reference, [], {:footnote_id=>ref_id})
+	def md_foot_ref(ref_id, al=nil)
+		md_el(:footnote_reference, [], {:footnote_id=>ref_id}, al)
 	end
 	
-	def md_par(children, meta={})
-		md_el(:paragraph, children, meta)
+	def md_par(children, al=nil)
+		md_el(:paragraph, children, meta={}, al)
 	end
 
 	# [1]: http://url [properties]
-	def md_ref_def(ref_id, url, title=nil, meta={})
+	def md_ref_def(ref_id, url, title=nil, meta={}, al=nil)
 		meta[:url] = url
 		meta[:ref_id] = ref_id
 		meta[:title] = title if title
-		md_el(:ref_definition, [], meta)
+		md_el(:ref_definition, [], meta, al)
+	end
+	
+	# inline attribute list
+	def md_ial(al)
+		al = Maruku::AttributeList.new(al) if 
+			not al.kind_of?Maruku::AttributeList
+		md_el(:ial, [], {:ial=>al})
+	end
+
+	# Attribute list definition
+	def md_ald(id, al)
+		md_el(:ald, [], {:ald_id=>id,:ald=>al})
+	end
+	
+	# Server directive <? code ?>
+	def md_server(code)
+		md_el(:server, [], {:code=>code})
 	end
 end
+end
+
+module MaRuKu
 
 class MDElement	
-	# outputs abbreviated form 
+	# outputs abbreviated form  (this should be eval()uable to get the document)
 	def inspect2 
+		s = 
 		case @node_type
 		when :paragraph
 			"md_par(%s)" % children_inspect
 		when :footnote_reference
-			"md_foot_ref(%s)" % @meta[:footnote_id].inspect
+			"md_foot_ref(%s)" % self.footnote_id.inspect
 		when :entity
-			"md_entity(%s)" % @meta[:entity_name].inspect
+			"md_entity(%s)" % self.entity_name.inspect
 		when :email_address
-			"md_email(%s)" % @meta[:email].inspect
+			"md_email(%s)" % self.email.inspect
 		when :inline_code
-			"md_code(%s)" % @meta[:raw_code].inspect
+			"md_code(%s)" % self.raw_code.inspect
 		when :raw_html
-			"md_html(%s)" % @meta[:raw_html].inspect
+			"md_html(%s)" % self.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
+			"md_url(%s)" % self.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
+			"md_image(%s, %s)" % [
+				children_inspect, 
+				self.ref_id.inspect]
+		when :im_image
+			"md_im_image(%s, %s, %s)" % [
+				children_inspect, 
+				self.url.inspect,
+				self.title.inspect]
 		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) : ""
+					children_inspect, self.ref_id.inspect]
+		when :im_link
+				"md_im_link(%s, %s, %s)" % [
+					children_inspect, 
+					self.url.inspect,
+					self.title.inspect,
 				]
-			end
 		when :ref_definition
-			"md_ref_def(%s, %s %s)" % 
-				[
-					@meta[:ref_id].inspect, 
-					@meta[:url].inspect,
-					@meta[:title] ? ","+@meta[:title].inspect : ""
+			"md_ref_def(%s, %s, %s)" % [
+					self.ref_id.inspect, 
+					self.url.inspect,
+					self.title.inspect
 				]
+		when :ial
+			"md_ial(%s)" % self.ial.inspect
 		else
-			nil
+			return nil
+		end
+		if @al and not @al.empty? then 
+			s = s.chop + ", #{@al.inspect})"
 		end
+		s
 	end
 	
 end
 
-
+end
 
 
 

data/lib/maruku/input/charsource.rb

@@ -0,0 +1,319 @@
+#--
+#   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; module In; module Markdown; module SpanLevelParser
+
+# a string scanner coded by me
+class CharSourceManual; end
+
+# a wrapper around StringScanner
+class CharSourceStrscan; end
+
+# A debug scanner that checks the correctness of both
+# by comparing their output
+class CharSourceDebug; end
+
+# Choose!
+
+#CharSource = CharSourceStrscan
+CharSource = CharSourceManual     # faster! 58ms vs. 65ms
+#CharSource = CharSourceDebug
+
+
+class CharSourceManual
+	include MaRuKu::Strings
+	
+	def initialize(s)
+		@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
+		nil
+	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)
+		# There is a bug here
+		if false
+			r2 = /^.{#{@buffer_index}}#{Regexp.escape string}/m
+			@buffer =~ r2
+		else
+			cur_chars(string.size) == string
+		end
+	end
+
+	def next_matches(r)
+		r2 = /^.{#{@buffer_index}}#{r}/m
+		md = r2.match @buffer
+		return !!md
+	end
+	
+	def read_regexp3(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}"
+		end
+		m
+	end
+
+		def read_regexp(r)
+			r2 = /^#{r}/
+			rest = current_remaining_buffer
+			m = r2.match(rest)
+			if m
+				@buffer_index += m.to_s.size
+#				puts "#{r} matched #{rest.inspect}: #{m.to_s.inspect}"
+			end
+			return 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
+			end
+		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
+		end
+	end
+	
+	def describe
+		describe_pos(@buffer, @buffer_index)
+	end
+	include SpanLevelParser
+end
+
+def describe_pos(buffer, buffer_index)
+	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"
+	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,">")
+	
+#		"CharSource: At character #{@buffer_index} of block "+
+#		" beginning with:\n    #{@buffer[0,50].inspect} ...\n"+
+#		" before: \n     ... #{cur_chars(50).inspect} ... "
+end
+
+
+require 'strscan'
+
+class CharSourceStrscan
+	include SpanLevelParser
+	include MaRuKu::Strings
+	
+	def initialize(s)
+		@s = StringScanner.new(s)
+	end
+	
+	# Return current char as a FixNum (or nil).
+	def cur_char
+		 @s.peek(1)[0]
+	end
+
+	# Return the next n chars as a String.
+	def cur_chars(n); 
+		@s.peek(n)
+	end
+	
+	# Return the char after current char as a FixNum (or nil).
+	def next_char; 
+		@s.peek(2)[1]
+	end
+	
+	def shift_char
+		(@s.get_byte)[0]
+	end
+	
+	def ignore_char
+		@s.get_byte
+		nil
+	end
+	
+	def ignore_chars(n)
+		n.times do @s.get_byte end
+		nil
+	end
+	
+	def current_remaining_buffer
+		@s.rest #nil #@buffer[@buffer_index, @buffer.size-@buffer_index]
+	end
+	
+	def cur_chars_are(string)
+		cur_chars(string.size) == string
+	end
+
+	def next_matches(r)
+		len = @s.match?(r)
+		return !!len
+	end
+	
+	def read_regexp(r)
+		string = @s.scan(r)
+		if string
+			return r.match(string)
+		else
+			return nil
+		end
+	end
+	
+	def consume_whitespace
+		@s.scan /\s+/
+		nil
+	end
+	
+	def describe
+		describe_pos(@s.string, @s.pos)
+	end
+	
+end
+
+
+class CharSourceDebug
+	def initialize(s)
+		@a = CharSourceManual.new(s)
+		@b = CharSourceStrscan.new(s)
+	end
+	
+	def method_missing(methodname, *args)
+		a_bef = @a.describe
+		b_bef = @b.describe
+		
+		a = @a.send(methodname, *args)
+		b = @b.send(methodname, *args)
+		
+#		if methodname == :describe
+#			return a
+#		end
+		
+		if a.kind_of? MatchData
+			if a.to_a != b.to_a
+				puts "called: #{methodname}(#{args})"
+				puts "Matchdata:\na = #{a.to_a.inspect}\nb = #{b.to_a.inspect}"
+				puts "AFTER: "+@a.describe
+				puts "AFTER: "+@b.describe
+				puts "BEFORE: "+a_bef
+				puts "BEFORE: "+b_bef
+				puts caller.join("\n")
+				exit
+			end
+		else
+			if a!=b
+				puts "called: #{methodname}(#{args})"
+				puts "Attenzione!\na = #{a.inspect}\nb = #{b.inspect}"
+				puts ""+@a.describe
+				puts ""+@b.describe
+				puts caller.join("\n")
+				exit
+			end
+		end
+		
+		if @a.cur_char != @b.cur_char
+			puts "Fuori sincronia dopo #{methodname}(#{args})"
+			puts ""+@a.describe
+			puts ""+@b.describe
+			exit
+		end
+		
+		return a
+	end
+end
+
+end end end end