eggshell 1.0.3 → 1.1.1

data/lib/eggshell/expression-evaluator/parser.rb

@@ -0,0 +1,422 @@
+module Eggshell; class ExpressionEvaluator;
+module Parser
+	ST_NULL = 0
+	ST_NUM = 1
+	ST_STRING = 2
+	ST_STRING_EMBED = 4
+	ST_STRING_BLOCK = 8
+	ST_LABEL = 16
+	ST_LABEL_CALL = 17
+	ST_LABEL_MEMBER = 19
+	ST_OPERATOR = 32
+	ST_OPERATOR_TERN = 33
+	ST_GROUP = 64
+	ST_HASH = 128
+	ST_ARRAY = 256
+	ST_INDEX_ACCESS = ST_ARRAY|ST_LABEL
+	
+	CONSTS = {
+		'true' => true,
+		'false' => false,
+		'nil' => nil,
+		'null' => nil
+	}.freeze
+	
+	# Indicates only one statement allowed
+	FL_ONE_STATEMENT = 1
+	# Indicates that for an opening brace (e.g. `if (...) {`), collect remaining items after brace. 
+	FL_BRACE_OP_COLLECT = 2
+
+	# Builds a parse tree from the lexer.
+	class DefaultParser
+		def initialize()
+			@lexer = Eggshell::ExpressionEvaluator::Lexer.new(self)
+		end
+
+		def reset()
+			@tree = []
+			@ptr = @tree
+			@last_ptr = [@tree]
+			@tokens = []
+			@state = [ST_NULL]
+			@term_last = [nil]
+			@term_str = nil
+			@quote_delim = nil
+			@word_pos = 0
+			@expect_label = false
+			@array_state = [0]
+			@hash_state = [nil]
+			@last_comma = false
+		end
+
+		def emit(type, data = nil, ts = nil, te = nil)
+			word = data[ts...te].pack('c*')
+			@tokens << word # if type != :space
+			lst = @state[-1]
+			
+			# before inserting term, need to make sure it follows semantics of function/array
+			# @todo look out for case of '(,' or '[,'
+			arg_check = true
+			if lst == ST_LABEL_CALL
+				arg_check = @ptr.length == 0 || @last_comma
+			elsif lst == ST_ARRAY
+				arg_check = @ptr.length == 1 || @last_comma
+			end
+			#arg_check = arg_check && (@hash_state[-1] == :colon || @hash_state[-1] == :comma)
+			@last_comma = false if type != :space
+			
+			expr_frag = ''
+			if @tokens.length > 5
+				expr_frag = @tokens[@tokens.length-5..-2].join('')
+			else
+				expr_frag = @tokens[0..-2].join('')
+			end
+
+			# @todo need to track last literal/var/func for operator syntax check
+			if type == :escape
+				raise Exception.new("expecting identifier after '#{@ptr[-1][1]}'") if @expect_label
+				raise Exception.new("escaping character outside of string") if lst != ST_STRING
+				word_unesc = ESCAPE_MAP[word]
+				raise Exception.new("invalid escape sequence: #{word}") if !word_unesc
+
+				@term_str += word_unesc
+				return
+			elsif type == :str_delim
+				raise Exception.new("expecting identifier after '#{@ptr[-1][1]}', not #{word}") if @expect_label
+				if !@quote_delim
+					@term_last.pop if lst != ST_INDEX_ACCESS
+					raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+					if @hash_state[-1] == :key
+						@hash_state[-1] = :colon
+					elsif @hash_state[-1] == :value
+						@hash_state[-1] = :comma
+					elsif @hash_state[-1] == :comma
+						raise Exception.new("expecting comma after: #{expr_frag}")
+					end
+					@quote_delim = word
+					@state << ST_STRING
+					@term_str = ''
+				elsif @quote_delim == word
+					@quote_delim = nil
+					@state.pop
+					@ptr << @term_str
+					@term_str = nil
+				end
+			elsif lst == ST_STRING
+				@term_str += word
+			elsif type == :number_literal
+				@term_last.pop if lst != ST_INDEX_ACCESS
+				raise Exception.new("expecting identifier after: '#{@ptr[-1][1]}'") if @expect_label
+				raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+				@ptr << (word.index('.') ? word.to_f : word.to_i)
+
+				if @hash_state[-1] == :key
+					@hash_state[-1] = :colon
+				elsif @hash_state[-1] == :value
+					@hash_state[-1] = :comma
+				end
+			elsif type == :identifier
+				if lst == ST_LABEL_MEMBER
+					@state.pop
+					@ptr << word
+					@last_ptr[-1][-1] << @ptr
+					@ptr = @last_ptr.pop
+				elsif @expect_label
+					@ptr[-1][1] += word
+					@expect_label = false
+				else
+					raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+					
+					if CONSTS.has_key?(word)
+						@ptr << CONSTS[word]
+					else
+						@ptr << [:var, word]
+					end
+
+					if @hash_state[-1] == :key
+						@hash_state[-1] = :colon
+					elsif @hash_state[-1] == :value
+						@hash_state[-1] = :comma
+					end
+				end
+				@term_last << ST_LABEL
+			elsif type == :logical_op
+				# STORED AS: `[:op, [operand1, operator1, operand2, operator2, ...]]
+				# > @last_ptr holds entire structure, @ptr holds structure[1]
+				# @todo deal with - prefix
+				@term_last.pop
+				raise Exception.new("expecting identifier after '#{@ptr[-1][1]}'") if @expect_label
+				if word == '?'
+					tern = [:op_tern, nil, [], nil]
+					tern[1] = @last_ptr[-1].pop
+					@last_ptr[-1] << tern
+					@ptr = tern[2]
+					@state[-1] = ST_OPERATOR_TERN
+				elsif lst == ST_OPERATOR
+					op = word.to_sym
+					prec_l = OPERATOR_MAP[@ptr[-2]]
+					prec_r = OPERATOR_MAP[op]
+
+					if prec_r > prec_l
+						# need to group next 2 terms since this operator has higher precedence
+						nop = [:op, [@ptr.pop]]
+						@state << ST_OPERATOR
+						@ptr << nop
+						@last_ptr << @ptr
+						@ptr = nop[1]
+					elsif prec_l > prec_r
+						# check if @last_ptr[-1] is an op; pop if so
+						type = @last_ptr[-2].is_a?(Array) ? @last_ptr[-2][0][0] : nil
+						if type == :op
+							@state.pop
+							@last_ptr.pop
+							@ptr = @last_ptr[-1][0][1]
+						end
+					end
+					@ptr << op
+				else
+					lele = @ptr.pop
+					op = [:op, [lele, word.to_sym]]
+					@last_ptr << @ptr
+					@ptr << op
+					@ptr = op[1]
+					@state << ST_OPERATOR
+				end
+			elsif type == :paren_group
+				# STORED AS: [:group, [nested_statement]]
+				# STORED AS: [:func, 'funcname', [args*]]
+				raise Exception.new("expecting identifier after '#{@ptr[-1][1]}'") if @expect_label
+				if word == '('
+					if @term_last[-1] == ST_LABEL
+						@state << ST_LABEL_CALL
+						@ptr[-1][0] = :func
+						@ptr[-1][2] = []
+						
+						@last_ptr << @ptr
+						@ptr = @ptr[-1][2]
+						@expect_separator = ','
+					else
+						raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+						@state << ST_GROUP
+						@last_ptr << @ptr
+						@ptr << [:group, []]
+						@ptr = @ptr[-1][1]
+					end
+					@term_last.pop
+				else
+					do_close = false
+					if lst == ST_OPERATOR
+						do_close = @state[-2] == ST_GROUP
+						if do_close
+							@state.pop
+							@ptr = @last_ptr.pop[1]
+						end
+					else
+						do_close = lst == ST_LABEL_CALL || lst == ST_GROUP
+					end
+						
+					if do_close
+						s = @state.pop
+						@ptr = @last_ptr.pop
+						@expect_separator = nil
+
+						if @hash_state[-1] == :key
+							@hash_state[-1] = :colon
+						elsif @hash_state[-1] == :value
+							@hash_state[-1] = :comma
+						end
+					else
+						# @todo exception
+					end
+				end
+			elsif type == :brace_group
+				raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+				if word == '{'
+					if @hash_state[-1] && @hash_state[-1] != :value
+						raise Exception.new("invalid hash start")
+					end
+
+					@state << ST_HASH
+					@last_ptr << @ptr
+					@ptr = [:hash]
+					@hash_state << :key
+				else
+					if lst == ST_HASH
+						if @hash_state[-1] != :comma
+							msg = "missing value for key #{@ptr[-1]}"
+							msg = "missing ':' and a value for key #{@ptr[-1]}" if @hash_state[-1] == :key
+							msg = "missing a value for key #{@ptr[-1]}" if @hash_state[-1] == :value
+							raise Exception.new(msg)
+						end
+
+						@last_ptr[-1] << @ptr
+						@ptr = @last_ptr.pop
+						@state.pop
+						@hash_state.pop
+
+						if @hash_state[-1] == :key
+							@hash_state[-1] = :colon
+						elsif @hash_state[-1] == :value
+							@hash_state[-1] = :comma
+						end
+					else
+						# @todo throw exception
+					end
+				end
+			elsif type == :index_group
+				if word == '['
+					if @term_last[-1] == ST_LABEL
+						@state << ST_INDEX_ACCESS
+						@last_ptr << @ptr
+						@ptr = [:index_access]
+					else
+						raise Exception.new("missing a comma after: #{expr_frag}") if !arg_check
+						# @todo check if array being defined within index_access
+						if @hash_state[-1] && @hash_state[-1] != :value
+							raise Exception.new("invalid array start near: #{expr_frag}")
+						end
+
+						@ptr << [:array]
+						@state << ST_ARRAY
+						@last_ptr << @ptr
+						@ptr = @ptr[-1]
+					end
+				else
+					if lst == ST_INDEX_ACCESS
+						acc = @ptr
+						@ptr = @last_ptr.pop
+						@ptr[-1] << acc
+						@state.pop
+					elsif lst == ST_ARRAY
+						@ptr = @last_ptr.pop
+						@state.pop
+
+						if @hash_state[-1] == :key
+							@hash_state[-1] = :colon
+						elsif @hash_state[-1] == :value
+							@hash_state[-1] = :comma
+						end
+					else
+						# @todo throw exception
+					end
+				end
+			elsif type == :separator
+				# @todo need to ensure proper separation!!!
+				if word == '.'
+					if @term_last[-1] == ST_LABEL
+						@state << ST_LABEL_MEMBER
+						@last_ptr << @ptr
+						@ptr = [:member_access]
+					else
+						# @todo throw exception
+					end
+				elsif word == ','
+					if lst == ST_HASH
+						if @hash_state[-1] == :comma
+							@hash_state[-1] = :key
+						else
+							raise Exception.new("misplaced comma near: #{expr_frag}")
+						end
+					elsif lst == ST_ARRAY
+						@last_comma = true
+					elsif lst == ST_LABEL_CALL
+						@last_comma = true
+					end
+				elsif word == ';'
+				end
+			elsif type == :modifier
+				if word == ':'
+					if lst == ST_HASH
+						if @hash_state[-1] == :colon
+							@hash_state[-1] = :value
+						else
+							raise Exception.new("misplaced colon near: #{expr_frag} -- #{@hash_state[-1]}")
+						end
+					elsif lst == ST_OPERATOR_TERN
+						# assumes [:op_tern, cond, true, false] structure
+						tern = @last_ptr[-1][-1]
+						if tern[3] == nil
+							tern[3] = []
+							@ptr = tern[3]
+						else
+							# @todo throw exception. more than 1 ':' encountered
+						end
+					elsif @term_last[-1] == ST_LABEL
+						@ptr[-1][1] += ':'
+						@expect_label = true
+						@term_last[-1] = nil
+					end
+				end
+			elsif type == :space
+			else
+				puts "woooo"
+			end
+		end
+		
+		def parse(src, flags = 0)
+			reset
+			begin
+				@lexer.process(src)
+				@tree
+			rescue => ex
+				$stderr.write("parse exception: #{ex}\n")
+				$stderr.write("\t#{ex.backtrace.join("\n\t")}\n")
+				nil
+			end
+		end
+		
+		def debug
+			puts "STATE : #{@state.inspect}"
+			puts "TREE  : #{@tree.inspect}"
+			puts "  PTR : #{@ptr.inspect}"
+			puts "TOKENS: #{@tokens.inspect}"
+		end
+	end
+	
+	def self.reassemble(struct, sep = '')
+		buff = []
+		s = ''
+		struct.each do |ele|
+			if ele.is_a?(Array)
+				if ele[0] == :op
+					buff << reassemble(ele[1])
+				elsif ele[0] == :op_tern
+					buff << reassemble(ele[1])
+					buff << ' ? '
+					buff << reassemble(ele[2])
+					buff << ' : '
+					buff << reassemble(ele[3])
+				elsif ele[0] == :func
+					buff << ele[1] + '('
+					buff << reassemble(ele[2], ',')
+					buff << ')'
+				elsif ele[0] == :group
+					buff << '('
+					buff << reassemble(ele[1..-1])
+					buff << ')'
+				elsif ele[0] == :var
+					if ele.length > 2
+						buff << reassemble(ele[1..-1])
+					else
+						buff << ele[1]
+					end
+				elsif ele[0] == :index_access
+					buff << '['
+					if ele[1].is_a?(Array)
+						buff << reassemble(ele[1])
+					else
+						buff << ele[1]
+					end
+					buff << ']'
+				end
+			else
+				buff << s
+				buff << (ele.is_a?(String) ? '"' + ele.gsub('"', '\\"') + '"' : ele)
+				s = sep
+			end
+		end
+		
+		buff.join('')
+	end
+end
+end; end;

