class Nokogiri::XML::Element

@see Nokogiri @private

Public Instance Methods

to_haml(tabs, options) click to toggle source

@see Html2haml::HTML::Node#to_haml

# File lib/html2haml/html.rb, line 292
def to_haml(tabs, options)
  return "" if converted_to_haml

  if name == "script" &&
      (attr_hash['type'].nil? || attr_hash['type'].to_s == "text/javascript") &&
      (attr_hash.keys - ['type']).empty?
    return to_haml_filter(:javascript, tabs, options)
  elsif name == "style" &&
      (attr_hash['type'].nil? || attr_hash['type'].to_s == "text/css") &&
      (attr_hash.keys - ['type']).empty?
    return to_haml_filter(:css, tabs, options)
  end

  output = tabulate(tabs)
  if options[:erb] && HAML_TAGS.include?(name)
    case name
    when "haml_loud"
      lines = CGI.unescapeHTML(inner_text).split("\n").
        map {|s| s.rstrip}.reject {|s| s.strip.empty?}

      if attribute("raw")
        lines.first.gsub!(/^[ \t]*/, "!= ")
      else
        lines.first.gsub!(/^[ \t]*/, "= ")
      end

      if lines.size > 1 # Multiline script block
        # Normalize the indentation so that the last line is the base
        indent_str = lines.last[/^[ \t]*/]
        indent_re = /^[ \t]{0,#{indent_str.count(" ") + 8 * indent_str.count("\t")}}/
        lines.map! {|s| s.gsub!(indent_re, '')}

        # Add an extra "  " to make it indented relative to "= "
        lines[1..-1].each {|s| s.gsub!(/^/, "  ")}

        # Add | at the end, properly aligned
        length = lines.map {|s| s.size}.max + 1
        lines.map! {|s| "%#{-length}s|" % s}

        if next_sibling && next_sibling.is_a?(Nokogiri::XML::Element) && next_sibling.name == "haml_loud" &&
            next_sibling.inner_text.split("\n").reject {|s| s.strip.empty?}.size > 1
          lines << "-#"
        end
      end
      return lines.map {|s| output + s + "\n"}.join
    when "haml_silent"
      return CGI.unescapeHTML(inner_text).split("\n").map do |line|
        next "" if line.strip.empty?
        "#{output}- #{line.strip}\n"
      end.join
    when "haml_block"
      return render_children("", tabs, options)
    end
  end

  if self.next && self.next.text? && self.next.content =~ /\A[^\s]/
    if self.previous.nil? || self.previous.text? &&
        (self.previous.content =~ /[^\s]\Z/ ||
         self.previous.content =~ /\A\s*\Z/ && self.previous.previous.nil?)
      nuke_outer_whitespace = true
    else
      output << "= succeed #{self.next.content.slice!(/\A[^\s]+/).dump} do\n"
      tabs += 1
      output << tabulate(tabs)
      #empty the text node since it was inserted into the block
      self.next.content = ""
    end
  end

  output << "%#{name}" unless name.to_s == 'div' &&
    (static_id?(options) ||
     static_classname?(options) &&
     attr_hash['class'].to_s.split(' ').any?(&method(:haml_css_attr?)))

  if attr_hash

    if static_id?(options)
      output << "##{attr_hash['id'].to_s}"
      remove_attribute('id')
    end
    if static_classname?(options)
      leftover = attr_hash['class'].to_s.split(' ').reject do |c|
        next unless haml_css_attr?(c)
        output << ".#{c}"
      end
      remove_attribute('class')
      set_attribute('class', leftover.join(' ')) unless leftover.empty?
    end
    output << haml_attributes(options) if attr_hash.length > 0
  end

  output << ">" if nuke_outer_whitespace
  output << "/" if to_xhtml.end_with?("/>")

  if children && children.size == 1
    child = children.first
    if child.is_a?(::Nokogiri::XML::Text)
      if !child.to_s.include?("\n")
        text = child.to_haml(tabs + 1, options)
        return output + " " + text.lstrip.gsub(/^\/, '') unless text.chomp.include?("\n") || text.empty?
        return output + "\n" + text
      elsif ["pre", "textarea"].include?(name) ||
          (name == "code" && parent.is_a?(::Nokogiri::XML::Element) && parent.name == "pre")
        return output + "\n#{tabulate(tabs + 1)}:preserve\n" +
          inner_text.gsub(/^/, tabulate(tabs + 2))
      end
    elsif child.is_a?(::Nokogiri::XML::Element) && child.name == "haml_loud"
      return output + child.to_haml(tabs + 1, options).lstrip
    end
  end

  render_children(output + "\n", tabs, options)
end

Private Instance Methods

attribute_value_can_be_bare_ruby?(value) click to toggle source
# File lib/html2haml/html.rb, line 440
def attribute_value_can_be_bare_ruby?(value)
  begin
    ruby = RubyParser.new.parse(value)
  rescue Racc::ParseError, RubyParser::SyntaxError
    return false
  end

  return false if ruby.nil?
  return true if ruby.sexp_type == :str   #regular string
  return true if ruby.sexp_type == :dstr  #string with interpolation
  return true if ruby.sexp_type == :lit   #symbol
  return true if ruby.sexp_type == :call && ruby.mass == 1 #local var or method with no params

  false
end
decode_entities(str) click to toggle source

TODO: this method is utterly awful, find a better way to decode HTML entities.

# File lib/html2haml/html.rb, line 484
def decode_entities(str)
  str.gsub(/&[\S]+;/) do |entity|
    begin
      [Nokogiri::HTML::NamedCharacters[entity[1..-2]]].pack("C")
    rescue TypeError
      entity
    end
  end
end
dynamic_attribute?(name, options) click to toggle source
# File lib/html2haml/html.rb, line 498
def dynamic_attribute?(name, options)
  options[:erb] and dynamic_attributes.key?(name)
end
dynamic_attributes() click to toggle source
# File lib/html2haml/html.rb, line 414
def dynamic_attributes
  #reject any attrs without <haml>
  @dynamic_attributes = attr_hash.select {|name, value| value =~ %r{<haml.*</haml} }
  @dynamic_attributes.each do |name, value|
    fragment = Nokogiri::XML.fragment(CGI.unescapeHTML(value))

    # unwrap interpolation if we can:
    if fragment.children.size == 1 && fragment.child.name == 'haml_loud'
      if attribute_value_can_be_bare_ruby?(fragment.text)
        value.replace(fragment.text.strip)
        next
      end
    end

    # turn erb into interpolations
    fragment.css('haml_loud').each do |el|
      inner_text = el.text.strip
      next if inner_text == ""
      el.replace('#{' + inner_text + '}')
    end

    # put the resulting text in a string
    value.replace('"' + fragment.text.strip + '"')
  end
end
haml_attribute_pair(name, value, options) click to toggle source

Returns the string representation of a single attribute key value pair

# File lib/html2haml/html.rb, line 528
def haml_attribute_pair(name, value, options)
  value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect

  if options[:html_style_attributes]
    return "#{name}=#{value}"
  end

  if name.index(/\W/)
    return "#{name.inspect} => #{value}"
  end

  if options[:ruby19_style_attributes]
    return "#{name}: #{value}"
  end

  ":#{name} => #{value}"
end
haml_attributes(options) click to toggle source

Returns a string representation of an attributes hash that's prettier than that produced by Hash#inspect

# File lib/html2haml/html.rb, line 516
def haml_attributes(options)
  attrs = attr_hash.sort.map do |name, value|
    haml_attribute_pair(name, value.to_s, options)
  end
  if options[:html_style_attributes]
    "(#{attrs.join(' ')})"
  else
    "{#{attrs.join(', ')}}"
  end
end
haml_css_attr?(attr) click to toggle source
# File lib/html2haml/html.rb, line 510
def haml_css_attr?(attr)
  attr =~ /^[-:\w]+$/
end
render_children(so_far, tabs, options) click to toggle source
# File lib/html2haml/html.rb, line 408
def render_children(so_far, tabs, options)
  (self.children || []).inject(so_far) do |output, child|
    output + child.to_haml(tabs + 1, options)
  end
end
static_attribute?(name, options) click to toggle source
# File lib/html2haml/html.rb, line 494
def static_attribute?(name, options)
  attr_hash[name] && !dynamic_attribute?(name, options)
end
static_classname?(options) click to toggle source
# File lib/html2haml/html.rb, line 506
def static_classname?(options)
  static_attribute?('class', options)
end
static_id?(options) click to toggle source
# File lib/html2haml/html.rb, line 502
def static_id?(options)
  static_attribute?('id', options) && haml_css_attr?(attr_hash['id'])
end
to_haml_filter(filter, tabs, options) click to toggle source
# File lib/html2haml/html.rb, line 457
def to_haml_filter(filter, tabs, options)
  content =
    if children.first && children.first.cdata?
      decode_entities(children.first.content_without_cdata_tokens)
    else
      decode_entities(self.inner_text)
    end

  content = erb_to_interpolation(content, options)
  content.gsub!(/\A\s*\n(\s*)/, '\1')
  original_indent = content[/\A(\s*)/, 1]
  if content.split("\n").all? {|l| l.strip.empty? || l =~ /^#{original_indent}/}
    content.gsub!(/^#{original_indent}/, tabulate(tabs + 1))
  else
    # Indentation is inconsistent. Strip whitespace from start and indent all
    # to ensure valid Haml.
    content.lstrip!
    content.gsub!(/^/, tabulate(tabs + 1))
  end

  content.rstrip!
  content << "\n"

  "#{tabulate(tabs)}:#{filter}\n#{content}"
end