Class: Deplate::Template

Inherits:
Object
  • Object
show all
Defined in:
lib/deplate/template.rb

Constant Summary collapse

@@templateKeys = 
['pre', 'body', 'post', 'doc', 'ARG', 'arg', 'clip']
@@deplate_for_template = 
nil
@@deplate_options = 
{
    :formatter          => Deplate::Formatter::Template,
    :onthefly_particles => false,
    :vanilla            => true,
    :inherit_options    => true,
    :paragraph_class    => Deplate::Element::Paragraph,
     :elements  => [
        Deplate::Element::Region,
        Deplate::Element::Command, 
        Deplate::Element::Whitespace,
    ],
     :commands  => {
        'INC'        => Deplate::Command::INC,
        'INCLUDE'    => Deplate::Command::INC,
        'GET'        => Deplate::Command::GET,
        'ARG'        => Deplate::Command::ARG,
        'XARG'       => Deplate::Command::XARG,
        'VAL'        => Deplate::Command::ARG,
        'XVAL'       => Deplate::Command::XARG,
        'DOC'        => Deplate::Command::VAR,
        'VAR'        => Deplate::Command::VAR,
        'OPT'        => Deplate::Command::OPT,
        'PROP'       => Deplate::Command::OPT,
        'PP'         => Deplate::Command::OPT,
        'PREMATTER'  => Deplate::Command::PREMATTER,
        'POSTMATTER' => Deplate::Command::POSTMATTER,
        'BODY'       => Deplate::Command::BODY,
        'WITH'       => Deplate::Command::WITH,
    },
     :regions   => {
        'Foreach' => Deplate::Regions::Foreach,
        'For'     => Deplate::Regions::Foreach,
        'Mingle'  => Deplate::Regions::Mingle,
        'Native'  => Deplate::Regions::Native,
        'Ruby'    => Deplate::Regions::Ruby,
        'Doc'     => Deplate::Regions::Var,
        'Var'     => Deplate::Regions::Var,
    },
    
    :particles => [
        Deplate::Particle::Escaped,
        Deplate::Particle::Macro,
        Deplate::Particle::Whitespace,
    ],
     :macros    => {
        'get'  => Deplate::Macro::Clip,
        'clip' => Deplate::Macro::Clip,
        'opt'  => Deplate::Macro::Opt,
        'arg'  => Deplate::Macro::Arg,
        'xarg' => Deplate::Macro::XArg,
        'val'  => Deplate::Macro::Arg,
        'xval' => Deplate::Macro::XArg,
        'var'  => Deplate::Macro::Var,
        'doc'  => Deplate::Macro::Var,
        'ruby' => Deplate::Macro::Ruby,
        'msg'  => Deplate::Macro::Msg,
        'date' => Deplate::Macro::Date,
    },
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(args) ⇒ Template

Returns a new instance of Template.



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/deplate/template.rb', line 193

def initialize(args)
    @source    = args[:source]
    @template  = args[:template]
    @container = args[:container]
    @master    = args[:master]
    # @deplate_options = @@deplate_options.dup
    @deplate_options = @@deplate_options
    if @master
        @deplate_options[:options] = @master.options.dup
        @deplate_options[:options].input_def = nil
        @deplate_options[:options].input_class = nil
    else
        @deplate_options[:options] = OpenStruct.new
    end
                    
    if @template
        return
    end
    file = args[:file]
    if file
        if File.exists?(file)
            begin
                File.open(file) do |io|
                    @template = io.read
                end
            rescue Exception => e
                Deplate::DeplateForTemplates.log([e.message], :error, @source)
                @template = ''
            end
        else
            Deplate::DeplateForTemplates.log(['Template not found', file], :error, @source)
        end
    else
        Deplate::DeplateForTemplates.log('No template defined', :error, @source)
    end
end

Instance Attribute Details

#body ⇒ Object (readonly)

Returns the value of attribute body.



191
192
193
 
# File 'lib/deplate/template.rb', line 191

def body
  @body
end

#mingled ⇒ Object (readonly)

Returns the value of attribute mingled.



100
101
102
 
# File 'lib/deplate/template.rb', line 100

def mingled
  @mingled
end

#post ⇒ Object (readonly)

Returns the value of attribute post.



191
192
193
 
# File 'lib/deplate/template.rb', line 191

def post
  @post
end

#pre ⇒ Object (readonly)

Returns the value of attribute pre.



191
192
193
 
# File 'lib/deplate/template.rb', line 191

def pre
  @pre
end

#template ⇒ Object (readonly)

Returns the value of attribute template.



191
192
193
 
# File 'lib/deplate/template.rb', line 191

def template
  @template
end

Class Method Details

.copy(deplate, src, dest, invoker = nil) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/deplate/template.rb', line 173

def copy(deplate, src, dest, invoker=nil)
    tpl = File.open(src) {|io| io.read}
    src = invoker ? invoker.source : nil
    tpl = Deplate::Template.new(:template  => tpl,
                                :source => src,
                                :container => self)
    args = {}
    if block_given?
        yield(args)
    end
    Deplate::Define.let_variables(deplate, args) do
        tpl = tpl.fill_in(deplate, :source => src)
    end
    tpl = tpl.join("\n")
    File.open(dest, 'w') {|io| io.puts(tpl)}
end

.deplate_options ⇒ Object 



169
170
171
 
# File 'lib/deplate/template.rb', line 169

def deplate_options
    @@deplate_options
end

Instance Method Details

#fill_in(deplate, args = {}) ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/deplate/template.rb', line 230

def fill_in(deplate, args={})
    @deplate  = deplate
    @output   = args[:output]
    @pre      = args[:pre]
    @body     = args[:body]
    @post     = args[:post]
    @source   = args[:source]
    @consumed = {
        :pre  => [],
        :body => [],
        :post => [],
    }
    @keep_whitespace = args.has_key?(:keep_whitespace) ? args[:keep_whitespace] : true
    case deplate.variables['template_version']
    when '1'
        fill_in_1
    else
        fill_in_2
    end
end

#fill_in_1 ⇒ Object 



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/deplate/template.rb', line 291

def fill_in_1
    accum     = []
    template  = @template
    for key in @@templateKeys
        loop do
            m = send("rx_" + key).match(template)
            if m
                accum << m.pre_match
                template = m.post_match
                begin
                    accum << send("process_" + key, m[3])
                rescue Deplate::TemplateError
                    Deplate::DeplateForTemplates.log(["Template definition error", m[0]], :error, @source)
                rescue Exception => err
                    Deplate::DeplateForTemplates.log(["Template error", m[0], err], :error, @source)
                end
            else
                accum << template
                break
            end
        end
        template = accum.join
        accum = []
    end
    
    template.gsub!(/\\([{}])/, "\\1")
    return [template]
end

#fill_in_2 ⇒ Object 



251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/deplate/template.rb', line 251

def fill_in_2
    if @@deplate_for_template
        d = @@deplate_for_template
    else
        d = @@deplate_for_template = Deplate::DeplateForTemplates.new('', @deplate_options)
        d.reset(true)
        d.push_input_format('template')
    end
    keep_whitespace  = d.options.keep_whitespace
    master           = d.options.master
    template_manager = d.options.template_manager
    begin
        d.reset
        d.variables    = @deplate.variables.dup
        # d.doc_services = @deplate.doc_services
        d.set_all_clips(@deplate.get_unprocessed_clips)
        d.options.template_manager    = self
        d.options.keep_whitespace     = @keep_whitespace
        d.options.master              = @master
        d.options.content_output      = @output
        d.options.content_pre_matter  = @pre
        d.options.content_body        = @body
        d.options.content_post_matter = @post
        @mingled = {}
        if @source
            ln = @source.begin
            fn = @source.file
        else
            ln = nil
            fn = nil
        end
        rv = [d.printable_strings(@template, ln, fn)]
        return rv
    ensure
        d.options.keep_whitespace  = keep_whitespace
        d.options.master           = master
        d.options.template_manager = template_manager
    end
end

#gen_range(string) ⇒ Object 



351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
 
# File 'lib/deplate/template.rb', line 351

def gen_range(string)
    add = []
    del = []
    if string and !string.empty?
        for i in string.split(/\s+/)
            n = i.split(/\.\./).collect do |s|
                negative = s =~ /^-/
                s = s[1..-1] if negative
                unless s =~ /^\d+$/
                    s = @deplate.slot_names[s.intern]
                    if s == 0
                        Deplate::DeplateForTemplates.log("Slot is zero, which is most likely an error", :anyway, @source)
                    end
                end
                s = s.to_i
                negative ? -s : s
            end
            a, b, rest = n
            if rest
                Deplate::DeplateForTemplates.log(["Bad range definition", i], :error, @source)
            else
                if b == 0
                    b = 100
                end
                if a < 0
                    arr = del
                else
                    arr = add
                end
                case n.size
                when 1
                    arr << a.abs
                when 2
                    arr << Range.new(a.abs, b.abs)
                else
                    Deplate::DeplateForTemplates.log(["Bad range definition", i], :error, @source)
                end
            end
        end
    end
    return add.compact, del.compact
end

#process_arg(arg) ⇒ Object

alias :process_arg :process_doc

Raises:



444
445
446
447
448
449
450
451
452
453
 
# File 'lib/deplate/template.rb', line 444

def process_arg(arg)
    if arg
        text = @deplate.variables[arg]
        if text
            container = @container || Deplate::PseudoContainer.new(@deplate, :source => @source)
            return @deplate.parse_and_format(container, text)
        end
    end
    raise Deplate::TemplateError.new
end

#process_ARG(arg) ⇒ Object

Raises:



430
431
432
433
434
435
436
437
438
 
# File 'lib/deplate/template.rb', line 430

def process_ARG(arg)
    if arg
        text = @deplate.variables[arg]
        if text
            return @deplate.printable_strings(text, @source.begin, @source.file)
        end
    end
    raise Deplate::TemplateError.new
end

#process_body(arg) ⇒ Object 



412
413
414
 
# File 'lib/deplate/template.rb', line 412

def process_body(arg)
    template_get_content(@body, arg)
end

#process_clip(arg) ⇒ Object

Raises:



458
459
460
461
462
463
464
465
466
 
# File 'lib/deplate/template.rb', line 458

def process_clip(arg)
    if arg
        c = @deplate.get_clip(arg)
        if c
            return c.elt
        end
    end
    raise Deplate::TemplateError.new
end

#process_doc(arg) ⇒ Object 



419
420
421
422
423
424
425
 
# File 'lib/deplate/template.rb', line 419

def process_doc(arg)
    if arg
        @deplate.variables[arg]
    else
        raise Deplate::TemplateError.new
    end
end

#process_post(arg) ⇒ Object 



405
406
407
 
# File 'lib/deplate/template.rb', line 405

def process_post(arg)
    template_get_content(@post, arg)
end

#process_pre(arg) ⇒ Object 



398
399
400
 
# File 'lib/deplate/template.rb', line 398

def process_pre(arg)
    template_get_content(@pre, arg)
end

#rx_ARG ⇒ Object 



427
428
429
 
# File 'lib/deplate/template.rb', line 427

def rx_ARG
    /^[ \t]*#(ARG)(:\s*([^}\s]+)\s*)?$/
end

#rx_arg ⇒ Object 



440
441
442
 
# File 'lib/deplate/template.rb', line 440

def rx_arg
    /\{(arg)(:\s*([^}\s]+)\s*)\}/
