eggshell 0.8.3 → 1.0.0

data/lib/eggshell/bundles/loader.rb

@@ -13,13 +13,14 @@ module Eggshell::Bundles::Loader
 	end
 
 	class LoaderMacro
+		include Eggshell::MacroHandler
 		def set_processor(proc)
 			@proc = proc
-			proc.register_macro(self, *%w(gems files bundles vars))
+			proc.add_macro_handler(self, *%w(gems files bundles vars))
 		end
 
-		def process(buffer, macname, args, lines, depth)
-			if macname == 'gems'
+		def process(type, args, lines, out, call_depth = 0)
+			if type == 'gems'
 				args.each do |gemname|
 					begin
 						require gemname
@@ -28,7 +29,7 @@ module Eggshell::Bundles::Loader
 						@proc._warn("could not load gem: #{gemname}")
 					end
 				end
-			elsif macname == 'files'
+			elsif type == 'files'
 				args.each do |file|
 					begin
 						if file[0] == '/'
@@ -45,7 +46,7 @@ module Eggshell::Bundles::Loader
 						@proc._warn("could not load file: #{file}")
 					end
 				end
-			elsif macname == 'bundles'
+			elsif type == 'bundles'
 				args.each do |bundle|
 					Eggshell::Bundles::Registry.attach_bundle(bundle, @proc.vars[:target])
 				end

data/lib/eggshell/expression-evaluator.rb

