Module: Merb::Template

Defined in:
lib/merb-core/controller/template.rb

Defined Under Namespace

Classes: Erubis

Constant Summary collapse

EXTENSIONS = 
{}
METHOD_LIST = 
{}
MTIMES = 
{}

Class Method Summary collapse

Class Method Details

.engine_for(path) ⇒ Object

Finds the engine for a particular path.

Parameters

path<String>

The path of the file to find an engine for.

Returns

Class

The engine.



122
123
124
125
 
# File 'lib/merb-core/controller/template.rb', line 122

def engine_for(path)
  path = File.expand_path(path)      
  EXTENSIONS[path.match(/\.([^\.]*)$/)[1]]
end

.inline_template(io, mod = Merb::InlineTemplates) ⇒ Object

Takes a template at a particular path and inlines it into a module and adds it to the METHOD_LIST table to speed lookup later.

Parameters

io<#path>

An IO that responds to #path (File or VirtualFile)

mod<Module>

The module to put the compiled method into. Defaults to Merb::InlineTemplates

Notes

Even though this method supports inlining into any module, the method must be available to instances of AbstractController that will use it.



105
106
107
108
109
110
111
 
# File 'lib/merb-core/controller/template.rb', line 105

def inline_template(io, mod = Merb::InlineTemplates)
  path = File.expand_path(io.path)
  ret = METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
    engine_for(path).compile_template(io, template_name(path), mod)
  io.close
  ret
end

.load_template_io(path) ⇒ Object

For a given path, get an IO object that responds to #path.

This is so that plugins can override this if they provide mechanisms for specifying templates that are not just simple files. The plugin is responsible for ensuring that the fake path provided will work with #template_for, and thus the RenderMixin in general.

Parameters

path<String>

A full path to find a template for. This is the

path that the RenderMixin assumes it should find the template
in.

Returns

IO#path

An IO object that responds to path (File or VirtualFile).



49
50
51
 
# File 'lib/merb-core/controller/template.rb', line 49

def load_template_io(path)
  File.open(path, "r")
end

.register_extensions(engine, extensions) ⇒ Object

Registers the extensions that will trigger a particular templating engine.

Parameters

engine<Class>

The class of the engine that is being registered

extensions<Array>

The list of extensions that will be registered with this templating language

Raises

ArgumentError

engine does not have a compile_template method.

Example

Merb::Template.register_extensions(Merb::Template::Erubis, ["erb"])

Raises:

  • (ArgumentError) 


143
144
145
146
147
148
149
150
 
# File 'lib/merb-core/controller/template.rb', line 143

def register_extensions(engine, extensions) 
  raise ArgumentError, "The class you are registering does not have a compile_template method" unless
    engine.respond_to?(:compile_template)
  extensions.each{|ext| EXTENSIONS[ext] = engine }
  Merb::AbstractController.class_eval <<-HERE
    include #{engine}::Mixin
  HERE
end

.template_extensions ⇒ Object

Get all known template extensions

Returns

Array:: Extension strings.



86
87
88
 
# File 'lib/merb-core/controller/template.rb', line 86

def template_extensions
  EXTENSIONS.keys
end

.template_for(path, template_stack = []) ⇒ Object

Get the name of the template method for a particular path.

Parameters

path<String>

A full path to find a template method for.

template_stack<Array>

The template stack. Not used.

Returns

DOC



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/merb-core/controller/template.rb', line 63

def template_for(path, template_stack = [])
  path = File.expand_path(path)
  
  ret = 
  if Merb::Config[:reload_templates]
    file = Dir["#{path}.{#{template_extensions.join(',')}}"].first
    METHOD_LIST[path] = file ? inline_template(load_template_io(file)) : nil
  else
    METHOD_LIST[path] ||= begin
      file = Dir["#{path}.{#{template_extensions.join(',')}}"].first          
      file ? inline_template(load_template_io(file)) : nil
    end
  end
  
  ret
end

.template_name(path) ⇒ Object

Get the template’s method name from a full path. This replaces non-alphanumeric characters with __ and “.” with “_”

Collisions are potentially possible with something like: ~foo.bar and __foo.bar or !foo.bar.

Parameters

path<String>

A full path to convert to a valid Ruby method name

Returns

String

The template name.

We might want to replace this with something that varies the character replaced based on the non-alphanumeric character to avoid edge-case collisions.



27
28
29
30
 
# File 'lib/merb-core/controller/template.rb', line 27

def template_name(path)
  path = File.expand_path(path)      
  path.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_")
end