spk-html5 0.10.1

data/lib/html5/html5parser/in_row_phase.rb

@@ -0,0 +1,96 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+  class InRowPhase < Phase
+
+    # http://www.whatwg.org/specs/web-apps/current-work/#in-row
+
+    handle_start 'html', %w( td th ) => 'TableCell', %w( caption col colgroup tbody tfoot thead tr ) => 'TableOther'
+
+    handle_end 'tr', 'table', %w( tbody tfoot thead ) => 'TableRowGroup', %w( body caption col colgroup html td th ) => 'Ignore'
+
+    def processCharacters(data)
+      @parser.phases[:inTable].processCharacters(data)
+    end
+
+    def processSpaceCharacters(data)
+      @parser.phases[:inTable].processSpaceCharacters(data)
+    end
+
+    def startTagTableCell(name, attributes)
+      clearStackToTableRowContext
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inCell]
+      @tree.activeFormattingElements.push(Marker)
+    end
+
+    def startTagTableOther(name, attributes)
+      ignoreEndTag = ignoreEndTagTr
+      endTagTr('tr')
+      # XXX how are we sure it's always ignored in the inner_html case?
+      @parser.phase.processStartTag(name, attributes) unless ignoreEndTag
+    end
+
+    def startTagOther(name, attributes)
+      @parser.phases[:inTable].processStartTag(name, attributes)
+    end
+
+    def endTagTr(name)
+      if ignoreEndTagTr
+        # inner_html case
+        assert @parser.inner_html
+        parse_error "unexpected-end-tag", {:name => name}
+      else
+        clearStackToTableRowContext
+        @tree.open_elements.pop
+        @parser.phase = @parser.phases[:inTableBody]
+      end
+    end
+
+    def endTagTable(name)
+      ignoreEndTag = ignoreEndTagTr
+      endTagTr('tr')
+      # Reprocess the current tag if the tr end tag was not ignored
+      # XXX how are we sure it's always ignored in the inner_html case?
+      @parser.phase.processEndTag(name) unless ignoreEndTag
+    end
+
+    def endTagTableRowGroup(name)
+      if in_scope?(name, true)
+        endTagTr('tr')
+        @parser.phase.processEndTag(name)
+      else
+        # inner_html case
+        parse_error "unexpected-end-tag", {:name => name}
+      end
+    end
+
+    def endTagIgnore(name)
+      parse_error("unexpected-end-tag-in-table-row",
+              {"name" => name})
+    end
+
+    def endTagOther(name)
+      @parser.phases[:inTable].processEndTag(name)
+    end
+
+    def process_eof
+      @parser.phases[:inTable].process_eof
+    end
+
+    protected
+
+    # XXX unify this with other table helper methods
+    def clearStackToTableRowContext
+      until %w[tr html].include?(name = @tree.open_elements.last.name)
+        parse_error("unexpected-implied-end-tag-in-table-row", {"name" => @tree.open_elements.last.name})
+        @tree.open_elements.pop
+      end
+    end
+
+    def ignoreEndTagTr
+      not in_scope?('tr', :tableVariant => true)
+    end
+
+  end
+end

data/lib/html5/html5parser/in_select_phase.rb

@@ -0,0 +1,90 @@
+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_start 'input'
+    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 startTagInput(name, attributes)
+      @parser.parse_error("unexpected-input-in-select")
+      endTagSelect("select")
+      @parser.phase.processStartTag(name, attributes)
+    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/html5/html5parser/in_select_table_phase.rb

