RubyGems - gammo - Versions diffs - 0.1.0 - Mend

gammo 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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