class Eggshell::Bundles::Basics::BasicMacros

Macros:

Public Class Methods

new() click to toggle source
# File lib/eggshell/bundles/basics-old.rb, line 529
def initialize
        @capvar = nil
        @collbuff = nil
        @depth = 0
end

Public Instance Methods

do_include(paths, buff, depth, opts = {}) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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