Class: Liza::Unit

Inherits:
Object
  • Object
show all
Defined in:
lib/liza/unit.rb

Direct Known Subclasses

Box, Controller, Panel, Part, System, Test

Defined Under Namespace

Classes: Error

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._erbs_for(format, names, allow_missing:) ⇒ Object 



574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/liza/unit.rb', line 574

def self._erbs_for format, names, allow_missing:
  ret = {}

  log_erb = log_level? :higher

  converters = DevBox[:shell].converters_to[format] || []
  converters_from = converters.map { _1[:from] }
  format_with_converters_from = [format, *converters_from]
  log "names #{stick :light_green, names.join(" ")} | formats #{stick :light_green, format_with_converters_from.join(" ")}" if log_erb

  names.each do |name|
    name_string = name.to_s
    log stick :onyx, "      #{name_string}#{".*.erb # filtering name  "} #{renderable_names.join(" ")}" if log_erb
    
    name_candidates = renderable_formats_for name_string
    if name_candidates.none?

      if allow_missing
        log stick :light_yellow, "      #{name_string}.#{format}.erb not found, but allow_missing: true" if log_erb
        found = Liza::Unit.erbs_defined.first
      else
        log stick :light_red, "    #{name}.#{format}.erb not found, and allow_missing: false"
        raise_error :renderer_not_found, name, format
      end

    else

      log stick :onyx, "      #{name_string}#{".*.erb # filtering format "}#{name_candidates.map(&:format).join(" ")}" if log_erb

      found = name_candidates.find do |erb|
        erb_format_sym = erb.format.to_sym
        format_with_converters_from.include? erb_format_sym
      end

      if found
        log stick :light_green, "      #{found.key} found" if log_erb
      else
        if allow_missing
          log stick :light_yellow, "    #{name}.#{format}.erb not found, but allow_missing: true" if log_erb
          found = Liza::Unit.erbs_defined.first
        else
          log stick :light_red, "    #{name}.#{format}.erb not found, and allow_missing: false"
          raise_error :renderer_not_found, name, format
        end
      end

    end

    ret[name] = found
  end

  ret
end

.add(list, key = nil, value) ⇒ Object 



111
112
113
114
115
116
117
 
# File 'lib/liza/unit.rb', line 111

def self.add list, key = nil, value
  if key
    fetch(list) { Hash.new }[key] = value
  else
    fetch(list) { Set.new } << value
  end
end

.cl ⇒ Object

:call-seq:

Unit.cl -> Class

Returns the class itself.



643
 
# File 'lib/liza/unit.rb', line 643

def self.cl() = self

.class_methods_defined ⇒ Array<Symbol>

Retrieves all defined class methods.

Returns:

  • (Array<Symbol>) —

    an array of all defined class method names



41
 
# File 'lib/liza/unit.rb', line 41

def self.class_methods_defined() = sections.values.map { _1[:class_methods] }.flatten

.const_added(name) ⇒ Object

Hook into constant definition to capture constants under the current section



27
28
29
30
31
32
33
34
 
# File 'lib/liza/unit.rb', line 27

def self.const_added(name)
  super
  # ensures dynamic constants are not captured
  return unless const_defined? name
  # ensures constants defined in the System class are not captured
  return if self < Liza::System
  sections[@current_section || :default][:constants] << name
end

.const_missing(name) ⇒ Object

CONST MISSING



70
71
72
73
74
75
76
77
78
 
# File 'lib/liza/unit.rb', line 70

def self.const_missing name
  Liza.const name
rescue Liza::ConstNotFound
  if Lizarb.ruby_supports_raise_cause?
    raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
  else
    raise NameError, "uninitialized constant #{name}", caller
  end
end

.constants_defined ⇒ Array<Symbol>

Retrieves all defined constants.

Returns:

  • (Array<Symbol>) —

    an array of all defined constant names



49
 
# File 'lib/liza/unit.rb', line 49

def self.constants_defined() = sections.values.map { _1[:constants] }.flatten

.define_error(error_key, &block) ⇒ Object 



225
226
227
228
229
230
231
232
233
 
# File 'lib/liza/unit.rb', line 225

def self.define_error(error_key, &block)
  self.const_set :Error, Class.new(StandardError) unless defined? Error

  error_class = Error
  error_class = Class.new error_class
  error_class = self.const_set "#{error_key.to_s.camelcase}Error", error_class
  
  errors[error_key] = [error_class, block]
