Class: HammerBuilder::Abstract

Inherits:
Object
  • Object
show all
Extended by:
DynamicClasses
Defined in:
lib/hammer_builder/abstract.rb,
lib/hammer_builder/abstract/abstract_tag.rb,
lib/hammer_builder/abstract/abstract_double_tag.rb,
lib/hammer_builder/abstract/abstract_single_tag.rb

Overview

Abstract implementation of Builder

Direct Known Subclasses

Standard

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from DynamicClasses

dynamic_classes, extended, inherited

Constructor Details

#initialize ⇒ Abstract

creates a new builder This is quite expensive, HammerBuilder::Pool should be used



57
58
59
60
61
62
63
64
65
 
# File 'lib/hammer_builder/abstract.rb', line 57

def initialize()
  @_output  = ""
  @_stack   = []
  @_current = nil
  # tag classes initialization
  tags.each do |klass|
    instance_variable_set(:"@_#{klass}", self.class.dynamic_classes[klass.camelize.to_sym].new(self))
  end
end

Instance Attribute Details

#_current ⇒ Object Also known as: current

current tag being builded



50
51
52
 
# File 'lib/hammer_builder/abstract.rb', line 50

def _current
  @_current
end

Instance Method Details

#cdata(content) ⇒ Object

insersts CDATA with content



86
87
88
89
 
# File 'lib/hammer_builder/abstract.rb', line 86

def cdata(content)
  flush
  @_output << Strings::CDATA_START << content.to_s << Strings::CDATA_END
end

#comment(comment) ⇒ Object

inserts comment



80
81
82
83
 
# File 'lib/hammer_builder/abstract.rb', line 80

def comment(comment)
  flush
  @_output << Strings::COMMENT_START << comment.to_s << Strings::COMMENT_END
end

#flush ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

flushes open tag



150
151
152
153
154
155
 
# File 'lib/hammer_builder/abstract.rb', line 150

def flush
  if @_current
    @_current.flush
    @_current = nil
  end
end

#go_in(*variables, &block) ⇒ Object Also known as: dive

enables you to evaluate block inside the builder with variables

Examples:

HammerBuilder::Formatted.new.go_in('asd') do |string|
  div string
end.to_html! #=> "<div>asd</div>"


125
126
127
128
 
# File 'lib/hammer_builder/abstract.rb', line 125

def go_in(*variables, &block)
  instance_exec *variables, &block
  self
end

#html5 ⇒ Object

renders html5 doc type

Examples:

html5 # => <!DOCTYPE html>


94
95
96
 
# File 'lib/hammer_builder/abstract.rb', line 94

def html5
  raw "<!DOCTYPE html>\n"
end

#join(collection, glue = nil) { ... } ⇒ Object

joins and renders collection with glue

Examples:

join([1, 1.2], lambda { text ', ' }) {|o| text o }        # => "1, 1.2"
join([1, 1.2], ', ') {|o| text o }                        # => "1, 1.2"
join([->{ text 1 }, 1.2], ', ') {|o| text o }             # => "1, 1.2"

Parameters:

  • collection (Array<Proc, Object>) —

    of objects or lambdas

  • glue (Proc, String) (defaults to: nil) —

    can be String which is rendered with #text or block to render

Yields:

  • how to render objects from collection, Proc in collection does not use this block



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/hammer_builder/abstract.rb', line 186

def join(collection, glue = nil, &it)
  # TODO as helper? two block method call #join(collection, &item).with(&glue)
  glue_block = case glue
    when String
      lambda { text glue }
    when Proc
      glue
    else
      lambda { }
  end

  collection.each_with_index do |obj, i|
    glue_block.call() if i > 0
    obj.is_a?(Proc) ? obj.call : it.call(obj)
  end
end

#js(js, options = { }) ⇒ Object

renders js

Examples:

js 'a_js_function();' #=> <script type="text/javascript">a_js_function();</script>

Parameters:

  • options (Hash) (defaults to: { }) —

    a customizable set of options

Options Hash (options):

  • :cdata (Boolean) — default: false —

    should cdata be used?



173
174
175
176
 
# File 'lib/hammer_builder/abstract.rb', line 173

def js(js, options = { })
  use_cdata = options.delete(:cdata) || false
  script({ :type => "text/javascript" }.merge(options)) { use_cdata ? cdata(js) : text(js) }
end

#raw(text) ⇒ Object

unescaped text to output



74
75
76
77
 
# File 'lib/hammer_builder/abstract.rb', line 74

def raw(text)
  flush
  @_output << text.to_s
end

#render(object, method, *args) { ... } ⇒ Object Also known as: r

renders object with method

Parameters:

  • object (Object) —

    an object to render

  • method (Symbol) —

    a method name which is used for rendering

  • args —

    arguments passed to rendering method

Yields:

  • block passed to rendering method



162
163
164
165
 
# File 'lib/hammer_builder/abstract.rb', line 162

def render(object, method, *args, &block)
  object.__send__ method, self, *args, &block
  self
end

#reset ⇒ Object

resets the builder to the state after creation - much faster then creating a new one



99
100
101
102
103
104
 
# File 'lib/hammer_builder/abstract.rb', line 99

def reset
  flush
  @_output.clear
  @_stack.clear
  self
end

#set_variables(instance_variables) { ... } ⇒ Object

sets instance variables when block is yielded

Parameters:

  • instance_variables (Hash{String => Object}) —

    hash of names and values to set

Yields:

  • block when variables are set, variables are cleaned up afterwards



135
136
137
138
139
140
 
# File 'lib/hammer_builder/abstract.rb', line 135

def set_variables(instance_variables)
  instance_variables.each { |name, value| instance_variable_set("@#{name}", value) }
  yield(self)
  instance_variables.each { |name, _| remove_instance_variable("@#{name}") }
  self
end

#text(text) ⇒ Object

escapes text to output



68
69
70
71
 
# File 'lib/hammer_builder/abstract.rb', line 68

def text(text)
  flush
  @_output << CGI.escapeHTML(text.to_s)
end

#to_html ⇒ String

Returns output.

Returns:

  • (String) —

    output



143
144
145
146
 
# File 'lib/hammer_builder/abstract.rb', line 143

def to_html()
  flush
  @_output.clone
end