Class: Eggshell::Bundles::Basics::BasicMacros

Inherits:

Object

• Object
• Eggshell::Bundles::Basics::BasicMacros

Includes:

MacroHandler

Defined in:

lib/eggshell/bundles/basics-old.rb

Overview

Macros:

• ‘include`

• ‘capture`

• ‘var`

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

• #do_include(paths, buff, depth, opts = {}) ⇒ Object
• #initialize ⇒ BasicMacros constructor

  A new instance of BasicMacros.

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

Methods included from MacroHandler

#chain_type, #collection_type

Constructor Details

#initialize ⇒ BasicMacros

Returns a new instance of BasicMacros.

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

def initialize
	@capvar = nil
	@collbuff = nil
	@depth = 0
end

Instance Method Details

#do_include(paths, buff, depth, opts = {}) ⇒ Object

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

def do_include(paths, buff, depth, opts = {})
	@proc.vars[:include_stack] = [] if !@proc.vars[:include_stack]
	paths = [paths] if !paths.is_a?(Array)
	# @todo check all include paths?
	paths.each do |inc|
		inc = @proc.expand_expr(inc.strip)
		checks = []
		if inc[0] != '/'
			@proc.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}"
			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
				begin
					buff << @proc.process(lines, depth + 1)
					@proc._debug("include: 200 #{inc}")
				rescue => ex
					@proc._error("include: 500 #{inc}: #{ex.message}")
				end
				
				@proc.vars[:include_stack].pop
				@proc.context.pop_line_counter
				break
			else
				@proc._warn("include: 404 #{inc}")
			end
		end
	end
end

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

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

def process(buffer, macname, args, lines, depth)
	if macname == '!'
		@proc.vars[:block_params] = @proc.expr_eval(args)
	elsif macname == 'process'
		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)
			else
				@proc.vars[key] = val
			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'
		paths = args[0]
		opts = args[1] || {}
		if opts['encoding']
			opts[:encoding] = opts['encoding']
		else
			opts[:encoding] = 'utf-8'
		end
		if lines && lines.length > 0
			paths = lines
		end
		do_include(paths, buffer, depth, opts)
	end
end

#set_processor(eggshell) ⇒ Object

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

def set_processor(eggshell)
	@proc = eggshell
	@proc.register_macro(self, *%w(! = capture var include process parse_test))
end