end

.descendants_select(system:) ⇒ Object 



168
169
170
 
# File 'lib/liza/unit.rb', line 168

def self.descendants_select system:
  descendants.select { _1.system? system }
end

.division ⇒ Object

CONTROLLER



196
197
198
 
# File 'lib/liza/unit.rb', line 196

def self.division
  Liza::Controller
end

.erbs_available(ref = Liza::Unit) ⇒ Object 



544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
 
# File 'lib/liza/unit.rb', line 544

def self.erbs_available ref = Liza::Unit
  @erbs_available ||= begin
    h = {}

    ancestors.take_while do |ancestor|
      ancestor != ref
    end.reverse.each do |ancestor|
      ancestor.erbs_defined.each do |erb|
        h[erb.key] = erb
      end
    end

    h.values
  end
end

.erbs_defined ⇒ Object

class level methods



540
541
542
 
# File 'lib/liza/unit.rb', line 540

def self.erbs_defined
  @erbs_defined ||= ErbShell.load(self.source_location_radical)
end

.erbs_for(format, names, allow_missing:) ⇒ Object 



568
569
570
571
572
 
# File 'lib/liza/unit.rb', line 568

def self.erbs_for format, names, allow_missing:
  @erbs_for ||= {}
  k = "#{format}-#{names.join("-")}"
  @erbs_for[k] ||= _erbs_for format, names, allow_missing:
end

.errors ⇒ Object 



221
222
223
 
# File 'lib/liza/unit.rb', line 221

def self.errors
  fetch(:errors) { {} }
end

.fetch(key, &block) ⇒ Object 



119
120
121
122
123
 
# File 'lib/liza/unit.rb', line 119

def self.fetch key, &block
  x = get key
  x ||= set key, instance_eval(&block)
  x
end

.get(key) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/liza/unit.rb', line 86

def self.get key
  return settings[key] if settings.has_key? key

  found = nil

  for klass in ancestors
    break unless klass.respond_to? :settings

    if klass.settings.has_key? key
      found = klass.settings[key]

      break
    end
  end

  found = settings[key] = found.dup if found.is_a? Enumerable

  found
end

.instance_methods_defined ⇒ Array<Symbol>

Retrieves all defined instance methods.

Returns:

  • (Array<Symbol>) —

    an array of all defined instance method names



45
 
# File 'lib/liza/unit.rb', line 45

def self.instance_methods_defined() = sections.values.map { _1[:instance_methods] }.flatten

.log(log_level = App::DEFAULT_LOG_LEVEL, object, unit: self, method_name: nil, sidebar: nil, kaller: caller) ⇒ Object 



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
 
# File 'lib/liza/unit.rb', line 252

def self.log(
  log_level = App::DEFAULT_LOG_LEVEL,
  object,
  unit: self,
  method_name: nil,
  sidebar: nil,
  kaller: caller
)
  log_level = log_levels[log_level] if log_level.is_a? Symbol
  raise "invalid log_level `#{log_level}`" unless log_levels.values.include? log_level
  return unless log_level? log_level

  unit_class = unit.is_a?(Class) ? unit : unit.class
  object_class = object.is_a?(Class) ? object : object.class
  
  env = {}
  env[:type] = :log
  env[:unit] = unit
  env[:unit_class] = unit_class
  env[:method_name] = method_name
  env[:sidebar] = sidebar
  env[:message_log_level] = log_level
  env[:unit_log_level] = unit.log_level
  env[:caller] = kaller
  env[:object] = object
  env[:object_class] = object_class
  
  DevBox.logg env
end

.log? ⇒ Boolean

Returns:

  • (Boolean) 


392
 
# File 'lib/liza/unit.rb', line 392

def self.log?(...)= log_level?(...)

.log_array(log_level = :normal, array, prefix: "", kaller: ) ⇒ Object 



372
373
374
375
376
377
378
379
 
# File 'lib/liza/unit.rb', line 372

def self.log_array log_level = :normal, array, prefix: "", kaller: caller[1..-1]
  prefix = prefix.to_s
  size = array.size.to_s.size+1
  
  array.each.with_index do |v, i|
    log log_level, "#{prefix}#{i.to_s.ljust size} = #{v.inspect}", kaller: kaller
  end
