RubyGems - gammo - Versions diffs - 0.1.0 - Mend

gammo 0.1.0

Files changed (53) hide show

checksums.yaml +7 -0
data/.gitignore +8 -0
data/.travis.yml +6 -0
data/Gemfile +9 -0
data/Gemfile.lock +27 -0
data/LICENSE.txt +21 -0
data/README.md +177 -0
data/Rakefile +25 -0
data/gammo.gemspec +23 -0
data/lib/gammo.rb +15 -0
data/lib/gammo/attribute.rb +17 -0
data/lib/gammo/fragment_parser.rb +65 -0
data/lib/gammo/node.rb +157 -0
data/lib/gammo/parser.rb +524 -0
data/lib/gammo/parser/constants.rb +94 -0
data/lib/gammo/parser/foreign.rb +307 -0
data/lib/gammo/parser/insertion_mode.rb +74 -0
data/lib/gammo/parser/insertion_mode/after_after_body.rb +36 -0
data/lib/gammo/parser/insertion_mode/after_after_frameset.rb +32 -0
data/lib/gammo/parser/insertion_mode/after_body.rb +46 -0
data/lib/gammo/parser/insertion_mode/after_frameset.rb +39 -0
data/lib/gammo/parser/insertion_mode/after_head.rb +70 -0
data/lib/gammo/parser/insertion_mode/before_head.rb +49 -0
data/lib/gammo/parser/insertion_mode/before_html.rb +45 -0
data/lib/gammo/parser/insertion_mode/in_body.rb +463 -0
data/lib/gammo/parser/insertion_mode/in_caption.rb +47 -0
data/lib/gammo/parser/insertion_mode/in_cell.rb +46 -0
data/lib/gammo/parser/insertion_mode/in_column_group.rb +66 -0
data/lib/gammo/parser/insertion_mode/in_frameset.rb +48 -0
data/lib/gammo/parser/insertion_mode/in_head.rb +98 -0
data/lib/gammo/parser/insertion_mode/in_head_noscript.rb +52 -0
data/lib/gammo/parser/insertion_mode/in_row.rb +53 -0
data/lib/gammo/parser/insertion_mode/in_select.rb +77 -0
data/lib/gammo/parser/insertion_mode/in_select_in_table.rb +46 -0
data/lib/gammo/parser/insertion_mode/in_table.rb +114 -0
data/lib/gammo/parser/insertion_mode/in_table_body.rb +55 -0
data/lib/gammo/parser/insertion_mode/in_template.rb +80 -0
data/lib/gammo/parser/insertion_mode/initial.rb +152 -0
data/lib/gammo/parser/insertion_mode/text.rb +32 -0
data/lib/gammo/parser/insertion_mode_stack.rb +8 -0
data/lib/gammo/parser/node_stack.rb +24 -0
data/lib/gammo/tags.rb +9 -0
data/lib/gammo/tags/table.rb +744 -0
data/lib/gammo/tokenizer.rb +373 -0
data/lib/gammo/tokenizer/debug.rb +34 -0
data/lib/gammo/tokenizer/entity.rb +2240 -0
data/lib/gammo/tokenizer/escape.rb +174 -0
data/lib/gammo/tokenizer/script_scanner.rb +229 -0
data/lib/gammo/tokenizer/tokens.rb +66 -0
data/lib/gammo/version.rb +3 -0
data/misc/html.yaml +384 -0
data/misc/table.erubi +14 -0
metadata +97 -0

data/lib/gammo/parser/insertion_mode/after_after_body.rb ADDED

@@ -0,0 +1,36 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.22.
+    class AfterAfterBody < InsertionMode
+      def error_token(_)
+        # ignore the token
+        halt true
+      end
+      def text_token(token)
+        halt InBody.new(parser).process if token.data.lstrip.length.zero?
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html
+          halt InBody.new(parser).process
+        end
+      end
+      def comment_token(token)
+        parser.document.append_child Node::Comment.new(data: token.data)
+        halt true
+      end
+      def doctype_token(token)
+        halt InBody.new(parser).process
+      end
+      def default(_)
+        parser.insertion_mode = InBody
+        halt false
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/after_after_frameset.rb ADDED