data/lib/eggshell/macro-handler.rb

@@ -21,7 +21,6 @@ module Eggshell::MacroHandler
 	include Eggshell::BaseHandler
 	include Eggshell::ProcessHandler
 
-	
 	COLLECT_NORMAL = :collect_normal
 	COLLECT_RAW_MACRO = :collect_raw_macro
 	COLLECT_RAW = :collect_raw
@@ -35,6 +34,19 @@ module Eggshell::MacroHandler
 		COLLECT_NORMAL
 	end
 
+	CHAIN_NONE = 0
+	CHAIN_START = 1
+	CHAIN_CONTINUE = 2
+	CHAIN_END = 3
+
+	# If a sequence of macros are related by conditional execution (if/elsif/else, for instance),
+	# this provides a hint to the processor in how to group and evaluate the macros.
+	#
+	# @return Array In the form `[CHAIN_TYPE, MACRO_START]`
+	def chain_type(macro)
+		[CHAIN_NONE, nil]
+	end
+
 	module Defaults
 		class NoOpHandler
 			include Eggshell::MacroHandler

data/lib/eggshell/parse-tree.rb

@@ -11,6 +11,7 @@
 # ]
 class Eggshell::ParseTree
 	BH = Eggshell::BlockHandler
+	MH = Eggshell::MacroHandler
 
 	IDX_TYPE = 0
 	IDX_NAME = 1
