Class: Eggshell::Bundles::Basics::ControlMacros

Inherits:

Object

• Object
• Eggshell::Bundles::Basics::ControlMacros

Includes:

MacroHandler

Defined in:

lib/eggshell/bundles/basics-old.rb

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

• #initialize ⇒ ControlMacros constructor

  A new instance of ControlMacros.

• #process(buffer, macname, args, lines, depth) ⇒ Object
• #set_processor(eggshell) ⇒ Object

Methods included from MacroHandler

#chain_type, #collection_type

Constructor Details

#initialize ⇒ ControlMacros

Returns a new instance of ControlMacros.

# File 'lib/eggshell/bundles/basics-old.rb', line 638

def initialize
	@stack = []
	@state = []
	@macstack = []
end

Instance Method Details

#process(buffer, macname, args, lines, depth) ⇒ Object

# File 'lib/eggshell/bundles/basics-old.rb', line 649

def process(buffer, macname, args, lines, depth)
	p0 = args.is_a?(Array) ? args[0] : nil
	lines ? lines.delete('') : ''

	macname = macname.to_sym
	st = @state[depth]
	if !@state[depth]
		st = {:type => macname}

		@state[depth] = st
		# erase nested state
		@state[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 = []
		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
			end
		end

		collector = []
		if looper
			counter = 0
			looper.each do |i1, i2|
				# for maps, use key as the counter
				val = nil
				if loop_is_map
					@proc.vars[st[:counter]] = i1
					val = i2
				else
					val = i1
					@proc.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)
						end
					end
				else
					process_lines(lines, buffer, depth + 1, st[:raw])
				end
				break if st[:break]

				counter += 1
			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
	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.to_sym

		# @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] = @proc.expr_eval(cond_struct)[0]
			end
		else
			st[:cond_eval] = true
		end

		if st[:cond_eval] && !st[:cond_met]
			st[:cond_met] = true
			process_lines(lines, buffer, depth + 1)
		end
	elsif macname == :break
		lvl = p0 || 1
		i = 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 = 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(eggshell) ⇒ Object

# File 'lib/eggshell/bundles/basics-old.rb', line 644

def set_processor(eggshell)
	@proc = eggshell
	@proc.register_macro(self, *%w(if elsif else loop for while break next))
end