Class: Chef::Mixin::Template::TemplateContext

Inherits:
Erubis::Context
  • Object
show all
Includes:
ChefContext
Defined in:
lib/chef/mixin/template.rb

Overview

TemplateContext is the base context class for all templates in Chef. It defines user-facing extensions to the base Erubis::Context to provide enhanced features. Individual instances of TemplateContext can be extended to add logic to a specific template.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(variables) ⇒ TemplateContext

Returns a new instance of TemplateContext.



91
92
93
94
 
# File 'lib/chef/mixin/template.rb', line 91

def initialize(variables)
  super
  @_extension_modules = []
end

Instance Attribute Details

#_extension_modules ⇒ Object (readonly)

Returns the value of attribute _extension_modules.



43
44
45
 
# File 'lib/chef/mixin/template.rb', line 43

def _extension_modules
  @_extension_modules
end

#cookbook_name ⇒ String (readonly)

name of the cookbook containing the template resource, e.g.:

test

Returns:



53
54
55
 
# File 'lib/chef/mixin/template.rb', line 53

def cookbook_name
  @cookbook_name
end

#recipe_line ⇒ String (readonly)

line in the recipe containing the template resource, e.g.:

2

Returns:



77
78
79
 
# File 'lib/chef/mixin/template.rb', line 77

def recipe_line
  @recipe_line
end

#recipe_line_string ⇒ String (readonly)

string representation of the line in the recipe containing the template resource, e.g.:

/Users/lamont/solo/cookbooks/test/recipes/default.rb:2:in `from_file'

Returns:



65
66
67
 
# File 'lib/chef/mixin/template.rb', line 65

def recipe_line_string
  @recipe_line_string
end

#recipe_name ⇒ String (readonly)

name of the recipe containing the template resource, e.g.:

default

Returns:



59
60
61
 
# File 'lib/chef/mixin/template.rb', line 59

def recipe_name
  @recipe_name
end

#recipe_path ⇒ String (readonly)

path to the recipe containing the template resource, e.g.:

/Users/lamont/solo/cookbooks/test/recipes/default.rb

Returns:



71
72
73
 
# File 'lib/chef/mixin/template.rb', line 71

def recipe_path
  @recipe_path
end

#template_name ⇒ String (readonly)

name of the template source itself, e.g.:

foo.erb

Returns:



83
84
85
 
# File 'lib/chef/mixin/template.rb', line 83

def template_name
  @template_name
end

#template_path ⇒ String (readonly)

path to the template source itself, e.g.:

/Users/lamont/solo/cookbooks/test/templates/default/foo.erb

Returns:



89
90
91
 
# File 'lib/chef/mixin/template.rb', line 89

def template_path
  @template_path
end

Instance Method Details

#_extend_modules(module_names) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/chef/mixin/template.rb', line 185

def _extend_modules(module_names)
  module_names.each do |mod|
    context_methods = %i{node render render_template render_template_from_string}
    context_methods.each do |core_method|
      if mod.method_defined?(core_method) || mod.private_method_defined?(core_method)
        Chef::Log.warn("Core template method `#{core_method}' overridden by extension module #{mod}")
      end
    end
    extend(mod)
    @_extension_modules << mod
  end
end

#_public_instance_variables ⇒ Object

Collects instance variables set on the current object as a Hash suitable for creating a new TemplateContext. Instance variables that are only valid for this specific instance are omitted from the collection.



202
203
204
205
206
207
208
209
210
211
 
# File 'lib/chef/mixin/template.rb', line 202

def _public_instance_variables
  all_ivars = instance_variables
  all_ivars.delete(:@_extension_modules)
  all_ivars.inject({}) do |ivar_map, ivar_symbol_name|
    value = instance_variable_get(ivar_symbol_name)
    name_without_at = ivar_symbol_name.to_s[1..].to_sym
    ivar_map[name_without_at] = value
    ivar_map
  end
end

#_render_template(template, context, options = {}) ⇒ Object

INTERNAL PUBLIC API



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/chef/mixin/template.rb', line 157

def _render_template(template, context, options = {})
  begin
    # eruby = Erubis::Eruby.new(template, options)
    eruby = Erubis::Eruby.new(template, options)
    output = eruby.evaluate(context)
  rescue Object => e
    raise TemplateError.new(e, template, context, options)
  end

  # CHEF-4399
  # Erubis always emits unix line endings during template
  # rendering. Chef used to convert line endings to the
  # original line endings in the template. However this
  # created problems in cases when cookbook developer is
  # coding the cookbook on windows but using it on non-windows
  # platforms.
  # The safest solution is to make sure that native to the
  # platform we are running on is used in order to minimize
  # potential issues for the applications that will consume
  # this template.

  if ChefUtils.windows?
    output = output.gsub(/\r?\n/, "\r\n")
  end

  output
end

#node ⇒ Object

Returns the current node object, or raises an error if it’s not set. Provides API consistency, allowing users to reference the node object by the bare ‘node` everywhere.



103
104
105
106
107
108
 
# File 'lib/chef/mixin/template.rb', line 103

def node
  return @node if @node

  raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
    "include a node variable if you plan to use it."
end

#render(partial_name, options = {}) ⇒ Object

Takes the name of the partial, plus a hash of options. Returns a string that contains the result of the evaluation of the partial.

All variables from the parent template will be propagated down to the partial, unless you pass the variables option (see below).

Valid options are:

:local

If true then the partial name will be interpreted as the path to a file on the local filesystem; if false (the default) it will be looked up in the cookbook according to the normal rules for templates.

:source

If specified then the partial will be looked up with this name or path (according to the local option) instead of partial_name.

:cookbook

Search for the partial in the provided cookbook instead of the cookbook that contains the top-level template.

:variables

A Hash of variable_name => value that will be made available to the partial. If specified, none of the variables from the master template will be, so if you need them you will need to propagate them explicitly.



133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/chef/mixin/template.rb', line 133

def render(partial_name, options = {})
  raise "You cannot render partials in this context" unless @template_finder

  partial_variables = options.delete(:variables) || _public_instance_variables
  partial_variables[:template_finder] = @template_finder
  partial_context = self.class.new(partial_variables)
  partial_context._extend_modules(@_extension_modules)

  template_location = @template_finder.find(partial_name, options)
  _render_template(IO.binread(template_location), partial_context, filename: template_location)
end

#render_template(template_location) ⇒ Object 



145
146
147
 
# File 'lib/chef/mixin/template.rb', line 145

def render_template(template_location)
  _render_template(IO.binread(template_location), self, filename: template_location)
end

#render_template_from_string(template) ⇒ Object 



149
150
151
 
# File 'lib/chef/mixin/template.rb', line 149

def render_template_from_string(template)
  _render_template(template, self)
end