@@ -0,0 +1,32 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.23.
+    class AfterAfterFrameset < InsertionMode
+      def comment_token(token)
+        parser.document.append_child Node::Comment.new(data: token.data)
+      end
+      def text_token(token)
+        halt InBody.new(parser).process unless token.data.gsub(/[^\s]/, '').empty?
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html
+          halt InBody.new(parser).process
+        when Tags::Noframes
+          halt InHead.new(parser).process
+        end
+      end
+      def doctype_token(token)
+        halt InBody.new(parser).process
+      end
+      def default(_)
+        # ignore the token
+        halt true
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/after_body.rb ADDED

@@ -0,0 +1,46 @@
+require 'gammo/node'
+module Gammo
+  class Parser
+    # Section 12.2.6.4.19.
+    class AfterBody < InsertionMode
+      def error_token(_)
+        # ignore the token
+        true
+      end
+      def text_token(token)
+        s = token.data.lstrip
+        halt InBody.new(parser).process if s.length.zero?
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html
+          halt InBody.new(parser).process
+        end
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Html
+          parser.insertion_mode = AfterAfterBody unless parser.fragment?
+          halt true
+        end
+      end
+      def comment_token(token)
+        open_elements = parser.open_elements
+        if open_elements.length < 1 || open_elements.first.tag != Tags::Html
+          raise ParseError, 'bad parser state: <html> element not found, in the after-body insertion mode'
+        end
+        open_elements.first.append_child Node::Comment.new(data: token.data)
+        halt true
+      end
+      def default(_)
+        parser.insertion_mode = InBody
+        halt false
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/after_frameset.rb ADDED

@@ -0,0 +1,39 @@
+require 'gammo/parser/insertion_mode/after_after_frameset'
+module Gammo
+  class Parser
+    # Section 12.2.6.4.21.
+    class AfterFrameset < InsertionMode
+      def comment_token(token)
+        parser.add_child Node::Comment.new(data: token.data)
+      end
+      def text_token(token)
+        s = token.data.gsub(/[^\s]/, '')
+        parser.add_text(s) unless s.empty?
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html
+          halt InBody.new(parser).process
+        when Tags::Noframes
+          halt InHead.new(parser).process
+        end
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Html
+          parser.insertion_mode = AfterAfterFrameset
+          halt true
+        end
+      end
+      def default(_)
+        # ignore the token
+        halt true
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/after_head.rb ADDED

@@ -0,0 +1,70 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.5.
+    class AfterHead < InsertionMode
+      def text_token(token)
+        s = token.data.lstrip
+        if s.length < token.data.length
+          # add the initial whitespace to the current node.
+          parser.add_text token.data.slice(0, token.data.length - s.length)
+          halt true if s == ''
+          token.data = s
+        end
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html then halt InBody.new(parser).process
+        when Tags::Body
+          parser.add_element
+          parser.frameset_ok = false
+          parser.insertion_mode = InBody
+          halt true
+        when Tags::Frameset
+          parser.add_element
+          parser.insertion_mode = InFrameset
+          halt true
+        when Tags::Base, Tags::Basefont, Tags::Bgsound, Tags::Link, Tags::Meta,
+          Tags::Noframes, Tags::Script, Tags::Style, Tags::Template, Tags::Title
+          parser.open_elements << parser.head
+          begin
+            halt InHead.new(parser).process
+          ensure
+            parser.open_elements.delete(parser.head)
+          end
+        when Tags::Head
+          # ignore the token
+          halt true
+        end
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Body, Tags::Html, Tags::Br
+          # drop down to creating an implied <body> tag.
+        when Tags::Template
+          halt InHead.new(parser).process
+        else
+          # ignore the token.
+          halt true
+        end
+      end
+      def comment_token(token)
+        parser.add_child Node::Comment.new(data: token.data)
+        halt true
+      end
+      def doctype_token(token)
+        # ignore the token.
+        halt true
+      end
+      def default(_)
+        parser.parse_implied_token(Tokenizer::StartTagToken, Tags::Body, Tags::Body.to_s)
+        parser.frameset_ok = true
+        halt false
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/before_head.rb ADDED

