module ActionView::Helpers::TagHelper

def boolean_tag_option(key) 

def boolean_tag_option(key)
  %(#{key}="#{key}")
end

def cdata_section(content)

# => world]]>
cdata_section("hello]]>world")

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

# => ]]>
cdata_section("")

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)
  splitted = content.to_s.gsub(']]>', ']]]]><![CDATA[>')
  "<![CDATA[#{splitted}]]>".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
  content     = ERB::Util.h(content) if escape
  "<#{name}#{tag_options}>#{PRE_CONTENT_STRINGS[name.to_sym]}#{content}</#{name}>".html_safe
end

def data_tag_option(key, value, escape) 

def data_tag_option(key, value, escape)
  key   = "data-#{key.to_s.dasherize}"
  unless value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(BigDecimal)
    value = value.to_json
  end
  tag_option(key, value, escape)
end

def escape_once(html)

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

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

Returns an escaped version of +html+ without affecting existing escaped entities. 
def escape_once(html)
  ERB::Util.html_escape_once(html)
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_option(key, value, escape) 

def tag_option(key, value, escape)
  value = value.join(" ") if value.is_a?(Array)
  value = ERB::Util.h(value) if escape
  %(#{key}="#{value}")
end

def tag_options(options, escape = true) 

def tag_options(options, escape = true)
  return if options.blank?
  attrs = []
  options.each_pair do |key, value|
    if key.to_s == 'data' && value.is_a?(Hash)
      value.each_pair do |k, v|
        attrs << data_tag_option(k, v, escape)
      end
    elsif BOOLEAN_ATTRIBUTES.include?(key)
      attrs << boolean_tag_option(key) if value
    elsif !value.nil?
      attrs << tag_option(key, value, escape)
    end
  end
  " #{attrs.sort! * ' '}" unless attrs.empty?
end