Class: Chef::Resource::Template

Inherits:
File show all
Includes:
Mixin::Securable
Defined in:
lib/chef/resource/template.rb

Constant Summary

Constants inherited from Chef::Resource

FORBIDDEN_IVARS, HIDDEN_IVARS, SmartOSPackage

Instance Attribute Summary collapse

Attributes inherited from File

#checksum

Attributes inherited from Chef::Resource

#allowed_actions, #cookbook_name, #elapsed_time, #enclosing_provider, #not_if_args, #only_if_args, #params, #provider, #recipe_name, #resource_name, #retries, #retry_delay, #run_context, #source_line, #updated

Instance Method Summary collapse

Methods included from Mixin::Securable

#group, included, #mode, #owner

Methods included from Mixin::Securable::WindowsSecurableAttributes

#inherits

Methods inherited from File

#atomic_update, #backup, #content, #diff, #force_unlink, #manage_symlink_source, #path

Methods inherited from Chef::Resource

#action, #after_created, #as_json, #cookbook_version, #customize_exception, #defined_at, #delayed_notifications, dsl_name, #epic_fail, #events, find_subclass_by_name, #identity, identity_attr, #ignore_failure, #immediate_notifications, inherited, #inspect, #is, json_create, #load_prior_resource, #method_missing, #name, #node, #noop, #not_if, #notifies, #notifies_delayed, #notifies_immediately, #only_if, platform_map, provider_base, #provider_for_action, provides, #resolve_notification_references, resource_classes, resource_for_node, resource_for_platform, #resources, #run_action, #should_skip?, #state, state_attrs, strict_const_defined?, #subscribes, #supports, #to_hash, #to_json, #to_s, #to_text, #updated?, #updated_by_last_action, #updated_by_last_action?, #validate_action, #validate_resource_spec!

Methods included from Mixin::ConvertToClassName

#convert_to_class_name, #convert_to_snake_case, #filename_to_qualified_string, #snake_case_basename

Methods included from Mixin::Deprecation

#deprecated_ivar

Methods included from DSL::RegistryHelper

#registry_data_exists?, #registry_get_subkeys, #registry_get_values, #registry_has_subkeys?, #registry_key_exists?, #registry_value_exists?

Methods included from DSL::PlatformIntrospection

#platform?, #platform_family?, #value_for_platform, #value_for_platform_family

Methods included from Mixin::ParamsValidate

#lazy, #set_or_return, #validate

Methods included from DSL::DataQuery

#data_bag, #data_bag_item, #search

Constructor Details

#initialize(name, run_context = nil) ⇒ Template

Returns a new instance of Template.



35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/chef/resource/template.rb', line 35

def initialize(name, run_context=nil)
  super
  @resource_name = :template
  @action = "create"
  @source = "#{::File.basename(name)}.erb"
  @cookbook = nil
  @local = false
  @variables = Hash.new
  @provider = Chef::Provider::Template
  @inline_helper_blocks = {}
  @inline_helper_modules = []
  @helper_modules = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Chef::Resource

Instance Attribute Details

#inline_helper_blocks ⇒ Object (readonly)

Returns the value of attribute inline_helper_blocks.



32
33
34
 
# File 'lib/chef/resource/template.rb', line 32

def inline_helper_blocks
  @inline_helper_blocks
end

#inline_helper_modules ⇒ Object (readonly)

Returns the value of attribute inline_helper_modules.



33
34
35
 
# File 'lib/chef/resource/template.rb', line 33

def inline_helper_modules
  @inline_helper_modules
end

Instance Method Details

#cookbook(args = nil) ⇒ Object 



65
66
67
68
69
70
71
 
# File 'lib/chef/resource/template.rb', line 65

def cookbook(args=nil)
  set_or_return(
    :cookbook,
    args,
    :kind_of => [ String ]
  )
end

#helper(method_name, &block) ⇒ Object

Declares a helper method to be defined in the template context when rendering.

Example:

Basic usage:

Given the following helper:

helper(:static_value) { "hello from helper" }

A template with the following code:

<%= static_value %>

Will render as;

hello from helper

Referencing Instance Variables:

Any instance variables available to the template can be referenced in the method body. For example, you can simplify accessing app-specific node attributes like this:

helper(:app) { @node[:my_app_attributes] }

And use it in a template like this:

<%= app[:listen_ports] %>

This is equivalent to the non-helper template code:

<%= @node[:my_app_attributes][:listen_ports] %>

Method Arguments:

Helper methods can also take arguments. The syntax available for argument specification will be dependent on ruby version. Ruby 1.8 only supports a subset of the argument specification syntax available for method definition, whereas 1.9 supports the full syntax.

Continuing the above example of simplifying attribute access, we can define a helper to look up app-specific attributes like this:

helper(:app) { |setting| @node[:my_app_attributes][setting] }

The template can then look up attributes like this:

<%= app(:listen_ports) %>



115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/chef/resource/template.rb', line 115

def helper(method_name, &block)
  unless block_given?
    raise Exceptions::ValidationFailed,
      "`helper(:method)` requires a block argument (e.g., `helper(:method) { code }`)"
  end

  unless method_name.kind_of?(Symbol)
    raise Exceptions::ValidationFailed,
      "method_name argument to `helper(method_name)` must be a symbol (e.g., `helper(:method) { code }`)"
  end

  @inline_helper_blocks[method_name] = block
end

#helper_modules ⇒ Object

Compiles all helpers from inline method definitions, inline module definitions, and external modules into an Array of Modules. The context object for the template is extended with these modules to provide per-resource template logic.



192
193
194
 
# File 'lib/chef/resource/template.rb', line 192

def helper_modules
  compiled_helper_methods + compiled_helper_modules + @helper_modules
end

#helpers(module_name = nil, &block) ⇒ Object

Declares a module to define helper methods in the template’s context when rendering. There are two primary forms.

Inline Module Definition

When a block is given, the block is used to define a module which is then mixed in to the template context w/ ‘extend`.

Inline Module Example

Given the following code in the template resource:

helpers do
  # Add "syntax sugar" for referencing app-specific attributes
  def app(attribute)
    @node[:my_app_attributes][attribute]
  end
end

You can use it in the template like so:

<%= app(:listen_ports) %>

Which is equivalent to:

<%= @node[:my_app_attributes][:listen_ports] %>

External Module Form

When a module name is given, the template context will be extended with that module. This is the recommended way to customize template contexts when you need to define more than an handful of helper functions (but also try to keep your template helpers from getting out of hand–if you have very complex logic in your template helpers, you should further extract your code into separate libraries).

External Module Example

To extract the above inline module code to a library, you’d create a library file like this:

module MyTemplateHelper
  # Add "syntax sugar" for referencing app-specific attributes
  def app(attribute)
    @node[:my_app_attributes][attribute]
  end
end

And in the template resource:

helpers(MyTemplateHelper)

The template code in the above example will work unmodified.



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/chef/resource/template.rb', line 169

def helpers(module_name=nil,&block)
  if block_given? and !module_name.nil?
    raise Exceptions::ValidationFailed,
      "Passing both a module and block to #helpers is not supported. Call #helpers multiple times instead"
  elsif block_given?
    @inline_helper_modules << block
  elsif module_name.kind_of?(::Module)
    @helper_modules << module_name
  elsif module_name.nil?
    raise Exceptions::ValidationFailed,
      "#helpers requires either a module name or inline module code as a block.\n" +
      "e.g.: helpers do; helper_code; end;\n" +
      "OR: helpers(MyHelpersModule)"
  else
    raise Exceptions::ValidationFailed,
      "Argument to #helpers must be a module. You gave #{module_name.inspect} (#{module_name.class})"
  end
end

#local(args = nil) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/chef/resource/template.rb', line 73

def local(args=nil)
  set_or_return(
    :local,
    args,
    :kind_of => [ TrueClass, FalseClass ]
  )
end

#source(file = nil) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/chef/resource/template.rb', line 49

def source(file=nil)
  set_or_return(
    :source,
    file,
    :kind_of => [ String ]
  )
end

#variables(args = nil) ⇒ Object 



57
58
59
60
61
62
63
 
# File 'lib/chef/resource/template.rb', line 57

def variables(args=nil)
  set_or_return(
    :variables,
    args,
    :kind_of => [ Hash ]
  )
end