Module: Hpricot::Builder

Module | Hpricot::Builder
In: | lib/hpricot/builder.rb

### Methods

<< add_child build concat doctype head html_tag set tag! text text! xhtml_strict xhtml_transitional

### Public Class methods

set(option, value)

[Source]

    # File lib/hpricot/builder.rb, line 37
        def self.set(option, value)
          @@default[option] = value
        end

### Public Instance methods

<<(string)

Alias for text

add_child(ele)

[Source]

    # File lib/hpricot/builder.rb, line 41
        def add_child ele
          ele.parent = self
          self.children ||= []
          self.children << ele
          ele
        end

build(*a, &b)

[Source]

    # File lib/hpricot/builder.rb, line 120
        def build(*a, &b)
          Hpricot.build(*a, &b)
        end

concat(string)

Alias for text

doctype(target, pub, sys)

[Source]

    # File lib/hpricot/builder.rb, line 148
        def doctype(target, pub, sys)
          add_child DocType.new(target, pub, sys)
        end

head(*args, &block)

Builds a head tag. Adds a `meta` tag inside with Content-Type set to `text/html; charset=utf-8`.

[Source]

    # File lib/hpricot/builder.rb, line 156
        def head(*args, &block)
          tag!(:head, *args) do
            tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag
            instance_eval(&block)
          end
        end

html_tag(sym, *args, &block)

Every HTML tag method goes through an html_tag call. So, calling `div` is equivalent to calling `html_tag(:div)`. All HTML tags in Hpricot‘s list are given generated wrappers for this method.

If the @auto_validation setting is on, this method will check for many common mistakes which could lead to invalid XHTML.

[Source]

    # File lib/hpricot/builder.rb, line 130
        def html_tag(sym, *args, &block)
          if @auto_validation and @tagset.self_closing.include?(sym) and block
            raise InvalidXhtmlError, "the `#{sym}' element is self-closing, please remove the block"
          elsif args.empty? and block.nil?
            CssProxy.new(self, sym)
          else
            tag!(sym, *args, &block)
          end
        end

tag!(tag, *args, &block)

Create a tag named `tag`. Other than the first argument which is the tag name, the arguments are the same as the tags implemented via method_missing.

[Source]

    # File lib/hpricot/builder.rb, line 63
        def tag!(tag, *args, &block)
          ele_id = nil
          if @auto_validation and @tagset
              if !@tagset.tagset.has_key?(tag)
                  raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
              elsif args.last.respond_to?(:to_hash)
                  attrs = args.last.to_hash

                  if @tagset.forms.include?(tag) and attrs[:id]
                    attrs[:name] ||= attrs[:id]
                  end

                  attrs.each do |k, v|
                      atname = k.to_s.downcase.intern
                      unless k =~ /:/ or @tagset.tagset[tag].include? atname
                          raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
                      end
                      if atname == :id
                          ele_id = v.to_s
                          if @elements.has_key? ele_id
                              raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
                          end
                      end
                  end
              end
          end

          # turn arguments into children or attributes
          childs = []
          attrs = args.grep(Hash)
          childs.concat((args - attrs).flatten.map do |x|
            if x.respond_to? :to_html
              Hpricot.make(x.to_html)
            elsif x
              Text.new(x.fast_xs)
            end
          end.flatten)
          attrs = attrs.inject({}) do |hsh, ath|
            ath.each do |k, v|
              hsh[k] = v.to_s.fast_xs if v
            end
            hsh
          end

          # create the element itself
          tag = tag.to_s
          f = Elem.new(tag, attrs, childs, ETag.new(tag))

          # build children from the block
          if block
            build(f, &block)
          end

          add_child f
          f
        end

text(string)

Write a `string` to the HTML stream without escaping it.

[Source]

    # File lib/hpricot/builder.rb, line 54
        def text(string)
          add_child Text.new(string)
          nil
        end

text!(string)

Write a `string` to the HTML stream, making sure to escape it.

[Source]

    # File lib/hpricot/builder.rb, line 49
        def text!(string)
          add_child Text.new(string.fast_xs)
        end

xhtml_strict(attrs = {}, &block)

Builds an html tag with XHTML 1.0 Strict doctype instead.

[Source]

    # File lib/hpricot/builder.rb, line 172
        def xhtml_strict(attrs = {}, &block)
          # self.tagset = Hpricot::XHTMLStrict
          xhtml_html(attrs, &block)
        end

xhtml_transitional(attrs = {}, &block)

Builds an html tag. An XML 1.0 instruction and an XHTML 1.0 Transitional doctype are prepended. Also assumes `:xmlns => "www.w3.org/1999/xhtml", :lang => "en"`.

[Source]

    # File lib/hpricot/builder.rb, line 166
        def xhtml_transitional(attrs = {}, &block)
          # self.tagset = Hpricot::XHTMLTransitional
          xhtml_html(attrs, &block)
        end

[Validate]