Template

# File lib/inversion/template.rb, line 245
def self::add_extensions( *modules )
        self.log.info "Adding extensions to %p: %p" % [ self, modules ]

        modules.each do |mod|
                include( mod )
                if mod.const_defined?( :ClassMethods )
                        submod = mod.const_get( :ClassMethods )
                        extend( submod )
                end
                if mod.const_defined?( :PrependedMethods )
                        submod = mod.const_get( :PrependedMethods )
                        prepend( submod )
                end
        end

end

# File lib/inversion/template.rb, line 153
def self::configure( config )
        if config
                Inversion.log.debug "Merging config %p with current config %p" % [ config, self.config ]
                merged_config = DEFAULT_CONFIG.merge( config )
                self.template_paths = Array( merged_config.delete(:template_paths) )
                self.config = merged_config
        else
                defaults = DEFAULT_CONFIG.dup
                self.template_paths = defaults.delete( :template_paths )
                self.config = defaults
        end
end

# File lib/inversion/template.rb, line 168
def self::load( path, parsestate=nil, opts={} )

        # Shift the options hash over if there isn't a parse state
        if parsestate.is_a?( Hash )
                opts = parsestate
                parsestate = nil
        end

        tmpl = nil
        path = Pathname( path )
        opts[:template_paths] ||= self.template_paths
        search_path = opts[:template_paths] + [ Dir.pwd ]
        self.log.debug "Searching template paths: %p" % [ search_path ]

        # Unrestricted template location.
        if path.absolute?
                tmpl = path

        # Template files searched under paths specified in 'template_paths', then
        # the current working directory. First match wins.
        else
                tmpl = search_path.collect {|dir| Pathname(dir) + path }.find do |fullpath|
                        fullpath.exist?
                end

                raise RuntimeError, "Unable to find template %p within configured paths %p" %
                        [ path.to_s, search_path ] if tmpl.nil?
        end

        # We trust files read from disk
        source = if opts.key?( :encoding )
                        tmpl.read( encoding: opts[:encoding] )
                else
                        tmpl.read
                end
        source.untaint

        # Load the instance and set the path to the source
        template = self.new( source, parsestate, opts )
        template.source_file = tmpl

        return template
end

# File lib/inversion/template.rb, line 264
def initialize( source, parsestate=nil, opts={} )
        if parsestate.is_a?( Hash )
                # self.log.debug "Shifting template options: %p" % [ parsestate ]
                opts = parsestate
                parsestate = nil
        else
                self.log.debug "Parse state is: %p" % [ parsestate ]
        end

        @source       = source
        @node_tree    = [] # Parser expects this to always be an Array
        @options      = self.class.config.merge( opts )
        @attributes   = {}
        @fragments    = {}
        @source_file  = nil
        @created_at   = Time.now
        @last_checked = @created_at

        self.parse( source, parsestate )
end