Class: Eggshell::Bundles::Basic::ControlLoopMacros

Inherits:

Object

• Object
• Eggshell::Bundles::Basic::ControlLoopMacros

Includes:

MacroHandler

Defined in:

lib/eggshell/bundles/basics.rb

Overview

Provides iteration and conditional functionality.

Defined Under Namespace

Classes: WhileLoopWrapper

Constant Summary

Constants included from MacroHandler

MacroHandler::CHAIN_CONTINUE, MacroHandler::CHAIN_END, MacroHandler::CHAIN_NONE, MacroHandler::CHAIN_START, MacroHandler::COLLECT_NORMAL, MacroHandler::COLLECT_RAW, MacroHandler::COLLECT_RAW_MACRO

Instance Method Summary

• #chain_type(name) ⇒ Object
• #process(name, args, lines, out, call_depth = 0) ⇒ Object
• #set_processor(proc, opts = nil) ⇒ Object

  pre.

Methods included from MacroHandler

#collection_type

Instance Method Details

#chain_type(name) ⇒ Object

# File 'lib/eggshell/bundles/basics.rb', line 823

def chain_type(name)
	if name == 'if'
		return [MH::CHAIN_START, name]
	elsif name == 'elsif'
		return [MH::CHAIN_CONTINUE, 'if']
	elsif name == 'else'
		return [MH::CHAIN_END, 'if']
	end
	
	[MH::CHAIN_NONE, nil]
end

#process(name, args, lines, out, call_depth = 0) ⇒ Object

# File 'lib/eggshell/bundles/basics.rb', line 835

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[call_depth] = st
		# erase nested state
		@state[call_depth+1] = nil
	end

	p0 = args[0]
	if macname == :for || macname == :loop || macname == :while
		p1 = args[1] || 'raw'

		looper = nil
		loop_is_map = false

		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)
				if st[:iter][0].is_a?(Symbol)
					st[:iter] = @eggshell.expr_eval(st[:iter])
				end

				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 = out
		raw = p1 == 'raw'

		if looper
			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
					@eggshell.vars[st[:counter]] = i1
					val = i2
				else
					val = st[:iter][i1]
					@eggshell.vars[st[:counter]] = counter
				end

				# inject value into :item -- if it's an expression, evaluate first
				iter_item = val.is_a?(Array) && val[0].is_a?(Symbol) ? @eggshell.expr_eval(val) : val
				@eggshell.vars[st[:item]] = iter_item

				# 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
					collector << @eggshell.assemble(lines, call_depth + 1)
				end

				break if st[:break]
			end
		end
		
		# clear state
		@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
		if st[:cond_count] == nil || macname == :if
			st[:cond_count] = 0 
			st[:cond_eval] = false
			st[:cond_met] = false
		end

		last_action = st[:last_action]
		st[:last_action] = macname

		# @todo more checks (e.g. no elsif after else, no multiple else, etc.)
		if !st[:if] || (macname != :else && !cond)
			# @todo exception?
			return
		end

		if macname != :else
			if !st[:cond_eval]
				#cond_struct = Eggshell::ExpressionEvaluator.struct(cond)
				st[:cond_eval] = @eggshell.expr_eval(cond)
				#puts "#{cond.inspect} => #{st[:cond_eval]}"
			end
		else
			st[:cond_eval] = true
		end

		if st[:cond_eval] && !st[:cond_met]
			st[:cond_met] = true
			#process_lines(lines, buffer, depth + 1)
			@eggshell.assemble(lines, call_depth + 1, {:out => out})
		end
	elsif macname == :break
		lvl = p0 || 1
		i = call_depth - 1

		# set breaks at each found loop until # of levels reached
		while i >= 0
			st = @state[i]
			i -= 1
			next if !st
			if st[:type] == :for || st[:type] == :while || st[:type] == :loop
				lvl -= 1
				st[:break] = true
				break if lvl <= 0
			end
		end
	elsif macname == :next
		lvl = p0 || 1
		i = call_depth - 1

		# set breaks at each found loop until # of levels reached
		while i >= 0
			st = @state[i]
			i -= 1
			next if !st
			if st[:type] == :for || st[:type] == :while || st[:type] == :loop
				lvl -= 1
				st[:next] = true
				break if lvl <= 0
			end
		end
	end
end

#set_processor(proc, opts = nil) ⇒ Object

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(0, ‘stop’: var, ‘step’: 1, ‘items’: …, ‘item’: ‘varname’, ‘counter’: ‘varname’[, mode])

# File 'lib/eggshell/bundles/basics.rb', line 811

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

	@state = []
	# @todo set loop limits from opts or defaults
end