Class: Arrow::TemplateFactory

Inherits:
Object
  • Object
show all
Defined in:
lib/arrow/templatefactory.rb

Overview

The TemplateFactory class, which is responsible for interpreting the 'templates' section of the configuration, and providing template-loading and -caching according to that configuration,

Authors

Please see the file LICENSE in the top-level directory for licensing details.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Object

deprecate_class_method, deprecate_method, inherited

Constructor Details

#initialize(config) ⇒ TemplateFactory

Create a new TemplateFactory from the given configuration object, which should specify a loader class for templates.



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/arrow/templatefactory.rb', line 56

def initialize( config )
	@config = config
	@cache = nil
	
	if config.templates.cache
		@cache = Arrow::Cache.new(
			"Template Factory",
			config.templates.cacheConfig,
			&method(:template_expiration_hook) )
	end

	@loader = self.class.build_template_loader( config )
	@path = config.templates.path

	super()
end

Instance Attribute Details

#cache ⇒ Object

The Arrow::Cache object used to cache template objects.



79
80
81
 
# File 'lib/arrow/templatefactory.rb', line 79

def cache
  @cache
end

#loader ⇒ Object

The loader object that the factory uses to load templates



82
83
84
 
# File 'lib/arrow/templatefactory.rb', line 82

def loader
  @loader
end

#path ⇒ Object

The path to search for templates



85
86
87
 
# File 'lib/arrow/templatefactory.rb', line 85

def path
  @path
end

Class Method Details

.build_template_loader(config) ⇒ Object

Given an Arrow::Config object (+config+), attempt to load and instantiate the configured template loader object.



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/arrow/templatefactory.rb', line 28

def self::build_template_loader( config )

	# Resolve the loader name into the Class object by traversing
	# constants.
	klass = config.templates.loader.
		split( /::/ ).
		inject( Object ) {|mod, name|
			mod.const_get( name ) or raise ConfigError,
				"No such template loader class #{name} for #{mod.name}"
		}

	if klass.respond_to?( :load, false )
		Arrow::Logger[ self ].debug "Loader (%s) class responds to ::load; using it directly: %p" %
			[ klass.name, klass.method(:load) ]
		return klass
	else
		Arrow::Logger[ self ].debug "Loader (%s) expects instantiation." % [ klass.name ]
		return klass.new( config )
	end
end

Instance Method Details

#get_template(name) ⇒ Object

Load a template object with the specified name.



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/arrow/templatefactory.rb', line 89

def get_template( name )
	self.log.debug "Fetching template '#{name}'"

	if @cache
		self.log.debug "Doing cached fetch."
		tmpl = @cache.fetch( name, &method(:load_from_file) )

		if tmpl.changed?
			self.log.debug "Template has changed on disk: reloading"
			@cache.invalidate( name )
			tmpl = @cache.fetch( name, &method(:load_from_file) )
		end

		return tmpl.dup
	else
		self.log.debug "Caching disabled. Loading from file."
		return self.load_from_file( name )
	end
end

#load_from_file(name) ⇒ Object

Load a template from its source file (ie., if caching is turned off or if the cached version is either expired or not yet seen)



112
113
114
115
 
# File 'lib/arrow/templatefactory.rb', line 112

def load_from_file( name )
	self.log.debug "Loading template #{name} from the filesystem"
	return @loader.load( name, @path )
end

#template_expiration_hook(key, template) ⇒ Object

Called when a template is expired from the cache



119
120
121
 
# File 'lib/arrow/templatefactory.rb', line 119

def template_expiration_hook( key, template )
	self.log.debug "Template %s is expiring." % key
end