maruku 0.6.0 → 0.7.3

data/lib/maruku/output/s5/to_s5.rb

@@ -1,138 +1,118 @@
-# This module groups all functions related to HTML export.
-module MaRuKu
+require 'maruku/output/to_html'
 
-begin
-        require 'rexml/formatters/pretty'
-        require 'rexml/formatters/default'
-        $rexml_new_version = true
-rescue LoadError
-        $rexml_new_version = false      
-end
-	 
-	class MDDocument
-
-	def s5_theme
-	  html_escape(self.attributes[:slide_theme] || "default")
-	end
-
-	def  html_escape(string)
-	  string.gsub( /&/, "&" ).
-	         gsub( /</, "&lt;" ).
-	         gsub( />/, "&gt;" ).
-	         gsub( /'/, "&#39;" ).
-	         gsub( /"/, "&quot;" )
-	end
-		
-	# Render as an HTML fragment (no head, just the content of BODY). (returns a string)
-	def to_s5(context={})
-		indent       = context[:indent]       || -1
-		ie_hack      = !context[:ie_hack].kind_of?(FalseClass)
-		content_only = !context[:content_only].kind_of?(FalseClass)
-
-		doc = Document.new(nil,{:respect_whitespace =>:all})
-
-		if content_only
-			body = Element.new('div', doc)
-		else
-			html = Element.new('html', doc)
-			html.add_namespace('http://www.w3.org/1999/xhtml')
-			html.add_namespace('svg', "http://www.w3.org/2000/svg" )
-
-			head = Element.new('head', html)
-			me = Element.new 'meta', head
-			me.attributes['http-equiv'] = 'Content-type'
-			me.attributes['content'] = 'text/html;charset=utf-8'	
-
-			# Create title element
-			doc_title = self.attributes[:title] || self.attributes[:subject] || ""
-			title = Element.new 'title', head
-				title << Text.new(doc_title)		
-			body = Element.new('body', html)
-			
-		end
-		
-		slide_header = self.attributes[:slide_header]
-		slide_footer = self.attributes[:slide_footer]
-		slide_subfooter = self.attributes[:slide_subfooter]
-		slide_topleft  = self.attributes[:slide_topleft]
-		slide_topright  = self.attributes[:slide_topright]
-		slide_bottomleft  = self.attributes[:slide_bottomleft]
-		slide_bottomright  = self.attributes[:slide_bottomright]
-
-		dummy_layout_slide = 
-		"
-		<div class='layout'>
-		<div id='controls'> </div>
-		<div id='currentSlide'> </div>
-		<div id='header'> #{slide_header}</div>
-		<div id='footer'>
-		<h1>#{slide_footer}</h1>
-		<h2>#{slide_subfooter}</h2>
-		</div>
-		<div class='topleft'> #{slide_topleft}</div>
-		<div class='topright'> #{slide_topright}</div>
-		<div class='bottomleft'> #{slide_bottomleft}</div>
-		<div class='bottomright'> #{slide_bottomright}</div>
-		</div>
+module MaRuKu
+  class MDDocument
+    def s5_theme
+      xtext(self.attributes[:slide_theme] || "default")
+    end
+
+    # Render as an HTML fragment (no head, just the content of BODY). (returns a string)
+    def to_s5(context={})
+      content_only = context[:content_only] != false
+      print_slides = context[:print_slides]
+
+      if content_only
+        body = xelem('div', doc)
+      else
+        html = xelem('html')
+        html['xmlns'] = 'http://www.w3.org/1999/xhtml'
+        html['xmlns:svg'] = "http://www.w3.org/2000/svg"
+        html['xml:lang'] = self.attributes[:lang] || 'en'
+
+        head = xelem('head')
+        html << head
+
+        me = xelem('meta')
+        me['http-equiv'] = 'Content-type'
+        me['content'] = 'text/html;charset=utf-8'
+        head << me
+
+        # Create title element
+        doc_title = self.attributes[:title] || self.attributes[:subject] || ""
+        begin
+          title_content = MaRuKu::HTMLFragment.new(doc_title).to_html
+        rescue
+          title_content = xtext(doc_title)
+        end
+        title = xelem('title') << title_content
+        head << title
+
+        body = xelem('body')
+        html << body
+      end
+
+      slide_header = self.attributes[:slide_header]
+      slide_footer = self.attributes[:slide_footer]
+      slide_subfooter = self.attributes[:slide_subfooter]
+      slide_topleft  = self.attributes[:slide_topleft]
+      slide_topright  = self.attributes[:slide_topright]
+      slide_bottomleft  = self.attributes[:slide_bottomleft]
+      slide_bottomright  = self.attributes[:slide_bottomright]
+
+      dummy_layout_slide = "
+    <div class='layout'>
+    <div id='controls'> </div>
+    <div id='currentSlide'> </div>
+    <div id='header'> #{slide_header}</div>
+    <div id='footer'>
+    <h1>#{slide_footer}</h1>
+    <h2>#{slide_subfooter}</h2>
+    </div>
+    <div class='topleft'> #{slide_topleft}</div>
+    <div class='topright'> #{slide_topright}</div>
+    <div class='bottomleft'> #{slide_bottomleft}</div>
+    <div class='bottomright'> #{slide_bottomright}</div>
+    </div>
                 "
-		body.add_element Document.new(dummy_layout_slide, {:respect_whitespace =>:all}).root
-
-		presentation = Element.new 'div', body
-		presentation.attributes['class'] = 'presentation'
-		
-		first_slide="
-	  <div class='slide'>
-	  <h1> #{self.attributes[:title] ||context[:title]}</h1>
-	  <h2> #{self.attributes[:subtitle] ||context[:subtitle]}</h2>
-	  <h3> #{self.attributes[:author] ||context[:author]}</h3>
-	  <h4> #{self.attributes[:company] ||context[:company]}</h4>
-	  </div>
-		"
-		presentation.add_element Document.new(first_slide).root
-
-		slide_num = 0
-		self.toc.section_children.each do |slide|
-			slide_num += 1
-			@doc.attributes[:doc_prefix] = "s#{slide_num}"
-			
-			puts "Slide #{slide_num}: " + slide.header_element.to_s
-			div = Element.new('div', presentation)
-			div.attributes['class'] = 'slide'
-			
-			h1 = Element.new 'h1', div
-			slide.header_element.children_to_html.each do |e| h1 << e; end
-			
-			array_to_html(slide.immediate_children).each do |e|  div << e  end
-				
-			# render footnotes
-			if @doc.footnotes_order.size > 0
-				div << render_footnotes
-				@doc.footnotes_order = []
-			end
-		end
-
-		xml  = "" 
-		if (content_only)
-		   if $rexml_new_version
-		     formatter = REXML::Formatters::Default.new(ie_hack)
-                     formatter.write(body, xml)
-		   else
-		     body.write(xml,indent,transitive=true,ie_hack);
-		  end
-		else
-		  doc2 = Document.new("<div>"+S5_external+"</div>",{:respect_whitespace =>:all})
-		  doc2.root.children.each{ |child| head << child }
-
-		  add_css_to(head)
-
-		  # REXML Bug? if indent!=-1 whitespace is not respected for 'pre' elements
-		  # containing code.
-		  html.write(xml,indent,transitive=true,ie_hack);
-		  Xhtml11_mathml2_svg11 + xml
-		end
-	end
-
-end 
-
-
+      body <<  dummy_layout_slide
+
+      presentation = xelem('div')
+      presentation['class'] = 'presentation'
+      body << presentation
+
+      first_slide = "
+    <div class='slide'>
+    <h1> #{self.attributes[:title] ||context[:title]}</h1>
+    <h2> #{self.attributes[:subtitle] ||context[:subtitle]}</h2>
+    <h3> #{self.attributes[:author] ||context[:author]}</h3>
+    <h4> #{self.attributes[:company] ||context[:company]}</h4>
+    </div>
+    "
+      presentation << first_slide
+
+      slide_num = 0
+      self.toc.section_children.each do |slide|
+        slide_num += 1
+        @doc.attributes[:doc_prefix] = "s#{slide_num}"
+
+        div = xelem('div')
+        presentation << div
+        div['class'] = 'slide'
+
+        h1 = xelem('h1')
+        puts "Slide #{slide_num}: #{slide.header_element.children_to_html.join}" if print_slides
+        slide.header_element.children_to_html.inject(h1, &:<<)
+        div << h1
+
+        array_to_html(slide.immediate_children).inject(div, &:<<)
+
+        # render footnotes
+        unless @doc.footnotes_order.empty?
+          div << render_footnotes
+          @doc.footnotes_order = []
+        end
+      end
+
+      if content_only
+        xml = body.to_html
+      else
+        head << S5_external
+
+        add_css_to(head)
+
+        xml = html.to_html
+        Xhtml11_mathml2_svg11 + xml
+      end
+    end
+  end
 end

data/lib/maruku/output/to_html.rb

@@ -1,991 +1,915 @@
-#--
-#   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 'rexml/document'
-
-begin
-	require 'rexml/formatters/pretty'
-	require 'rexml/formatters/default'
-	$rexml_new_version = true
-rescue LoadError
-	$rexml_new_version = false	
-end
+require 'maruku/string_utils'
+require 'cgi'
 
-class String
-	# A string is rendered into HTML by creating
-	# a REXML::Text node. REXML takes care of all the encoding.
-	def to_html
-		REXML::Text.new(self)
-	end
-end
+# This module groups all functions related to HTML export.
+module MaRuKu::Out::HTML
+
+  # Escape text for use in HTML (content or attributes) by running it through
+  # standard XML escaping (quotes and angle brackets and ampersands)
+  def self.escapeHTML(text)
+    CGI.escapeHTML(text)
+    # TODO: When we drop Rubies < 1.9.3, re-add .gsub(/[^[:print:]\n\r\t]/, '') to
+    # get rid of non-printable control characters.
+  end
+
+  # A simple class to represent an HTML element for output.
+  class HTMLElement
+    attr_accessor :name
+    attr_accessor :attributes
+    attr_accessor :children
+
+    def initialize(name, attr={}, children=[])
+      self.name = name
+      self.attributes = attr || {}
+      self.children = Array(children)
+      children << yield if block_given?
+    end
 
+    def <<(child)
+      children << child if children
+      self
+    end
 
-# This module groups all functions related to HTML export.
-module MaRuKu; module Out; module HTML
-	include REXML
-	
-	# Render as an HTML fragment (no head, just the content of BODY). (returns a string)
-	def to_html(context={})
-		indent = context[:indent] || -1
-		ie_hack = context[:ie_hack] || true
-		
-		div = Element.new 'dummy'
-			children_to_html.each do |e|
-				div << e
-			end
-
-			# render footnotes
-			if @doc.footnotes_order.size > 0
-				div << render_footnotes
-			end
-		
-		doc = Document.new(nil,{:respect_whitespace =>:all})
-		doc << div
-		
-		# REXML Bug? if indent!=-1 whitespace is not respected for 'pre' elements
-		# containing code.
-		xml =""
-
-		if $rexml_new_version
-			formatter = if indent > -1
-	          REXML::Formatters::Pretty.new( indent, ie_hack )
-	        else
-	          REXML::Formatters::Default.new( ie_hack )
-	        end
-			formatter.write( div, xml)
-		else
-			div.write(xml,indent,transitive=true,ie_hack)
-		end
-
-		xml.gsub!(/\A<dummy>\s*/,'')
-		xml.gsub!(/\s*<\/dummy>\Z/,'')
-		xml.gsub!(/\A<dummy\s*\/>/,'')
-		xml
-	end
-	
-	# Render to a complete HTML document (returns a string)
-	def to_html_document(context={})
-		indent = context[:indent] || -1
-		ie_hack = context[:ie_hack] ||true
-		doc = to_html_document_tree
-		xml  = "" 
-		
-		# REXML Bug? if indent!=-1 whitespace is not respected for 'pre' elements
-		# containing code.
-		doc.write(xml,indent,transitive=true,ie_hack);
-		
-		Xhtml11_mathml2_svg11 + xml
-	end
-	
-				
-		Xhtml10strict  = 
-"<?xml version='1.0' encoding='utf-8'?>
-<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN'
-'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>\n"
-		
-	Xhtml11strict_mathml2 = '<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
-               "http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd" [
-  <!ENTITY mathml "http://www.w3.org/1998/Math/MathML">
-]>
-'
+    def [](key)
+      attributes[key.to_s]
+    end
+
+    def []=(key, value)
+      attributes[key.to_s] = value
+    end
+
+    def add_class(class_name)
+      attributes['class'] = ((attributes['class']||'').split(' ') + [class_name]).join(' ')
+    end
+
+    # These elements have no children and should be rendered with a self-closing tag.
+    # It's not an exhaustive list, but they cover everything we use.
+    SELF_CLOSING = Set.new %w[br hr img link meta]
+
+    def to_html
+      m = "<#{name}"
+      attributes.each do |k, v|
+        m << " #{k.to_s}=\"#{v.to_s}\""
+      end
+
+      if SELF_CLOSING.include? name
+        m << " />"
+      else
+        content = children.map(&:to_s)
+        m << ">" << content.join('') << "</#{name}>"
+      end
+    end
+
+    alias :to_str :to_html
+    alias :to_s :to_html
+  end
+
+  # Render as an HTML fragment (no head, just the content of BODY). (returns a string)
+  def to_html(context={})
+    output = ""
+    children_to_html.each do |e|
+      output << e.to_s
+    end
 
-Xhtml11_mathml2_svg11 = 
-'<?xml version="1.0" encoding="utf-8"?>
+    # render footnotes
+    unless @doc.footnotes_order.empty?
+      output << render_footnotes
+    end
+
+    output
+  end
+
+  Xhtml11_mathml2_svg11 =
+    '<?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE html PUBLIC
     "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN"
     "http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">
 '
-	
-	
-	def xml_newline() Text.new("\n") end
-		
-
-=begin maruku_doc
-Attribute: title
-Scope: document
-
-Sets the title of the document.
-If a title is not specified, the first header will be used.
-
-These should be equivalent:
-
-	Title: my document
-
-	Content
-
-and
-
-	my document
-	===========
-
-	Content
-
-In both cases, the title is set to "my document".
-=end
-
-=begin maruku_doc
-Attribute: doc_prefix
-Scope: document
-
-String to disambiguate footnote links.
-=end
-
-
-=begin maruku_doc
-Attribute: subject
-Scope: document
-
-Synonim for `title`.
-=end
-
-
-	# Render to an HTML fragment (returns a REXML document tree)
-	def to_html_tree
-		div = Element.new 'div'
-			div.attributes['class'] = 'maruku_wrapper_div'
-				children_to_html.each do |e|
-						  div << e
-				end
-
-				# render footnotes
-				if @doc.footnotes_order.size > 0
-						  div << render_footnotes
-				end
-
-		 doc = Document.new(nil,{:respect_whitespace =>:all})
-		 doc << div
-	end
-
-=begin maruku_doc
-Attribute: css
-Scope: document
-Output: HTML
-Summary: Activates CSS stylesheets for HTML.
-
-`css` should be a space-separated list of urls.
-
-Example:
-
-	CSS: style.css math.css
-
-=end
-
-	METAS = %w{description keywords author revised}
-
-	# Render to a complete HTML document (returns a REXML document tree)
-	def to_html_document_tree
-		doc = Document.new(nil,{:respect_whitespace =>:all})
-	#	doc << XMLDecl.new
-		
-		root = Element.new('html', doc)
-		root.add_namespace('http://www.w3.org/1999/xhtml')
-		root.add_namespace('svg', "http://www.w3.org/2000/svg" )
-		lang = self.attributes[:lang] || 'en'
-		root.attributes['xml:lang'] = lang
-		
-		root << xml_newline
-		head = Element.new 'head', root
-		
-			#<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
-			me = Element.new 'meta', head
-			me.attributes['http-equiv'] = 'Content-type'
-#			me.attributes['content'] = 'text/html;charset=utf-8'	
-			me.attributes['content'] = 'application/xhtml+xml;charset=utf-8'	
-		
-			METAS.each do |m|
-				if value = self.attributes[m.to_sym]
-					meta = Element.new 'meta', head
-					meta.attributes['name'] = m
-					meta.attributes['content'] = value.to_s
-				end
-			end
-			
-			
-			self.attributes.each do |k,v|
-				if k.to_s =~ /\Ameta-(.*)\Z/
-					meta = Element.new 'meta', head
-					meta.attributes['name'] = $1
-					meta.attributes['content'] = v.to_s
-				end
-			end
-			
-
-			
-			# Create title element
-			doc_title = self.attributes[:title] || self.attributes[:subject] || ""
-			title = Element.new 'title', head
-				title << Text.new(doc_title)
-							
-			add_css_to(head)
-			
-		
-		root << xml_newline
-		
-		body = Element.new 'body'
-		
-			children_to_html.each do |e|
-				body << e
-			end
-
-			# render footnotes
-			if @doc.footnotes_order.size > 0
-				body << render_footnotes
-			end
-			
-			# When we are rendering a whole document, we add a signature 
-			# at the bottom. 
-			if get_setting(:maruku_signature)
-				body << maruku_html_signature 
-			end
-			
-		root << body
-		
-		doc
-	end
-
-	def add_css_to(head)
-		if css_list = self.attributes[:css]
-			css_list.split.each do |css|
-			# <link type="text/css" rel="stylesheet" href="..." />
-			link = Element.new 'link'
-			link.attributes['type'] = 'text/css'
-			link.attributes['rel'] = 'stylesheet'
-			link.attributes['href'] = css
-			head << link 
-			head << xml_newline
-			end
-		end
-	end
-	
-	# returns "st","nd","rd" or "th" as appropriate
-	def day_suffix(day)
-		s = {
-			1 => 'st',
-			2 => 'nd',
-			3 => 'rd',
-			21 => 'st',
-			22 => 'nd',
-			23 => 'rd',
-			31 => 'st'
-		}
-		return s[day] || 'th';
-	end
-
-	# formats a nice date
-	def nice_date
-		t = Time.now
-		t.strftime(" at %H:%M on ")+
-		t.strftime("%A, %B %d")+
-		day_suffix(t.day)+
-		t.strftime(", %Y")
-	end
-	
-	def maruku_html_signature		
-		div = Element.new 'div'
-			div.attributes['class'] = 'maruku_signature'
-			Element.new 'hr', div
-			span = Element.new 'span', div
-				span.attributes['style'] = 'font-size: small; font-style: italic'
-				span << Text.new('Created by ')
-				a = Element.new('a', span)
-					a.attributes['href'] = 'http://maruku.rubyforge.org'
-					a.attributes['title'] = 'Maruku: a Markdown-superset interpreter for Ruby'
-					a << Text.new('Maruku')
-				span << Text.new(nice_date+".")
-		div
-	end
-	
-	def render_footnotes()
-		div = Element.new 'div'
-		div.attributes['class'] = 'footnotes'
-		div <<  Element.new('hr')
-			ol = Element.new 'ol'
-			@doc.footnotes_order.each_with_index do |fid, i| num = i+1
-				f = self.footnotes[fid]
-				if f
-					li = f.wrap_as_element('li')
-					li.attributes['id'] = "#{get_setting(:doc_prefix)}fn:#{num}"
-					
-					a = Element.new 'a'
-						a.attributes['href'] = "\##{get_setting(:doc_prefix)}fnref:#{num}"
-						a.attributes['rev'] = 'footnote'
-						a<< Text.new('&#8617;', true, nil, true)
-					li.insert_after(li.children.last, a)
-					ol << li
-				else
-					maruku_error "Could not find footnote id '#{fid}' among ["+
-					 self.footnotes.keys.map{|s|"'"+s+"'"}.join(', ')+"]."
-				end
-			end
-		div << ol
-		div
-	end
-
-
-	def to_html_hrule; create_html_element 'hr' end
-	def to_html_linebreak; Element.new 'br' end
-
-	# renders children as html and wraps into an element of given name
-	# 
-	# Sets 'id' if meta is set
-	def wrap_as_element(name, attributes_to_copy=[])
-		m = create_html_element(name, attributes_to_copy)
-			children_to_html.each do |e| m << e; end
-			
-#			m << Comment.new( "{"+self.al.to_md+"}") if not self.al.empty?
-#			m << Comment.new( @attributes.inspect) if not @attributes.empty?
-		m
-	end
-	
-=begin maruku_doc
-Attribute: id
-Scope: element
-Output: LaTeX, HTML
-
-It is copied as a standard HTML attribute.
-
-Moreover, it used as a label name for hyperlinks in both HTML and
-in PDF.
-
-=end
-
-=begin maruku_doc
-Attribute: class
-Scope: element
-Output: HTML
-
-It is copied as a standard HTML attribute.
-=end
-
-=begin maruku_doc
-Attribute: style
-Scope: element
-Output: HTML
-
-It is copied as a standard HTML attribute.
-=end
-	
-		
-	
-	
-	
-	HTML4Attributes = {}
-	
-	coreattrs = [:id, :class, :style, :title]
-	i18n = [:lang, 'xml:lang'.to_sym]
-	events = [
-		:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, 
-		:onmousemove, :onmouseout,
-		:onkeypress, :onkeydown, :onkeyup]	
-	attrs = coreattrs + i18n + events
-	cellhalign = [:align, :char, :charoff]
-	cellvalign = [:valign]
-	[
-		['body', attrs + [:onload, :onunload]],
-		['address', attrs],
-		['div', attrs],
-		['a', attrs+[:charset, :type, :name, :rel, :rev, :accesskey, :shape, :coords, :tabindex, 
-			:onfocus,:onblur]],
-		['img', attrs + [:longdesc, :name, :height, :width, :alt] ],
-		['p', attrs],
-		[['h1','h2','h3','h4','h5','h6'], attrs], 
-		[['pre'], attrs],
-		[['q', 'blockquote'], attrs+[:cite]],
-		[['ins','del'], attrs+[:cite,:datetime]],
-		[['ol','ul','li'], attrs],
-		['table',attrs+[:summary, :width, :frame, :rules, :border, :cellspacing, :cellpadding]],
-		['caption',attrs],	
-		[['colgroup','col'],attrs+[:span, :width]+cellhalign+cellvalign],
-		[['thead','tbody','tfoot'], attrs+cellhalign+cellvalign],
-		[['td','td','th'], attrs+[:abbr, :axis, :headers, :scope, :rowspan, :colspan, :cellvalign, :cellhalign]],
-		
-		# altri
-		[['em','code','strong','hr','span','dl','dd','dt'], attrs]
-	].each do |el, a| [*el].each do |e| HTML4Attributes[e] = a end end
-		
-		
-	def create_html_element(name, attributes_to_copy=[])
-		m = Element.new name
-			if atts = HTML4Attributes[name] then 
-				atts.each do |att|
-					if v = @attributes[att] then 
-						m.attributes[att.to_s] = v.to_s 
-					end
-				end
-			else
-			#	puts "not atts for #{name.inspect}"
-			end
-		m
-	end
-
-	
-	def to_html_ul
-		if @attributes[:toc]
-			# render toc
-			html_toc = @doc.toc.to_html
-			return html_toc
-		else
-			add_ws  wrap_as_element('ul')               
-		end
-	end
-	
-	
-	def to_html_paragraph; add_ws wrap_as_element('p')                end
-	def to_html_ol;        add_ws wrap_as_element('ol')        end
-	def to_html_li;        add_ws wrap_as_element('li')        end
-	def to_html_li_span;   add_ws wrap_as_element('li')        end
-	def to_html_quote;     add_ws wrap_as_element('blockquote')  end
-	def to_html_strong;    wrap_as_element('strong')           end
-	def to_html_emphasis;  wrap_as_element('em')               end
-
-=begin maruku_doc
-Attribute: use_numbered_headers
-Scope: document
-Summary: Activates the numbering of headers.
-
-If `true`, section headers will be numbered.
-
-In LaTeX export, the numbering of headers is managed
-by Maruku, to have the same results in both HTML and LaTeX.
-=end
-
-	# nil if not applicable, else string
-	def section_number
-		return nil if not get_setting(:use_numbered_headers)
-		
-		n = @attributes[:section_number]
-		if n && (not n.empty?)
-			 n.join('.')+". "
-		else
-			nil
-		end
-	end
-	
-	# nil if not applicable, else SPAN element
-	def render_section_number
-		# if we are bound to a section, add section number
-		if num = section_number
-			span = Element.new 'span'
-			span.attributes['class'] = 'maruku_section_number'
-			span << Text.new(section_number)
-			span
-		else
-			nil
-		end
-	end
-	
-	def to_html_header
-		element_name = "h#{self.level}" 
-		h = wrap_as_element element_name
-		
-		if span = render_section_number
-			h.insert_before(h.children.first, span)
-		end
-		add_ws h
-	end
-
-	def source2html(source)
-#		source = source.gsub(/&/,'&amp;')
-		source = Text.normalize(source)
-		source = source.gsub(/\&apos;/,'&#39;') # IE bug
-		source = source.gsub(/'/,'&#39;') # IE bug
-		Text.new(source, true, nil, true )
-	end
-		
-=begin maruku_doc
-Attribute: html_use_syntax
-Scope: global, document, element
-Output: HTML
-Summary: Enables the use of the `syntax` package.
-Related: lang, code_lang
-Default: <?mrk md_code(Globals[:html_use_syntax].to_s) ?>
-
-If true, the `syntax` package is used. It supports the `ruby` and `xml`
-languages. Remember to set the `lang` attribute of the code block.
-
-Examples:
-
-		require 'maruku'
-	{:lang=ruby html_use_syntax=true}
-
-and 
-	
-		<div style="text-align:center">Div</div>
-	{:lang=html html_use_syntax=true}
-
-produces:
-
-	require 'maruku'
-{:lang=ruby html_use_syntax=true}
-
-and
-
-	<div style="text-align:center">Div</div>
-{:lang=html html_use_syntax=true}
-
-=end
-
-	$syntax_loaded = false
-	def to_html_code; 
-		source = self.raw_code
-
-		lang = self.attributes[:lang] || @doc.attributes[:code_lang] 
-
-		lang = 'xml' if lang=='html'
-
-		use_syntax = get_setting :html_use_syntax
-		
-		element = 
-		if use_syntax && lang
-			begin
-				if not $syntax_loaded
-					require 'rubygems'
-					require 'syntax'
-					require 'syntax/convertors/html'
-					$syntax_loaded = true
-				end
-				convertor = Syntax::Convertors::HTML.for_syntax lang
-				
-				# eliminate trailing newlines otherwise Syntax crashes
-				source = source.gsub(/\n*\Z/,'')
-				
-				html = convertor.convert( source )
-				html = html.gsub(/\&apos;/,'&#39;') # IE bug
-				html = html.gsub(/'/,'&#39;') # IE bug
-	#			html = html.gsub(/&/,'&amp;') 
-				
-				code = Document.new(html, {:respect_whitespace =>:all}).root
-				code.name = 'code'
-				code.attributes['class'] = lang
-				code.attributes['lang'] = lang
-				
-				pre = Element.new 'pre'
-				pre << code
-				pre
-			rescue LoadError => e
-				maruku_error "Could not load package 'syntax'.\n"+
-					"Please install it, for example using 'gem install syntax'."
-				to_html_code_using_pre(source)	
-			rescue Object => e
-				maruku_error"Error while using the syntax library for code:\n#{source.inspect}"+
-				 "Lang is #{lang} object is: \n"+
-				  self.inspect + 
-				"\nException: #{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
-				
-				tell_user("Using normal PRE because the syntax library did not work.")
-				to_html_code_using_pre(source)
-			end
-		else
-			to_html_code_using_pre(source)
-		end
-		
-		color = get_setting(:code_background_color)
-		if color != Globals[:code_background_color]
-			element.attributes['style'] = "background-color: #{color};"
-		end
-		add_ws element
-	end
-	
-=begin maruku_doc
-Attribute: code_background_color
-Scope: global, document, element
-Summary: Background color for code blocks.
-
-The format is either a named color (`green`, `red`) or a CSS color
-of the form `#ff00ff`. 
-
-* for **HTML output**, the value is put straight in the `background-color` CSS 
-  property of the block.
-
-* for **LaTeX output**, if it is a named color, it must be a color accepted
-  by the LaTeX `color` packages. If it is of the form `#ff00ff`, Maruku
-  defines a color using the `\color[rgb]{r,g,b}` macro. 
-
-  For example, for `#0000ff`, the macro is called as: `\color[rgb]{0,0,1}`.
-
-=end
-	
-	
-	def to_html_code_using_pre(source)
-		pre = create_html_element  'pre'
-		code = Element.new 'code', pre
-		s = source
-		
-#		s  = s.gsub(/&/,'&amp;')
-		s = Text.normalize(s)
-		s  = s.gsub(/\&apos;/,'&#39;') # IE bug
-		s  = s.gsub(/'/,'&#39;') # IE bug
-
-		if get_setting(:code_show_spaces) 
-			# 187 = raquo
-			# 160 = nbsp
-			# 172 = not
-			s.gsub!(/\t/,'&#187;'+'&#160;'*3)
-			s.gsub!(/ /,'&#172;')
-		end
-
-		text = Text.new(s, respect_ws=true, parent=nil, raw=true )
-		
-		if lang = self.attributes[:lang]
-			code.attributes['lang'] = lang
-			code.attributes['class'] = lang
-		end
-		code << text
-		pre
-	end
-
-	def to_html_inline_code; 
-		pre =  create_html_element 'code'
-			source = self.raw_code
-			pre << source2html(source) 
-			
-			color = get_setting(:code_background_color)
-			if color != Globals[:code_background_color]
-				pre.attributes['style'] = "background-color: #{color};"+(pre.attributes['style']||"")
-			end
-			
-		pre
-	end
-
-	def add_class_to(el, cl)
-		el.attributes['class'] = 
-		if already = el.attributes['class']
-			already + " " + cl
-		else
-			cl
-		end
-	end
-
-	def add_class_to_link(a)
-		return # not ready yet
-		
-		# url = a.attributes['href']
-		# return if not url
-		# 
-		# if url =~ /^#/
-		# 	add_class_to(a, 'maruku-link-samedoc')
-		# elsif url =~ /^http:/
-		# 	add_class_to(a, 'maruku-link-external')
-		# else
-		# 	add_class_to(a, 'maruku-link-local')
-		# end
-		# 	
-#		puts a.attributes['class']
-	end
-	
-	
-	def to_html_immediate_link
-		a =  create_html_element 'a'
-		url = self.url
-		text = url.gsub(/^mailto:/,'') # don't show mailto
-		a << Text.new(text)
-		a.attributes['href'] = url
-		add_class_to_link(a)
-		a
-	end
-	
-	def to_html_link
-		a =  wrap_as_element 'a'
-		id = self.ref_id
-		
-		if ref = @doc.refs[id]
-			url = ref[:url]
-			title = ref[:title]
-			a.attributes['href'] = url if url
-			a.attributes['title'] = title if title
-		else
-			maruku_error "Could not find ref_id = #{id.inspect} for #{self.inspect}\n"+
-				"Available refs are #{@doc.refs.keys.inspect}"
-			tell_user "Not creating a link for ref_id = #{id.inspect}."
-			return wrap_as_element('span')
-		end
-
-#		add_class_to_link(a)
-		return a
-	end
-	
-	def to_html_im_link
-		if url = self.url
-			title = self.title
-			a =  wrap_as_element 'a'
-			a.attributes['href'] = url
-			a.attributes['title'] = title if title
-			return a
-		else
-			maruku_error"Could not find url in #{self.inspect}"
-			tell_user "Not creating a link for ref_id = #{id.inspect}."
-			return wrap_as_element('span')
-		end
-	end
-	
-	def add_ws(e)
-		[Text.new("\n"), e, Text.new("\n")]
-	end
-##### Email address
-	
-	def obfuscate(s)
-		res = ''
-		s.each_byte do |char|
-			res +=  "&#%03d;" % char
-		end
-		res
-	end
-	
-	def to_html_email_address
-		email = self.email
-		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))
-			# Sorry, for the moment it doesn't work
-			a.attributes['href'] = "mailto:#{email}"
-			
-			a << Text.new(obfuscate(email),false,nil,true)
-		a
-	end
-
-##### Images
-
-	def to_html_image
-		a =  create_html_element 'img'
-		id = self.ref_id
-		if ref = @doc.refs[id]
-			url = ref[:url]
-			title = ref[:title]
-			a.attributes['src'] = url.to_s
-			a.attributes['alt'] = children_to_s 
-		else
-			maruku_error"Could not find id = #{id.inspect} for\n #{self.inspect}"
-			tell_user "Could not create image with ref_id = #{id.inspect};"+
-				 " Using SPAN element as replacement."
-				return wrap_as_element('span')
-		end
-		return a
-	end
-	
-	def to_html_im_image
-		if not url = self.url
-			maruku_error "Image with no url: #{self.inspect}"
-			tell_user "Could not create image with ref_id = #{id.inspect};"+
-				" Using SPAN element as replacement."
-			return wrap_as_element('span')
-		end
-		title = self.title
-		a =  create_html_element 'img'
-			a.attributes['src'] = url.to_s
-			a.attributes['alt'] = children_to_s 
-		return a
-	end
-
-=begin maruku_doc
-Attribute: filter_html
-Scope: document
-
-If true, raw HTML is discarded from the output.
-
-=end
-
-	def to_html_raw_html
-		return [] if get_setting(:filter_html)
-		
-		raw_html = self.raw_html
-		if rexml_doc = @parsed_html
-			root = rexml_doc.root
-			if root.nil?
-				s = "Bug in REXML: root() of Document is nil: \n#{rexml_doc.inspect}\n"+
-				"Raw HTML:\n#{raw_html.inspect}"
-				maruku_error s
-				tell_user 'The REXML version you have has a bug, omitting HTML'
-				div = Element.new 'div'
-				#div << Text.new(s)
-				return div
-			end
-			
-			# copies the @children array (FIXME is it deep?)
-			elements =  root.to_a 
-			return elements
-		else # invalid
-			# Creates red box with offending HTML
-			tell_user "Wrapping bad html in a PRE with class 'markdown-html-error'\n"+
-				add_tabs(raw_html,1,'|')
-			pre = Element.new('pre')
-			pre.attributes['style'] = 'border: solid 3px red; background-color: pink'
-			pre.attributes['class'] = 'markdown-html-error'
-			pre << Text.new("REXML could not parse this XML/HTML: \n#{raw_html}", true)
-			return pre
-		end
-	end
-
-	def to_html_abbr
-		abbr = Element.new 'abbr'
-		abbr << Text.new(children[0])
-		abbr.attributes['title'] = self.title if self.title
-		abbr
-	end
-	
-	def to_html_footnote_reference
-		id = self.footnote_id
-		
-		# save the order of used footnotes
-		order = @doc.footnotes_order
-		
-		if order.include? id
-		  # footnote has already been used
-		  return []
-	  end
-	  
-	  if not @doc.footnotes[id]
-	    return []
-    end
-	  
-		# take next number
-		order << id
-		
-		#num = order.size; 
-		num = order.index(id) + 1
-		  
-		sup = Element.new 'sup'
-		sup.attributes['id'] = "#{get_setting(:doc_prefix)}fnref:#{num}"
-			a = Element.new 'a'
-			a << Text.new(num.to_s)
-			a.attributes['href'] = "\##{get_setting(:doc_prefix)}fn:#{num}"
-			a.attributes['rel'] = 'footnote'
-		sup << a
-			
-		sup
-	end
-	
-## Definition lists ###
-	def to_html_definition_list() add_ws wrap_as_element('dl') end
-	def to_html_definition() children_to_html end
-	def to_html_definition_term() add_ws wrap_as_element('dt') end
-	def to_html_definition_data() add_ws wrap_as_element('dd') end	
-
-	# FIXME: Ugly code
-	def to_html_table
-		align = self.align
-		num_columns = align.size
-
-		head = @children.slice(0, num_columns)
-		rows = []
-		i = num_columns
-		while i<@children.size
-			rows << @children.slice(i, num_columns)
-			i += num_columns
-		end
-		
-		table = create_html_element 'table'
-			thead = Element.new 'thead'
-			tr = Element.new 'tr'
-				array_to_html(head).each do |x| tr<<x end
-			thead << tr
-			table << thead
-			
-			tbody = Element.new 'tbody'
-			rows.each do |row|
-				tr = Element.new 'tr'
-					array_to_html(row).each_with_index do |x,i| 
-						x.attributes['style'] ="text-align: #{align[i].to_s};" 
-						tr<<x 
-					end
-						
-				tbody << tr << Text.new("\n")
-			end
-			table << tbody
-		table
-	end
-	
-	def to_html_head_cell; wrap_as_element('th') end
-	def to_html_cell
-		if @attributes[:scope]
-			wrap_as_element('th', [:scope])
-		else
-			wrap_as_element('td')
-		end
- 	end
-	
-	def to_html_entity 
-		MaRuKu::Out::Latex.need_entity_table
-      
-		entity_name = self.entity_name
-		
-		if (e = MaRuKu::Out::Latex::ENTITY_TABLE[entity_name]) && e.html_num
-			entity_name = e.html_num
-		end
-		
-		# Fix for Internet Explorer
-		if entity_name == 'apos'
-			entity_name = 39
-		end
-
-		
-		if entity_name.kind_of? Fixnum
-#			Entity.new(entity_name)
-			Text.new('&#%d;' % [entity_name],  false, nil, true)
-		else
-			Text.new('&%s;' % [entity_name],  false, nil, true)
-		end
-	end
-
-	def to_html_xml_instr
-		target = self.target || ''
-		code = self.code || ''
-		REXML::Instruction.new(target, code)
-	end
-
-	# Convert each child to html
-	def children_to_html
-		array_to_html(@children)
-	end
-
-	def array_to_html(array)
-		e = []
-		array.each do |c|
-			method = c.kind_of?(MDElement) ? 
-			   "to_html_#{c.node_type}" : "to_html"
-
-			if not c.respond_to?(method)
-				#raise "Object does not answer to #{method}: #{c.class} #{c.inspect}"
-				next
-			end
-
-			h =  c.send(method)
-
-			if h.nil?
-				raise "Nil html created by method  #{method}:\n#{h.inspect}\n"+
-				" for object #{c.inspect[0,300]}"
-			end
-
-			if h.kind_of?Array
-				e = e + h #h.each do |hh| e << hh end
-			else
-				e << h
-			end
-		end
-		e
-	end
-
-	def to_html_ref_definition; [] end
-	def to_latex_ref_definition; [] end
-
-end # HTML
-end # out
-end # MaRuKu
+
+  # Render to a complete HTML document (returns a string)
+  def to_html_document(context={})
+    doc = to_html_document_tree
+
+    xml = doc.to_s
+    Xhtml11_mathml2_svg11 + xml
+  end
+
+  # Helper to create a text node
+  def xtext(text)
+    MaRuKu::Out::HTML.escapeHTML(text)
+  end
+
+  # Helper to create an element
+  def xelem(type)
+    HTMLElement.new(type)
+  end
+
+  def xml_newline
+    "\n"
+  end
+
+  #=begin maruku_doc
+  # Attribute: title
+  # Scope: document
+  #
+  # Sets the title of the document.
+  # If a title is not specified, the first header will be used.
+  #
+  # These should be equivalent:
+  #
+  #   Title: my document
+  #
+  #   Content
+  #
+  # and
+  #
+  #   my document
+  #   ===========
+  #
+  #   Content
+  #
+  # In both cases, the title is set to "my document".
+  #=end
+
+  #=begin maruku_doc
+  # Attribute: doc_prefix
+  # Scope: document
+  #
+  # String to disambiguate footnote links.
+  #=end
+
+
+  #=begin maruku_doc
+  # Attribute: subject
+  # Scope: document
+
+  # Synonym for `title`.
+  #=end
+
+  #=begin maruku_doc
+  # Attribute: css
+  # Scope: document
+  # Output: HTML
+  # Summary: Activates CSS stylesheets for HTML.
+  #
+  # `css` should be a space-separated list of urls.
+  #
+  # Example:
+  #
+  #   CSS: style.css math.css
+  #
+  #=end
+
+  # Render to a complete HTML document (returns an HTMLElement document tree)
+  def to_html_document_tree
+    root = xelem('html')
+    root['xmlns'] = 'http://www.w3.org/1999/xhtml'
+    root['xmlns:svg'] = "http://www.w3.org/2000/svg"
+    root['xml:lang'] = self.attributes[:lang] || 'en'
+
+    root << xml_newline
+    head = xelem('head')
+    root << head
+
+    #<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
+    me = xelem('meta')
+    me['http-equiv'] = 'Content-type'
+    me['content'] = 'application/xhtml+xml;charset=utf-8'
+    head << me
+
+    %w(description keywords author revised).each do |m|
+      if value = self.attributes[m.to_sym]
+        meta = xelem('meta')
+        meta['name'] = m
+        meta['content'] = value.to_s
+        head << meta
+      end
+    end
+
+    self.attributes.each do |k,v|
+      if k.to_s =~ /\Ameta-(.*)\z/
+        meta = xelem('meta')
+        meta['name'] = $1
+        meta['content'] = v.to_s
+        head << meta
+      end
+    end
+
+    # Create title element
+    doc_title = self.attributes[:title] || self.attributes[:subject] || ""
+    begin
+      title_content = MaRuKu::HTMLFragment.new(doc_title).to_html
+    rescue
+      title_content = xtext(doc_title)
+    end
+    title = xelem('title') << title_content
+    head << title
+    add_css_to(head)
+
+    root << xml_newline
+
+    body = xelem('body')
+
+    children_to_html.each do |e|
+      body << e.to_s
+    end
+
+    # render footnotes
+    unless @doc.footnotes_order.empty?
+      body << render_footnotes
+    end
+
+    # When we are rendering a whole document, we add a signature
+    # at the bottom.
+    if get_setting(:maruku_signature)
+      body << maruku_html_signature
+    end
+
+    root << body
+  end
+
+  def add_css_to(head)
+    if css_list = self.attributes[:css]
+      css_list.split.each do |css|
+        # <link type="text/css" rel="stylesheet" href="..." />
+        link = xelem('link')
+        link['type'] = 'text/css'
+        link['rel'] = 'stylesheet'
+        link['href'] = css
+        head << link << xml_newline
+      end
+    end
+  end
+
+  # returns "st","nd","rd" or "th" as appropriate
+  def day_suffix(day)
+    s = {
+      1 => 'st',
+      2 => 'nd',
+      3 => 'rd',
+      21 => 'st',
+      22 => 'nd',
+      23 => 'rd',
+      31 => 'st'
+    }
+    s[day] || 'th';
+  end
+
+  # formats a nice date
+  def nice_date
+    Time.now.strftime(" at %H:%M on %A, %B %d") +
+      day_suffix(t.day) +
+      t.strftime(", %Y")
+  end
+
+  def maruku_html_signature
+    div = xelem('div')
+    div['class'] = 'maruku_signature'
+    div << xelem('hr')
+    span = xelem('span')
+    span['style'] = 'font-size: small; font-style: italic'
+    div << span << xtext('Created by ')
+    a = xelem('a')
+    a['href'] = MaRuKu::MARUKU_URL
+    a['title'] = 'Maruku: a Markdown-superset interpreter for Ruby'
+    a << xtext('Maruku')
+    span << xtext(nice_date + ".")
+    div
+  end
+
+  def render_footnotes
+    div = xelem('div')
+    div['class'] = 'footnotes'
+    div << xelem('hr')
+    ol = xelem('ol')
+
+    @doc.footnotes_order.each_with_index do |fid, i|
+      num = i + 1
+      if f = self.footnotes[fid]
+        li = f.wrap_as_element('li')
+        li['id'] = "#{get_setting(:doc_prefix)}fn:#{num}"
+
+        a = xelem('a')
+        a['href'] = "\##{get_setting(:doc_prefix)}fnref:#{num}"
+        a['rev'] = 'footnote'
+        a << xtext([8617].pack('U*'))
+
+        last = nil
+        li.children.reverse_each do |child|
+          if child.is_a?(HTMLElement)
+            last = child
+            break
+          end
+        end
+
+        if last && last.name == "p"
+          last << xtext(' ') << a
+        else
+          li.children << a
+        end
+        ol << li
+      else
+        maruku_error "Could not find footnote id '#{fid}' among [#{self.footnotes.keys.inspect}]."
+      end
+    end
+
+    div << ol
+  end
+
+  def to_html_hrule
+    xelem('hr')
+  end
+
+  def to_html_linebreak
+    xelem('br')
+  end
+
+  # renders children as html and wraps into an element of given name
+  #
+  # Sets 'id' if meta is set
+  def wrap_as_element(name, attributes={})
+    html_element name, children_to_html, attributes
+  end
+
+  #=begin maruku_doc
+  # Attribute: id
+  # Scope: element
+  # Output: LaTeX, HTML
+  #
+  # It is copied as a standard HTML attribute.
+  #
+  # Moreover, it used as a label name for hyperlinks in both HTML and
+  # in PDF.
+  #=end
+
+  #=begin maruku_doc
+  # Attribute: class
+  # Scope: element
+  # Output: HTML
+  #
+  # It is copied as a standard HTML attribute.
+  #=end
+
+  #=begin maruku_doc
+  # Attribute: style
+  # Scope: element
+  # Output: HTML
+  #
+  # It is copied as a standard HTML attribute.
+  #=end
+
+  HTML4Attributes = {}
+
+  coreattrs = [:id, :class, :style, :title, :accesskey, :contenteditable, :dir,
+               :draggable, :spellcheck, :tabindex]
+  i18n = [:lang, :'xml:lang']
+  events = [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover,
+            :onmousemove, :onmouseout,
+            :onkeypress, :onkeydown, :onkeyup]
+  common_attrs = coreattrs + i18n + events
+  cells = [:align, :char, :charoff, :valign]
+
+  # Each row maps a list of tags to the list of attributes beyond the common_attributes
+  # that are valid on those elements
+  [
+   ['body', [:onload, :onunload]],
+   ['a', [:charset, :type, :name, :rel, :rev, :accesskey, :shape, :coords, :tabindex,
+          :onfocus,:onblur]],
+   ['img', [:longdesc, :name, :height, :width, :alt]],
+   ['ol', [:reversed, :start]],
+   ['li', [:value]],
+   ['table', [:summary, :width, :frame, :rules, :border, :cellspacing, :cellpadding]],
+   [%w(q blockquote), [:cite]],
+   [%w(ins del), [:cite, :datetime]],
+   [%w(colgroup col), [:span, :width] + cells],
+   [%w(thead tbody tfoot), cells],
+   [%w(td td th), [:abbr, :axis, :headers, :scope, :rowspan, :colspan] + cells],
+   [%w(em code strong hr span dl dd dt address div p pre caption ul h1 h2 h3 h4 h5 h6), []]
+  ].each do |elements, attributes|
+    [*elements].each do |element|
+      HTML4Attributes[element] = common_attrs + attributes
+    end
+  end
+
+  # Pretty much the same as the HTMLElement constructor except it
+  # copies standard attributes out of the Maruku Element's attributes hash.
+  def html_element(name, content="", attributes={})
+    attributes = content if attributes.empty? && content.is_a?(Hash)
+
+    Array(HTML4Attributes[name]).each do |att|
+      if v = @attributes[att]
+        attributes[att.to_s] = MaRuKu::Out::HTML.escapeHTML(v.to_s)
+      end
+    end
+
+    content = yield if block_given?
+
+    HTMLElement.new(name, attributes, content)
+  end
+
+  def to_html_ul
+    if @attributes[:toc]
+      # render toc
+      @doc.toc.to_html
+    else
+      add_ws wrap_as_element('ul')
+    end
+  end
+
+  def to_html_paragraph
+    add_ws wrap_as_element('p')
+  end
+
+  def to_html_ol
+    add_ws wrap_as_element('ol')
+  end
+
+  def to_html_li
+    add_ws wrap_as_element('li')
+  end
+
+  def to_html_quote
+    add_ws wrap_as_element('blockquote')
+  end
+
+  def to_html_strong
+    wrap_as_element('strong')
+  end
+
+  def to_html_emphasis
+    wrap_as_element('em')
+  end
+
+  #=begin maruku_doc
+  # Attribute: use_numbered_headers
+  # Scope: document
+  # Summary: Activates the numbering of headers.
+  #
+  # If `true`, section headers will be numbered.
+  #
+  # In LaTeX export, the numbering of headers is managed
+  # by Maruku, to have the same results in both HTML and LaTeX.
+  #=end
+
+  # nil if not applicable, else string
+  def section_number
+    return nil unless get_setting(:use_numbered_headers)
+
+    n = Array(@attributes[:section_number])
+    return nil if n.empty?
+
+    n.join('.') + ". "
+  end
+
+  # nil if not applicable, else SPAN element
+  def render_section_number
+    return nil unless section_number && !section_number.empty?
+
+    # if we are bound to a section, add section number
+    span = xelem('span')
+    span['class'] = 'maruku_section_number'
+    span << xtext(section_number)
+  end
+
+  def to_html_header
+    element_name = "h#{self.level}"
+    h = wrap_as_element element_name
+
+    if span = render_section_number
+      h.children.unshift(span)
+    end
+
+    add_ws h
+  end
+
+  #=begin maruku_doc
+  # Attribute: html_use_syntax
+  # Scope: global, document, element
+  # Output: HTML
+  # Summary: Enables the use of the `syntax` package.
+  # Related: lang, code_lang
+  # Default: <?mrk md_code(Globals[:html_use_syntax].to_s) ?>
+  #
+  # If true, the `syntax` package is used. It supports the `ruby` and `xml`
+  # languages. Remember to set the `lang` attribute of the code block.
+  #
+  # Examples:
+  #
+  #     require 'maruku'
+  #   {:lang=ruby html_use_syntax=true}
+  #
+  # and
+  #
+  #     <div style="text-align:center">Div</div>
+  #   {:lang=html html_use_syntax=true}
+  #
+  # produces:
+  #
+  #   require 'maruku'
+  # {:lang=ruby html_use_syntax=true}
+  #
+  # and
+  #
+  #   <div style="text-align:center">Div</div>
+  # {:lang=html html_use_syntax=true}
+  #
+  #=end
+
+  $syntax_loaded = false
+  def to_html_code
+    source = self.raw_code
+
+    code_lang = self.lang || self.attributes[:lang] || @doc.attributes[:code_lang]
+
+    code_lang = 'xml' if code_lang == 'html'
+    code_lang = 'css21' if code_lang == 'css'
+
+    use_syntax = get_setting :html_use_syntax
+
+    element =
+      if use_syntax && code_lang
+        begin
+          unless $syntax_loaded
+            require 'rubygems'
+            require 'syntax'
+            require 'syntax/convertors/html'
+            $syntax_loaded = true
+          end
+          convertor = Syntax::Convertors::HTML.for_syntax code_lang
+
+          # eliminate trailing newlines otherwise Syntax crashes
+          source = source.sub(/\n*\z/, '')
+
+          html = convertor.convert(source)
+
+          html.gsub!(/\&apos;|'/,'&#39;') # IE bug
+
+          d = MaRuKu::HTMLFragment.new(html)
+          highlighted = d.to_html.sub(/\A<pre>(.*)<\/pre>\z/m, '\1')
+          code = HTMLElement.new('code', { :class => code_lang }, highlighted)
+
+          pre = xelem('pre')
+          # add a class here, too, for compatibility with existing implementations
+          pre['class'] = code_lang
+          pre << code
+          pre
+        rescue LoadError => e
+          maruku_error "Could not load package 'syntax'.\n" +
+            "Please install it, for example using 'gem install syntax'."
+          to_html_code_using_pre(source, code_lang)
+        rescue => e
+          maruku_error "Error while using the syntax library for code:\n#{source.inspect}" +
+            "Lang is #{code_lang} object is: \n" +
+            self.inspect +
+            "\nException: #{e.class}: #{e.message}"
+
+          tell_user("Using normal PRE because the syntax library did not work.")
+          to_html_code_using_pre(source, code_lang)
+        end
+      else
+        to_html_code_using_pre(source, code_lang)
+      end
+
+    color = get_setting(:code_background_color)
+    if color != MaRuKu::Globals[:code_background_color]
+      element['style'] = "background-color: #{color};"
+    end
+
+    add_ws element
+  end
+
+  #=begin maruku_doc
+  # Attribute: code_background_color
+  # Scope: global, document, element
+  # Summary: Background color for code blocks.
+  #
+  # The format is either a named color (`green`, `red`) or a CSS color
+  # of the form `#ff00ff`.
+  #
+  # * for **HTML output**, the value is put straight in the `background-color` CSS
+  #   property of the block.
+  #
+  # * for **LaTeX output**, if it is a named color, it must be a color accepted
+  #   by the LaTeX `color` packages. If it is of the form `#ff00ff`, Maruku
+  #   defines a color using the `\color[rgb]{r,g,b}` macro.
+  #
+  #   For example, for `#0000ff`, the macro is called as: `\color[rgb]{0,0,1}`.
+  #=end
+
+
+  def to_html_code_using_pre(source, code_lang=nil)
+    code = xelem('code')
+    pre = xelem('pre')
+    pre << code
+
+    if get_setting(:code_show_spaces)
+      # 187 = raquo
+      # 160 = nbsp
+      # 172 = not
+      source = source.gsub(/\t/,'&#187;' + '&#160;' * 3).gsub(/ /,'&#172;')
+    end
+
+    code << xtext(source)
+
+    code_lang ||= self.attributes[:lang]
+    if code_lang
+      pre['class'] = code['class'] = code_lang
+    end
+
+    pre
+  end
+
+  def to_html_inline_code
+    code_attrs = {}
+    source = xtext(self.raw_code)
+
+    color = get_setting(:code_background_color)
+    if color != MaRuKu::Globals[:code_background_color]
+      code_attrs['style'] = "background-color: #{color};" + (code_attrs['style'] || "")
+    end
+
+    html_element('code', source, code_attrs)
+  end
+
+  def add_class_to(el, cl)
+    el['class'] =
+      if already = el['class']
+        already + " " + cl
+      else
+        cl
+      end
+  end
+
+  def to_html_immediate_link
+    text = self.url.gsub(/^mailto:/, '') # don't show mailto
+    html_element('a', text, 'href' => self.url)
+  end
+
+  def to_html_link
+    a = {}
+    id = self.ref_id || children_to_s
+
+    if ref = @doc.refs[sanitize_ref_id(id)] || @doc.refs[sanitize_ref_id(children_to_s)]
+      a['href'] = ref[:url] if ref[:url]
+      a['title'] = ref[:title] if ref[:title]
+    else
+      maruku_error "Could not find ref_id = #{id.inspect} for #{self.inspect}\n" +
+        "Available refs are #{@doc.refs.keys.inspect}"
+      tell_user "Not creating a link for ref_id = #{id.inspect}.\n"
+      if (self.ref_id)
+        return "[#{children_to_s}][#{id}]"
+      else
+        return "[#{children_to_s}]"
+      end
+    end
+
+    wrap_as_element('a', a)
+  end
+
+  def to_html_im_link
+    if self.url
+      a = {}
+      a['href'] = self.url
+      a['title'] = self.title if self.title
+      wrap_as_element('a', a)
+    else
+      maruku_error "Could not find url in #{self.inspect}"
+      tell_user "Not creating a link for ref_id = #{id.inspect}."
+      wrap_as_element('span')
+    end
+  end
+
+  def add_ws(e)
+    [xml_newline, e, xml_newline]
+  end
+
+  ##### Email address
+
+  def obfuscate(s)
+    s.bytes.inject('') do |res, char|
+      res << "&#%03d;" % char
+    end
+  end
+
+  def to_html_email_address
+    obfuscated = obfuscate(self.email)
+    html_element('a', obfuscated, :href => "mailto:#{obfuscated}")
+  end
+
+  ##### Images
+
+  def to_html_image
+    a = {}
+    id = self.ref_id
+    if ref = @doc.refs[sanitize_ref_id(id)] || @doc.refs[sanitize_ref_id(children_to_s)]
+      a['src'] = ref[:url].to_s
+      a['alt'] = children_to_s
+      a['title'] = ref[:title].to_s if ref[:title]
+      html_element('img', nil, a)
+    else
+      maruku_error "Could not find id = #{id.inspect} for\n #{self.inspect}"
+      tell_user "Could not create image with ref_id = #{id.inspect};" +
+        " Using SPAN element as replacement."
+      wrap_as_element('span')
+    end
+  end
+
+  def to_html_im_image
+    if self.url
+      attrs = {}
+      attrs['src'] = self.url.to_s
+      attrs['alt'] = children_to_s
+      attrs['title'] = self.title.to_s if self.title
+      html_element('img', nil, attrs)
+    else
+      maruku_error "Image with no url: #{self.inspect}"
+      tell_user "Could not create image without a source URL;" +
+        " Using SPAN element as replacement."
+      wrap_as_element('span')
+    end
+  end
+
+  #=begin maruku_doc
+  # Attribute: filter_html
+  # Scope: document
+  #
+  # If true, raw HTML is discarded from the output.
+  #
+  #=end
+
+  def to_html_raw_html
+    return [] if get_setting(:filter_html)
+    return parsed_html.to_html if parsed_html
+
+    # If there's no parsed HTML
+    raw_html = self.raw_html
+
+    # Creates red box with offending HTML
+    tell_user "Wrapping bad html in a PRE with class 'markdown-html-error'\n" +
+      raw_html.gsub(/^/, '|')
+    pre = xelem('pre')
+    pre['style'] = 'border: solid 3px red; background-color: pink'
+    pre['class'] = 'markdown-html-error'
+    pre << xtext("Maruku could not parse this XML/HTML: \n#{raw_html}")
+  end
+
+  def to_html_abbr
+    abbr = xelem('abbr')
+    abbr << xtext(children[0])
+    abbr['title'] = self.title if self.title
+    abbr
+  end
+
+  def to_html_footnote_reference
+    id = self.footnote_id
+
+    # save the order of used footnotes
+    order = @doc.footnotes_order
+
+    # footnote has already been used
+    return [] if order.include?(id)
+
+    return [] unless @doc.footnotes[id]
+
+    # take next number
+    order << id
+
+    num = order.index(id) + 1
+
+    sup = xelem('sup')
+    sup['id'] = "#{get_setting(:doc_prefix)}fnref:#{num}"
+    a = xelem('a')
+    a << xtext(num.to_s)
+    a['href'] = "\##{get_setting(:doc_prefix)}fn:#{num}"
+    a['rel'] = 'footnote'
+    sup << a
+  end
+
+  ## Definition lists ###
+  def to_html_definition_list
+    add_ws wrap_as_element('dl')
+  end
+
+  def to_html_definition
+    children_to_html
+  end
+
+  def to_html_definition_term
+    add_ws wrap_as_element('dt')
+  end
+
+  def to_html_definition_data
+    add_ws wrap_as_element('dd')
+  end
+
+  def to_html_table
+    num_columns = self.align.size
+
+    # The table data is passed as a multi-dimensional array
+    # we just need to split the head from the body
+    head, *rows = @children
+
+    table = html_element('table')
+    thead = xelem('thead')
+    tr = xelem('tr')
+    array_to_html(head).inject(tr, &:<<)
+    thead << tr
+    table << thead
+
+    tbody = xelem('tbody')
+    rows.each do |row|
+      tr = xelem('tr')
+      array_to_html(row).each_with_index do |x, i|
+        x['style'] ="text-align: #{self.align[i].to_s};"
+        tr << x
+      end
+
+      tbody << tr << xml_newline
+    end
+
+    table << tbody
+  end
+
+  def to_html_head_cell
+    wrap_as_element('th')
+  end
+
+  def to_html_cell
+    if @attributes[:scope]
+      wrap_as_element('th')
+    else
+      wrap_as_element('td')
+    end
+  end
+
+  def to_html_entity
+    entity_name = self.entity_name
+
+    if entity = MaRuKu::Out::EntityTable.instance.entity(entity_name)
+      entity_name = entity.html_num
+    end
+
+    if entity_name.kind_of? Integer
+      # Convert numeric entities to unicode characters
+      xtext([entity_name].pack('U*'))
+    else
+      "&#{entity_name};"
+    end
+  end
+
+  def to_html_xml_instr
+    target = self.target || ''
+    code = self.code || ''
+
+    # A blank target is invalid XML. Just create a text node?
+    if target.empty?
+      xtext("<?#{code}?>")
+    else
+      "<?#{target} #{code}?>"
+    end
+  end
+
+  # Convert each child to html
+  def children_to_html
+    array_to_html(@children)
+  end
+
+  def array_to_html(array)
+    e = []
+    array.each do |c|
+      if c.kind_of?(String)
+        e << xtext(c)
+      else
+        if c.kind_of?(HTMLElement)
+          e << c
+          next
+        end
+
+        method = c.kind_of?(MaRuKu::MDElement) ? "to_html_#{c.node_type}" : "to_html"
+        next unless c.respond_to?(method)
+
+        h = c.send(method)
+
+        unless h
+          raise "Nil html created by method  #{method}:\n#{h.inspect}\n" +
+            " for object #{c.inspect[0,300]}"
+        end
+
+        if h.kind_of? Array
+          e.concat h
+        else
+          e << h
+        end
+      end
+    end
+    e
+  end
+
+  def to_html_ref_definition
+    []
+  end
+
+  def to_latex_ref_definition
+    []
+  end
+end