end

.log_hash(log_level = :normal, hash, prefix: "", kaller: ) ⇒ Object 



352
353
354
355
356
357
358
359
 
# File 'lib/liza/unit.rb', line 352

def self.log_hash log_level = :normal, hash, prefix: "", kaller: caller[1..-1]
  prefix = prefix.to_s
  size = hash.keys.map(&:to_s).map(&:size).max
  
  hash.each do |k,v|
    log log_level, "#{prefix}#{k.to_s.ljust size} = #{v.to_s.inspect}", kaller: kaller
  end
end

.log_level(new_value = nil) ⇒ Object 



330
331
332
333
334
335
336
337
338
 
# File 'lib/liza/unit.rb', line 330

def self.log_level new_value = nil
  if new_value
    new_value = log_levels[new_value] if new_value.is_a? Symbol
    raise "invalid log_level `#{new_value}`" unless log_levels.values.include? new_value
    set :log_level, new_value
  else
    get :log_level
  end
end

.log_level?(log_level = App::DEFAULT_LOG_LEVEL) ⇒ Boolean

Returns:

  • (Boolean) 


395
396
397
398
 
# File 'lib/liza/unit.rb', line 395

def self.log_level? log_level = App::DEFAULT_LOG_LEVEL
  log_level = log_levels[log_level] if log_level.is_a? Symbol
  log_level <= self.log_level
end

.log_levels ⇒ Object

LOG



249
 
# File 'lib/liza/unit.rb', line 249

def self.log_levels()=App::LOG_LEVELS

.method_added(method_name) ⇒ Object

Hook into method definition to capture instance methods under the current section



22
23
24
 
# File 'lib/liza/unit.rb', line 22

def self.method_added(method_name)
  sections[@current_section || :default][:instance_methods] << method_name
end

.methods_defined ⇒ Object

Alias for class_methods_defined



37
 
# File 'lib/liza/unit.rb', line 37

def self.methods_defined() = class_methods_defined

.namespace ⇒ Object 



155
156
157
158
159
160
161
162
 
# File 'lib/liza/unit.rb', line 155

def self.namespace
  return @namespace if defined? @namespace

  @namespace ||= Object unless to_s.include? "::"
  @namespace ||= Liza if to_s.start_with? "Liza::"
  @namespace ||= system
  @namespace
end

.part(key, insertion = :default) ⇒ Object

Inserts a part into the unit.

Parameters:

  • key (Symbol) —

    the key of the part

  • insertion (Symbol) (defaults to: :default) —

    the insertion method



60
61
62
63
64
65
66
 
# File 'lib/liza/unit.rb', line 60

def self.part(key, insertion = :default)
  part_class = Liza.const "#{key}_part"
  insertion = part_class.insertion(insertion)

  section "#{key}_part"
  class_exec(&insertion)
end

.raise_error(error_key, *args, kaller: caller) ⇒ Object

Raises:

  • (error) 


235
236
237
238
 
# File 'lib/liza/unit.rb', line 235

def self.raise_error(error_key, *args, kaller: caller)
  error, message_block = errors[error_key]
  raise error, message_block.call(args), kaller
end

.reload! ⇒ Object 



630
631
632
 
# File 'lib/liza/unit.rb', line 630

def self.reload!
  Lizarb.reload
end

.renderable_formats_for(name_string) ⇒ Object 



564
565
566
 
# File 'lib/liza/unit.rb', line 564

def self.renderable_formats_for name_string
  erbs_available.select { _1.name == name_string }
end

.renderable_names ⇒ Object 



560
561
562
 
# File 'lib/liza/unit.rb', line 560

def self.renderable_names
  erbs_available.map(&:name).uniq
end

.section(name) ⇒ Object

Define a section



4
5
6
 
# File 'lib/liza/unit.rb', line 4

def self.section(name)
  @current_section = name.to_sym
end

.sections ⇒ Object

Retrieve the sections



9
10
11
 
# File 'lib/liza/unit.rb', line 9

def self.sections
  @sections ||= Hash.new { |h, k| h[k] = { constants: [], class_methods: [], instance_methods: [] } }
end

.set(key, value) ⇒ Object 



106
107
108
109
 
# File 'lib/liza/unit.rb', line 106

def self.set key, value
  settings[key] = value
  value
end