end

#rx_body ⇒ Object 



409
410
411
 
# File 'lib/deplate/template.rb', line 409

def rx_body
    /^[ \t]*#(BODY)(:\s*([^}\s]+)\s*)?$/
end

#rx_clip ⇒ Object 



455
456
457
 
# File 'lib/deplate/template.rb', line 455

def rx_clip
    /\{(get)(:\s*([^}\s]+)\s*)\}/
end

#rx_doc ⇒ Object 



416
417
418
 
# File 'lib/deplate/template.rb', line 416

def rx_doc
    /\{(doc)(:\s*([^}\s]+)\s*)\}/
end

#rx_post ⇒ Object 



402
403
404
 
# File 'lib/deplate/template.rb', line 402

def rx_post
    /^[ \t]*#(POSTMATTER)(:\s*([^}\s]+)\s*)?$/
end

#rx_pre ⇒ Object 



395
396
397
 
# File 'lib/deplate/template.rb', line 395

def rx_pre
    /^[ \t]*#(PREMATTER)(:\s*([^}\s]+)\s*)?$/
end

#template_get_content(type, ranges) ⇒ Object 



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/deplate/template.rb', line 320

def template_get_content(type, ranges)
    case type
    when :pre
        content = @pre
    when :post
        content = @post
    when :body
        content = @body
    end

    acc = []
    cnt = content.dup
    for r in @consumed[type]
        cnt[r] = nil
    end
    add, del = gen_range(ranges)
    if add.empty?
        for i in del
            cnt[i] = nil
        end
        acc = cnt
    else
        @consumed[type] += add
        for i in add
            acc << cnt[i]
        end
    end

    return acc.flatten.compact.join("\n")
end