eggshell 0.8.3 → 1.0.0

data/lib/eggshell/bundles/basics.rb

@@ -1,293 +1,239 @@
-class Eggshell::Bundles::Basics
+module Eggshell::Bundles::Basic
 	BUNDLE_ID = 'basics'
 	EE = Eggshell::ExpressionEvaluator
+	BH = Eggshell::BlockHandler
+	MH = Eggshell::MacroHandler
+	FH = Eggshell::FormatHandler
 
 	def self.new_instance(proc, opts = nil)
-		BasicBlocks.new.set_processor(proc)
-		SectionBlocks.new.set_processor(proc)
-		InlineMacros.new.set_processor(proc)
-		BasicMacros.new.set_processor(proc)
-		ControlMacros.new.set_processor(proc)
+		TextBlocks.new.set_processor(proc, opts)
+		TableBlock.new.set_processor(proc, opts)
+		ListBlocks.new.set_processor(proc, opts)
+		SectionBlocks.new.set_processor(proc, opts)
+		
+		CoreMacros.new.set_processor(proc, opts)
+		ControlLoopMacros.new.set_processor(proc, opts)
+		
+		BasicFormatHandlers.new.set_processor(proc, opts)
 
-		proc.register_functions('', StdFunctions::FUNC_NAMES)
+		#proc.register_functions('', StdFunctions::FUNC_NAMES)
 		proc.register_functions('sprintf', Kernel)
 	end
 
-	# `table` block parameters:
-	# - `row.classes`: defaults to `['odd', 'even']`. The number of elements represents the number of cycles.
-	class BasicBlocks
-		include Eggshell::BlockHandler
-
-		CELL_ATTR_START = '!'
-		CELL_ATTR_END = '<!'
+	class TextBlocks
+		include BH
+		include BH::BlockParams
+		include BH::HtmlUtils
+		
+		# HTML tags that have end-block checks. any block starting with one of these tags will have
+		# its contents passed through until end of the tag (essentially, raw)
+		# @todo what else should be treated?
+		HTML_BLOCK = /^<(style|script|table|dl|select|textarea|\!--|\?)/
+		HTML_BLOCK_END = {
+			'<!--' => '-->',
+			'<?' => '\\?>'
+		}.freeze
+		
+		# For lines starting with only these tags, accept as-is
+		HTML_PASSTHRU = /^\s*<(\/?(html|head|meta|link|title|body|br|section|div|blockquote|p|pre))/
 