.settings ⇒ Object 



82
83
84
 
# File 'lib/liza/unit.rb', line 82

def self.settings
  @settings ||= {}
end

.singleton_method_added(method_name) ⇒ Object

Hook into singleton method definition to capture class methods under the current section



14
15
16
 
# File 'lib/liza/unit.rb', line 14

def self.singleton_method_added(method_name)
  sections[@current_section || :default][:class_methods] << method_name
end

.sleep(seconds) ⇒ Object 



407
408
409
410
 
# File 'lib/liza/unit.rb', line 407

def self.sleep(seconds)
  log :lower, "Sleeping for #{seconds}s... #{ "| #{caller[0]}" if log? :low }"
  Kernel.sleep seconds
end

.stick(*args) ⇒ Object 



312
313
314
 
# File 'lib/liza/unit.rb', line 312

def self.stick(*args)
  StickLog.new(*args)
end

.sticks(*args) ⇒ Object 



320
321
322
 
# File 'lib/liza/unit.rb', line 320

def self.sticks(*args)
  StickLog.bundle(*args)
end

.subclasses_select(system:) ⇒ Object 



164
165
166
 
# File 'lib/liza/unit.rb', line 164

def self.subclasses_select system:
  subclasses.select { _1.system? system }
end

.subunits ⇒ Object 



172
173
174
175
 
# File 'lib/liza/unit.rb', line 172

def self.subunits
  Lizarb.eager_load!
  subclasses.select { _1.name&.start_with?(/[A-Z]/) }
end

.system ⇒ Object

SYSTEM



202
203
204
205
206
207
208
209
 
# File 'lib/liza/unit.rb', line 202

def self.system
  if name&.include? "::"
    return System if first_namespace == "Liza"
    Object.const_get first_namespace
  else
    superclass.system
  end
end

.system?(system) ⇒ Boolean

Returns:

  • (Boolean) 


177
178
179
180
 
# File 'lib/liza/unit.rb', line 177

def self.system? system
  system = Liza.const "#{system}_system" if system.is_a? Symbol
  system == get(:system)
end

.test_class ⇒ Object

TEST



184
185
186
187
188
189
190
191
192
 
# File 'lib/liza/unit.rb', line 184

def self.test_class
  if first_namespace == "Liza"
    Liza.const_get "#{last_namespace}Test"
  elsif self < Liza::System
    const "#{last_namespace}Test"
  else
    Object.const_get "#{name}Test"
  end
end

.time_diff(t, digits = 4) ⇒ Object

:call-seq:

Unit.time_diff(t[, digits]) -> String

Returns a time difference string with a fixed decimal precision.

  • t: A time-like object to compare to the current time.
  • digits: Integer specifying the decimal precision (defaults to 4).

Raises ArgumentError if digits is not a positive Integer.

Raises:

  • (ArgumentError) 


663
664
665
666
667
668
 
# File 'lib/liza/unit.rb', line 663

def self.time_diff(t, digits = 4)
  raise ArgumentError, "digits must be a positive integer" unless digits.is_a?(Integer) && digits.positive?
  f = (Time.now.to_f - t.to_f).floor(digits)
  u, d = f.to_s.split "."
  "#{u}.#{d.ljust digits, "0"}"
end

Instance Method Details

#add(list, key = nil, value) ⇒ Object 



139
140
141
142
143
144
145
 
# File 'lib/liza/unit.rb', line 139

def add list, key = nil, value
  if key
    fetch(list) { Hash.new }[key] = value
  else
    fetch(list) { Set.new } << value
  end
end

#cl ⇒ Object

:call-seq:

unit_instance.cl -> Class

Returns the class of the current instance.



650
 
# File 'lib/liza/unit.rb', line 650

def cl() = self.class

#fetch(key, &block) ⇒ Object 



147
148
149
150
151
 
# File 'lib/liza/unit.rb', line 147

def fetch key, &block
  x = get key
  x ||= set key, instance_eval(&block)
  x
end

#get(key) ⇒ Object 



129
130
131
132
133
 
# File 'lib/liza/unit.rb', line 129

def get key
  return settings[key] if settings.has_key? key

  self.class.get key
end

#log(log_level = App::DEFAULT_LOG_LEVEL, object, unit: self, method_name: nil, sidebar: nil, kaller: caller) ⇒ Object 



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/liza/unit.rb', line 282