@@ -30,23 +31,23 @@ class Eggshell::ParseTree
 		@ptr = @tree
 	end
 	
-	def new_macro(line_obj, line_start)
+	def new_macro(line_obj, line_start, macro, args, delim, mode)
 		line = line_obj.line
-		macro, args, delim = Eggshell::Processor.parse_macro_start(line)
+		#macro, args, delim = Eggshell::Processor.parse_macro_start(line)
 
 		push_block
 
 		if delim
-			@modes << :macro
+			@modes << (mode == MH::COLLECT_RAW_MACRO ? :macro_raw : 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]
+			entry = [:macro, macro, args, [], line_start, line_start]
 			@ptr << entry
 			@ptr = entry[IDX_LINES]
 		else
-			@ptr << [:macro, macro, args, [], line_start]
+			@ptr << [:macro, macro, args, [], line_start, line_start]
 		end
 	end
 	
@@ -65,24 +66,26 @@ class Eggshell::ParseTree
 		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)
+	def new_block(handler, type, line_obj, consume_mode, line_start, eggshell)
+		block_type, args, line = eggshell.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
+			#@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
+				#mode = :raw
+				@modes << :raw
 			else consume_mode == BH::COLLECT
-				mode = :block
+				#mode = :block
+				@modes << :block
 			end
 		else
