bean-kramdown 0.13.5

data/lib/kramdown/parser/bean_kramdown.rb

@@ -0,0 +1,25 @@
+require 'kramdown/parser/kramdown'
+
+module Kramdown
+  module Parser
+    class BeanKramdown < Kramdown
+
+      # Array with all the parsing methods that should be removed from the standard kramdown parser.
+      EXCEPT = [:codeblock_fenced, :block_extensions, :span_extensions]
+
+      # initialise new parsers
+      def initialize(source, options)
+        super
+        
+        @block_parsers.unshift(:info_box)
+        @span_parsers.unshift(:oembed)
+        
+        @block_parsers.delete_if {|i| EXCEPT.include?(i)}
+        @span_parsers.delete_if {|i| EXCEPT.include?(i)}
+      end
+
+      require 'kramdown/parser/bean_kramdown/info_box'
+      require 'kramdown/parser/bean_kramdown/oembed'
+    end
+  end
+end

data/lib/kramdown/parser/bean_kramdown/info_box.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/extensions'
+require 'kramdown/parser/kramdown/eob'
+
+module Kramdown
+  module Parser
+    class BeanKramdown
+
+      INFO_BOX_START = /^#{OPT_SPACE}% ?/
+
+      # Parse the info box at the current location.
+      def parse_info_box
+        result = @src.scan(PARAGRAPH_MATCH)
+        while !@src.match?(self.class::LAZY_END)
+          result << @src.scan(PARAGRAPH_MATCH)
+        end
+        result.gsub!(INFO_BOX_START, '')
+
+        el = new_block_el(:info_box)
+        @tree.children << el
+        parse_blocks(el, result)
+        true
+      end
+
+      define_parser(:info_box, INFO_BOX_START)
+
+
+    end
+  end
+end