def log(
  log_level = App::DEFAULT_LOG_LEVEL,
  object,
  unit: self,
  method_name: nil,
  sidebar: nil,
  kaller: caller
)
  log_level = log_levels[log_level] if log_level.is_a? Symbol
  raise "invalid log_level `#{log_level}`" unless log_levels.values.include? log_level
  return unless log_level? log_level

  unit_class = unit.is_a?(Class) ? unit : unit.class
  object_class = object.is_a?(Class) ? object : object.class

  env = {}
  env[:type] = :log
  env[:unit] = unit
  env[:unit_class] = unit_class
  env[:method_name] = method_name
  env[:sidebar] = sidebar
  env[:message_log_level] = log_level
  env[:unit_log_level] = unit.log_level
  env[:caller] = kaller
  env[:object] = object
  env[:object_class] = object_class
  
  DevBox.logg env
end

#log? ⇒ Boolean

Returns:

  • (Boolean) 


393
 
# File 'lib/liza/unit.rb', line 393

def log?(...)= log_level?(...)

#log_array(log_level = :normal, array, prefix: "", kaller: ) ⇒ Object 



381
382
383
384
385
386
387
388
 
# File 'lib/liza/unit.rb', line 381

def log_array log_level = :normal, array, prefix: "", kaller: caller[1..-1]
  prefix = prefix.to_s
  size = array.size.to_s.size+1
  
  array.each.with_index do |v, i|
    log log_level, "#{prefix}#{i.to_s.ljust size} = #{v.inspect}", kaller: kaller
  end
end

#log_hash(log_level = :normal, hash, prefix: "", kaller: ) ⇒ Object 



361
362
363
364
365
366
367
368
 
# File 'lib/liza/unit.rb', line 361

def log_hash log_level = :normal, hash, prefix: "", kaller: caller[1..-1]
  prefix = prefix.to_s
  size = hash.keys.map(&:to_s).map(&:size).max
  
  hash.each do |k,v|
    log log_level, "#{prefix}#{k.to_s.ljust size} = #{v.to_s.inspect}", kaller: kaller
  end
end

#log_level(new_value = nil) ⇒ Object 



340
341
342
343
344
345
346
347
348
 
# File 'lib/liza/unit.rb', line 340

def log_level new_value = nil
  if new_value
    new_value = log_levels[new_value] if new_value.is_a? Symbol
    raise "invalid log_level `#{new_value}`" unless log_levels.values.include? new_value
    set :log_level, new_value
  else
    get :log_level
  end
end

#log_level?(log_level = App::DEFAULT_LOG_LEVEL) ⇒ Boolean

Returns:

  • (Boolean) 


400
401
402
403
 
# File 'lib/liza/unit.rb', line 400

def log_level? log_level = App::DEFAULT_LOG_LEVEL
  log_level = log_levels[log_level] if log_level.is_a? Symbol
  log_level <= self.log_level
end

#log_levels ⇒ Object 



250
 
# File 'lib/liza/unit.rb', line 250

def log_levels()= App::LOG_LEVELS

#log_render_convert(key, length, t, kaller:) ⇒ Object 



530
531
532
 
# File 'lib/liza/unit.rb', line 530

def log_render_convert key, length, t, kaller: 
  log "convert  #{"#{key}".ljust_blanks 23} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
end

#log_render_format(key, length, t, kaller:) ⇒ Object 



534
535
536
 
# File 'lib/liza/unit.rb', line 534

def log_render_format key, length, t, kaller: 
  log "format  #{"#{key}".ljust_blanks 23} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
end

#log_render_in(keys, kaller:) ⇒ Object 



514
515
516
517
518
519
520
 
# File 'lib/liza/unit.rb', line 514

def log_render_in keys, kaller: 
  if render_stack.any?
    log "render → #{keys.join " "}", kaller: kaller
  else
    log "render #{"→ " * keys.size}#{keys.join " "}", kaller: kaller
  end
end

#log_render_out(key, length, t, kaller:) ⇒ Object 



522
523
524
525
526
527
528
 
# File 'lib/liza/unit.rb', line 522

def log_render_out key, length, t, kaller: 
  if render_stack.any?
    log "render #{"← #{key}".ljust_blanks 25} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
  else
    log "render #{"← #{key}".ljust_blanks 25} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
  end
