feedtools 0.2.26 → 0.2.27

data/lib/feed_tools/vendor/html5/lib/html5/html5parser/in_select_phase.rb

@@ -0,0 +1,85 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+  class InSelectPhase < Phase
+
+    # http://www.whatwg.org/specs/web-apps/current-work/#in-select
+
+    handle_start 'html', 'option', 'optgroup', 'select'
+
+    handle_end 'option', 'optgroup', 'select', %w( caption table tbody tfoot thead tr td th ) => 'TableElements'
+
+    def processCharacters(data)
+      @tree.insertText(data)
+    end
+
+    def startTagOption(name, attributes)
+      # We need to imply </option> if <option> is the current node.
+      @tree.open_elements.pop if @tree.open_elements.last.name == 'option'
+      @tree.insert_element(name, attributes)
+    end
+
+    def startTagOptgroup(name, attributes)
+      @tree.open_elements.pop if @tree.open_elements.last.name == 'option'
+      @tree.open_elements.pop if @tree.open_elements.last.name == 'optgroup'
+      @tree.insert_element(name, attributes)
+    end
+
+    def startTagSelect(name, attributes)
+      parse_error("unexpected-select-in-select")
+      endTagSelect('select')
+    end
+
+    def startTagOther(name, attributes)
+      parse_error("unexpected-start-tag-in-select", {"name" => name})
+    end
+
+    def endTagOption(name)
+      if @tree.open_elements.last.name == 'option'
+        @tree.open_elements.pop
+      else
+        parse_error("unexpected-end-tag-in-select", {"name" => "option"})
+      end
+    end
+
+    def endTagOptgroup(name)
+      # </optgroup> implicitly closes <option>
+      if @tree.open_elements.last.name == 'option' and @tree.open_elements[-2].name == 'optgroup'
+        @tree.open_elements.pop
+      end
+      # It also closes </optgroup>
+      if @tree.open_elements.last.name == 'optgroup'
+        @tree.open_elements.pop
+      # But nothing else
+      else
+        parse_error("unexpected-end-tag-in-select",
+                {"name" => "optgroup"})
+      end
+    end
+
+    def endTagSelect(name)
+      if in_scope?('select', true)
+        remove_open_elements_until('select')
+
+        @parser.reset_insertion_mode
+      else
+        # inner_html case
+        parse_error
+      end
+    end
+
+    def endTagTableElements(name)
+      parse_error("unexpected-end-tag-in-select", {"name" => name})
+
+      if in_scope?(name, true)
+        endTagSelect('select')
+        @parser.phase.processEndTag(name)
+      end
+    end
+
+    def endTagOther(name)
+      parse_error("unexpected-end-tag-in-select", {"name" => name})
+    end
+
+  end
+end

data/lib/feed_tools/vendor/html5/lib/html5/html5parser/in_table_body_phase.rb