data/lib/kramdown/parser/bean_kramdown/oembed.rb

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+#
+# This file has been edited to suit the needs of The Beans Group Ltd. Changes were made to the types of media availbable
+# images keep their ! however new types are ? for oembedd etc
+# If you wish to change the types of media you need to change the OEMBED_START constant to include your special symbol 
+# for the new media object as well as change the reg ex on the parser definition towards the bottom of this file.
+#
+
+require 'open-uri'
+require 'cgi'
+require 'json'
+
+module Kramdown
+  module Parser
+    class BeanKramdown
+
+      # Normalize the oembed identifier.
+      def normalize_oembed_id(id)
+        id.gsub(/(\s|\n)+/, ' ').downcase
+      end
+
+      OEMBED_DEFINITION_START = /^#{OPT_SPACE}\[([^\n\]]+)\]:[ \t]*(?:<(.*?)>|([^'"\n]*?\S[^'"\n]*?))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
+
+      # Parse the oembed definition at the current location.
+      def parse_oembed_definition
+        @src.pos += @src.matched_size
+        oembed_id, oembed_url, oembed_title = normalize_oembed_id(@src[1]), @src[2] || @src[3], @src[5]
+        warning("Duplicate oembed ID '#{oembed_id}' - overwriting") if @oembed_defs[oembed_id]
+        @oembed_defs[oembed_id] = [oembed_url, oembed_title]
+        @tree.children << Element.new(:eob, :oembed_def)
+        true
+      end
+      define_parser(:oembed_definition, OEMBED_DEFINITION_START)
+
+
+      # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
+      # and the element itself to the @tree.
+      def add_oembed(el, href, title, alt_text = nil)
+        
+        providers = {
+          :twitter         => "https://api.twitter.com/1/statuses/oembed.json?url=%s",
+          :youtube         => "http://www.youtube.com/oembed?url=%s&format=json&maxwidth=550",
+          :flickr          => "http://flickr.com/services/oembed?url=%s&maxwidth=460&format=json&maxwidth=550",
+          :vidler          => "http://lab.viddler.com/services/oembed/?url=%s&type=simple&format=json",
+          :qik             => "http://qik.com/api/oembed.json?url=%s&maxwidth=550",
+          :revision3       => "http://revision3.com/api/oembed/?url=%s&format=json&maxwidth=550",
+          :hulu            => "http://www.hulu.com/api/oembed.json?url=%s&maxwidth=550",
+          :vimeo           => "http://vimeo.com/api/oembed.json?url=%s&maxwidth=550",
+          :collegehumor    => "http://www.collegehumor.com/oembed.json?url=%s&maxwidth=550",
+          # :pollyeverywhere => "http://www.polleverywhere.com/services/oembed?url=%s&format=json",
+          # :opera           => "http://my.opera.com/service/oembed/?url=%s",
+          :embedly         => "http://api.embed.ly/1/oembed?url=%w&maxwidth=550",
+          :ifixit          => "http://www.ifixit.com/Embed?url=%s&format=json",
+          :smugmug         => "http://api.smugmug.com/services/oembed/?url=%s&format=json",
+          :slideshare      => "http://www.slideshare.net/api/oembed/2?url=%s&format=json&maxwidth=550",
+          :wordpress       => "http://public-api.wordpress.com/oembed/1.0/?format=json&url=%s&maxwidth=550"
+        }
+        # ready the hash for matching
+        provider_names = (providers.keys.each { |name| name.to_s }).join('|')
+        # match possible providers to see if we have a provider suitable for embedding the current href/url 
+        result = href.match provider_names
+        if result and result[0]
+          safe_href = CGI.escape(href)
+          provider = result[0].to_sym
+          oembed_url = providers[provider] % safe_href
+          # unique figure id
+          fig_id = rand(1000)
+          # oembed 
+          el = Element.new :oembed
+          begin
+            # get the oEmbed content
+            result = JSON.parse(open(oembed_url).read)
+            el.attr['provider_name'] = result['provider_name']
+            case result['type']
+            when "photo"
+              title = result['title']
+              el.attr['role'] = "img"
+              img = Element.new(:img)
+              img.attr['src'] = result['url']
+              img.attr['alt'] = result['title']
+              img.attr['width'] = result['width']
+              img.attr['height'] = result['height']
+              img.children.clear
+              el.children << img
+            when "video"
+              title = result['title']
+              el.attr['html'] = CGI.unescapeHTML(result['html'])
+            when "rich"
+              el.attr['html'] = CGI.unescapeHTML(result['html'])
+            end
+            
+          if title
+            # unique figure id
+            el_id = rand(1000)
+            el.attr['id'] = el_id
+            cap = Element.new(:figCaption, title)
+            cap.attr['id'] = el_id
+            if el.attr['role'] === "img"
+              link = Element.new(:a, result['author_name'])
+              link.attr['href'] = result['author_url']
+              cap.children << link
+            end
+            el.children << cap 
+          end
+          @tree.children << el
+            
+          rescue
+            warning("Could not retrieve oEmbed information for URL #{oembed_url}")
+          end
+        else
+          warning("No oEmbed provider found for URL #{href}")
+        end
+        
+        
+        
+        # if el.type == :a
+        #   el.attr['href'] = href
+        # else
+        #   el.attr['src'] = href
+        #   el.attr['alt'] = alt_text
+        #   el.children.clear
+        # end
+        # el.attr['title'] = title if title
+        # @tree.children << el
+      end
+
+      OEMBED_BRACKET_STOP_RE = /(\])|!?\[/
+      OEMBED_PAREN_STOP_RE = /(\()|(\))|\s(?=['"])/
+      OEMBED_INLINE_ID_RE = /\s*?\[([^\]]+)?\]/
+      OEMBED_INLINE_TITLE_RE = /\s*?(["'])(.+?)\1\s*?\)/
+      OEMBED_START = /\?\[(?=[^^])/
+
+      # Parse the oembed at the current scanner position. This method is used to parse normal oembeds as
+      # well as image oembeds.
+      def parse_oembed
+        result = @src.scan(OEMBED_START)
+        reset_pos = @src.pos
+        oembed_type = :img
+
+        el = Element.new(oembed_type)
+
+        count = 1
+        found = parse_spans(el, OEMBED_BRACKET_STOP_RE) do
+          count = count + (@src[1] ? -1 : 1)
+          count - el.children.select {|c| c.type == :img}.size == 0
+        end
+        if !found || (oembed_type == :a && el.children.empty?)
+          @src.pos = reset_pos
+          add_text(result)
+          return
+        end
+        alt_text = extract_string(reset_pos...@src.pos, @src)
+        @src.scan(OEMBED_BRACKET_STOP_RE)
+
+        # reference style oembed or no oembed url
+        if @src.scan(OEMBED_INLINE_ID_RE) || !@src.check(/\(/)
+          oembed_id = normalize_oembed_id(@src[1] || alt_text)
+          if @oembed_defs.has_key?(oembed_id)
+            add_oembed(el, @oembed_defs[oembed_id].first, @oembed_defs[oembed_id].last, alt_text)
+          else
+            warning("No oembed definition for oembed ID '#{oembed_id}' found")
+            @src.pos = reset_pos
+            add_text(result)
+          end
+          return
+        end
+
+        # oembed url in parentheses
+        if @src.scan(/\(<(.*?)>/)
+          oembed_url = @src[1]
+          if @src.scan(/\)/)
+            add_oembed(el, oembed_url, nil, alt_text)
+            return
+          end
+        else
+          oembed_url = ''
+          nr_of_brackets = 0
+          while temp = @src.scan_until(OEMBED_PAREN_STOP_RE)
+            oembed_url << temp
+            if @src[2]
+              nr_of_brackets -= 1
+              break if nr_of_brackets == 0
+            elsif @src[1]
+              nr_of_brackets += 1
+            else
+              break
+            end
+          end
+          oembed_url = oembed_url[1..-2]
+          oembed_url.strip!
+
+          if nr_of_brackets == 0
+            add_oembed(el, oembed_url, nil, alt_text)
+            return
+          end
+        end
+
+        if @src.scan(OEMBED_INLINE_TITLE_RE)
+          add_oembed(el, oembed_url, @src[2], alt_text)
+        else
+          @src.pos = reset_pos
+          add_text(result)
+        end
+      end
+      define_parser(:oembed, OEMBED_START, '\?\[')
+
+    end
+  end
+end

data/lib/kramdown/parser/html.rb

@@ -0,0 +1,570 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+require 'rexml/parsers/baseparser'
+require 'strscan'
+
+module Kramdown
+
+  module Parser
+
+    # Used for parsing a HTML document.
+    #
+    # The parsing code is in the Parser module that can also be used by other parsers.
+    class Html < Base
+
+      # Contains all constants that are used when parsing.
+      module Constants
+
+        #:stopdoc:
+        # The following regexps are based on the ones used by REXML, with some slight modifications.
+        HTML_DOCTYPE_RE = /<!DOCTYPE.*?>/m
+        HTML_COMMENT_RE = /<!--(.*?)-->/m
+        HTML_INSTRUCTION_RE = /<\?(.*?)\?>/m
+        HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})(?:\s*=\s*(["'])(.*?)\2)?/m
+        HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}(?:\s*=\s*(["']).*?\3)?)*)\s*(\/)?>/m
+        HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::UNAME_STR})\s*>/m
+        HTML_ENTITY_RE = /&([\w:][\-\w\.:]*);|&#(\d+);|&\#x([0-9a-fA-F]+);/
+
+        HTML_CONTENT_MODEL_BLOCK = %w{address applet article aside button blockquote body
+             dd div dl fieldset figure figcaption footer form header hgroup iframe li map menu nav
+              noscript object section td}
+        HTML_CONTENT_MODEL_SPAN  = %w{a abbr acronym b bdo big button cite caption del dfn dt em
+             h1 h2 h3 h4 h5 h6 i ins kbd label legend optgroup p q rb rbc
+             rp rt rtc ruby samp select small span strong sub sup summary th tt var}
+        HTML_CONTENT_MODEL_RAW   = %w{script style math option textarea pre code}
+        # The following elements are also parsed as raw since they need child elements that cannot
+        # be expressed using kramdown syntax: colgroup table tbody thead tfoot tr ul ol
+
+        HTML_CONTENT_MODEL = Hash.new {|h,k| h[k] = :raw}
+        HTML_CONTENT_MODEL_BLOCK.each {|i| HTML_CONTENT_MODEL[i] = :block}
+        HTML_CONTENT_MODEL_SPAN.each {|i| HTML_CONTENT_MODEL[i] = :span}
+        HTML_CONTENT_MODEL_RAW.each {|i| HTML_CONTENT_MODEL[i] = :raw}
+
+        # Some HTML elements like script belong to both categories (i.e. are valid in block and
+        # span HTML) and don't appear therefore!
+        HTML_SPAN_ELEMENTS = %w{a abbr acronym b big bdo br button cite code del dfn em i img input
+                              ins kbd label option q rb rbc rp rt rtc ruby samp select small span
+                              strong sub sup textarea tt var}
+        HTML_BLOCK_ELEMENTS = %w{address article aside applet body button blockquote caption col colgroup dd div dl dt fieldset
+                               figcaption footer form h1 h2 h3 h4 h5 h6 header hgroup hr html head iframe legend menu
+                               li map nav ol optgroup p pre section summary table tbody td th thead tfoot tr ul}
+        HTML_ELEMENTS_WITHOUT_BODY = %w{area base br col command embed hr img input keygen link meta param source track wbr}
+      end
+
+
+      # Contains the parsing methods. This module can be mixed into any parser to get HTML parsing
+      # functionality. The only thing that must be provided by the class are instance variable
+      # @stack for storing the needed state and @src (instance of StringScanner) for the actual
+      # parsing.
+      module Parser
+
+        include Constants
+
+        # Process the HTML start tag that has already be scanned/checked via @src.
+        #
+        # Does the common processing steps and then yields to the caller for further processing
+        # (first parameter is the created element, the second parameter is +true+ if the HTML
+        # element is already closed, ie. contains no body).
+        def handle_html_start_tag # :yields: el, closed
+          name = @src[1].downcase
+          closed = !@src[4].nil?
+          attrs = Utils::OrderedHash.new
+          @src[2].scan(HTML_ATTRIBUTE_RE).each {|attr,sep,val| attrs[attr.downcase] = val || ""}
+
+          el = Element.new(:html_element, name, attrs, :category => :block)
+          @tree.children << el
+
+          if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+            warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
+            closed = true
+          end
+          if name == 'script' || name == 'style'
+            handle_raw_html_tag(name)
+            yield(el, true)
+          else
+            yield(el, closed)
+          end
+        end
+
+        # Handle the raw HTML tag at the current position.
+        def handle_raw_html_tag(name)
+          curpos = @src.pos
+          if @src.scan_until(/(?=<\/#{name}\s*>)/mi)
+            add_text(extract_string(curpos...@src.pos, @src), @tree.children.last, :raw)
+            @src.scan(HTML_TAG_CLOSE_RE)
+          else
+            add_text(@src.rest, @tree.children.last, :raw)
+            @src.terminate
+            warning("Found no end tag for '#{name}' - auto-closing it")
+          end
+        end
+
+        HTML_RAW_START = /(?=<(#{REXML::Parsers::BaseParser::UNAME_STR}|\/|!--|\?))/ # :nodoc:
+
+        # Parse raw HTML from the current source position, storing the found elements in +el+.
+        # Parsing continues until one of the following criteria are fulfilled:
+        #
+        # - The end of the document is reached.
+        # - The matching end tag for the element +el+ is found (only used if +el+ is an HTML
+        #   element).
+        #
+        # When an HTML start tag is found, processing is deferred to #handle_html_start_tag,
+        # providing the block given to this method.
+        def parse_raw_html(el, &block)
+          @stack.push(@tree)
+          @tree = el
+
+          done = false
+          while !@src.eos? && !done
+            if result = @src.scan_until(HTML_RAW_START)
+              add_text(result, @tree, :text)
+              if result = @src.scan(HTML_COMMENT_RE)
+                @tree.children << Element.new(:xml_comment, result, nil, :category => :block)
+              elsif result = @src.scan(HTML_INSTRUCTION_RE)
+                @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
+              elsif @src.scan(HTML_TAG_RE)
+                handle_html_start_tag(&block)
+              elsif @src.scan(HTML_TAG_CLOSE_RE)
+                if @tree.value == @src[1].downcase
+                  done = true
+                else
+                  warning("Found invalidly used HTML closing tag for '#{@src[1].downcase}' - ignoring it")
+                end
+              else
+                add_text(@src.getch, @tree, :text)
+              end
+            else
+              add_text(@src.rest, @tree, :text)
+              @src.terminate
+              warning("Found no end tag for '#{@tree.value}' - auto-closing it") if @tree.type == :html_element
+              done = true
+            end
+          end
+
+          @tree = @stack.pop
+        end
+
+      end
+
+
+      # Converts HTML elements to native elements if possible.
+      class ElementConverter
+
+        # :stopdoc:
+
+        include Constants
+        include ::Kramdown::Utils::Entities
+
+        REMOVE_TEXT_CHILDREN =  %w{html head hgroup ol ul dl table colgroup tbody thead tfoot tr select optgroup}
+        WRAP_TEXT_CHILDREN = %w{body section nav article aside header footer address div li dd blockquote figure
+                                figcaption fieldset form}
+        REMOVE_WHITESPACE_CHILDREN = %w{body section nav article aside header footer address
+                                        div li dd blockquote figure figcaption td th fieldset form}
+        STRIP_WHITESPACE = %w{address article aside blockquote body caption dd div dl dt fieldset figcaption form footer
+                              header h1 h2 h3 h4 h5 h6 legend li nav p section td th}
+        SIMPLE_ELEMENTS = %w{em strong blockquote hr br img p thead tbody tfoot tr td th ul ol dl li dl dt dd}
+
+        def initialize(root)
+          @root = root
+        end
+
+        def self.convert(root, el = root)
+          new(root).process(el)
+        end
+
+        # Convert the element +el+ and its children.
+        def process(el, do_conversion = true, preserve_text = false, parent = nil)
+          case el.type
+          when :xml_comment, :xml_pi
+            ptype = if parent.nil?
+                      'div'
+                    else
+                      case parent.type
+                      when :html_element then parent.value
+                      when :code_span then 'code'
+                      when :code_block then 'pre'
+                      when :header then 'h1'
+                      else parent.type.to_s
+                      end
+                    end
+            el.options.replace({:category => (HTML_CONTENT_MODEL[ptype] == :span ? :span : :block)})
+            return
+          when :html_element
+          when :root
+            el.children.each {|c| process(c)}
+            remove_whitespace_children(el)
+            return
+          else return
+          end
+
+          mname = "convert_#{el.value}"
+          if do_conversion && self.class.method_defined?(mname)
+            send(mname, el)
+          else
+            type = el.value
+            remove_text_children(el) if do_conversion && REMOVE_TEXT_CHILDREN.include?(type)
+
+            if do_conversion && SIMPLE_ELEMENTS.include?(type)
+              set_basics(el, type.intern)
+              process_children(el, do_conversion, preserve_text)
+            else
+              process_html_element(el, do_conversion, preserve_text)
+            end
+
+            if do_conversion
+              strip_whitespace(el) if STRIP_WHITESPACE.include?(type)
+              remove_whitespace_children(el) if REMOVE_WHITESPACE_CHILDREN.include?(type)
+              wrap_text_children(el) if WRAP_TEXT_CHILDREN.include?(type)
+            end
+          end
+        end
+
+        def process_children(el, do_conversion = true, preserve_text = false)
+          el.children.map! do |c|
+            if c.type == :text
+              process_text(c.value, preserve_text || !do_conversion)
+            else
+              process(c, do_conversion, preserve_text, el)
+              c
+            end
+          end.flatten!
+        end
+
+        # Process the HTML text +raw+: compress whitespace (if +preserve+ is +false+) and convert
+        # entities in entity elements.
+        def process_text(raw, preserve = false)
+          raw.gsub!(/\s+/, ' ') unless preserve
+          src = StringScanner.new(raw)
+          result = []
+          while !src.eos?
+            if tmp = src.scan_until(/(?=#{HTML_ENTITY_RE})/)
+              result << Element.new(:text, tmp)
+              src.scan(HTML_ENTITY_RE)
+              val = src[1] || (src[2] && src[2].to_i) || src[3].hex
+              result << if %w{lsquo rsquo ldquo rdquo}.include?(val)
+                          Element.new(:smart_quote, val.intern)
+                        elsif %w{mdash ndash hellip laquo raquo}.include?(val)
+                          Element.new(:typographic_sym, val.intern)
+                        else
+                          begin
+                            Element.new(:entity, entity(val), nil, :original => src.matched)
+                          rescue ::Kramdown::Error
+                            src.pos -= src.matched_size - 1
+                            Element.new(:entity, ::Kramdown::Utils::Entities.entity('amp'))
+                          end
+                        end
+            else
+              result << Element.new(:text, src.rest)
+              src.terminate
+            end
+          end
+          result
+        end
+
+        def process_html_element(el, do_conversion = true, preserve_text = false)
+          el.options.replace(:category => HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
+                             :content_model => (do_conversion ? HTML_CONTENT_MODEL[el.value] : :raw))
+          process_children(el, do_conversion, preserve_text)
+        end
+
+        def remove_text_children(el)
+          el.children.delete_if {|c| c.type == :text}
+        end
+
+        def wrap_text_children(el)
+          tmp = []
+          last_is_p = false
+          el.children.each do |c|
+            if Element.category(c) != :block || c.type == :text
+              if !last_is_p
+                tmp << Element.new(:p, nil, nil, :transparent => true)
+                last_is_p = true
+              end
+              tmp.last.children << c
+              tmp
+            else
+              tmp << c
+              last_is_p = false
+            end
+          end
+          el.children = tmp
+        end
+
+        def strip_whitespace(el)
+          return if el.children.empty?
+          if el.children.first.type == :text
+            el.children.first.value.lstrip!
+          end
+          if el.children.last.type == :text
+            el.children.last.value.rstrip!
+          end
+        end
+
+        def remove_whitespace_children(el)
+          i = -1
+          el.children = el.children.reject do |c|
+            i += 1
+            c.type == :text && c.value.strip.empty? &&
+              (i == 0 || i == el.children.length - 1 || (Element.category(el.children[i-1]) == :block &&
+                                                         Element.category(el.children[i+1]) == :block))
+          end
+        end
+
+        def set_basics(el, type, opts = {})
+          el.type = type
+          el.options.replace(opts)
+          el.value = nil
+        end
+
+        def extract_text(el, raw)
+          raw << el.value.to_s if el.type == :text
+          el.children.each {|c| extract_text(c, raw)}
+        end
+
+        def convert_a(el)
+          if el.attr['href']
+            set_basics(el, :a)
+            process_children(el)
+          else
+            process_html_element(el, false)
+          end
+        end
+
+        EMPHASIS_TYPE_MAP = {'em' => :em, 'i' => :em, 'strong' => :strong, 'b' => :strong}
+        def convert_em(el)
+          text = ''
+          extract_text(el, text)
+          if text =~ /\A\s/ || text =~ /\s\z/
+            process_html_element(el, false)
+          else
+            set_basics(el, EMPHASIS_TYPE_MAP[el.value])
+            process_children(el)
+          end
+        end
+        %w{b strong i}.each do |i|
+          alias_method("convert_#{i}".to_sym, :convert_em)
+        end
+
+        def convert_h1(el)
+          set_basics(el, :header, :level => el.value[1..1].to_i)
+          extract_text(el, el.options[:raw_text] = '')
+          process_children(el)
+        end
+        %w{h2 h3 h4 h5 h6}.each do |i|
+          alias_method("convert_#{i}".to_sym, :convert_h1)
+        end
+
+        def convert_code(el)
+          raw = ''
+          extract_text(el, raw)
+          result = process_text(raw, true)
+          begin
+            str = result.inject('') do |mem, c|
+              if c.type == :text
+                mem << c.value
+              elsif c.type == :entity
+                if RUBY_VERSION >= '1.9'
+                  mem << c.value.char.encode(@root.options[:encoding])
+                elsif [60, 62, 34, 38].include?(c.value.code_point)
+                  mem << c.value.code_point.chr
+                end
+              elsif c.type == :smart_quote || c.type == :typographic_sym
+                mem << entity(c.value.to_s).char.encode(@root.options[:encoding])
+              else
+                raise "Bug - please report"
+              end
+            end
+            result.clear
+            result << Element.new(:text, str)
+          rescue
+          end
+          if result.length > 1 || result.first.type != :text
+            process_html_element(el, false, true)
+          else
+            if el.value == 'code'
+              set_basics(el, :codespan)
+            else
+              set_basics(el, :codeblock)
+            end
+            el.value = result.first.value
+            el.children.clear
+          end
+        end
+        alias :convert_pre :convert_code
+
+        def convert_table(el)
+          if !is_simple_table?(el)
+            process_html_element(el, false)
+            return
+          end
+          remove_text_children(el)
+          process_children(el)
+          set_basics(el, :table)
+
+          calc_alignment = lambda do |c|
+            if c.type == :tr
+              el.options[:alignment] = c.children.map do |td|
+                if td.attr['style']
+                  td.attr['style'].slice!(/(?:;\s*)?text-align:\s+(center|left|right)/)
+                  td.attr.delete('style') if td.attr['style'].strip.empty?
+                  $1.to_sym
+                else
+                  :default
+                end
+              end
+            else
+              c.children.each {|cc| calc_alignment.call(cc)}
+            end
+          end
+          calc_alignment.call(el)
+          el.children.delete_if {|c| c.type == :html_element}
+
+          change_th_type = lambda do |c|
+            if c.type == :th
+              c.type = :td
+            else
+              c.children.each {|cc| change_th_type.call(cc)}
+            end
+          end
+          change_th_type.call(el)
+
+          if el.children.first.type == :tr
+            tbody = Element.new(:tbody)
+            tbody.children = el.children
+            el.children = [tbody]
+          end
+        end
+
+        def is_simple_table?(el)
+          only_phrasing_content = lambda do |c|
+            c.children.all? do |cc|
+              (cc.type == :text || !HTML_BLOCK_ELEMENTS.include?(cc.value)) && only_phrasing_content.call(cc)
+            end
+          end
+          check_cells = Proc.new do |c|
+            if c.value == 'th' || c.value == 'td'
+              return false if !only_phrasing_content.call(c)
+            else
+              c.children.each {|cc| check_cells.call(cc)}
+            end
+          end
+          check_cells.call(el)
+
+          nr_cells = 0
+          check_nr_cells = lambda do |t|
+            if t.value == 'tr'
+              count = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.length
+              if count != nr_cells
+                if nr_cells == 0
+                  nr_cells = count
+                else
+                  nr_cells = -1
+                  break
+                end
+              end
+            else
+              t.children.each {|cc| check_nr_cells.call(cc)}
+            end
+          end
+          check_nr_cells.call(el)
+          return false if nr_cells == -1
+
+          alignment = nil
+          check_alignment = Proc.new do |t|
+            if t.value == 'tr'
+              cur_alignment = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.map do |cell|
+                md = /text-align:\s+(center|left|right|justify|inherit)/.match(cell.attr['style'].to_s)
+                return false if md && (md[1] == 'justify' || md[1] == 'inherit')
+                md.nil? ? :default : md[1]
+              end
+              alignment = cur_alignment if alignment.nil?
+              return false if alignment != cur_alignment
+            else
+              t.children.each {|cc| check_alignment.call(cc)}
+            end
+          end
+          check_alignment.call(el)
+
+          check_rows = lambda do |t, type|
+            t.children.all? {|r| (r.value == 'tr' || r.type == :text) && r.children.all? {|c| c.value == type || c.type == :text}}
+          end
+          check_rows.call(el, 'td') ||
+            (el.children.all? do |t|
+               t.type == :text || (t.value == 'thead' && check_rows.call(t, 'th')) ||
+                 ((t.value == 'tfoot' || t.value == 'tbody') && check_rows.call(t, 'td'))
+             end && el.children.any? {|t| t.value == 'tbody'})
+        end
+
+        def convert_script(el)
+          if !is_math_tag?(el)
+            process_html_element(el)
+          else
+            handle_math_tag(el)
+          end
+        end
+
+        def is_math_tag?(el)
+          el.attr['type'].to_s =~ /\bmath\/tex\b/
+        end
+
+        def handle_math_tag(el)
+          set_basics(el, :math, :category => (el.attr['type'] =~ /mode=display/ ? :block : :span))
+          el.value = el.children.shift.value.sub(/\A<!\[CDATA\[(.*)\]\]>\z/m, '\1')
+          el.attr.delete('type')
+        end
+
+      end
+
+      include Parser
+
+      # Parse the source string provided on initialization as HTML document.
+      def parse
+        @stack, @tree = [], @root
+        @src = StringScanner.new(adapt_source(source))
+
+        while true
+          if result = @src.scan(/\s*#{HTML_INSTRUCTION_RE}/)
+            @tree.children << Element.new(:xml_pi, result.strip, nil, :category => :block)
+          elsif result = @src.scan(/\s*#{HTML_DOCTYPE_RE}/)
+            # ignore the doctype
+          elsif result = @src.scan(/\s*#{HTML_COMMENT_RE}/)
+            @tree.children << Element.new(:xml_comment, result.strip, nil, :category => :block)
+          else
+            break
+          end
+        end
+
+        tag_handler = lambda do |c, closed|
+          parse_raw_html(c, &tag_handler) if !closed
+        end
+        parse_raw_html(@tree, &tag_handler)
+
+        ElementConverter.convert(@tree)
+      end
+
+    end
+
+  end
+
+end
+