Class: Processor::ErbTemplate

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Processor

check_filelist, chmod, copy, #load_tags, local_execute, 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/erb_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/erb_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.



69
70
71
72
 
# File 'lib/depengine/processor/erb_template.rb', line 69

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

Instance Method Details

#parse(template, content) ⇒ Object 



74
75
76
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
120
 
# File 'lib/depengine/processor/erb_template.rb', line 74

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
      read_mode        = ''
      if RUBY_VERSION < '1.9'
        read_mode = 'r'
      else
        read_mode = 'rb'
      end
      File.open(template, read_mode) do |f|
        c = '' # rubocop:disable Lint/UselessAssignment
        f.ungetc c unless (c = f.getc) == "\uFEFF" # remove BOM, if present
        while line = f.gets # rubocop:disable Lint/AssignmentInCondition
          template_content << line
        end
      end
    else
      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 => 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
 
# File 'lib/depengine/processor/erb_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 options[:excludes]
      options[:excludes].each do |exclude|
        next unless target.include? exclude
        $log.writer.debug "Skip template #{target}"
        Find.prune
      end
    end

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