@@ -0,0 +1,49 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.3
+    class BeforeHead < InsertionMode
+      def text_token(token)
+        token.data = token.data.lstrip
+        halt true if token.data.length.zero?
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Head
+          parser.add_element
+          parser.head = parser.top
+          parser.insertion_mode = InHead
+          halt true
+        when Tags::Html
+          halt InBody.new(parser).process
+        end
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Head, Tags::Body, Tags::Html, Tags::Br
+          parser.parse_implied_token Tokenizer::StartTagToken, Tags::Head, Tags::Head.to_s
+          halt false
+        else
+          # ignore the token.
+          halt true
+        end
+      end
+      def comment_token(token)
+        parser.add_child(Node::Comment.new(data: token.data))
+        halt true
+      end
+      def doctype_token(token)
+        # ignore the token.
+        halt true
+      end
+      def default(_)
+        parser.parse_implied_token Tokenizer::StartTagToken, Tags::Head, Tags::Head.to_s
+        halt false
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/before_html.rb ADDED

@@ -0,0 +1,45 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.2
+    class BeforeHTML < InsertionMode
+      # Ignores the token.
+      def doctype_token(_)
+        halt true
+      end
+      def text_token(token)
+        token.data = token.data.lstrip
+        # it's all whitespace so ignore it.
+        halt true if token.data.length.zero?
+      end
+      def start_tag_token(token)
+        return unless token.tag == Tags::Html
+        parser.add_element
+        parser.insertion_mode = BeforeHead
+        halt true
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Head, Tags::Body, Tags::Html, Tags::Br
+          parser.parse_implied_token Tokenizer::StartTagToken, Tags::Html, Tags::Html.to_s
+          halt false
+        else
+          # ignore the token.
+          halt true
+        end
+      end
+      def comment_token(token)
+        parser.document.append_child Node::Comment.new(data: token.data)
+        halt true
+      end
+      def default(_)
+        parser.parse_implied_token Tokenizer::StartTagToken, Tags::Html, Tags::Html.to_s
+        halt false
+      end
+    end
+  end
+end

data/lib/gammo/parser/insertion_mode/in_body.rb ADDED

