module ActionView::Helpers::TagHelper

def cdata_section(content)

# =>
cdata_section(File.read("hello_world.txt"))

# => ]]>
cdata_section("")
==== Examples

and end with (and may not contain) the string ]]>.
otherwise be recognized as markup. CDATA sections begin with the string
are used to escape blocks of text containing characters which would
Returns a CDATA section with the given +content+. CDATA sections 
def cdata_section(content)
  "<![CDATA[#{content}]]>".html_safe
end

def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)

# =>
Hello world!

<% end -%>
Hello world!
<%= content_tag :div, :class => "strong" do -%>

# =>
content_tag("select", options, :multiple => true)
# =>

Hello world!


content_tag(:div, content_tag(:p, "Hello world!"), :class => "strong")
# =>

Hello world!


content_tag(:p, "Hello world!")
==== Examples

symbols or strings for the attribute names.
readonly), which you can give a value of true in the +options+ hash. You can use
The +options+ hash is used with attributes with no value like (disabled and
==== Options

Set escape to false to disable attribute value escaping.
in which case, you pass your +options+ as the second parameter.
Instead of passing the content as an argument, you can also use a block
HTML attributes by passing an attributes hash to +options+.
Returns an HTML block tag of type +name+ surrounding the +content+. Add 
def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
  if block_given?
    options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
    content_tag_string(name, capture(&block), options, escape)
  else
    content_tag_string(name, content_or_options_with_block, options, escape)
  end
end

def content_tag_string(name, content, options, escape = true) 

def content_tag_string(name, content, options, escape = true)
  tag_options = tag_options(options, escape) if options
  "<#{name}#{tag_options}>#{PRE_CONTENT_STRINGS[name.to_sym]}#{escape ? ERB::Util.h(content) : content}</#{name}>".html_safe
end

def escape_once(html)

# => "<< Accept & Checkout"
escape_once("<< Accept & Checkout")

# => "1 < 2 & 3"
escape_once("1 < 2 & 3")
==== Examples

Returns an escaped version of +html+ without affecting existing escaped entities. 
def escape_once(html)
  ActiveSupport::Multibyte.clean(html.to_s).gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |special| ERB::Util::HTML_ESCAPE[special] }
end

def tag(name, options = nil, open = false, escape = true)

# =>

tag("div", :data => {:name => 'Stephen', :city_state => %w(Chicago IL)})

# =>
tag("img", {:src => "open & shut.png"}, false, false)

# =>
tag("img", :src => "open & shut.png")

# =>
tag("input", :type => 'text', :disabled => true)

# =>

tag("br", nil, true)

# =>

tag("br")
==== Examples

from 1.4.3.
This may come in handy when using jQuery's HTML5-aware .data()
Values are encoded to JSON, with the exception of strings and symbols.

thus accessed as dataset.userId.
For example, a key +user_id+ would render as data-user-id and
To play nicely with JavaScript conventions sub-attributes are dasherized.

pointing to a hash of sub-attributes.
HTML5 data-* attributes can be set with a single +data+ key

+disabled+ and +readonly+.
Use +true+ with boolean attributes that can render with no value, like

You can use symbols or strings for the attribute names.
==== Options

escaping.
hash to +options+. Set +escape+ to false to disable attribute value
with HTML 4.0 and below. Add HTML attributes by passing an attributes
compliant. Set +open+ to true to create an open tag compatible
Returns an empty HTML tag of type +name+ which by default is XHTML 
def tag(name, options = nil, open = false, escape = true)
  "<#{name}#{tag_options(options, escape) if options}#{open ? ">" : " />"}".html_safe
end

def tag_options(options, escape = true) 

def tag_options(options, escape = true)
  unless options.blank?
    attrs = []
    options.each_pair do |key, value|
      if key.to_s == 'data' && value.is_a?(Hash)
        value.each do |k, v|
          unless v.is_a?(String) || v.is_a?(Symbol) || v.is_a?(BigDecimal)
            v = v.to_json
          end
          v = ERB::Util.html_escape(v) if escape
          attrs << %(data-#{k.to_s.dasherize}="#{v}")
        end
      elsif BOOLEAN_ATTRIBUTES.include?(key)
        attrs << %(#{key}="#{key}") if value
      elsif !value.nil?
        final_value = value.is_a?(Array) ? value.join(" ") : value
        final_value = ERB::Util.html_escape(final_value) if escape
        attrs << %(#{key}="#{final_value}")
      end
    end
    " #{attrs.sort * ' '}".html_safe unless attrs.empty?
  end
end