-		def set_processor(proc)
-			@proc = proc
-			@proc.register_block(self, *%w(table pre p bq div raw ol ul # - / | >))
+		def initialize
+			@block_types = ['p', 'bq', 'pre', 'div', 'raw', 'html_pass', 'html_block']
 		end
 
-		def start(name, line, buffer, indents = '', indent_level = 0)
-			set_block_params(name)
-			bp = @block_params[name]
-
-			if name == '#' || name == '-' || name == 'ol' || name == 'ul'
-				@type = :list
-				@lines = []
-				@lines << [line, indent_level, name == '#' ? 'ol' : 'ul'] if name == '#' || name == '-'
-				@indent_start = indent_level
-				return COLLECT
+		START_TEXT = /^(p|bq|pre|raw|div)[(.]/
+		
+		def can_handle(line)
+			match = START_TEXT.match(line)
+			if match
+				@block_type = match[1]
+				if @block_type == 'pre' || @block_type == 'raw'
+					return BH::COLLECT_RAW
+				else
+					return BH::COLLECT
+				end
 			end
-
-			if name == 'table' || name == '/' || name == '|'
-				@type = :table
-				@lines = []
-				@lines << line if name != 'table'
-				return COLLECT
+			
+			if line.match(HTML_PASSTHRU)
+				@block_type = 'html_pass'
+				return BH::DONE
 			end
+			
+			html = line.match(HTML_BLOCK)
+			if html
+				@block_type = 'html_block'
+
+				end_html = HTML_BLOCK_END["<#{html[1]}"]
+				end_html = "</#{html[1]}>$" if !end_html
+				if line.match(end_html)
+					return BH::DONE
+				end
 
-			if name == '>'
-				@type = :dt
-				@lines = [line.split('::', 2)]
-				return COLLECT
+				@end_html = end_html
+				return BH::COLLECT_RAW
 			end
 
-			# assume block text
-			@type = name
-			if line.index(name) == 0
-				line = line.lstrip
-			end
-			@lines = [@type == 'raw' ? @proc.expand_expr(line) : @proc.fmt_line(line)]
-			return @type == 'raw' ? COLLECT_RAW : COLLECT
+			return BH::RETRY
 		end
-
-		def collect(line, buff, indents = '', indent_level = 0)
-			line = '' if !line
-			ret = COLLECT
-			if @type == :list
-				ret = do_list(line, buff, indents, indent_level)
-			elsif @type == :table
-				ret = do_table(line, buff, indents, indent_level)
-			elsif @type == :dt
-				ret = do_dt(line, buff, indents, indent_level)
+		
+		def continue_with(line)
+			if @block_type == 'html_block'
+				done = line.match(@end_html)
+				if done
+					return BH::DONE
+				else
+					return BH::COLLECT
+				end
 			else
-				ret = do_default(line, buff, indents, indent_level)
+				if @block_type == 'pre' || @block_type == 'raw'
+					if line && line != ''
+						return BH::COLLECT
+					end
+				elsif line
+					if line == '' || line.match(HTML_PASSTHRU) != nil || line.match(HTML_BLOCK) != nil
+						return BH::RETRY
+					end
+					return BH::COLLECT
+				end
 			end
-			return ret
+
+			return BH::RETRY
 		end
 
-		def do_list(line, buff, indents = '', indent_level = 0)
-			ret = COLLECT
-			lstrip = line.lstrip
-			if line && (lstrip[0] == '#' || lstrip[0] == '-')
-				@lines << [line[1..-1].strip, indent_level+@indent_start, lstrip[0] == '#' ? 'ol' : 'ul']
-			else
-				# if non-empty line, reprocess this line but also process buffer
-				ret = (line && line != '') ? RETRY : DONE
-				order_stack = []
-				otype_stack = []
-				last = nil
-				@lines.each do |tuple|
-					line, indent, type = tuple
-					# normalize indent
-					indent -= @indent_start
-					if order_stack.length == 0
-						order_stack << "<#{type}>"
-						otype_stack << type
-					# @todo make sure that previous item was a list
-					# remove closing li to enclose sublist
-					elsif indent > (otype_stack.length-1) && order_stack.length > 0
-						last = order_stack[-1]
-						last = last[0...last.length-5]
-						order_stack[-1] = last
+		def process(type, args, lines, out, call_depth = 0)
+			buff = []
 
-						order_stack << "#{"\t"*indent}<#{type}>"
-						otype_stack << type
-					elsif indent < (otype_stack.length-1)
-						count = otype_stack.length - 1 - indent
-						while count > 0
-							ltype = otype_stack.pop	
-							order_stack << "#{"\t"*count}</#{ltype}>\n#{"\t"*(count-1)}</li>"
-							count -= 1
-						end
-					end
-					order_stack << "#{"\t"*indent}<li>#{@proc.fmt_line(line)}</li>"
+			if type == 'html_pass' || type == 'html_block'
+				out << @eggshell.expand_expr(lines.join("\n"))
+			else
+				tagname = type == 'bq' ? 'blockquote' : type
+				args = [] if !args
+				bp = get_block_params(type, args[0])
+				raw = type == 'pre' || type == 'raw'
+
+				line_break = raw ? '' : '<br />'
+				lines.each do |line|
+					str = line.is_a?(Eggshell::Line) ? line.to_s : line
+					str.chomp!
+					buff << str
 				end
 
-				# close nested lists
-				d = otype_stack.length
-				c = 1
-				otype_stack.each do |type|
-					ident = d - c
-					order_stack << "#{"\t" * ident}</#{type}>#{c == d ? '' : "</li>"}"
-					c += 1
+				# @todo don't call expand_expr if raw && args[0]['no_expand']?
+				buff = buff.join("#{line_break}\n")
+				buff = @eggshell.expand_formatting(buff) if !raw
+				buff = @eggshell.unescape(@eggshell.expand_expr(buff))
+				
+				if type != 'raw'
+					out << [create_tag(type, bp), buff, "</#{type}>"].join('')
+				else
+					out << buff
 				end
-				buff << order_stack.join("\n")
 			end
-			ret
 		end
+	end
 
-		def do_table(line, buff, indents = '', indent_level = 0)
-			ret = COLLECT
-			if line[0] == '|' || line[0] == '/'
-				@lines << line
-			else
-				ret = (line[0] != '\\' && line != '') ? RETRY : DONE
-				map = @block_params['table'] || {}
-				tbl_class = map['class'] || ''
-				tbl_style = map['style'] || ''
-				tbl_attrib = ''
-				if map['attribs'].is_a?(String)
-					tbl_attrib = map['attribs']
-				elsif map['attribs'].is_a?(Hash)
-					map['attribs'].each do |key,val|
-						tbl_attrib = "#{tbl_attrib} #{key}='#{val}'"
-					end
-				end
-				row_classes = map['row.classes']
-				row_classes = ['odd', 'even'] if !row_classes.is_a?(Array)
-
-				@proc.vars['t.row'] = 0
-				buff << "<table class='#{tbl_class}' style='#{tbl_style}'#{tbl_attrib}>"
-				cols = []
-				rows = 0
-				rc = 0
-				@lines.each do |line|
-					ccount = 0
-					if line[0] == '/' && rows == 0
-						cols = line[1..line.length].split('|')
-						buff << "<thead><tr class='#{map['head.class']}'>"
-						cols.each do |col|
-							buff << "\t#{fmt_cell(col, true, ccount)}"
-							ccount += 1
-						end
-						buff << '</tr></thead>'
-						buff << '<tbody>'
-					elsif line[0] == '/'
-						# implies footer
-						cols = line[1..line.length].split('|')
-						buff << "<tfoot><tr class='#{map['foot.class']}'>"
-						cols.each do |col|
-							buff << "\t#{fmt_cell(col, true, ccount)}"
-							ccount += 1
-						end
-						buff << '</tr></tfoot>'
-					elsif line[0] == '|' || line[0..1] == '|>'
-						idx = 1
-						sep = /(?<!\\)\|/
-						if line[1] == '>'
-							idx = 2
-							sep = /(?<!\\)\|\>/
-						end
-						cols = line[idx..line.length].split(sep)
-						@proc.vars['t.row'] = rc
-						rclass = row_classes[rc % row_classes.length]
-						buff << "<tr class='tr-row-#{rc} #{rclass}'>"
-						cols.each do |col|
-							buff << "\t#{fmt_cell(col, false, ccount)}"
-							ccount += 1
-						end
-						buff << '</tr>'
-						rc += 1
-					else
-						cols = line[1..line.length].split('|') if line[0] == '\\'
-					end
-					rows += 1
-				end
+	"""
+	/head|head
+	|col|col|col
+	|>col|>col|>col
+	|!@att=val att2=val2@!col|col
+	/foot|foot
+	"""
+	class TableBlock
+		include BH
+		include BH::BlockParams
+		include BH::HtmlUtils
+		
+		def initialize
+			@block_types = ['table']
+		end
 
-				buff << '</tbody>'
-				if cols.length > 0
-					# @todo process footer
+		# @todo support opening row with !@ (which would then get applied to <tr>)
+		DELIM1 = '|'
+		DELIM2 = '|>'
+		HEADER = '/'
+		CELL_ATTR_START = '!@'
+		CELL_ATTR_IDX = 1
+		CELL_ATTR_END = '@!'
+
+		def can_handle(line)
+			if !@block_type
+				if line.match(/^(table[(.]?|\||\|>|\/)/)
+					@block_type = 'table'
+					return BH::COLLECT
 				end
-				buff << "</table>"
-				@proc.vars['table.class'] = ''
-				@proc.vars['table.style'] = ''
-				@proc.vars['table.attribs'] = ''
 			end
-			ret
+			return BH::RETRY
 		end
 
-		def do_dt(line, buff, indents = '', indent_level = 0)
-			ret = COLLECT
-			if line == '' || line[0] != '>'
-				ret = DONE
-				ret = RETRY if line[0] != '>'
-
-				buff << "<dl class='#{@proc.vars['dd.class']}'>"
-				@lines.each do |line|
-					key = line[0]
-					val = line[1]
-					buff << "<dt class='#{@proc.vars['dt.class']}'>#{key}</dt><dd class='#{@proc.vars['dd.class']}'>#{val}</dd>"
-				end
-				buff << "</dl>"
-			else
-				@lines << line[1..-1].split('::', 2)
-				ret = COLLECT
+		def continue_with(line)
+			if line.match(/^(\||\|>|\/)/)
+				return BH::COLLECT
 			end
-			ret
+			return BH::RETRY
 		end
 
-		def do_default(line, buff, indents = '', indent_level = 0)
-			ret = COLLECT
-			blank = false
-
-			raw = @type == 'raw'
-			pre = @type == 'pre'
-			nofmt = raw
-
-			# we need to group indented lines as part of block, especially if it's otherwise empty
-			if raw || pre || @type == 'bq'
-				raw = true
-				# strip off first indent
-				if indent_level > 0
-					#idx = indents.length / indent_level
-					line = indents + line
-					if pre
-						line = "\n#{line}"
-					elsif line == ''
-						line = ' '
+		T_ROW = 't.row'
+		def process(type, args, lines, out, call_depth = 0)
+			args = [] if !args
+			bp = get_block_params(type, args[0])
+			row_classes = bp['row.classes']
+			row_classes = ['odd', 'even'] if !row_classes.is_a?(Array)
+
+			@eggshell.vars[T_ROW] = 0
+			out << create_tag('table', bp)
+			cols = []
+			rows = 0
+			rc = 0
+			lines.each do |line_obj|
+				ccount = 0
+				line = line_obj.line
+				if line[0] == '/' && rows == 0
+					cols = line[1..line.length].split('|')
+					out << "<thead><tr class='#{map['head.class']}'>"
+					cols.each do |col|
+						out << "\t#{fmt_cell(col, true, ccount)}"
+						ccount += 1
 					end
-				else
-					blank = line == ''
-					if pre
-						line = "\n#{line}"
+					out << '</tr></thead>'
+					out << '<tbody>'
+				elsif line[0] == '/'
+					# implies footer
+					cols = line[1..line.length].split('|')
+					out << "<tfoot><tr class='#{map['foot.class']}'>"
+					cols.each do |col|
+						out << "\t#{fmt_cell(col, true, ccount)}"
+						ccount += 1
 					end
-				end
-			else
-				line = " " if line == '\\'
-				blank = line == ''
-			end
-
-			if blank
-				@lines.delete('')
-				start_tag = ''
-				end_tag = ''
-				content = ''
-				if @type != 'raw'
-					bp = @block_params[@type]
-					attrs = bp['attributes'] || {}
-					attrs['class'] = bp['class'] || ''
-					attrs['style'] = bp['style'] || ''
-					attrs['id'] = bp['id'] || ''
-					@type = 'blockquote' if @type == 'bq'
-					# @todo get attributes from block param
-					start_tag = create_tag(@type, attrs)
-					end_tag = "</#{@type}>"
-					join = @type == 'pre' ? "" : "<br />\n"
-
-					content = "#{start_tag}#{@lines.join(join)}#{end_tag}"
+					out << '</tr></tfoot>'
+				elsif line[0] == DELIM1 || line[0..1] == DELIM2
+					idx = 1
+					sep = /(?<!\\)\|/
+					if line[1] == '>'
+						idx = 2
+						sep = /(?<!\\)\|\>/
+					end
+					cols = line[idx..line.length].split(sep)
+					@eggshell.vars[T_ROW] = rc
+					rclass = row_classes[rc % row_classes.length]
+					out << "<tr class='tr-row-#{rc} #{rclass}'>"
+					cols.each do |col|
+						out << "\t#{fmt_cell(col, false, ccount)}"
+						ccount += 1
+					end
+					out << '</tr>'
+					rc += 1
 				else
-					content = @lines.join("\n")
+					cols = line[1..line.length].split('|') if line[0] == '\\'
 				end
+				rows += 1
+			end
 
-				buff << content
-				@lines = []
-				ret = DONE
-			else
-				line = !nofmt ? @proc.fmt_line(line) : @proc.expand_expr(line)
-				@lines << line
-				ret = raw ? COLLECT_RAW : COLLECT
+			out << '</tbody>'
+			if cols.length > 0
+				# @todo process footer
 			end
-			ret
+			out << "</table>"
 		end
 
 		def fmt_cell(val, header = false, colnum = 0)
@@ -297,19 +243,21 @@ class Eggshell::Bundles::Basics
 
 			if val[0] == '\\'
 				val = val[1..val.length]
-			elsif val[0] == CELL_ATTR_START
+			elsif val[0..CELL_ATTR_IDX] == CELL_ATTR_START
 				rt = val.index(CELL_ATTR_END)
 				if rt
-					attribs = val[1...rt]
+					attribs = val[CELL_ATTR_IDX+1...rt]
 					val = val[rt+CELL_ATTR_END.length..val.length]
 				end
 			end
 
 			# inject column position via class
 			olen = attribs.length
-			attribs = attribs.gsub(/class=(['"])/, 'class=$1' + "td-col-#{colnum}")
-			if olen == attribs.length
+			match = attribs.match(/class=(['"])([^'"]*)(['"])/)
+			if !match
 				attribs += " class='td-col-#{colnum}'"
+			else
+				attribs = attribs.gsub(match[0], "class='#{match[2]} td-col-#{colnum}'")
 			end
 
 			buff << "<#{tag} #{attribs}>"
@@ -318,59 +266,149 @@ class Eggshell::Bundles::Basics
 				val = val[1..val.length]
 			end
 
-			buff << @proc.fmt_line(val)
+			buff << @eggshell.expand_formatting(val)
 			buff << "</#{tag}>"
 			return buff.join('')
 		end
 	end
 	
-	# Handles blocks that deal with sectioning of content.
-	<<-docblock
-	h1. Header 1
-	h2. Header 2
-	h3({class: 'header-3', id: 'custom-id'}). Header 3
-
-	section.
-	h1. Another Header 1 inside a section
-	end-section.
-
-	!# outputs a table of contents based on all headers accumulated
-	!# define the output of each header (or use 'default' as fallback)
-	toc.
-	start: <div class='toc'>
-	end: </div>
-	default: <div class='toc-$level'><a href='$id'>$title</a></div>
-	h4: <div class='toc-h4 special-exception'><a href='$id'>$title</a></div>
-	section: <div class='toc-section-wrap'>
-	section_end: </div>
-	docblock
-	class SectionBlocks
-		include Eggshell::BlockHandler
+	class ListBlocks
+		include BH
+		include BH::BlockParams
+		include BH::HtmlUtils
 		
+		def initialize
+			@block_types = ['ul', 'ol', 'dl']
+		end
+
+		START_LIST = /^(ol|ul|dl)[(.]/
+		START_LIST_SHORT = /^\s*([#>-])/
+
+		def can_handle(line)
+			match = START_LIST.match(line)
+			if match
+				@block_type = match[1]
+				return BH::COLLECT
+			end
+
+			match = START_LIST_SHORT.match(line)
+			if match
+				if match[1] == '>'
+					@block_type = 'dl'
+				else
+					@block_type = match[1] == '-' ? 'ul' : 'ol'
+				end
+				return BH::COLLECT
+			end
+			
+			return BH::RETRY
+		end
+		
+		def continue_with(line)
+			if line == nil || line == "" || !START_LIST_SHORT.match(line)
+				return BH::RETRY
+			else
+				return BH::COLLECT
+			end
+		end
+
+		# @todo support ability to add attributes to sub-lists (maybe '[-#] @\(....\)')
+		def process(type, args, lines, out, call_depth = 0)
+			if type == 'dl'
+				# @todo
+			else
+				order_stack = []
+				otype_stack = []
+				last = nil
+				first_type = nil
+
+				if lines[0] && !lines[0].line.match(/[-#]/)
+					line = lines.shift
+				end
+
+				lines.each do |line_obj|
+					line = line_obj.line
+					indent = line_obj.indent_lvl
+					ltype = line[0] == '-' ? 'ul' : 'ol'
+					line = line[1..line.length].strip
+
+					if order_stack.length == 0
+						# use the given type to start; infer for sub-lists
+						order_stack << create_tag(type, get_block_params(type, args[0]))
+						otype_stack << type
+					# @todo make sure that previous item was a list
+					# remove closing li to enclose sublist
+					elsif indent > (otype_stack.length-1) && order_stack.length > 0
+						last = order_stack[-1]
+						last = last[0...last.length-5]
+						order_stack[-1] = last
+
+						order_stack << "#{"\t"*indent}<#{ltype}>"
+						otype_stack << ltype
+					elsif indent < (otype_stack.length-1)
+						count = otype_stack.length - 1
+						while count > indent
+							ltype = otype_stack.pop	
+							order_stack << "#{"\t"*count}</#{ltype}>\n#{"\t"*(count-1)}</li>"
+							count -= 1
+						end
+					end
+					order_stack << "#{"\t"*indent}<li>#{line}</li>"
+				end
+
+				# close nested lists
+				d = otype_stack.length
+				c = 1
+				otype_stack.reverse.each do |ltype|
+					ident = d - c
+					order_stack << "#{"\t" * ident}</#{ltype}>\n#{ident-1 >= 0 ? "\t"*(ident-1) : ''}#{c == d ? '' : "</li>"}"
+					c += 1
+				end
+				out << @eggshell.expand_all(order_stack.join("\n"))
+			end
+		end
+	end
+
+	class SectionBlocks
+		include BH
+		include BH::BlockParams
+		include BH::HtmlUtils
+
+		SECTION ='section'
+		SECTION_END = 'section-end'
 		TOC_TEMPLATE = {
 			:default => "<div class='toc-h$level'><a href='\#$id'>$title</a></div>"
 		}
 
-		def set_processor(proc)
-			@proc = proc
-			@proc.register_block(self, *%w(h1 h2 h3 h4 h5 h6 hr section end-section toc))
+		def initialize
+			@block_types = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', SECTION, SECTION_END, 'toc']
 			@header_list = []
 			@header_idx = {}
 		end
 
-		def start(name, line, buffer, indents = '', indent_level = 0)
-			set_block_params(name)
-			bp = @block_params[name]
+		START = /^(h[1-6]|section|toc)[(.]/
 
-			if name[0] == 'h'
-				if name == 'hr'
-					buffer << "<hr />"
+		def can_handle(line)
+			match = START.match(line)
+			if match
+				@block_type = match[1]
+				return @block_type != 'toc' ? BH::DONE : BH::COLLECT
+			end
+			return BH::RETRY
+		end
+
+		def process(type, args, lines, out, call_depth = 0)
+			bp = get_block_params(type, args[0])
+			line = lines[0]
+			line = line.line.strip if line.is_a?(Eggshell::Line)
+
+			if type[0] == 'h'
+				if type == 'hr'
+					out << create_tag(type, bp, false)
 				else
-					lvl = name[1].to_i
-					attrs = bp['attributes'] || {}
-					attrs['class'] = bp['class'] || ''
-					attrs['style'] = bp['style'] || ''
+					lvl = type[1].to_i
 
+					# assign unique id
 					id = bp['id'] || line.downcase.strip.gsub(/[^a-z0-9_-]+/, '-')
 					lid = id
 					i = 1
@@ -379,205 +417,212 @@ class Eggshell::Bundles::Basics
 						i += 1
 					end
 					id = lid
-					attrs['id'] = id
-					title = @proc.fmt_line(line)
+					bp['id'] = id
+					title = @eggshell.expand_formatting(line)
 
-					buffer << "#{create_tag(name, attrs)}#{title}</#{name}>"
+					out << "#{create_tag(type, bp)}#{title}</#{type}>"
 
-					@header_list << {:level => lvl, :id => lid, :title => title, :tag => name}
+					@header_list << {:level => lvl, :id => lid, :title => title, :tag => type}
 					@header_idx[lid] = @header_list.length - 1
 				end
-				return DONE
-			elsif name == 'section'
-				attrs = bp['attributes'] || {}
-				attrs['class'] = bp['class'] || ''
-				attrs['style'] = bp['style'] || ''
-				attrs['id'] = bp['id'] || ''
-				buffer << create_tag('section', attrs)
-				@header_list << name
-				return DONE
-			elsif name == 'end-section'
-				buffer << '</section>'
-				@header_list << name
-				return DONE
-			elsif name == 'toc'
-				@toc_template = TOC_TEMPLATE.clone
-				return COLLECT
-			end
-		end
-		
-		def collect(line, buffer, indents = '', indent_level = 0)
-			if line == '' || !line
-				buffer << @proc.fmt_line(@toc_template[:start]) if @toc_template[:start]
+			elsif type == SECTION
+				out << create_tag(SECTION, bp)
+				@header_list << type
+			elsif type == SECTION_END
+				out << '</section>'
+				@header_list << type
+			elsif type == 'toc'
+				# first, parse the toc definitions from lines
+				toc_template = TOC_TEMPLATE.clone
+				lines.each do |line_obj|
+					line = line_obj.is_a?(Eggshell::Line) ? line_obj.line : line
+					key, val = line.split(':', 2)
+					toc_template[key.to_sym] = val
+				end
+
+				# now go through collected headers and sections and generate toc
+				out << @eggshell.expand_formatting(toc_template[:start]) if toc_template[:start]
 				@header_list.each do |entry|
-					if entry == 'section'
-						buffer << @proc.fmt_line(@toc_template[:section]) if @toc_template[:section]
-					elsif entry == 'section_end'
-						buffer << @proc.fmt_line(@toc_template[:section_end]) if @toc_template[:section_end]
+					if entry == SECTION
+						out << @eggshell.expand_formatting(toc_template[:section]) if toc_template[:section]
+					elsif entry == SECTION_END
+						out << @eggshell.expand_formatting(toc_template[:section_end]) if toc_template[:section_end]
 					elsif entry.is_a?(Hash)
-						tpl = @toc_template[entry[:tag]] || @toc_template[:default]
-						buffer << @proc.fmt_line(
+						tpl = toc_template[entry[:tag]] || toc_template[:default]
+						out << @eggshell.expand_formatting(
 							tpl.gsub('$id', entry[:id]).gsub('$title', entry[:title]).gsub('$level', entry[:level].to_s)
 						)
 					end
 				end
-				buffer << @proc.fmt_line(@toc_template[:end]) if @toc_template[:end]
-				return DONE
-			else
-				key, val = line.split(':', 2)
-				@toc_template[key.to_sym] = val
-				return COLLECT
+				out << @eggshell.expand_formatting(toc_template[:end]) if toc_template[:end]
 			end
 		end
 	end
 	
-	class InlineMacros
-		include Eggshell::MacroHandler
-
-		def initialize
-			@capvar = nil
-			@collbuff = nil
-			@depth = 0
-		end
-
-		HASH_FMT_DECORATORS = {
-			'[*' => '<b>',
-			'[**' => '<strong>',
-			'[_' => '<i>',
-			'[__' => '<em>',
-			'*]'=> '</b>',
-			'**]' => '</strong>',
-			'_]' => '</i>',
-			'__]' => '</em>',
-			'[-_' => '<u>',
-			'_-]' => '</u>',
-			'[-' => '<strike>',
-			'-]' => '</strike>'
+	class BasicFormatHandlers
+		include FH
+		include FH::Utils
+		include BH::HtmlUtils
+		
+		TAG_MAP = {
+			'[*' => 'b',
+			'[**' => 'strong',
+			'[/' => 'i',
+			'[//' => 'em',
+			'[__' => 'u',
+			'[-' => 'strike',
+			'[^' => 'sup',
+			'[_' => 'sub',
+			'[[' => 'span'
 		}.freeze
 
-		def set_processor(eggshell)
-			@proc = eggshell
-			@proc.register_macro(self, '[!', '[~', '[^', '[.', '[*', '[**', '[/', '[//', '[_', '[-')
+		ESCAPE_MAP_HTML = {
+			'<' => '&lt;',
+			'>' => '&gt;',
+			'/<' => '&laquo;',
+			'>/' => '&raquo;',
+			'/\'' => '&lsquo;',
+			'\'/' => '&rsquo;',
+			'/"' => '&ldquo;',
+			'"/' => '&rdquo;',
+			'c' => '&copy;',
+			'r' => '&reg;',
+			'!' => '&iexcl;',
+			'-' => '&ndash;',
+			'--' => '&mdash;',
+			'&' => '&amp;'
+		}.freeze
+		
+		def initialize
+			@fmt_delimeters = [
+				['[*', '*]'], # bold
+				['[**', '**]'], # strong
+				['[/', '/]'], # italic
+				['[//', '//]'], # emphasis
+				['[__', '__]'], # underline
+				['[-', '-]'], # strike
+				['[^', '^]'], # superscript
+				['[_', '_]'], # subscript,
+				['[[', ']]'], # span
+				['[~', '~]'], # anchor
+				['[!', '!]'], # image
+				['%{', '}%', true], # entity expansion
+				['`', '`', '%{'], # code, backtick
+				['{{', '}}', '%{'] # code, normal
+			]
 		end
 
-		def process(buffer, macname, args, lines, depth)
-			prefix = macname[0..1]
-			textpart = args.shift
-			tag = nil
-
-			case prefix
-			when '[^'
-				tag = 'sup'
-			when '[.'
-				tag = 'sub'
-			when '[*'
-				tag = macname == '[**' ? 'strong' : 'b'
-			when '[/'
-				tag = macname == '[//' ? 'em' : 'i'
-			when '[-'
-				tag = 'strike'
-			when '[_'
-				tag = 'u'
-			when '[~'
-				tag = 'a'
-				link = textpart ? textpart.strip : textpart
-				text = nil
-				if link == ''
-					text = ''
-				elsif link.index('; ') == nil
-					textpart = link
-					args.unshift('href:'+ link);
-				else
-					textpart, link = link.split('; ')
-					link = '' if !link
-					args.unshift('href:'+link)
-				end
-			when '[!'
-				tag = 'img'
-				args.unshift('src:'+textpart)
-				textpart = nil
+		def format(tag, str)
+			if tag == '{{' || tag == '`'
+				cls = tag == '{{' ? 'normal' : 'backtick'
+				return "<code class='#{cls}'>#{str}</code>"
+			elsif tag == '%{'
+				# @todo find a way to expand char map and handle unmapped strings at runtime
+				buff = ''
+				str.split(' ').each do |part|
+					c = ESCAPE_MAP_HTML[part]
+					buff += c || part
+				end
+				return buff
 			end
 			
-			buffer << restructure_html(tag, textpart ? textpart.strip : textpart, args)
-		end
-		
-		def restructure_html(tag, text, attributes = [])
-			buff = "<#{tag}"
-			attributes.each do |attrib|
-				key, val = attrib.split(':', 2)
-				# @todo html escape?
-				if val
-					buff = "#{buff} #{key}=\"#{val.gsub('\\|', '|')}\""
-				else
-					buff = "#{buff} #{key}"
+			st = tag[0..1]
+			args = parse_args(str.strip)
+			akey = BH::BlockParams::ATTRIBUTES
+			atts = {akey => {}}
+			atts[akey].update(args.pop)
+
+			tagname = nil
+			tagopen = true
+			text = args[0]
+
+			if tag == '[~'
+				link, text = args
+				link = '' if !link 
+				text = '' if !text
+				if text.strip == ''
+					text = link
 				end
+				atts[akey]['href'] = link if link != ''
+				tagname = 'a'
+			elsif tag == '[!'
+				link, alt = args
+				link = '' if !link
+				alt = '' if !alt
+				
+				atts[akey]['src'] = link if link != ''
+				atts[akey]['alt'] = alt if alt != ''
+				tagname = 'img'
+				tagopen = false
+			else
+				tagname = TAG_MAP[tag]
 			end
 
-			if text == nil
-				buff += ' />'
+			if tagopen
+				return "#{create_tag(tagname, atts)}#{text}</#{tagname}>"
 			else
-				buff = "#{buff}>#{text}</#{tag}>"
+				return create_tag(tagname, atts, false)
 			end
-			buff
-		end
-	end	
-
-	# Macros:
-	# 
-	# - `include`
-	# - `capture`
-	# - `var`
-	class BasicMacros
-		include Eggshell::MacroHandler
-
-		def initialize
-			@capvar = nil
-			@collbuff = nil
-			@depth = 0
 		end
+	end
 
-		def set_processor(eggshell)
-			@proc = eggshell
-			@proc.register_macro(self, *%w(! = capture var include process parse_test))
+	# These macros are highly recommended to always be part of an instance of the processor.
+	#
+	# {{!}} sets default parameter values (block parameters) so that they don't have to be
+	# specified for every block instance.
+	#
+	# {{process}} always dynamic processing of content. This allows previous macros to build
+	# up a document dynamically.
+	class CoreMacros
+		include MH
+		include BH::BlockParams
+		
+		CAP_OUT = 'capture_output'
+
+		def set_processor(proc, opts = nil)
+			opts = {} if !opts
+			@opts = opts
+			@eggshell = proc
+			@eggshell.add_macro_handler(self, '=', '!', 'process', 'capture', 'raw')
+			@eggshell.add_macro_handler(self, 'include') if !@opts['macro.include.off']
+			@vars = @eggshell.vars
+
+			@vars[:include_stack] = []
+			if opts['include.options']
+				opts['include.options'].each do |k,v|
+					@vars[k.to_sym] = v
+				end
+			end
+			
+			if @vars[:include_paths].length == 0
+				@vars[:include_paths] = [Dir.getwd]
+			end
 		end
 
-		def process(buffer, macname, args, lines, depth)
-			if macname == '!'
-				@proc.vars[:block_params] = @proc.expr_eval(args)
-			elsif macname == 'process'
+		def process(name, args, lines, out, call_depth = 0)
+			if name == '='
+				# @todo expand args[0]?
 				if args[0]
-					proclines = @proc.expr_eval(args[0])
-					proclines = proclines.split(/[\r\n]+/) if proclines.is_a?(String)
-					buffer << @proc.process(proclines, depth + 1) if proclines.is_a?(Array)
-				end
-			elsif macname == 'capture'
-				# @todo check args for fragment to parse
-				return if !lines
-				var = args[0]
-				@proc.vars[var] = @proc.process(lines, depth)
-			elsif macname == 'var' || macname == '='
-				# @todo support multiple vars via lines
-				# @todo expand value if expression
-				if args.length >= 2
-					key = args[0]
-					val = args[1]
-					
-					if val.is_a?(Array) && val[0].is_a?(Symbol)
-						@proc.vars[key] = @proc.expr_eval(val)
+					val = nil
+					if args[1].is_a?(Array) && args[1][0].is_a?(Symbol)
+						val = @eggshell.expr_eval(args[1])
 					else
-						@proc.vars[key] = val
+						val = args[1]
 					end
-					
-					# @todo fix this so it's possible to set things like arr[0].setter, etc.
-					# ptrs = EE.retrieve_var(key, @proc.vars, {}, true)
-					# val = val.is_a?(Array) && val[0] == :var ? EE.retrieve_var(val[1], @proc.vars, {}) : val
-					# if ptrs
-					# 	EE.set_var(ptrs[0], ptrs[1][0], ptrs[1][1], val)
-					# else
-					# 	@proc.vars[key] = val
-					# end
-				end
-			elsif macname == 'include'
+					@eggshell.vars[args[0]] = val
+				end
+			elsif name == '!'
+				block_name = args[0]
+				block_params = args[1]
+				set_block_params(block_name, block_params) if block_name
+			elsif name == 'process'
+				
+			elsif name == 'capture'
+				var = args[0] || CAP_OUT
+				captured = @eggshell.assemble(lines, call_depth + 1)
+				captured = @eggshell.expand_expr(captured)
+				@eggshell.vars[var] = captured
+			elsif name == 'include'
 				paths = args[0]
 				opts = args[1] || {}
 				if opts['encoding']
@@ -588,167 +633,218 @@ class Eggshell::Bundles::Basics
 				if lines && lines.length > 0
 					paths = lines
 				end
-				do_include(paths, buffer, depth, opts)
+				do_include(paths, out, call_depth, opts)
+			elsif name == 'raw'
+				lines.each do |unit|
+					if unit.is_a?(Array)
+						if unit[0] == :block
+							unit[Eggshell::ParseTree::IDX_LINES].each do |line|
+								out << line.to_s
+							end
+						else
+							out << @eggshell.assemble(unit)
+						end
+					else
+						out << line
+					end
+				end
 			end
 		end
-
-		def do_include(paths, buff, depth, opts = {})
-			@proc.vars[:include_stack] = [] if !@proc.vars[:include_stack]
+		
+		def do_include(paths, buff, call_depth, opts = {})
 			paths = [paths] if !paths.is_a?(Array)
 			# @todo check all include paths?
 			paths.each do |inc|
-				inc = @proc.expand_expr(inc.strip)
+				inc = inc.line if inc.is_a?(Eggshell::Line)
+				inc = @eggshell.expand_expr(inc.strip)
 				checks = []
 				if inc[0] != '/'
-					@proc.vars[:include_paths].each do |root|
+					@vars[:include_paths].each do |root|
 						checks << "#{root}/#{inc}"
 					end
 					# @todo if :include_root, expand path and check that it's under the root, otherwise, sandbox
 				else
 					# sandboxed root include
-					if @proc.vars[:include_root]
-						checks << "#{@proc.vars[:include_root]}#{inc}"
+					if @eggshell.vars[:include_root]
+						checks << "#{@vars[:include_root]}#{inc}"
 					else
 						checks << inc
 					end
 				end
-
 				checks.each do |inc|
 					if File.exists?(inc)
 						lines = IO.readlines(inc, $/, opts)
-						@proc.vars[:include_stack] << inc
-						@proc.context.push_line_counter
+						@vars[:include_stack] << inc
 						begin
-							buff << @proc.process(lines, depth + 1)
-							@proc._debug("include: 200 #{inc}")
+							buff << @eggshell.process(lines, 0, call_depth + 1)
+							@eggshell._debug("include: 200 #{inc}")
 						rescue => ex
-							@proc._error("include: 500 #{inc}: #{ex.message}")
+							@eggshell._error("include: 500 #{inc}: #{ex.message}#{ex.backtrace.join("\n\t")}")
 						end
 						
-						@proc.vars[:include_stack].pop
-						@proc.context.pop_line_counter
+						@vars[:include_stack].pop
 						break
 					else
-						@proc._warn("include: 404 #{inc}")
+						@eggshell._warn("include: 404 #{inc}")
 					end
 				end
 			end
 		end
 	end
+	
+	# Provides iteration and conditional functionality.
+	class ControlLoopMacros
+		include MH
+		
+		class WhileLoopWrapper
+			def initialize(eggshell, cond)
+				@eggshell = eggshell
+				@cond = cond
+			end
 
-	class ControlMacros
-		include Eggshell::MacroHandler
+			def each(&block)
+				counter = 0
+				struct = Eggshell::ExpressionEvaluator.struct(@cond)
 
-		def initialize
-			@stack = []
-			@state = []
-			@macstack = []
+				cond = @eggshell.expr_eval(struct)
+				while cond
+					yield(counter)
+					counter += 1
+					cond = @eggshell.expr_eval(struct)
+				end
+			end
 		end
 
-		def set_processor(eggshell)
-			@proc = eggshell
-			@proc.register_macro(self, *%w(if elsif else loop for while break next))
-		end
+		# pre.
+		# @if("expression") {}
+		# @elsif("expression") {}
+		# else {}
+		#
+		# #! modes:
+		# #! 'raw' (default): collects all generated lines as raw (unless there are sub-macros, which would just collect the output as as-is)
+		# #! 'eval': evaluates each unit via Eggshell::Processor.assemble
+		# #! note that interpolated expressions are expanded in raw mode
+		# #
+		# @for({'start': 0, 'stop': var, 'step': 1, 'items': ..., 'item': 'varname', 'counter': 'varname'}[, mode])
+		def set_processor(proc, opts = nil)
+			opts = {} if !opts
+			@opts = opts
+			@eggshell = proc
+			@eggshell.add_macro_handler(self, *%w(if elsif else loop for while break next))
+			@vars = @eggshell.vars
+			@eggshell.vars[:loop_max_limit] = 1000
 
-		def process(buffer, macname, args, lines, depth)
-			p0 = args.is_a?(Array) ? args[0] : nil
-			lines ? lines.delete('') : ''
+			@state = []
+			# @todo set loop limits from opts or defaults
+		end
 
-			macname = macname.to_sym
-			st = @state[depth]
-			if !@state[depth]
+		def process(name, args, lines, out, call_depth = 0)
+			macname = name.to_sym
+			st = @state[call_depth]
+			if !@state[call_depth]
 				st = {:type => macname}
 
-				@state[depth] = st
+				@state[call_depth] = st
 				# erase nested state
-				@state[depth+1] = nil
+				@state[call_depth+1] = nil
 			end
 
-			if macname == :for || macname == :loop
-				p0 = p0 || {}
-				st[:var] = p0['var']
-				st[:start] = p0['start']
-				st[:stop] = p0['stop']
-				st[:step] = p0['step'] || 1
-				st[:iter] = p0['items'] || 'items'
-				st[:item] = p0['item'] || 'item'
-				st[:counter] = p0['counter'] || 'counter'
-				st[:raw]  = p0['raw'] # @todo inherit if not set?
-				st[:collect] = p0['collect']
-				st[:agg_block] = p0['aggregate_block']
-
-				mbuff = []
+			p0 = args[0]
+			if macname == :for || macname == :loop || macname == :while
+				p1 = args[1] || 'raw'
+
 				looper = nil
 				loop_is_map = false
 
-				# in for, construct range that can be looped over
-				# in loop, detect 'each' method
-				if macname == :for
-					st[:item] = st[:var]
-					looper = Range.new(st[:start], st[:stop]).step(st[:step]).to_a
-				elsif macname == :loop
-					begin
-						looper = st[:iter].is_a?(Array) && st[:iter][0].is_a?(Symbol) ? @proc.expr_eval(st[:iter]) : st[:iter]
-						looper = nil if !looper.respond_to?(:each)
-						loop_is_map = looper.is_a?(Hash)
-					rescue
+				if macname == :while
+					if p0
+						looper = WhileLoopWrapper.new(@eggshell, p0)
+					end
+				else
+					p0 ||= 'true'
+					st[:iter] = p0['items'] || nil
+					st[:item] = p0['item'] || 'item'
+					st[:var] = p0['var']
+					st[:start] = p0['start']
+					st[:stop] = p0['stop']
+					st[:step] = p0['step'] || 1
+					st[:counter] = p0['counter'] || 'counter'
+
+					if st[:iter].is_a?(Array)
+						st[:start] = 0 if !st[:start]
+						st[:stop] = st[:iter].length - 1 if !st[:stop]
+						st[:step] = 1 if !st[:step]
+						looper = Range.new(st[:start], st[:stop]).step(st[:step]).to_a
+					elsif st[:iter].respond_to?(:each)
+						looper = st[:iter]
+						loop_is_map = true
 					end
 				end
 
-				collector = []
+				collector = out
+				raw = p1 == 'raw'
+
 				if looper
-					counter = 0
+					counter = -1
 					looper.each do |i1, i2|
+						counter += 1
+						break if @eggshell.vars[:loop_max_limit] == counter
 						# for maps, use key as the counter
 						val = nil
 						if loop_is_map
-							@proc.vars[st[:counter]] = i1
+							@eggshell.vars[st[:counter]] = i1
 							val = i2
 						else
 							val = i1
-							@proc.vars[st[:counter]] = counter
+							@eggshell.vars[st[:counter]] = counter
 						end
 
 						# inject value into :item -- if it's an expression, evaluate first
-						@proc.vars[st[:item]] = val.is_a?(Array) && val[0].is_a?(Symbol) ? @proc.expr_eval(val) : val
-						# divert lines to collector
-						if st[:collect]
-							lines.each do |_line|
-								if _line.is_a?(String)
-									collector << @proc.expand_expr(_line)
-								elsif _line.is_a?(Eggshell::Block)
-									_line.process(collector)
+						@eggshell.vars[st[:item]] = val.is_a?(Array) && val[0].is_a?(Symbol) ? @eggshell.expr_eval(val) : val
+
+						# if doing raw, pass through block lines with variable expansion. preserve object type (e.g. Line or String);
+						# sub-macros will get passed collector var as output to assemble().
+						# otherwise, call assemble() on all lines
+						if raw
+							lines.each do |unit|
+								if unit.is_a?(Array)
+									if unit[0] == :block
+										unit[Eggshell::ParseTree::IDX_LINES].each do |line|
+											nline = line
+											if line.is_a?(String)
+												nline = @eggshell.expand_expr(line)
+											else
+												# rather than expand_expr on raw, assume line.line is a subset of line.raw
+												_raw = line.raw
+												_line = @eggshell.expand_expr(line.line)
+												_raw = _raw.gsub(line.line, _line) if _raw
+												nline = line.replace(_line, _raw)
+											end
+											collector << nline
+										end
+									else
+										@eggshell.assemble([unit], call_depth + 1, {:out => collector})
+									end
+								else
+									collector << @eggshell.expand_expr(line.to_s)
 								end
 							end
 						else
-							process_lines(lines, buffer, depth + 1, st[:raw])
+							collector << @eggshell.assemble(lines, call_depth + 1)
 						end
-						break if st[:break]
 
-						counter += 1
+						break if st[:break]
 					end
 				end
 				
-				# since there are lines here, process collected as an aggregated set of blocks
-				if collector.length > 0
-					if st[:collect] == 'aggregate'
-						if st[:agg_block]
-							collector.unshift(st[:agg_block])
-						end
-						process_lines(collector, buffer, depth + 1, false)
-					else
-						buffer << collector.join("\n")
-					end
-				end
-
 				# clear state
-				@state[depth] = nil
-			elsif macname == :while
-				raw = args[1]
-				while @proc.expr_eval(p0)
-					process_lines(lines, buffer, depth + 1, raw)
-					break if st[:break]
-				end
+				@state[call_depth] = nil
+			# elsif macname == :while
+			# 	raw = args[1]
+			# 	while @eggshell.expr_eval(p0)
+			# 		process_lines(lines, buffer, depth + 1, raw)
+			# 		break if st[:break]
+			# 	end
 			elsif macname == :if || macname == :elsif || macname == :else
 				cond = p0
 				st[:if] = true if macname == :if
@@ -770,7 +866,7 @@ class Eggshell::Bundles::Basics
 				if macname != :else
 					if !st[:cond_eval]
 						cond_struct = Eggshell::ExpressionEvaluator.struct(cond)
-						st[:cond_eval] = @proc.expr_eval(cond_struct)[0]
+						st[:cond_eval] = @eggshell.expr_eval(cond_struct)
 					end
 				else
 					st[:cond_eval] = true
@@ -778,11 +874,12 @@ class Eggshell::Bundles::Basics
 
 				if st[:cond_eval] && !st[:cond_met]
 					st[:cond_met] = true
-					process_lines(lines, buffer, depth + 1)
+					#process_lines(lines, buffer, depth + 1)
+					@eggshell.assemble(lines, call_depth + 1, {:out => out})
 				end
 			elsif macname == :break
 				lvl = p0 || 1
-				i = depth - 1
+				i = call_depth - 1
 
 				# set breaks at each found loop until # of levels reached
 				while i >= 0
@@ -812,43 +909,7 @@ class Eggshell::Bundles::Basics
 				end
 			end
 		end
-
-		def process_lines(lines, buffer, depth, raw = false)
-			return if !lines
-			ln = []
-			lines.each do |line|
-				if line.is_a?(Eggshell::Block)
-					if ln.length > 0
-						buffer << (raw ? @proc.expand_expr(ln.join("\n")) : @proc.process(ln, depth))
-						ln = []
-					end
-					line.process(buffer, depth)
-					if @state[depth-1][:next]
-						@state[depth-1][:next] = false
-						break
-					end
-				else
-					ln << line
-				end
-			end
-			if ln.length > 0
-				buffer << (raw ? @proc.expand_expr(ln.join("\n")) : @proc.process(ln, depth))
-			end
-		end
-
-		protected :process_lines
 	end
-
-	# Baseline functions.
-	# @todo catch exceptions???
-	module StdFunctions
-		# Repeats `str` by a given `amt`
-		def self.str_repeat(str, amt)
-			return str * amt
-		end
-
-		FUNC_NAMES = %w(str_repeat).freeze
-	end
-
+	
 	include Eggshell::Bundles::Bundle
 end