end

#raise_error(error_key, *args, kaller: caller) ⇒ Object

Raises:

  • (error) 


240
241
242
243
 
# File 'lib/liza/unit.rb', line 240

def raise_error(error_key, *args, kaller: caller)
  error, message_block = self.class.errors[error_key]
  raise error, message_block.call(args), kaller
end

#reload! ⇒ Object 



634
635
636
 
# File 'lib/liza/unit.rb', line 634

def reload!
  Lizarb.reload
end

#render(*keys, format: nil, converted: false, formatted: false, allow_missing: true) ⇒ Object 



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
 
# File 'lib/liza/unit.rb', line 454

def render(
  *keys,
  format: nil,
  converted: false,
  formatted: false,
  allow_missing: true
)
  original_render_format = @render_format
  format = @render_format ||= @format if format.nil?
  raise "@render_format or @format must be set, or format keyword-argument must be given" if format.nil?
  @render_format = format = format.to_sym

  log_rendering = log_level? :high
  
  if keys.any?
    log_render_in keys, kaller: caller if log_rendering

    erbs = self.class.erbs_for format, keys, allow_missing: allow_missing
    erbs.to_a.reverse.each do |key, erb|
      if true
        t = Time.now
        s = erb.result binding, self
        log_render_out "#{erb.name}.#{erb.format}", s.length, t.diff, kaller: caller if log_rendering
      end
      
      if converted and DevBox[:shell].convert? erb.format
        t = Time.now
        convert_env = {format: format, convert_in: s}
        DevBox.convert(convert_env)
        s = convert_env[:convert_out]
        log_render_convert "#{erb.name}.#{format}", s.length, t.diff, kaller: caller if log_rendering
      end

      if formatted and DevBox[:shell].format? erb.format
        t = Time.now
        format_env = {format: format, format_in: s}
        DevBox.format(format_env)
        s = format_env[:format_out]
        log_render_format "#{erb.name}.#{format}", s.length, t.diff, kaller: caller if log_rendering
      end

      render_stack.push s

      raise_error :render_stack_is_full, kaller: caller if render_stack.size > 10
    end

    @render_format = original_render_format
    render_stack.pop
  elsif render_stack.any?
    @render_format = original_render_format
    render_stack.pop
  else
    raise_error :render_stack_is_empty, kaller: caller
  end
end

#render!(*keys, format: nil, converted: false, formatted: false) ⇒ Object 



439
440
441
442
443
444
445
446
447
448
449
450
451
452
 
# File 'lib/liza/unit.rb', line 439

def render!(
  *keys,
  format: nil,
  converted: false,
  formatted: false
)
  render(
    *keys,
    format: format,
    converted: converted,
    formatted: formatted,
    allow_missing: false
  )
end

#render_stack ⇒ Object 



510
511
512
 
# File 'lib/liza/unit.rb', line 510

def render_stack
  @render_stack ||= []
end

#set(key, value) ⇒ Object 



135
136
137
 
# File 'lib/liza/unit.rb', line 135

def set key, value
  settings[key] = value
end

#settings ⇒ Object 



125
126
127
 
# File 'lib/liza/unit.rb', line 125

def settings
  @settings ||= {}
end

#sleep(seconds) ⇒ Object 



412
413
414
415
 
# File 'lib/liza/unit.rb', line 412

def sleep(seconds)
  log :lower, "Sleeping for #{seconds}s... #{ caller[0] if log? :low }"
  Kernel.sleep seconds
end

#stick(*args) ⇒ Object 



316
317
318
 
# File 'lib/liza/unit.rb', line 316

def stick(*args)
  StickLog.new(*args)
end

#sticks(*args) ⇒ Object 



324
325
326
 
# File 'lib/liza/unit.rb', line 324

def sticks(*args)
  StickLog.bundle(*args)
end

#system ⇒ Object 



213
214
215
 
# File 'lib/liza/unit.rb', line 213

def system
  self.class.system
end

#time_diff(t, digits = 4) ⇒ Object

:call-seq:

unit_instance.time_diff(t[, digits]) -> String

Convenience instance method delegating to Unit.time_diff. Returns the time difference string with the specified decimal precision.



677
 
# File 'lib/liza/unit.rb', line 677

def time_diff(t, digits = 4)= self.class.time_diff t, digits