@@ -0,0 +1,86 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+  class InTableBodyPhase < Phase
+
+    # http://www.whatwg.org/specs/web-apps/current-work/#in-table0
+
+    handle_start 'html', 'tr', %w( td th ) => 'TableCell', %w( caption col colgroup tbody tfoot thead ) => 'TableOther'
+
+    handle_end 'table', %w( tbody tfoot thead ) => 'TableRowGroup', %w( body caption col colgroup html td th tr ) => 'Ignore'
+
+    def processCharacters(data)
+      @parser.phases[:inTable].processCharacters(data)
+    end
+
+    def startTagTr(name, attributes)
+      clearStackToTableBodyContext
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inRow]
+    end
+
+    def startTagTableCell(name, attributes)
+      parse_error("unexpected-cell-in-table-body", {"name" => name})
+      startTagTr('tr', {})
+      @parser.phase.processStartTag(name, attributes)
+    end
+
+    def startTagTableOther(name, attributes)
+      # XXX AT Any ideas on how to share this with endTagTable?
+      if in_scope?('tbody', true) or in_scope?('thead', true) or in_scope?('tfoot', true)
+        clearStackToTableBodyContext
+        endTagTableRowGroup(@tree.open_elements.last.name)
+        @parser.phase.processStartTag(name, attributes)
+      else
+        # inner_html case
+        parse_error
+      end
+    end
+
+    def startTagOther(name, attributes)
+      @parser.phases[:inTable].processStartTag(name, attributes)
+    end
+
+    def endTagTableRowGroup(name)
+      if in_scope?(name, true)
+        clearStackToTableBodyContext
+        @tree.open_elements.pop
+        @parser.phase = @parser.phases[:inTable]
+      else
+        parse_error("unexpected-end-tag-in-table-body",
+                {"name" => name})
+      end
+    end
+
+    def endTagTable(name)
+      if in_scope?('tbody', true) or in_scope?('thead', true) or in_scope?('tfoot', true)
+        clearStackToTableBodyContext
+        endTagTableRowGroup(@tree.open_elements.last.name)
+        @parser.phase.processEndTag(name)
+      else
+        # inner_html case
+        parse_error
+      end
+    end
+
+    def endTagIgnore(name)
+      parse_error("unexpected-end-tag-in-table-body",
+            {"name" => name})
+    end
+
+    def endTagOther(name)
+      @parser.phases[:inTable].processEndTag(name)
+    end
+
+    protected
+
+    def clearStackToTableBodyContext
+      until %w[tbody tfoot thead html].include?(name = @tree.open_elements.last.name)
+        parse_error("unexpected-implied-end-tag-in-table",
+                {"name" => @tree.open_elements.last.name})
+        @tree.open_elements.pop
+      end
+    end
+
+  end
+end

data/lib/feed_tools/vendor/html5/lib/html5/html5parser/in_table_phase.rb

@@ -0,0 +1,115 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+  class InTablePhase < Phase
+
+    # http://www.whatwg.org/specs/web-apps/current-work/#in-table
+
+    handle_start 'html', 'caption', 'colgroup', 'col', 'table'
+
+    handle_start %w( tbody tfoot thead ) => 'RowGroup', %w( td th tr ) => 'ImplyTbody'
+
+    handle_end 'table', %w( body caption col colgroup html tbody td tfoot th thead tr ) => 'Ignore'
+
+    def processCharacters(data)
+      parse_error("unexpected-char-implies-table-voodoo")
+      # Make all the special element rearranging voodoo kick in
+      @tree.insert_from_table = true
+      # Process the character in the "in body" mode
+      @parser.phases[:inBody].processCharacters(data)
+      @tree.insert_from_table = false
+    end
+
+    def startTagCaption(name, attributes)
+      clearStackToTableContext
+      @tree.activeFormattingElements.push(Marker)
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inCaption]
+    end
+
+    def startTagColgroup(name, attributes)
+      clearStackToTableContext
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inColumnGroup]
+    end
+
+    def startTagCol(name, attributes)
+      startTagColgroup('colgroup', {})
+      @parser.phase.processStartTag(name, attributes)
+    end
+
+    def startTagRowGroup(name, attributes)
+      clearStackToTableContext
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inTableBody]
+    end
+
+    def startTagImplyTbody(name, attributes)
+      startTagRowGroup('tbody', {})
+      @parser.phase.processStartTag(name, attributes)
+    end
+
+    def startTagTable(name, attributes)
+      parse_error("unexpected-start-tag-implies-end-tag",
+            {"startName" => "table", "endName" => "table"})
+      @parser.phase.processEndTag('table')
+      @parser.phase.processStartTag(name, attributes) unless @parser.inner_html
+    end
+
+    def startTagOther(name, attributes)
+      parse_error("unexpected-start-tag-implies-table-voodoo",
+              {"name" => name})
+      # Make all the special element rearranging voodoo kick in
+      @tree.insert_from_table = true
+      # Process the start tag in the "in body" mode
+      @parser.phases[:inBody].processStartTag(name, attributes)
+      @tree.insert_from_table = false
+    end
+
+    def endTagTable(name)
+      if in_scope?('table', true)
+        @tree.generateImpliedEndTags
+
+        unless @tree.open_elements.last.name == 'table'
+          parse_error("end-tag-too-early-named",
+                    {"gotName" => "table",
+                     "expectedName" => @tree.open_elements.last.name})
+        end
+
+        remove_open_elements_until('table')
+
+        @parser.reset_insertion_mode
+      else
+        # inner_html case
+        assert @parser.inner_html
+        parse_error
+      end
+    end
+
+    def endTagIgnore(name)
+      parse_error("unexpected-end-tag", {"name" => name})
+    end
+
+    def endTagOther(name)
+      parse_error("unexpected-end-tag-implies-table-voodoo", {"name" => name})
+      # Make all the special element rearranging voodoo kick in
+      @tree.insert_from_table = true
+      # Process the end tag in the "in body" mode
+      @parser.phases[:inBody].processEndTag(name)
+      @tree.insert_from_table = false
+    end
+
+    protected
+
+    def clearStackToTableContext
+      # "clear the stack back to a table context"
+      until %w[table html].include?(name = @tree.open_elements.last.name)
+        parse_error("unexpected-implied-end-tag-in-table",
+                {"name" =>  @tree.open_elements.last.name})
+        @tree.open_elements.pop
+      end
+      # When the current node is <html> it's an inner_html case
+    end
+
+  end
+end

