Class: Processor::Template

Inherits:
Object
  • Object
show all
Includes:
Processor
Defined in:
lib/depengine/processor/template.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Processor

check_filelist, chmod, copy, #load_tags, mkdir, mklink, remove, tgz_file, untgz_file, unzip_file

Instance Attribute Details

#basepath ⇒ Object

Returns the value of attribute basepath.



4
5
6
 
# File 'lib/depengine/processor/template.rb', line 4

def basepath
  @basepath
end

#cdb=(value) ⇒ Object (writeonly)

Sets the attribute cdb

Parameters:

  • value —

    the value to set the attribute cdb to.



5
6
7
 
# File 'lib/depengine/processor/template.rb', line 5

def cdb=(value)
  @cdb = value
end

Class Method Details

.parse(template, content) ⇒ Object

This function returns the output of a parsed template, ‘template’ can be a filename or a String.



72
73
74
75
 
# File 'lib/depengine/processor/template.rb', line 72

def self.parse(template, content)
  $log.writer.debug "Parse Template #{template}"
  Template.new.parse(template, content)
end

Instance Method Details

#parse(template, content) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
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
 
# File 'lib/depengine/processor/template.rb', line 77

def parse(template, content)
  context = load_tags(content, @cdb)
  begin
    parser           = Radius::Parser.new(context, :tag_prefix => 't')
    template_content = ""
    result           = ""
    if File.file? template
      $log.writer.debug "template #{template} seems to be a file, reading it..."
      File.open(template, "rb") do |f|
        c = ""
        f.ungetc c unless (c = f.getc)=="\uFEFF" # remove BOM, if present
        while line = f.gets
          template_content << line
        end
      end
    else
      $log.writer.debug "tempalte is not a file, using it as source"
      template_content = template
    end

    result          = parser.parse(template_content)
    nested_result_1 = ""
    nested_result_2 = result
    nested_loop     = 0
    while( nested_result_1 != nested_result_2 )
      if nested_loop >= 100
        $log.writer.error "Template stack overflow, too many nested tags"
        exit 1
      end
      nested_result_1 = parser.parse(nested_result_2)
      nested_result_2 = parser.parse(nested_result_1)

      nested_loop = nested_loop + 1
   end
   result = nested_result_2
  rescue Exception => e
    $log.writer.error "Error in template processing: #{template}"
    $log.writer.error e.message
    exit 1
  end

  result
end

#parse_template(template_source, content, outdir, options = {}) ⇒ Object

Render a template and write the output to a file or directory structure under ‘basepath’



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/depengine/processor/template.rb', line 9

def parse_template(template_source, content, outdir, options={})
  Helper.validates_presence_of basepath, "Basepath not set for template engine"
  # expand basepath
  self.basepath = File.expand_path basepath

  if File.file?( File.join( basepath, template_source ) )
    source_root_path = File.join( basepath, File.dirname(template_source) )
    single_file      = File.join( basepath, template_source )
  else
    # source is a directory
    source_root_path = File.join( basepath, template_source)
    single_file      = nil
  end
  target_root_path = File.join( basepath, outdir )
  target_path      = target_root_path

  Find.find( single_file || source_root_path ) do |path|
    # next if we found ourself
    next if path == source_root_path

    sub_dir     = File.join( File.dirname( path ).split(/\//) - \
                  source_root_path.split(/\//) )
    target_path = File.join( target_root_path, sub_dir )
    target      = File.join( target_path, File.basename( path ) )

    if not options[:excludes].nil?
      options[:excludes].each do |exclude|
        if target.include? exclude
          $log.writer.debug "Skip template #{target}"
          Find.prune
          next
        end
      end
    end

    if File.directory? path
      if not File.directory? target
        FileUtils.mkdir_p( target )
        $log.writer.debug "Create directory #{target}"
      end
    else
      target_file = File.join( target_path, \
                               File.basename(target, ".tpl"))
      begin
        if not File.binary? path and not File.zero? path
          writer = File.new(target_file, 'w')
          writer.write(parse(path, content))
          writer.close if not writer.nil?
          writer = nil
        else
          FileUtils.cp(path, File.expand_path(target_file))
        end
      rescue Exception => e
        $log.writer.error "Can not write output from template to #{target_file}"
        $log.writer.error e.message
        exit 1
      end
    end
  end
end