@@ -0,0 +1,463 @@
+module Gammo
+  class Parser
+    # Section 12.2.6.4.6.
+    class InBody < InsertionMode
+      def text_token(token)
+        data = token.data
+        node = parser.open_elements.last
+        case node.tag
+        when Tags::Pre, Tags::Listing
+          unless node.first_child
+            # ignore a newline at the start of the <pre> block.
+            data = data.slice(1..-1) if !data.empty? && data[0] == ?\r
+            data = data.slice(1..-1) if !data.empty? && data[0] == ?\n
+          end
+        end
+        data = data.gsub("\x00", '')
+        halt true if data.empty?
+        parser.reconstruct_active_formatting_elements
+        parser.frameset_ok = false if parser.frameset_ok && !data.lstrip.empty?
+        parser.add_text(data)
+      end
+      def start_tag_token(token)
+        case token.tag
+        when Tags::Html
+          halt true if parser.open_elements.any? { |oe| oe.tag == Tags::Template }
+          copy_attributes(parser.open_elements[0], token)
+        when Tags::Base, Tags::Basefont, Tags::Bgsound, Tags::Link, Tags::Meta,
+          Tags::Noframes, Tags::Script, Tags::Style, Tags::Template, Tags::Title
+          halt InHead.new(parser).process
+        when Tags::Body
+          halt true if parser.open_elements.any? { |oe| oe.tag == Tags::Template }
+          if parser.open_elements.length >= 2
+            body = parser.open_elements[1]
+            if body.instance_of?(Node::Element) && body.tag == Tags::Body
+              parser.frameset_ok = false
+              copy_attributes(body, parser.token)
+            end
+          end
+        when Tags::Frameset
+          if !parser.frameset_ok || parser.open_elements.length < 2 || parser.open_elements[1].tag != Tags::Body
+            # ignore the token
+            halt true
+          end
+          body = parser.open_elements[1]
+          body.parent.remove_child(body) if body.parent
+          parser.open_elements = parser.open_elements.slice(0, 1)
+          parser.add_element
+          parser.insertion_mode = InFrameset
+          halt true
+        when Tags::Address, Tags::Article, Tags::Aside, Tags::Blockquote,
+          Tags::Center, Tags::Dialog, Tags::Details, Tags::Dir, Tags::Div,
+          Tags::Dl, Tags::Fieldset, Tags::Figcaption, Tags::Figure,
+          Tags::Footer, Tags::Header, Tags::Hgroup, Tags::Main, Tags::Menu,
+          Tags::Nav, Tags::Ol, Tags::P, Tags::Section, Tags::Summary, Tags::Ul
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.add_element
+        when Tags::H1, Tags::H2, Tags::H3, Tags::H4, Tags::H5, Tags::H6
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          node = parser.top
+          case node.tag
+          when Tags::H1, Tags::H2, Tags::H3, Tags::H4, Tags::H5, Tags::H6
+            parser.open_elements.pop
+          end
+          parser.add_element
+        when Tags::Pre, Tags::Listing
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.add_element
+          parser.frameset_ok = false
+        when Tags::Form
+          # ignore the token.
+          halt true if parser.form && !parser.open_elements.any? { |oe| oe.tag == Tags::Template }
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.add_element
+          parser.form = parser.top unless parser.open_elements.any? { |oe| oe.tag == Tags::Template }
+        when Tags::Li
+          parser.frameset_ok = false
+          parser.open_elements.reverse_each_with_index do |open_element, index|
+            case open_element.tag
+            when Tags::Li then parser.open_elements = parser.open_elements.slice(0, index)
+            when Tags::Address, Tags::Div, Tags::P then next
+            else
+              next unless parser.special_element?(open_element)
+            end
+            break
+          end
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.add_element
+        when Tags::Dd, Tags::Dt
+          parser.frameset_ok = false
+          parser.open_elements.reverse_each_with_index do |open_element, index|
+            case open_element.tag
+            when Tags::Dd, Tags::Dt then parser.open_elements = parser.open_elements.slice(0, index)
+            when Tags::Address, Tags::Div, Tags::P then next
+            else
+              next unless parser.special_element?(open_element)
+            end
+            break
+          end
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.add_element
+        when Tags::Plaintext
+          parser.pop_until BUTTON_SCOPE, Tags::P
+          parser.add_element
+        when Tags::Button
+          parser.pop_until DEFAULT_SCOPE, Tags::Button
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+          parser.frameset_ok = false
+        when Tags::A
+          parser.active_formatting_elements.reverse_each do |afe|
+            break if afe.is_a?(Node::ScopeMarker)
+            next unless afe.instance_of?(Node::Element) && afe.tag == Tags::A
+            adoption_agency_for_end_tag_formatting(Tags::A, "a")
+            parser.open_elements.delete(afe)
+            parser.active_formatting_elements.delete(afe)
+            break
+          end
+          parser.reconstruct_active_formatting_elements
+          parser.add_formatting_element
+        when Tags::B, Tags::Big, Tags::Code, Tags::Em, Tags::Font, Tags::I,
+          Tags::S, Tags::Small, Tags::Strike, Tags::Strong, Tags::Tt, Tags::U
+          parser.reconstruct_active_formatting_elements
+          parser.add_formatting_element
+        when Tags::Nobr
+          parser.reconstruct_active_formatting_elements
+          if parser.element_in_scope?(DEFAULT_SCOPE, Tags::Nobr)
+            adoption_agency_for_end_tag_formatting(Tags::Nobr, "nobr")
+            parser.reconstruct_active_formatting_elements
+          end
+          parser.add_formatting_element
+        when Tags::Applet, Tags::Marquee, Tags::Object
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+          parser.active_formatting_elements << Node::DEFAULT_SCOPE_MARKER
+          parser.frameset_ok = false
+        when Tags::Table
+          parser.pop_until(BUTTON_SCOPE, Tags::P) unless parser.quirks
+          parser.add_element
+          parser.frameset_ok = false
+          parser.insertion_mode = InTable
+          halt true
+        when Tags::Area, Tags::Br, Tags::Embed, Tags::Img, Tags::Input, Tags::Keygen, Tags::Wbr
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+          parser.open_elements.pop
+          parser.acknowledge_self_closing_tag
+          token.attributes.each do |attr|
+            # skip setting frameset_ok = false
+            halt true if attr.key == 'type' && attr.value.downcase == 'hidden'
+          end if token.tag == Tags::Input
+          parser.frameset_ok = false
+        when Tags::Param, Tags::Source, Tags::Track
+          parser.add_element
+          parser.open_elements.pop
+          parser.acknowledge_self_closing_tag
+        when Tags::Hr
+          parser.pop_until BUTTON_SCOPE, Tags::P
+          parser.add_element
+          parser.open_elements.pop
+          parser.acknowledge_self_closing_tag
+          parser.frameset_ok = false
+        when Tags::Image
+          token.tag = Tags::Img
+          # todo: fixme <img>
+          token.data = Tags::Img.to_s
+          halt false
+        when Tags::Textarea
+          parser.add_element
+          parser.set_original_insertion_mode
+          parser.frameset_ok = false
+          parser.insertion_mode = Text
+        when Tags::Xmp
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+          parser.reconstruct_active_formatting_elements
+          parser.frameset_ok = false
+          parser.add_element
+          parser.set_original_insertion_mode
+          parser.insertion_mode = Text
+        when Tags::Iframe
+          parser.frameset_ok = false
+          parser.parse_generic_raw_text_element
+        when Tags::Noembed
+          parser.parse_generic_raw_text_element
+        when Tags::Noscript
+          if parser.scripting?
+            parser.parse_generic_raw_text_element
+            halt true
+          end
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+          parser.tokenizer.next_is_not_raw_text!
+        when Tags::Select
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+          parser.frameset_ok = false
+          parser.insertion_mode = InSelect
+          halt true
+        when Tags::Optgroup, Tags::Option
+          parser.open_elements.pop if parser.top.tag == Tags::Option
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+        when Tags::Rb, Tags::Rtc
+          parser.generate_implied_end_tags if parser.element_in_scope?(DEFAULT_SCOPE, Tags::Ruby)
+          parser.add_element
+        when Tags::Rp, Tags::Rt
+          parser.generate_implied_end_tags('rtc') if parser.element_in_scope?(DEFAULT_SCOPE, Tags::Ruby)
+          parser.add_element
+        when Tags::Math, Tags::Svg
+          parser.reconstruct_active_formatting_elements
+          parser.adjust_attribute_names(token.attributes, token.tag == Tags::Math ? Parser::MATH_ML_ATTRIBUTE_ADJUSTMENTS : Parser::SVG_ATTRIBUTE_ADJUSTMENTS)
+          parser.adjust_foreign_attributes(token.attributes)
+          parser.add_element
+          parser.top.namespace = token.data
+          if parser.has_self_closing_token
+            parser.open_elements.pop
+            parser.acknowledge_self_closing_tag
+          end
+          halt true
+        when Tags::Caption, Tags::Col, Tags::Colgroup, Tags::Frame, Tags::Head, Tags::Tbody, Tags::Td, Tags::Tfoot, Tags::Th, Tags::Thead, Tags::Tr
+          # ignore the token.
+        else
+          parser.reconstruct_active_formatting_elements
+          parser.add_element
+        end
+      end
+      def end_tag_token(token)
+        case token.tag
+        when Tags::Body
+          parser.insertion_mode = AfterBody if parser.element_in_scope?(DEFAULT_SCOPE, Tags::Body)
+        when Tags::Html
+          halt true unless parser.element_in_scope?(DEFAULT_SCOPE, Tags::Body)
+          parser.parse_implied_token(Tokenizer::EndTagToken, Tags::Body, Tags::Body.to_s)
+          halt false
+        when Tags::Address, Tags::Article, Tags::Aside, Tags::Blockquote,
+          Tags::Button, Tags::Center, Tags::Dialog, Tags::Details, Tags::Dir,
+          Tags::Div, Tags::Dl, Tags::Fieldset, Tags::Figcaption, Tags::Figure,
+          Tags::Footer, Tags::Header, Tags::Hgroup, Tags::Listing, Tags::Main,
+          Tags::Menu, Tags::Nav, Tags::Ol, Tags::Pre, Tags::Section,
+          Tags::Summary, Tags::Ul
+          parser.pop_until(DEFAULT_SCOPE, token.tag)
+        when Tags::Form
+          if parser.open_elements.any? { |oe| oe.tag == Tags::Template }
+            index = parser.index_of_element_in_scope(DEFAULT_SCOPE, Tags::Form)
+            # ignore the token.
+            halt true if index == -1
+            parser.generate_implied_end_tags
+            # ignore the token.
+            halt true if parser.open_elements[index].tag != Tags::Form
+            parser.pop_until(DEFAULT_SCOPE, Tags::Form)
+          else
+            node = parser.form
+            parser.form = nil
+            index = parser.index_of_element_in_scope(DEFAULT_SCOPE, Tags::Form)
+            # ignore the token.
+            halt true if node == nil || index == -1 || parser.open_elements[index] != node
+            parser.generate_implied_end_tags
+            parser.open_elements.delete(node)
+          end
+        when Tags::P
+          parser.parse_implied_token(Tokenizer::StartTagToken, Tags::P, Tags::P.to_s) unless parser.element_in_scope?(BUTTON_SCOPE, Tags::P)
+          parser.pop_until(BUTTON_SCOPE, Tags::P)
+        when Tags::Li
+          parser.pop_until(LIST_ITEM_SCOPE, Tags::Li)
+        when Tags::Dd, Tags::Dt
+          parser.pop_until(DEFAULT_SCOPE, token.tag)
+        when Tags::H1, Tags::H2, Tags::H3, Tags::H4, Tags::H5, Tags::H6
+          parser.pop_until(DEFAULT_SCOPE, Tags::H1, Tags::H2, Tags::H3, Tags::H4, Tags::H5, Tags::H6)
+        when Tags::A, Tags::B, Tags::Big, Tags::Code, Tags::Em, Tags::Font,
+          Tags::I, Tags::Nobr, Tags::S, Tags::Small, Tags::Strike,
+          Tags::Strong, Tags::Tt, Tags::U
+          adoption_agency_for_end_tag_formatting(token.tag, token.data)
+        when Tags::Applet, Tags::Marquee, Tags::Object
+          parser.clear_active_formatting_elements if parser.pop_until(DEFAULT_SCOPE, token.tag)
+        when Tags::Br
+          # FIXME
+          parser.token = Tokenizer::StartTagToken.new(token.data, tag: token.tag)
+          halt false
+        when Tags::Template
+          halt InHead.new(parser).process
+        else
+          adoption_agency_for_end_tag_formatting(token.tag, token.data)
+        end
+      end
+      def comment_token(token)
+        parser.add_child Node::Comment.new(data: token.data)
+      end
+      def error_token(token)
+        if parser.template_stack.length > 0
+          parser.insertion_mode = InTemplate
+          halt false
+        else
+          parser.open_elements.any? do |oe|
+            case oe.tag
+            when Tags::Dd, Tags::Dt, Tags::Li, Tags::Optgroup, Tags::Option, Tags::P,
+              Tags::Rb, Tags::Rp, Tags::Rt, Tags::Rtc, Tags::Tbody, Tags::Td, Tags::Tfoot,
+              Tags::Th, Tags::Thead, Tags::Tr, Tags::Body, Tags::Html
+            else
+              halt true
+            end
+          end
+          halt true
+        end
+      end
+      def default(_)
+        halt true
+      end
+      # Implements "adoption agency" algorithm.
+      # https://html.spec.whatwg.org/multipage/syntax.html#adoptionAgency
+      # @!visibility private
+      def adoption_agency_for_end_tag_formatting(tag, tagname)
+        # Step 1-2.
+        current = parser.open_elements.last
+        if current.data == tagname && parser.active_formatting_elements.index(current) == -1
+          parser.open_elements.pop
+          return
+        end
+        # Step 3-5. The outer loop
+        8.times do |n|
+          # Step 6: Find the formatting element.
+          formatting_element = nil
+          parser.active_formatting_elements.reverse_each do |afe|
+            break if afe.instance_of? Node::ScopeMarker
+            if afe.tag == tag
+              formatting_element = afe
+              break
+            end
+          end
+          unless formatting_element
+            adoption_agency_for_end_tag_other(tag, tagname)
+            return
+          end
+          # Step 7. Ignore the tag if formatting element is not in the stack of
+          # open elements.
+          index = parser.open_elements.index(formatting_element)
+          unless index
+            parser.active_formatting_elements.delete(formatting_element)
+            return
+          end
+          # Step 8. Ignore the tag if formatting element is not in the scope.
+          return unless parser.element_in_scope?(DEFAULT_SCOPE, tag)
+          # Step 9. This step is omitted because it's just a parse error but no
+          # need to return.
+          # Step 10-11. Find the furthest block.
+          furthest_block = parser.open_elements.slice(index..-1).find(&parser.method(:special_element?))
+          unless furthest_block
+            element = parser.open_elements.pop
+            element = parser.open_elements.pop while element != formatting_element
+            parser.active_formatting_elements.delete(element)
+            return
+          end
+          # Step 12-13. Find the common ancestor and bookmark node.
+          common_ancestor = parser.open_elements[index - 1]
+          bookmark = parser.active_formatting_elements.index(formatting_element)
+          # Step 14. The inner loop. find the last node to reparent.
+          last_node = furthest_block
+          node = furthest_block
+          x = parser.open_elements.index(node)
+          # Step 14.1.
+          j = 0
+          loop do
+            # Step 14.2.
+            j += 1
+            # Step 14.3.
+            x -= 1
+            node = parser.open_elements[x]
+            # Step 14.4.
+            break if node == formatting_element
+            # Step 14.5. Remove node from the list of active formatting elements if
+            # inner loop counter is greater than three and node is in the list of
+            # active formatting elements.
+            ni = parser.active_formatting_elements.index(node)
+            if ni && j > 3
+              parser.active_formatting_elements.delete(node)
+              # If any element of the list of active formatting elements is removed,
+              # we need to take care whether bookmark should be decremented or not.
+              # This is because the value of bookmark may exceed the size of the
+              # list by removing elements from the list.
+              bookmark -= 1 if ni <= bookmark
+              next
+            end
+            # Step 14.6. Continue the next inner loop if node is not in the list of
+            # active formatting elements.
+            unless parser.active_formatting_elements.include?(node)
+              parser.open_elements.delete(node)
+              next
+            end
+            # Step 14.7
+            clone = node.clone
+            afei = parser.active_formatting_elements.index(node)
+            oei = parser.open_elements.index(node)
+            raise ParseError, 'bad parser state: expected elements are not found' if !(afei && oei)
+            parser.active_formatting_elements[afei] = clone
+            parser.open_elements[oei] = clone
+            node = clone
+            # Step 14.8
+            bookmark = (parser.active_formatting_elements.index(node) + 1) || 0 if last_node == furthest_block
+            # Step 14.9
+            last_node.parent.remove_child(last_node) if last_node.parent
+            node.append_child(last_node)
+            # Step 14.10
+            last_node = node
+          end
+          # Step 15. Reparent last_node to the common ancestor,
+          # or for misnested table nodes, to the foster parent.
+          last_node.parent.remove_child(last_node) if last_node.parent
+          case common_ancestor.tag
+          when Tags::Table, Tags::Tbody, Tags::Tfoot, Tags::Thead, Tags::Tr
+            parser.foster_parent(last_node)
+          else
+            common_ancestor.append_child(last_node)
+          end
+          # Steps 16-18. Reparent nodes from the furthest block's children
+          # to a clone of the formatting element.
+          clone = formatting_element.clone
+          reparent_children(clone, furthest_block)
+          furthest_block.append_child(clone)
+          # Step 19. Fix up the list of active formatting elements.
+          old_loc = parser.active_formatting_elements.index(formatting_element)
+          bookmark -= 1 if old_loc && old_loc < bookmark
+          parser.active_formatting_elements.delete(formatting_element)
+          parser.active_formatting_elements.insert(bookmark, clone)
+          # Step 20. Fix up the stack of open elements.
+          parser.open_elements.delete(formatting_element)
+          parser.open_elements.insert(parser.open_elements.index(furthest_block) + 1, clone)
+        end
+      end
+      # @!visibility private
+      def adoption_agency_for_end_tag_other(tag, tagname)
+        parser.open_elements.reverse_each_with_index do |open_element, index|
+          if open_element.tag == tag && open_element.data == tagname
+            parser.open_elements = parser.open_elements.slice(0, index)
+            break
+          end
+          break if parser.special_element?(open_element)
+        end
+      end
+      # @!visibility private
+      def reparent_children(dst, src)
+        while child = src.first_child
+          src.remove_child(child)
+          dst.append_child(child)
+        end
+      end
+    end
+  end
+end