Module: Roda::RodaPlugins::PrecompileTemplates::ClassMethods

Defined in:
lib/roda/plugins/precompile_templates.rb

Instance Method Summary collapse

Instance Method Details

#freeze_template_caches! ⇒ Object

Freeze the template caches. Should be called after precompiling all templates during application startup, if you don’t want to allow templates to be cached at runtime. In addition to ensuring that no templates are compiled at runtime, this also speeds up rendering by freezing the template caches, so that a mutex is not needed to access them.



55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/roda/plugins/precompile_templates.rb', line 55

def freeze_template_caches!
  _freeze_layout_method

  opts[:render] = render_opts.merge(
    :cache=>render_opts[:cache].freeze,
    :template_method_cache=>render_opts[:template_method_cache].freeze,
  ).freeze
  self::RodaCompiledTemplates.freeze

  nil
end

#precompile_templates(pattern, opts = OPTS) ⇒ Object

Precompile the templates using the given options. Note that this doesn’t handle optimized template methods supported in newer versions of Roda, but there are still cases where makes sense to use it.

You can call precompile_templates with the pattern of templates you would like to precompile:

precompile_templates "views/**/*.erb"

That will precompile all erb template files in the views directory or any subdirectory.

If the templates use local variables, you need to specify which local variables to precompile, which should be an array of symbols:

precompile_templates 'views/users/_*.erb', locals: [:user]

You can specify other render options when calling precompile_templates, including :cache_key, :template_class, and :template_opts. If you are passing any of those options to render/view for the template, you should pass the same options when precompiling the template.

To compile inline templates, just pass a single hash containing an :inline to precompile_templates:

precompile_templates inline: some_template_string



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/roda/plugins/precompile_templates.rb', line 93

def precompile_templates(pattern, opts=OPTS)
  if pattern.is_a?(Hash)
    opts = pattern.merge(opts)
  end

  if locals = opts[:locals]
    locals.sort!
  else
    locals = EMPTY_ARRAY
  end

  compile_opts = if pattern.is_a?(Hash)
    [opts]
  else
    Dir[pattern].map{|file| opts.merge(:path=>File.expand_path(file, nil))}
  end

  instance = allocate
  compile_opts.each do |compile_opt|
    template = instance.send(:retrieve_template, compile_opt)
    begin
      Render.tilt_template_compiled_method(template, locals, self)
    rescue NotImplementedError
      # When freezing template caches, you may want to precompile a template for a
      # template type that doesn't support template precompilation, just to populate
      # the cache.  Tilt rescues NotImplementedError in this case, which we can ignore.
      nil
    end
  end

  nil
end

#precompile_views(views, locals = EMPTY_ARRAY) ⇒ Object

Precompile the given views with the given locals, handling optimized template methods.



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/roda/plugins/precompile_templates.rb', line 127

def precompile_views(views, locals=EMPTY_ARRAY)
  instance = allocate
  views = Array(views)

  if locals.empty?
    opts = OPTS
  else
    locals_hash = {}
    locals.each{|k| locals_hash[k] = nil}
    opts = {:locals=>locals_hash}
  end

  views.each do |view|
    instance.send(:retrieve_template, instance.send(:render_template_opts, view, opts))
  end

  if locals_hash
    views.each do |view|
      instance.send(:_optimized_render_method_for_locals, view, locals_hash)
    end
  end

  nil
end