data/lib/feed_tools/vendor/html5/lib/html5/html5parser/initial_phase.rb

@@ -0,0 +1,133 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+  class InitialPhase < Phase
+
+    # This phase deals with error handling as well which is currently not
+    # covered in the specification. The error handling is typically known as
+    # "quirks mode". It is expected that a future version of HTML5 will define this.
+
+    def process_eof
+      parse_error("expected-doctype-but-got-eof")
+      @parser.phase = @parser.phases[:rootElement]
+      @parser.phase.process_eof
+    end
+
+    def processComment(data)
+      @tree.insert_comment(data, @tree.document)
+    end
+
+    def processDoctype(name, publicId, systemId, correct)
+      if name.downcase != 'html' or publicId or systemId
+        parse_error("unknown-doctype")
+      end
+      # XXX need to update DOCTYPE tokens
+      @tree.insertDoctype(name, publicId, systemId)
+
+      publicId = publicId.to_s.upcase
+
+      if name.downcase != 'html'
+        # XXX quirks mode
+      else
+        if ["+//silmaril//dtd html pro v0r11 19970101//en",
+            "-//advasoft ltd//dtd html 3.0 aswedit + extensions//en",
+            "-//as//dtd html 3.0 aswedit + extensions//en",
+            "-//ietf//dtd html 2.0 level 1//en",
+            "-//ietf//dtd html 2.0 level 2//en",
+            "-//ietf//dtd html 2.0 strict level 1//en",
+            "-//ietf//dtd html 2.0 strict level 2//en",
+            "-//ietf//dtd html 2.0 strict//en",
+            "-//ietf//dtd html 2.0//en",
+            "-//ietf//dtd html 2.1e//en",
+            "-//ietf//dtd html 3.0//en",
+            "-//ietf//dtd html 3.0//en//",
+            "-//ietf//dtd html 3.2 final//en",
+            "-//ietf//dtd html 3.2//en",
+            "-//ietf//dtd html 3//en",
+            "-//ietf//dtd html level 0//en",
+            "-//ietf//dtd html level 0//en//2.0",
+            "-//ietf//dtd html level 1//en",
+            "-//ietf//dtd html level 1//en//2.0",
+            "-//ietf//dtd html level 2//en",
+            "-//ietf//dtd html level 2//en//2.0",
+            "-//ietf//dtd html level 3//en",
+            "-//ietf//dtd html level 3//en//3.0",
+            "-//ietf//dtd html strict level 0//en",
+            "-//ietf//dtd html strict level 0//en//2.0",
+            "-//ietf//dtd html strict level 1//en",
+            "-//ietf//dtd html strict level 1//en//2.0",
+            "-//ietf//dtd html strict level 2//en",
+            "-//ietf//dtd html strict level 2//en//2.0",
+            "-//ietf//dtd html strict level 3//en",
+            "-//ietf//dtd html strict level 3//en//3.0",
+            "-//ietf//dtd html strict//en",
+            "-//ietf//dtd html strict//en//2.0",
+            "-//ietf//dtd html strict//en//3.0",
+            "-//ietf//dtd html//en",
+            "-//ietf//dtd html//en//2.0",
+            "-//ietf//dtd html//en//3.0",
+            "-//metrius//dtd metrius presentational//en",
+            "-//microsoft//dtd internet explorer 2.0 html strict//en",
+            "-//microsoft//dtd internet explorer 2.0 html//en",
+            "-//microsoft//dtd internet explorer 2.0 tables//en",
+            "-//microsoft//dtd internet explorer 3.0 html strict//en",
+            "-//microsoft//dtd internet explorer 3.0 html//en",
+            "-//microsoft//dtd internet explorer 3.0 tables//en",
+            "-//netscape comm. corp.//dtd html//en",
+            "-//netscape comm. corp.//dtd strict html//en",
+            "-//o'reilly and associates//dtd html 2.0//en",
+            "-//o'reilly and associates//dtd html extended 1.0//en",
+            "-//spyglass//dtd html 2.0 extended//en",
+            "-//sq//dtd html 2.0 hotmetal + extensions//en",
+            "-//sun microsystems corp.//dtd hotjava html//en",
+            "-//sun microsystems corp.//dtd hotjava strict html//en",
+            "-//w3c//dtd html 3 1995-03-24//en",
+            "-//w3c//dtd html 3.2 draft//en",
+            "-//w3c//dtd html 3.2 final//en",
+            "-//w3c//dtd html 3.2//en",
+            "-//w3c//dtd html 3.2s draft//en",
+            "-//w3c//dtd html 4.0 frameset//en",
+            "-//w3c//dtd html 4.0 transitional//en",
+            "-//w3c//dtd html experimental 19960712//en",
+            "-//w3c//dtd html experimental 970421//en",
+            "-//w3c//dtd w3 html//en",
+            "-//w3o//dtd w3 html 3.0//en",
+            "-//w3o//dtd w3 html 3.0//en//",
+            "-//w3o//dtd w3 html strict 3.0//en//",
+            "-//webtechs//dtd mozilla html 2.0//en",
+            "-//webtechs//dtd mozilla html//en",
+            "-/w3c/dtd html 4.0 transitional/en",
+            "html"].include?(publicId) or
+          (systemId == nil and
+            ["-//w3c//dtd html 4.01 frameset//EN",
+             "-//w3c//dtd html 4.01 transitional//EN"].include?(publicId)) or
+          (systemId == "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd")
+            #XXX quirks mode
+          end
+      end
+
+      @parser.phase = @parser.phases[:rootElement]
+    end
+
+    def processSpaceCharacters(data)
+    end
+
+    def processCharacters(data)
+      parse_error("expected-doctype-but-got-chars")
+      @parser.phase = @parser.phases[:rootElement]
+      @parser.phase.processCharacters(data)
+    end
+
+    def processStartTag(name, attributes)
+      parse_error("expected-doctype-but-got-start-tag", {"name" => name})
+      @parser.phase = @parser.phases[:rootElement]
+      @parser.phase.processStartTag(name, attributes)
+    end
+
+    def processEndTag(name)
+      parse_error("expected-doctype-but-got-end-tag", {"name" => name})
+      @parser.phase = @parser.phases[:rootElement]
+      @parser.phase.processEndTag(name)
+    end
+  end
+end