-			@ptr << [:block, type, args, [nline], line_start]
+			@ptr << [:block, type, args, [nline], line_start, line_start]
 		end
 	end
 
@@ -113,6 +116,10 @@ class Eggshell::ParseTree
 		more
 	end
 	
+	def collect_macro_raw(line_obj)
+		@ptr << line_obj
+	end
+	
 	def raw_line(line_obj)
 		@ptr << line_obj
 	end
@@ -127,6 +134,10 @@ class Eggshell::ParseTree
 		@modes[-1]
 	end
 	
+	def collect_mode
+		@collect_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
@@ -146,4 +157,44 @@ class Eggshell::ParseTree
 			end
 		end
 	end
+	
+	# Groups together chained macros. This ensures proper block-chain flow. Note that
+	# a related sequence is grouped within a {{pipe}} macro.
+	def self.condense(processor, units)
+		condensed  = []
+
+		last_macro = nil
+		units.each do |unit|
+			if !unit.is_a?(Array) || unit[0] == :block
+				condensed << unit
+			else
+				mhandler = processor.get_macro_handler(unit[1])
+				chain_type = nil
+				chain_macro = nil
+				chain_type, chain_macro = mhandler.chain_type(unit[1]) if mhandler
+				if chain_type != MH::CHAIN_NONE
+					if chain_type == MH::CHAIN_START
+						unit[3] = condense(processor, unit[3])
+						condensed << [:macro, 'pipe', [{'chained'=>chain_macro}], [unit], unit[4], -1]
+						last_macro = unit[1]
+					elsif chain_type == MH::CHAIN_CONTINUE && chain_macro == last_macro
+						unit[3] = condense(processor, unit[3])
+						condensed[-1][3] << unit
+					elsif chain_type == MH::CHAIN_END && chain_macro == last_macro
+						unit[3] = condense(processor, unit[3])
+						condensed[-1][3] << unit
+						condensed[-1][5] = unit[5]
+						last_macro = nil
+					else
+						condensed << unit
+						last_macro = nil
+					end
+				else
+					condensed << unit
+				end
+			end
+		end
+
+		condensed
+	end
 end