class MaRuKu::REXMLHTMLFragment

An HTMLFragment implementation using REXML

def add_class(class_name)

Add a class to the children of this fragment

def add_class(class_name)
  @fragment.each_element do |c|
    c.attributes['class'] = ((c.attributes['class']||'').split(' ') + [class_name]).join(' ')
  end
end

def first_node_name

The name of the first element in the fragment

def first_node_name
  first_child = @fragment.children.first
  (first_child && first_child.respond_to?(:name)) ? first_child.name : nil
end

def initialize(raw_html)

def initialize(raw_html)
  wrapped = '<!DOCTYPE html PUBLIC
//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN"
ttp://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">
l>' + raw_html.strip + '</html>'
  @fragment = REXML::Document.new(wrapped).root
end

def process_markdown_inside_elements(doc)

replace their contents with the processed version.
Process markdown within the contents of some elements and

def process_markdown_inside_elements(doc)
  elts = []
  @fragment.each_element('//*[@markdown]') do |e|
    elts << e
  end
  d = @fragment.children.first
  if d && HTML_INLINE_ELEMS.include?(first_node_name)
    elts << d unless d.attributes['markdown']
    elts += span_descendents(d)
  end
  # find span elements or elements with 'markdown' attribute
  elts.each do |e|
    # should we parse block-level or span-level?
    how = e.attributes['markdown']
    e.attributes.delete('markdown')
    next if "0" == how # user requests no markdown parsing inside
    parse_blocks = (how == 'block') || BLOCK_TAGS.include?(e.name)
    # Select all text children of e
    e.texts.each do |original_text|
      s = MaRuKu::Out::HTML.escapeHTML(original_text.value)
      unless s.strip.empty?
        # TODO extract common functionality
        parsed = parse_blocks ? doc.parse_text_as_markdown(s) : doc.parse_span(s)
        # restore leading and trailing spaces
        padding = /\A(\s*).*?(\s*)\z/.match(s)
        parsed = [padding[1]] + parsed + [padding[2]] if padding
        el = doc.md_el(:dummy, parsed)
        new_html = "<dummy>"
        el.children_to_html.each do |x|
          new_html << x.to_s
        end
        new_html << "</dummy>"
        newdoc = REXML::Document.new(new_html).root
        p = original_text.parent
        newdoc.children.each do |c|
          p.insert_before(original_text, c)
        end
        p.delete(original_text)
      end
    end
  end
end

def span_descendents(e)

Returns:

(Array) -

Parameters:

e (REXML::Element) -- An element.

def span_descendents(e)
  descendents = []
  e.each_element do |c|
    name = c.respond_to?(:name) ? c.name : nil
    if name && HTML_INLINE_ELEMS.include?(c.name)
      descendents << c
      descendents += span_descendents(c)
    end
  end
end

def to_html

def to_html
  formatter = REXML::Formatters::Default.new(true)
  @fragment.children.inject("") do |out, child|
    out << formatter.write(child, '')
  end
end

Modules

Classes