@@ -5,6 +5,7 @@ class Eggshell::ExpressionEvaluator
 	REGEX_EXPR_PLACEHOLDERS = /(\\|\$\[|\$\{|\]|\}|\+|\-|>|<|=|\s+|\(|\)|\*|\/`)/
 	REGEX_EXPR_STATEMENT = /(\(|\)|,|\[|\]|\+|-|\*|\/|%|<=|>=|==|<|>|"|'|\s+|\\|\{|\}|:|\?)/
 	REGEX_OPERATORS = /\+|-|\*|\/|%|<=|>=|<|>|==|!=|&&|\|\||&|\|/
+	REGEX_VARNAME = /[\w\d]+/
 
 	LOG_OP = 2
 	LOG_LEVEL = 0
@@ -345,12 +346,19 @@ class Eggshell::ExpressionEvaluator
 				term = nil
 				term_state = nil
 			elsif tok == '{'
-				if state[-1] == :nil && stack[0][-1][0] == :fn
+				if state[-1] == :nil #&& stack[0][-1][0] == :fn
 					delim = '{'
 					while toks[i]
 						delim += toks[i]
 						i += 1
 					end
+					
+					# @todo is it safe to do stack[0]? stick to ptr instead?
+					if term
+						stack[0] << term_val(term, term_state == :quote)
+						term = nil
+						term_state = nil
+					end
 					stack[0] << [:brace_op, delim]
 					break
 			  	end
@@ -494,7 +502,8 @@ class Eggshell::ExpressionEvaluator
 				# look-ahead to build variable reference
 				ntok = toks[i]
 				while ntok
-					if ntok != ',' && ntok != ':' && ntok != '(' && ntok != ')' && ntok != '}' && !ntok.match(REGEX_OPERATORS)
+					#if ntok != ',' && ntok != ':' && ntok != '(' && ntok != ')' && ntok != '}' && ntok != '{' && !ntok.match(REGEX_OPERATORS)
+					if ntok.match(REGEX_VARNAME)
 						if ntok != ' ' && ntok != "\t"
 							term += ntok
 						end
@@ -506,7 +515,7 @@ class Eggshell::ExpressionEvaluator
 				end
 			end
 		end
-
+		
 		# @todo validate completeness of state (e.g. no omitted parenthesis)
 		if state[1] || term
 			_transition.call(state[-1])
@@ -690,6 +699,7 @@ class Eggshell::ExpressionEvaluator
 	def self.expr_eval_op(op, lterm, rterm)
 		ret = nil
 		#$stderr.write "** #{lterm.inspect} ( #{op} ) #{rterm.inspect}\n"
+
 		case op
 		when '=='
 			ret = lterm == rterm

data/lib/eggshell/format-handler.rb

@@ -0,0 +1,40 @@
+# Interface for handling inline formatting. Markup follows this general structure:
+# {{open_delim + string + close_delim}}. Opening and closing delimiters are defined
+# by the handler.
+module Eggshell::FormatHandler
+	def set_processor(proc, opts = nil)
+		@eggopts = opts || {}
+		@eggshell = proc
+		@eggshell.add_format_handler(self, @fmt_delimeters)
+		if self.respond_to?(:post_processor)
+			post_processor
+		end
+	end
+
+	# @param String tag The opening delimeter.
+	# @param String str The string between delimeters.
+	def format(tag, str)
+	end
+	
+	module Utils
+		# Parses arguments in the form: `arg0 ; arg1 ; ...|att=val|att2=val|...`
+		#
+		# The first portion is the direct argument. For instance, a link like 
+		# `[~ link ; text ~]` or an image like `[! src ; alt !]`. The remaining
+		# piped args are key-value pairs (use `\\|` to escape) which might
+		# be embedded in the tag or signal some further transformations.
+		#
+		# @return An array where the last element is always a {{Hash}}
+		def parse_args(arg_str)
+			raw_args = arg_str.split(/(?<!\\)\|/)
+			args = raw_args.shift.split(/ ; /)
+			map = {}
+			raw_args.each do |rarg|
+				k, v = rarg.split('=', 2)
+				map[k] = v
+			end
+			args << map
+			args
+		end
+	end
+end

data/lib/eggshell/macro-handler.rb

@@ -17,24 +17,30 @@
 # misc content
 # @end_block_macro
 #
-# 
 module Eggshell::MacroHandler
-	def set_processor(proc)
-	end
+	include Eggshell::BaseHandler
+	include Eggshell::ProcessHandler
+
+	
+	COLLECT_NORMAL = :collect_normal
+	COLLECT_RAW_MACRO = :collect_raw_macro
+	COLLECT_RAW = :collect_raw
 
-	def process(buffer, macname, args, lines, indent)
+	# Indicates how to process lines contained with in the macro. {{COLLECT_NORMAL}}
+	# continues to evaluate block and macro content. {{COLLECT_RAW_MACRO}} collects
+	# all lines as raw unless a macro is encountered. {{COLLECT_RAW}} collects all
+	# lines as raw, regardless of nested macros.
+	# @todo needed?
+	def collection_type(macro)
+		COLLECT_NORMAL
 	end
 
 	module Defaults
 		class NoOpHandler
 			include Eggshell::MacroHandler
 
-			def set_processor(proc)
-				@proc = proc
-			end
-
-			def process(buffer, macname, args, lines, indent)
-				@proc._warn("couldn't find macro: #{macname}")
+			def process(name, args, lines, out, call_depth = 0)
+				@eggshell._warn("not implemented: #{macname}")
 			end
 		end	
 	end

data/lib/eggshell/parse-tree.rb

@@ -0,0 +1,149 @@
+# Holds a hierarchical collection of blocks and macros. The tree follows
+# this structure:
+#
+# pre. [
+# String*,
+# [:block, 'block_name', [], line_start]* # last entry is array of Eggshell::Line,
+# [:macro, 'macro_name', {}, [
+# 		__repeat_of_parse_tree
+# 		]
+# 	], line_start*
+# ]
+class Eggshell::ParseTree
+	BH = Eggshell::BlockHandler
+
+	IDX_TYPE = 0
+	IDX_NAME = 1
+	IDX_ARGS = 2
+	IDX_LINES = 3
+	IDX_LINES_START = 4
+	IDX_LINES_END = 5
+
+	def initialize
+		#@eggshell = eggshell
+		@modes = [:nil]
+		@tree = []
+		@lines = []
+		@macro_delims = []
+		@macro_open = []
+		@macro_ptr = []
+		@ptr = @tree
+	end
+	
+	def new_macro(line_obj, line_start)
+		line = line_obj.line
+		macro, args, delim = Eggshell::Processor.parse_macro_start(line)
+
+		push_block
+
+		if delim
+			@modes << :macro
+			@macro_delims << delim.reverse.gsub('[', ']').gsub('(', ')').gsub('{', '}')
+			@macro_open << line
+			@macro_ptr << @ptr
+			# set ptr to entry's tree
+			entry = [:macro, macro, args, [], line_start]
+			@ptr << entry
+			@ptr = entry[IDX_LINES]
+		else
+			@ptr << [:macro, macro, args, [], line_start]
+		end
+	end
+	
+	def macro_delim_match(line_obj, line_num)
+		if @macro_delims[-1] == line_obj.line
+			if @modes[-1] == :block
+				push_block
+			end
+			@macro_delims.pop
+			@macro_open.pop
+			@ptr = @macro_ptr.pop
+			@ptr[-1] << line_num
+			last_mode = @modes.pop
+			return true
+		end
+		return false
+	end
+
+	def new_block(handler, type, line_obj, consume_mode, line_start)
+		block_type, args, line = Eggshell::Processor.parse_block_start(line_obj.line)
+		nline = Eggshell::Line.new(line, line_obj.tab_str, line_obj.indent_lvl, line_obj.line_num)
+
+		if consume_mode != BH::DONE
+			@modes << :block
+			if line != ''
+				@lines << nline
+				line_start -= 1
+			end
+			@cur_block = [handler, type, args, line_start]
+			if consume_mode == BH::COLLECT_RAW
+				mode = :raw
+			else consume_mode == BH::COLLECT
+				mode = :block
+			end
+		else
+			@ptr << [:block, type, args, [nline], line_start]
+		end
+	end
+
+	def push_block
+		if @modes[-1] == :block
+			if @cur_block
+				line_end = @cur_block[3]
+				line_end = @lines[-1].line_num if @lines[-1]
+				@ptr << [:block, @cur_block[1], @cur_block[2], @lines, @cur_block[3], line_end]
+				@lines = []
+				@cur_block[0].reset
+				@cur_block = nil
+			end
+			@modes.pop
+		end
+	end
+
+	def collect(line_obj)
+		more = @cur_block[0].continue_with(line_obj.line)
+		if more != BH::RETRY
+			@lines << line_obj
+			if more == BH::DONE
+				push_block
+			end
+		else
+			push_block
+		end
+		more
+	end
+	
+	def raw_line(line_obj)
+		@ptr << line_obj
+	end
+	
+	def tree
+		@tree.clone
+	end
+	
+	# @todo return macro_open
+	
+	def mode
+		@modes[-1]
+	end
+	
+	# Does basic output of parse tree structure to visually inspect parsed info.
+	def self.walk(struct = nil, indent = 0, out = nil)
+		out = $stdout if !out
+		struct.each do |row|
+			if row.is_a?(Eggshell::Line)
+				out.write "#{'  '*indent}#{row.to_s.inspect} ##{row.line_num}\n"
+			elsif row.is_a?(Array)
+				if row[0] == :macro
+					out.write "#{'  '*indent}@#{row[1]}(#{row[2].inspect}) | end=#{row[-1]}\n"
+					walk(row[3], indent + 1, out)
+				elsif row[0] == :block
+					out.write "#{'  '*indent}#{row[1]}(#{row[2].inspect}) | end=#{row[-1]}\n"
+					walk(row[3], indent + 1, out)
+				end
+			else
+				out.write "#{'  '*indent}#{row.inspect} ?\n"
+			end
+		end
+	end
+end

data/lib/eggshell/processor-context.rb

@@ -1,28 +1,15 @@
 # Holds things like variables, line/char count, and other useful information for a {{Processor}} instance.
 class Eggshell::ProcessorContext
 	def initialize
-		@vars = {:references => {}, :toc => [], :include_paths => [], 'log.level' => '1'}
+		@vars = {:references => {}, :toc => [], :include_paths => [], 'log.level' => 1}
 		@funcs = {}
 		@macros = {}
-		@blocks = {}
+		@blocks = []
+		@blocks_map = {}
 		@block_params = {}
 		@expr_cache = {}
-
-		# keeps track of line counters based on include
-		@lcounters = [Eggshell::LineCounter.new]
+		@fmt_handlers = {}
 	end
 	
-	attr_reader :vars, :funcs, :macros, :blocks, :block_params, :expr_cache
-	
-	def push_line_counter
-		@lcounters << Eggshell::LineCounter.new
-	end
-	
-	def pop_line_counter
-		@lcounters.pop
-	end
-	
-	def line_counter
-		@lcounters[-1]
-	end
+	attr_reader :vars, :funcs, :macros, :blocks, :blocks_map, :block_params, :expr_cache, :fmt_handlers
 end