@@ -0,0 +1,35 @@
+require 'html5/html5parser/phase'
+
+module HTML5
+class InSelectInTablePhase < Phase
+
+  handle_start %w(caption table tbody tfoot thead tr td th) => 'Table'
+  handle_end   %w(caption table tbody tfoot thead tr td th) =>  'Table'
+
+  def processCharacters(data)
+    @parser.phases[:inSelect].processCharacters(data)
+  end
+
+  def startTagTable(name, attributes)
+    @parser.parse_error("unexpected-table-element-start-tag-in-select-in-table", {:name => name})
+    endTagOther("select")
+    @parser.phase.processStartTag(name, attributes)
+  end
+
+  def startTagOther(name, attributes)
+    @parser.phases[:inSelect].processStartTag(name, attributes)
+  end
+
+  def endTagTable(name)
+    @parser.parse_error("unexpected-table-element-end-tag-in-select-in-table", {:name => name})
+    if @tree.elementInScope(name, true)
+      endTagOther("select")
+      @parser.phase.processEndTag(name)
+    end
+  end
+
+  def endTagOther(name)
+   @parser.phases[:inSelect].processEndTag(name)
+  end
+end
+end

data/lib/html5/html5parser/in_table_body_phase.rb

@@ -0,0 +1,92 @@
+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 processSpaceCharacters(data)
+      @parser.phases[:inTable].processSpaceCharacters(data)
+    end
+
+    def process_eof
+      @parser.phases[:inTable].process_eof
+    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 "unexpected-start-tag", {:name => name}
+      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 "unexpected-end-tag", {:name => name}
+      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/html5/html5parser/in_table_phase.rb

@@ -0,0 +1,177 @@
+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_start %w(style script)
+    
+    handle_start 'input'
+
+    handle_end 'table', %w( body caption col colgroup html tbody td tfoot th thead tr ) => 'Ignore'
+
+    def processSpaceCharacters(data)
+      if !current_table.flags.include?("tainted")
+        @tree.insertText(data)
+      else
+        processCharacters(data)
+      end
+    end
+
+    def processCharacters(data)
+      if ["style", "script"].include?(@tree.open_elements.last.name)
+        @tree.insertText(data)
+      else
+        if !current_table.flags.include?("tainted")
+          @parser.parse_error("unexpected-char-implies-table-voodoo")
+          current_table.flags << "tainted"
+        end
+        # Do the table magic!
+        @tree.insert_from_table = true
+        @parser.phases[:inBody].processCharacters(data)
+        @tree.insert_from_table = false
+      end
+    end
+
+    def process_eof
+      if @tree.open_elements.last.name != "html"
+        @parser.parse_error("eof-in-table")
+      else
+        assert @parser.innerHTML
+      end
+    end
+
+    def startTagCaption(name, attributes)
+      clear_stack_to_table_context
+      @tree.activeFormattingElements.push(Marker)
+      @tree.insert_element(name, attributes)
+      @parser.phase = @parser.phases[:inCaption]
+    end
+
+    def startTagColgroup(name, attributes)
+      clear_stack_to_table_context
+      @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)
+      clear_stack_to_table_context
+      @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)
+      @parser.parse_error("unexpected-start-tag-implies-table-voodoo", {:name => name})
+      if !current_table.flags.include?("tainted")
+        current_table.flags.push("tainted")
+      end
+      @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 startTagStyleScript(name, attributes)
+      if !current_table.flags.include?("tainted")
+         @parser.phases[:inHead].processStartTag(name, attributes)
+      else
+         startTagOther(name, attributes)
+      end
+    end
+
+    def startTagInput(name, attributes)
+      if attributes.include?("type") &&
+         attributes["type"].downcase == "hidden" &&
+         !current_table.flags.include?("tainted")
+        @parser.parse_error("unpexted-hidden-input-in-table")
+        @tree.insert_element(name, attributes)
+        # XXX associate with form
+        @tree.open_elements.pop
+      else
+        self.startTagOther(name, attributes)
+      end
+    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 "unexpected-end-tag", {:name => name}
+      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
+
+    def endStyleScript name
+      if !current_table().flags.include?("tainted")
+        @parser.phases[:inHead].processEndTag(name)
+      else
+        endTagOther(name)
+      end
+    end
+
+    protected
+
+    def clear_stack_to_table_context
+      # "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
+
+    def current_table
+      i = -1
+      i -= 1 while @tree.open_elements[i].name != "table"
+      @tree.open_elements[i]
+    end
+
+  end
+end