data/lib/feed_tools/vendor/html5/lib/html5/html5parser/phase.rb

@@ -0,0 +1,154 @@
+module HTML5
+  # Base class for helper objects that implement each phase of processing.
+  #
+  # Handler methods should be in the following order (they can be omitted):
+  #
+  #   * EOF
+  #   * Comment
+  #   * Doctype
+  #   * SpaceCharacters
+  #   * Characters
+  #   * StartTag
+  #     - startTag* methods
+  #   * EndTag
+  #     - endTag* methods
+  #
+  class Phase
+
+    extend Forwardable
+    def_delegators :@parser, :parse_error
+
+    # The following example call:
+    #
+    #   tag_handlers('startTag', 'html', %w( base link meta ), %w( li dt dd ) => 'ListItem')
+    #
+    # ...would return a hash equal to this:
+    #
+    #   { 'html' => 'startTagHtml',
+    #     'base' => 'startTagBaseLinkMeta',
+    #     'link' => 'startTagBaseLinkMeta',
+    #     'meta' => 'startTagBaseLinkMeta',
+    #     'li'   => 'startTagListItem',
+    #     'dt'   => 'startTagListItem',
+    #     'dd'   => 'startTagListItem'  }
+    #
+    def self.tag_handlers(prefix, *tags)
+      mapping = {}
+      if tags.last.is_a?(Hash)
+        tags.pop.each do |names, handler_method_suffix|
+          handler_method = prefix + handler_method_suffix
+          Array(names).each {|name| mapping[name] = handler_method }
+        end
+      end
+      tags.each do |names|
+        names = Array(names)
+        handler_method = prefix + names.map {|name| name.capitalize }.join
+        names.each {|name| mapping[name] = handler_method }
+      end
+      mapping
+    end
+
+    def self.start_tag_handlers
+      @start_tag_handlers ||= Hash.new('startTagOther')
+    end
+
+    # Declare what start tags this Phase handles. Can be called more than once.
+    #
+    # Example usage:
+    #
+    #   handle_start 'html'
+    #   # html start tags will be handled by a method named 'startTagHtml'
+    #
+    #   handle_start %( base link meta )
+    #   # base, link and meta start tags will be handled by a method named 'startTagBaseLinkMeta'
+    #
+    #   handle_start %( li dt dd ) => 'ListItem'
+    #   # li, dt, and dd start tags will be handled by a method named 'startTagListItem'
+    #
+    def self.handle_start(*tags)
+      start_tag_handlers.update tag_handlers('startTag', *tags)
+    end
+
+    def self.end_tag_handlers
+      @end_tag_handlers ||= Hash.new('endTagOther')
+    end
+
+    # Declare what end tags this Phase handles. Behaves like handle_start.
+    #
+    def self.handle_end(*tags)
+      end_tag_handlers.update tag_handlers('endTag', *tags)
+    end
+
+    def initialize(parser, tree)
+      @parser, @tree = parser, tree
+    end
+
+    def process_eof
+      @tree.generateImpliedEndTags
+
+      if @tree.open_elements.length > 2
+        parse_error("expected-closing-tag-but-got-eof")
+      elsif @tree.open_elements.length == 2 and @tree.open_elements[1].name != 'body'
+        # This happens for framesets or something?
+        parse_error("expected-closing-tag-but-got-eof")
+      elsif @parser.inner_html and @tree.open_elements.length > 1 
+        # XXX This is not what the specification says. Not sure what to do here.
+        parse_error("eof-in-innerhtml")
+      end
+      # Betting ends.
+    end
+
+    def processComment(data)
+      # For most phases the following is correct. Where it's not it will be
+      # overridden.
+      @tree.insert_comment(data, @tree.open_elements.last)
+    end
+
+    def processDoctype(name, publicId, systemId, correct)
+      parse_error("unexpected-doctype")
+    end
+
+    def processSpaceCharacters(data)
+      @tree.insertText(data)
+    end
+
+    def processStartTag(name, attributes)
+      send self.class.start_tag_handlers[name], name, attributes
+    end
+
+    def startTagHtml(name, attributes)
+      if @parser.first_start_tag == false and name == 'html'
+         parse_error("non-html-root")
+      end
+      # XXX Need a check here to see if the first start tag token emitted is
+      # this token... If it's not, invoke parse_error.
+      attributes.each do |attr, value|
+        unless @tree.open_elements.first.attributes.has_key?(attr)
+          @tree.open_elements.first.attributes[attr] = value
+        end
+      end
+      @parser.first_start_tag = false
+    end
+
+    def processEndTag(name)
+      send self.class.end_tag_handlers[name], name
+    end
+
+    def assert(value)
+      throw AssertionError.new unless value
+    end
+
+    def in_scope?(*args)
+      @tree.elementInScope(*args)
+    end
+
+    def remove_open_elements_until(name=nil)
+      finished = false
+      until finished
+        element = @tree.open_elements.pop
+        finished = name.nil? ? yield(element) : element.name == name
+      end
+      return element
+    end
+  end
+end