Module: Tagz

Included in:
Namespace::Globally, Namespace::Privately
Defined in:
lib/tagz.rb,
lib/tagz.rb

Overview

supporting code

Defined Under Namespace

Modules: Namespace

Class Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *a, &b) ⇒ Object (private)

catch special tagz methods



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
# File 'lib/tagz.rb', line 136

def method_missing(m, *a, &b)
  strategy =
    case m.to_s
      when %r/^(.*[^_])_(!)?$/o
        :open_tag
      when %r/^_([^_].*)$/o
        :close_tag
      when 'e'
        :element
      when '__', '___'
        :puts
      else
        nil
    end

  if(strategy.nil? or (tagz.nil? and Tagz.privately===self))
    begin
      return super
    ensure
      :do_nothing_until_strange_core_dump_in_ruby_2_5_is_fixed
      # $!.set_backtrace caller(1) if $!
    end
  end
  
  case strategy
    when :open_tag
      m, bang = $1, $2
      b ||= lambda{} if bang
      tagz{ tagz__(m, *a, &b) }

    when :close_tag
      m = $1
      tagz{ __tagz(m, *a, &b) }

    when :element
      Tagz.element.new(*a, &b)

    when :puts
      tagz do
        tagz.push("\n")
        unless a.empty?
          tagz.push(a.join)
          tagz.push("\n")
        end
      end
  end
end

Class Method Details

.descriptionObject



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# File 'lib/tagz.rb', line 13

def Tagz.description
  <<-____

    tagz.rb is generates html, xml, or any sgml variant like a small ninja
    running across the backs of a herd of giraffes swatting of heads like
    a mark-up weedwacker.  weighing in at less than 300 lines of code
    tagz.rb adds an html/xml/sgml syntax to ruby that is both unobtrusive,
    safe, and available globally to objects without the need for any
    builder or superfluous objects.  tagz.rb is designed for applications
    that generate html to be able to do so easily in any context without
    heavyweight syntax or scoping issues, like a ninja sword through
    butter.

  ____
end

.escape(*strings) ⇒ Object



408
409
410
# File 'lib/tagz.rb', line 408

def Tagz.escape(*strings)
  Tagz.escape_html(strings.join)
end

.escape!(options = {}) ⇒ Object

configure tagz escaping



491
492
493
494
495
496
497
498
499
500
501
# File 'lib/tagz.rb', line 491

def Tagz.escape!(options = {})
  options = {:keys => options, :values => options, :content => options} unless options.is_a?(Hash)

  escape_keys = options[:keys]||options['keys']||options[:key]||options['key']
  escape_values = options[:values]||options['values']||options[:value]||options['value']
  escape_contents = options[:contents]||options['contents']||options[:content]||options['content']

  Tagz.escape_keys!(!!escape_keys)
  Tagz.escape_values!(!!escape_values)
  Tagz.escape_contents!(!!escape_contents)
end

.escape_html(s) ⇒ Object



388
389
390
391
392
393
394
395
396
# File 'lib/tagz.rb', line 388

def Tagz.escape_html(s)
  s = s.to_s

  if Tagz.html_safe?(s)
    s
  else
    Tagz.html_safe(s.gsub(/[&"'><]/, Tagz.escape_html_map))
  end
end

.escape_html_mapObject

escape utils



380
381
382
# File 'lib/tagz.rb', line 380

def Tagz.escape_html_map
  @escape_html_map ||= { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
end

.escape_html_once(s) ⇒ Object



398
399
400
401
402
# File 'lib/tagz.rb', line 398

def Tagz.escape_html_once(s)
  result = s.to_s.gsub(Tagz.html_escape_once_regexp){|_| Tagz.escape_html_map[_]}

  Tagz.html_safe?(s) ? Tagz.html_safe(result) : result
end

.escape_html_once_regexpObject



384
385
386
# File 'lib/tagz.rb', line 384

def Tagz.escape_html_once_regexp
  @escape_html_once_regexp ||= /["><']|&(?!([a-zA-Z]+|(#\d+));)/
end

.escapeAttribute(*strings) ⇒ Object



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

def Tagz.escapeAttribute(*strings)
  Tagz.escape_html(strings.join)
end

.escapeHTML(*strings) ⇒ Object



404
405
406
# File 'lib/tagz.rb', line 404

def Tagz.escapeHTML(*strings)
  Tagz.escape_html(strings.join)
end

.h(string) ⇒ Object



449
450
451
# File 'lib/tagz.rb', line 449

def Tagz.h(string)
  Tagz.escape_html(string)
end

.html_mode!Object



515
516
517
518
519
520
521
# File 'lib/tagz.rb', line 515

def Tagz.html_mode!
  Tagz.escape!(
    :keys => true,
    :values => false,
    :content => false
  )
end

.html_safe(*args, &block) ⇒ Object

raw utils



418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
# File 'lib/tagz.rb', line 418

def Tagz.html_safe(*args, &block)
  html_safe = namespace(:HTMLSafe)

  if args.empty? and block.nil?
    return html_safe
  end

  first = args.first

  case
    when first.is_a?(html_safe)
      return first

    when args.size == 1
      string = first
      html_safe.new(string)

    else
      string = [args, (block ? block.call : nil)].flatten.compact.join(' ')
      html_safe.new(string)
  end
end

.html_safe?(string) ⇒ Boolean

Returns:

  • (Boolean)


441
442
443
# File 'lib/tagz.rb', line 441

def Tagz.html_safe?(string)
  string.html_safe? rescue false
end

.i_do_not_know_what_the_hell_i_am_doing!Object



505
506
507
# File 'lib/tagz.rb', line 505

def Tagz.i_do_not_know_what_the_hell_i_am_doing!
  escape!(true)
end

.i_know_what_the_hell_i_am_doing!Object



502
503
504
# File 'lib/tagz.rb', line 502

def Tagz.i_know_what_the_hell_i_am_doing!
  escape!(false)
end

.raw(*args, &block) ⇒ Object



445
446
447
# File 'lib/tagz.rb', line 445

def Tagz.raw(*args, &block)
  Tagz.html_safe(*args, &block)
end

.singleton_class(&block) ⇒ Object

singleton_class access for ad-hoc method adding from inside namespace



191
192
193
194
195
196
197
198
# File 'lib/tagz.rb', line 191

def Tagz.singleton_class(&block)
  @singleton_class ||= (
    class << Tagz
      self
    end
  )
  block ? @singleton_class.module_eval(&block) : @singleton_class
end

.versionObject



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

def Tagz.version()
  '9.10.0'
end

.xml_mode!Object



508
509
510
511
512
513
514
# File 'lib/tagz.rb', line 508

def Tagz.xml_mode!
  Tagz.escape!(
    :keys => true,
    :values => true,
    :contents => true
  )
end