diff --git a/lib/better_html/better_erb.rb b/lib/better_html/better_erb.rb
index 5fc8ecb..83b49ed 100644
--- a/lib/better_html/better_erb.rb
+++ b/lib/better_html/better_erb.rb
@@ -65,7 +65,7 @@ def generate(template, source)
 
         generator = klass.new(
           erb,
-          **options
+          **options,
         )
         generator.validate! if generator.respond_to?(:validate!)
         generator.src
diff --git a/lib/better_html/better_erb/runtime_checks.rb b/lib/better_html/better_erb/runtime_checks.rb
index 1463d6e..5426bc9 100644
--- a/lib/better_html/better_erb/runtime_checks.rb
+++ b/lib/better_html/better_erb/runtime_checks.rb
@@ -119,7 +119,7 @@ def check_tag_name(type, start, stop, line, column)
         return if text.upcase == "!DOCTYPE"
         return if @config.partial_tag_name_pattern.match?(text)
 
-        s = +"Invalid tag name #{text.inspect} does not match "\
+        s = +"Invalid tag name #{text.inspect} does not match " \
           "regular expression #{@config.partial_tag_name_pattern.inspect}\n"
         s << build_location(line, column, text.size)
         raise BetterHtml::HtmlError, s
@@ -129,7 +129,7 @@ def check_attribute_name(type, start, stop, line, column)
         text = @parser.document[start...stop]
         return if @config.partial_attribute_name_pattern.match?(text)
 
-        s = +"Invalid attribute name #{text.inspect} does not match "\
+        s = +"Invalid attribute name #{text.inspect} does not match " \
           "regular expression #{@config.partial_attribute_name_pattern.inspect}\n"
         s << build_location(line, column, text.size)
         raise BetterHtml::HtmlError, s
diff --git a/lib/better_html/better_erb/validated_output_buffer.rb b/lib/better_html/better_erb/validated_output_buffer.rb
index 3544b46..9b536ec 100644
--- a/lib/better_html/better_erb/validated_output_buffer.rb
+++ b/lib/better_html/better_erb/validated_output_buffer.rb
@@ -17,7 +17,7 @@ def safe_quoted_value_append=(value)
           value = properly_escaped(value)
 
           if value.include?(@context[:quote_character])
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
               "into a quoted attribute value. The value cannot contain the character #{@context[:quote_character]}."
           end
 
@@ -25,15 +25,15 @@ def safe_quoted_value_append=(value)
         end
 
         def safe_unquoted_value_append=(value)
-          raise DontInterpolateHere, "Do not interpolate without quotes around this "\
-            "attribute value. Instead of "\
-            "<#{@context[:tag_name]} #{@context[:attribute_name]}=#{@context[:attribute_value]}<%=#{@code}%>> "\
+          raise DontInterpolateHere, "Do not interpolate without quotes around this " \
+            "attribute value. Instead of " \
+            "<#{@context[:tag_name]} #{@context[:attribute_name]}=#{@context[:attribute_value]}<%=#{@code}%>> " \
             "try <#{@context[:tag_name]} #{@context[:attribute_name]}=\"#{@context[:attribute_value]}<%=#{@code}%>\">."
         end
 
         def safe_space_after_attribute_append=(value)
-          raise DontInterpolateHere, "Add a space after this attribute value. Instead of "\
-            "<#{@context[:tag_name]} #{@context[:attribute_name]}=\"#{@context[:attribute_value]}\"<%=#{@code}%>> "\
+          raise DontInterpolateHere, "Add a space after this attribute value. Instead of " \
+            "<#{@context[:tag_name]} #{@context[:attribute_name]}=\"#{@context[:attribute_value]}\"<%=#{@code}%>> " \
             "try <#{@context[:tag_name]} #{@context[:attribute_name]}=\"#{@context[:attribute_value]}\" <%=#{@code}%>>."
         end
 
@@ -43,7 +43,7 @@ def safe_attribute_name_append=(value)
           value = value.to_s
 
           unless value =~ /\A[a-z0-9\-]*\z/
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
               "into a attribute name around '#{@context[:attribute_name]}<%=#{@code}%>'."
           end
 
@@ -54,8 +54,8 @@ def safe_after_attribute_name_append=(value)
           return if value.nil?
 
           unless value.is_a?(BetterHtml::HtmlAttributes)
-            raise DontInterpolateHere, "Do not interpolate #{value.class} in a tag. "\
-              "Instead of <#{@context[:tag_name]} <%=#{@code}%>> please "\
+            raise DontInterpolateHere, "Do not interpolate #{value.class} in a tag. " \
+              "Instead of <#{@context[:tag_name]} <%=#{@code}%>> please " \
               "try <#{@context[:tag_name]} <%= html_attributes(attr: value) %>>."
           end
 
@@ -63,7 +63,7 @@ def safe_after_attribute_name_append=(value)
         end
 
         def safe_after_equal_append=(value)
-          raise DontInterpolateHere, "Do not interpolate without quotes after "\
+          raise DontInterpolateHere, "Do not interpolate without quotes after " \
             "attribute around '#{@context[:attribute_name]}=<%=#{@code}%>'."
         end
 
@@ -71,8 +71,8 @@ def safe_tag_append=(value)
           return if value.nil?
 
           unless value.is_a?(BetterHtml::HtmlAttributes)
-            raise DontInterpolateHere, "Do not interpolate #{value.class} in a tag. "\
-              "Instead of <#{@context[:tag_name]} <%=#{@code}%>> please "\
+            raise DontInterpolateHere, "Do not interpolate #{value.class} in a tag. " \
+              "Instead of <#{@context[:tag_name]} <%=#{@code}%>> please " \
               "try <#{@context[:tag_name]} <%= html_attributes(attr: value) %>>."
           end
 
@@ -85,7 +85,7 @@ def safe_tag_name_append=(value)
           value = value.to_s
 
           unless value =~ /\A[a-z0-9\:\-]*\z/
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
               "into a tag name around: <#{@context[:tag_name]}<%=#{@code}%>>."
           end
 
@@ -100,12 +100,12 @@ def safe_rawtext_append=(value)
           if @context[:tag_name].downcase == "script" &&
               (value =~ /<script/i || value =~ %r{</script}i)
             # https://www.w3.org/TR/html5/scripting-1.html#restrictions-for-contents-of-script-elements
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
-              "into a script tag around: <#{@context[:tag_name]}>#{@context[:rawtext_text]}<%=#{@code}%>. "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
+              "into a script tag around: <#{@context[:tag_name]}>#{@context[:rawtext_text]}<%=#{@code}%>. " \
               "A script tag cannot contain <script or </script anywhere inside of it."
           elsif value =~ /<#{Regexp.escape(@context[:tag_name].downcase)}/i ||
               value =~ %r{</#{Regexp.escape(@context[:tag_name].downcase)}}i
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
               "into a #{@context[:tag_name].downcase} tag around: " \
               "<#{@context[:tag_name]}>#{@context[:rawtext_text]}<%=#{@code}%>."
           end
@@ -120,7 +120,7 @@ def safe_comment_append=(value)
 
           # in a <!-- ...here --> we disallow -->
           if value =~ /-->/
-            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation "\
+            raise UnsafeHtmlError, "Detected invalid characters as part of the interpolation " \
               "into a html comment around: <!--#{@context[:comment_text]}<%=#{@code}%>."
           end
 
diff --git a/lib/better_html/html_attributes.rb b/lib/better_html/html_attributes.rb
index cc61311..1c2f5c8 100644
--- a/lib/better_html/html_attributes.rb
+++ b/lib/better_html/html_attributes.rb
@@ -19,7 +19,7 @@ def to_s
           value = value.to_s
           escaped_value = value.html_safe? ? value : CGI.escapeHTML(value)
           if escaped_value.include?('"')
-            raise ArgumentError, "The value provided for attribute '#{key}' contains a `\"` "\
+            raise ArgumentError, "The value provided for attribute '#{key}' contains a `\"` " \
               "character which is not allowed. Did you call .html_safe without properly escaping this data?"
           end
           "#{key}=\"#{escaped_value}\""
diff --git a/lib/better_html/parser.rb b/lib/better_html/parser.rb
index 236693a..a6a8b11 100644
--- a/lib/better_html/parser.rb
+++ b/lib/better_html/parser.rb
@@ -53,7 +53,7 @@ def parser_errors
       @erb.parser.errors.map do |error|
         Error.new(
           error.message,
-          location: Tokenizer::Location.new(@buffer, error.position, error.position + 1)
+          location: Tokenizer::Location.new(@buffer, error.position, error.position + 1),
         )
       end
     end
@@ -183,9 +183,13 @@ def build_attribute_name_node(tokens)
     end
 
     def build_attribute_value_node(tokens)
-      children = shift_all_with_interpolation(tokens,
-        :attribute_quoted_value_start, :attribute_quoted_value,
-        :attribute_quoted_value_end, :attribute_unquoted_value)
+      children = shift_all_with_interpolation(
+        tokens,
+        :attribute_quoted_value_start,
+        :attribute_quoted_value,
+        :attribute_quoted_value_end,
+        :attribute_unquoted_value,
+      )
 
       build_node(:attribute_value, children)
     end
@@ -199,7 +203,7 @@ def build_node(type, tokens, pre: nil, post: nil)
       BetterHtml::AST::Node.new(
         type,
         tokens.present? ? wrap_tokens(tokens) : [],
-        loc: tokens.present? ? build_location([pre, *tokens, post]) : empty_location
+        loc: tokens.present? ? build_location([pre, *tokens, post]) : empty_location,
       )
     end
 
@@ -298,8 +302,13 @@ def wrap_token(object)
 
       if object.is_a?(::AST::Node)
         object
-      elsif [:text, :tag_name, :attribute_name, :attribute_quoted_value,
-             :attribute_unquoted_value,].include?(object.type)
+      elsif [
+        :text,
+        :tag_name,
+        :attribute_name,
+        :attribute_quoted_value,
+        :attribute_unquoted_value,
+      ].include?(object.type)
         object.loc.source
       elsif [:attribute_quoted_value_start, :attribute_quoted_value_end].include?(object.type)
         BetterHtml::AST::Node.new(:quote, [object.loc.source], loc: object.loc)
diff --git a/lib/better_html/test_helper/safe_erb/allowed_script_type.rb b/lib/better_html/test_helper/safe_erb/allowed_script_type.rb
index b822808..efe0f26 100644
--- a/lib/better_html/test_helper/safe_erb/allowed_script_type.rb
+++ b/lib/better_html/test_helper/safe_erb/allowed_script_type.rb
@@ -24,7 +24,7 @@ def validate_type(tag)
 
           add_error(
             "#{type_attribute.value} is not a valid type, valid types are #{VALID_JAVASCRIPT_TAG_TYPES.join(", ")}",
-            location: type_attribute.loc
+            location: type_attribute.loc,
           )
         end
       end
diff --git a/lib/better_html/test_helper/safe_erb/tag_interpolation.rb b/lib/better_html/test_helper/safe_erb/tag_interpolation.rb
index 6490a93..0f20f59 100644
--- a/lib/better_html/test_helper/safe_erb/tag_interpolation.rb
+++ b/lib/better_html/test_helper/safe_erb/tag_interpolation.rb
@@ -7,8 +7,18 @@ module BetterHtml
   module TestHelper
     module SafeErb
       class TagInterpolation < Base
-        NO_HTML_TAGS = ["title", "textarea", "script", "style", "xmp", "iframe", "noembed", "noframes", "listing",
-                        "plaintext",]
+        NO_HTML_TAGS = [
+          "title",
+          "textarea",
+          "script",
+          "style",
+          "xmp",
+          "iframe",
+          "noembed",
+          "noframes",
+          "listing",
+          "plaintext",
+        ]
 
         def validate
           @parser.nodes_with_type(:tag).each do |tag_node|
@@ -28,8 +38,8 @@ def validate
         def no_html_tag?(node)
           ast = @parser.ast.to_a
           index = ast.find_index(node)
-          return unless (previous_node = ast[index - 1])
-          return unless previous_node.type == :tag
+          return false unless (previous_node = ast[index - 1])
+          return false unless previous_node.type == :tag
 
           tag = BetterHtml::Tree::Tag.from_node(previous_node)
           NO_HTML_TAGS.include?(tag.name) && !tag.closing?
@@ -57,7 +67,7 @@ def validate_attribute(attribute)
             elsif indicator == "=="
               add_error(
                 "erb interpolation with '<%==' inside html attribute is never safe",
-                location: erb_node.loc
+                location: erb_node.loc,
               )
             end
           end
@@ -122,14 +132,14 @@ def handle_missing_safe_wrapper(parent_node, ruby_node, attr_name)
           if method_calls.empty?
             add_error(
               "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-              location: nested_location(parent_node, ruby_node)
+              location: nested_location(parent_node, ruby_node),
             )
             true
           elsif unsafe_calls.any?
             unsafe_calls.each do |call_node|
               add_error(
                 "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-                location: nested_location(parent_node, call_node)
+                location: nested_location(parent_node, call_node),
               )
             end
             true
@@ -148,7 +158,7 @@ def validate_tag_interpolation(parent_node, ruby_node, attr_name)
 
             add_error(
               "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-              location: nested_location(parent_node, ruby_node)
+              location: nested_location(parent_node, ruby_node),
             )
           end
         end
@@ -158,12 +168,12 @@ def no_unsafe_calls(parent_node, ruby_node)
             if call.method_name?(:raw)
               add_error(
                 "erb interpolation with '<%= raw(...) %>' in this context is never safe",
-                location: nested_location(parent_node, ruby_node)
+                location: nested_location(parent_node, ruby_node),
               )
             elsif call.method_name?(:html_safe)
               add_error(
                 "erb interpolation with '<%= (...).html_safe %>' in this context is never safe",
-                location: nested_location(parent_node, ruby_node)
+                location: nested_location(parent_node, ruby_node),
               )
             end
           end
@@ -173,7 +183,7 @@ def nested_location(parent_node, ruby_node)
           Tokenizer::Location.new(
             parent_node.loc.source_buffer,
             parent_node.loc.begin_pos + ruby_node.loc.expression.begin_pos,
-            parent_node.loc.begin_pos + ruby_node.loc.expression.end_pos
+            parent_node.loc.begin_pos + ruby_node.loc.expression.end_pos,
           )
         end
       end
diff --git a/lib/better_html/test_helper/safe_lodash_tester.rb b/lib/better_html/test_helper/safe_lodash_tester.rb
index b83ac7e..8d949d1 100644
--- a/lib/better_html/test_helper/safe_lodash_tester.rb
+++ b/lib/better_html/test_helper/safe_lodash_tester.rb
@@ -74,7 +74,7 @@ def validate!
 
             add_error(
               "No script tags allowed nested in lodash templates",
-              location: tag_node.loc
+              location: tag_node.loc,
             )
           end
 
@@ -104,7 +104,7 @@ def validate_tag_attributes(tag)
               elsif indicator_node.loc.source == "!"
                 add_error(
                   "lodash interpolation with '[%!' inside html attribute is never safe",
-                  location: lodash_node.loc
+                  location: lodash_node.loc,
                 )
               end
             end
@@ -116,9 +116,9 @@ def validate_tag_expression(attribute, lodash_node)
           source = code_node.loc.source.strip
           if @config.javascript_attribute_name?(attribute.name) && !@config.lodash_safe_javascript_expression?(source)
             add_error(
-              "lodash interpolation in javascript attribute "\
+              "lodash interpolation in javascript attribute " \
                 "`#{attribute.name}` must call `JSON.stringify(#{source})`",
-              location: lodash_node.loc
+              location: lodash_node.loc,
             )
           end
         end
@@ -132,7 +132,7 @@ def validate_no_statements(node)
         def add_no_statement_error(loc)
           add_error(
             "javascript statement not allowed here; did you mean '[%=' ?",
-            location: loc
+            location: loc,
           )
         end
       end
diff --git a/lib/better_html/tokenizer/base_erb.rb b/lib/better_html/tokenizer/base_erb.rb
index 13c3eec..fff7e3c 100644
--- a/lib/better_html/tokenizer/base_erb.rb
+++ b/lib/better_html/tokenizer/base_erb.rb
@@ -80,7 +80,7 @@ def add_erb_tokens(ltrim, indicator, code, rtrim)
       def add_token(type, begin_pos, end_pos)
         token = Token.new(
           type: type,
-          loc: Location.new(@buffer, begin_pos, end_pos)
+          loc: Location.new(@buffer, begin_pos, end_pos),
         )
         @tokens << token
         token
diff --git a/lib/better_html/tokenizer/html_lodash.rb b/lib/better_html/tokenizer/html_lodash.rb
index e07f327..d4adcb1 100644
--- a/lib/better_html/tokenizer/html_lodash.rb
+++ b/lib/better_html/tokenizer/html_lodash.rb
@@ -96,7 +96,7 @@ def add_lodash_tokens(indicator, code)
       def add_token(type, begin_pos: nil, end_pos: nil)
         token = Token.new(
           type: type,
-          loc: Location.new(@buffer, begin_pos, end_pos)
+          loc: Location.new(@buffer, begin_pos, end_pos),
         )
         @tokens << token
         token
diff --git a/lib/better_html/tokenizer/location.rb b/lib/better_html/tokenizer/location.rb
index c210160..13e779d 100644
--- a/lib/better_html/tokenizer/location.rb
+++ b/lib/better_html/tokenizer/location.rb
@@ -39,7 +39,7 @@ def line_range
       def line_source_with_underline
         spaces = source_line.scan(/\A\s*/).first
         column_without_spaces = [column - spaces.length, 0].max
-        underscore_length = [[end_pos - begin_pos, source_line.length - column_without_spaces].min, 1].max
+        underscore_length = (end_pos - begin_pos).clamp(1, (source_line.length - column_without_spaces))
         "#{source_line.gsub(/\A\s*/, "")}\n#{" " * column_without_spaces}#{"^" * underscore_length}"
       end
 
diff --git a/lib/tasks/better_html_tasks.rake b/lib/tasks/better_html_tasks.rake
index c8f9c19..9134ca6 100644
--- a/lib/tasks/better_html_tasks.rake
+++ b/lib/tasks/better_html_tasks.rake
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # desc "Explaining what the task does"
 # task :better_html do
 #   # Task goes here
diff --git a/test/better_html/better_erb/implementation_test.rb b/test/better_html/better_erb/implementation_test.rb
index 2b75bd5..1685927 100644
--- a/test/better_html/better_erb/implementation_test.rb
+++ b/test/better_html/better_erb/implementation_test.rb
@@ -35,18 +35,20 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a href=\"<%= value %>\">", locals: { value: ' \'">x '.html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a quoted attribute value. The value cannot contain the character \".", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a quoted attribute value. The value cannot contain the character \".",
+          e.message
       end
 
       test "interpolate html_safe inside single quoted attribute" do
         config = build_config(allow_single_quoted_attributes: true)
         e = assert_raises(ActionView::Template::Error) do
-          render("<a href=\'<%= value %>\'>", config: config, locals: { value: ' \'">x '.html_safe })
+          render("<a href='<%= value %>'>", config: config, locals: { value: ' \'">x '.html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a quoted attribute value. The value cannot contain the character '.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a quoted attribute value. The value cannot contain the character '.",
+          e.message
       end
 
       test "interpolate in attribute name" do
@@ -59,8 +61,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a data-<%= value %>-foo>", locals: { value: "un safe" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a attribute name around 'data-<%= value %>'.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a attribute name around 'data-<%= value %>'.",
+          e.message
       end
 
       test "interpolate in attribute name with unsafe value with equal sign" do
@@ -68,8 +71,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a data-<%= value %>-foo>", locals: { value: "un=safe" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the "\
-          "interpolation into a attribute name around 'data-<%= value %>'.", e.message
+        assert_equal "Detected invalid characters as part of the " \
+          "interpolation into a attribute name around 'data-<%= value %>'.",
+          e.message
       end
 
       test "interpolate in attribute name with unsafe value with quote" do
@@ -77,8 +81,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a data-<%= value %>-foo>", locals: { value: "un\"safe" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the "\
-          "interpolation into a attribute name around 'data-<%= value %>'.", e.message
+        assert_equal "Detected invalid characters as part of the " \
+          "interpolation into a attribute name around 'data-<%= value %>'.",
+          e.message
       end
 
       test "interpolate after an attribute name without a value" do
@@ -92,8 +97,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a data-foo=<%= html_attributes(foo: 'bar') %>>", config: config)
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Do not interpolate without quotes after "\
-          "attribute around 'data-foo=<%= html_attributes(foo: 'bar') %>'.", e.message
+        assert_equal "Do not interpolate without quotes after " \
+          "attribute around 'data-foo=<%= html_attributes(foo: 'bar') %>'.",
+          e.message
       end
 
       test "interpolate after an attribute value" do
@@ -101,9 +107,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a foo=\"xx\"<%= html_attributes(foo: 'bar') %>>")
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Add a space after this attribute value. "\
-          "Instead of <a foo=\"xx\"<%= html_attributes(foo: 'bar') %>>"\
-          " try <a foo=\"xx\" <%= html_attributes(foo: 'bar') %>>.", e.message
+        assert_equal "Add a space after this attribute value. " \
+          "Instead of <a foo=\"xx\"<%= html_attributes(foo: 'bar') %>> " \
+          "try <a foo=\"xx\" <%= html_attributes(foo: 'bar') %>>.",
+          e.message
       end
 
       test "interpolate in attribute without quotes" do
@@ -112,8 +119,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a href=<%= value %>>", config: config, locals: { value: "un safe" })
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Do not interpolate without quotes after "\
-          "attribute around 'href=<%= value %>'.", e.message
+        assert_equal "Do not interpolate without quotes after " \
+          "attribute around 'href=<%= value %>'.",
+          e.message
       end
 
       test "interpolate in attribute after value" do
@@ -122,9 +130,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a href=something<%= value %>>", config: config, locals: { value: "" })
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Do not interpolate without quotes around this "\
-          "attribute value. Instead of <a href=something<%= value %>> "\
-          "try <a href=\"something<%= value %>\">.", e.message
+        assert_equal "Do not interpolate without quotes around this " \
+          "attribute value. Instead of <a href=something<%= value %>> " \
+          "try <a href=\"something<%= value %>\">.",
+          e.message
       end
 
       test "interpolate in tag name" do
@@ -137,8 +146,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<tag-<%= value %>-foo>", locals: { value: "un safe" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a tag name around: <tag-<%= value %>>.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a tag name around: <tag-<%= value %>>.",
+          e.message
       end
 
       test "interpolate in tag name with slash" do
@@ -146,8 +156,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<tag-<%= value %>-foo>", locals: { value: "un/safe" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a tag name around: <tag-<%= value %>>.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a tag name around: <tag-<%= value %>>.",
+          e.message
       end
 
       test "interpolate in tag name with end of tag" do
@@ -155,8 +166,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<tag-<%= value %>-foo>", locals: { value: "><script>" })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a tag name around: <tag-<%= value %>>.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a tag name around: <tag-<%= value %>>.",
+          e.message
       end
 
       test "interpolate in comment" do
@@ -169,8 +181,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<!-- <%= value %> -->", locals: { value: "-->".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a html comment around: <!-- <%= value %>.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a html comment around: <!-- <%= value %>.",
+          e.message
       end
 
       test "non html_safe interpolation into comment tag" do
@@ -189,9 +202,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<script> foo <%= value %> bar<script>", locals: { value: "<!--".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a script tag around: <script> foo <%= value %>. "\
-          "A script tag cannot contain <script or </script anywhere inside of it.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a script tag around: <script> foo <%= value %>. " \
+          "A script tag cannot contain <script or </script anywhere inside of it.",
+          e.message
       end
 
       test "interpolate in script tag with start of script" do
@@ -199,9 +213,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<script> foo <%= value %> bar</script>", locals: { value: "<script".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a script tag around: <script> foo <%= value %>. "\
-          "A script tag cannot contain <script or </script anywhere inside of it.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a script tag around: <script> foo <%= value %>. " \
+          "A script tag cannot contain <script or </script anywhere inside of it.",
+          e.message
       end
 
       test "interpolate in script tag with raw interpolation" do
@@ -214,9 +229,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<script> foo <%= value %> bar</script>", locals: { value: "<ScRIpT".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a script tag around: <script> foo <%= value %>. "\
-          "A script tag cannot contain <script or </script anywhere inside of it.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a script tag around: <script> foo <%= value %>. " \
+          "A script tag cannot contain <script or </script anywhere inside of it.",
+          e.message
       end
 
       test "interpolate in script tag with end of script" do
@@ -224,9 +240,10 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<script> foo <%= value %> bar</script>", locals: { value: "</script".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a script tag around: <script> foo <%= value %>. "\
-          "A script tag cannot contain <script or </script anywhere inside of it.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a script tag around: <script> foo <%= value %>. " \
+          "A script tag cannot contain <script or </script anywhere inside of it.",
+          e.message
       end
 
       test "interpolate html_attributes" do
@@ -239,8 +256,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<a <%= 'foo=\"bar\"' %>>")
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Do not interpolate String in a tag. Instead "\
-          "of <a <%= 'foo=\"bar\"' %>> please try <a <%= html_attributes(attr: value) %>>.", e.message
+        assert_equal "Do not interpolate String in a tag. Instead " \
+          "of <a <%= 'foo=\"bar\"' %>> please try <a <%= html_attributes(attr: value) %>>.",
+          e.message
       end
 
       test "non html_safe interpolation into rawtext tag" do
@@ -258,8 +276,9 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<title><%= value %></title>", locals: { value: "</title>".html_safe })
         end
         assert_kind_of BetterHtml::UnsafeHtmlError, e.cause
-        assert_equal "Detected invalid characters as part of the interpolation "\
-          "into a title tag around: <title><%= value %>.", e.message
+        assert_equal "Detected invalid characters as part of the interpolation " \
+          "into a title tag around: <title><%= value %>.",
+          e.message
       end
 
       test "interpolate block in middle of tag" do
@@ -271,10 +290,11 @@ class ImplementationTest < ActiveSupport::TestCase
           HTML
         end
         assert_kind_of BetterHtml::DontInterpolateHere, e.cause
-        assert_equal "Ruby statement not allowed.\n"\
-          "In 'tag' on line 1 column 19:\n"\
-          "        <a href=\"\" <%= something do %>\n"\
-          "                   ^^^^^^^^^^^^^^^^^^^", e.message
+        assert_equal "Ruby statement not allowed.\n" \
+          "In 'tag' on line 1 column 19:\n        " \
+          "<a href=\"\" <%= something do %>\n                   " \
+          "^^^^^^^^^^^^^^^^^^^",
+          e.message
       end
 
       test "interpolate with output block is valid syntax" do
@@ -301,7 +321,7 @@ class ImplementationTest < ActiveSupport::TestCase
         assert_equal(
           "<div><input type=\"submit\" name=\"commit\" value=\"Save changes\" data-disable-with=\"Save changes\" />" \
             "</div>",
-          render("<div><%= send 'submit_tag' %></div>")
+          render("<div><%= send 'submit_tag' %></div>"),
         )
       end
 
@@ -310,10 +330,11 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<foo~bar></foo~bar>")
         end
         assert_kind_of BetterHtml::HtmlError, e.cause
-        assert_equal "Invalid tag name \"foo~bar\" does not match regular expression /\\A[a-z0-9\\-\\:]+\\z/\n"\
-          "On line 1 column 1:\n"\
-          "<foo~bar></foo~bar>\n"\
-          " ^^^^^^^", e.message
+        assert_equal "Invalid tag name \"foo~bar\" does not match regular expression /\\A[a-z0-9\\-\\:]+\\z/\n" \
+          "On line 1 column 1:\n" \
+          "<foo~bar></foo~bar>\n " \
+          "^^^^^^^",
+          e.message
       end
 
       test "attribute names are validated against attribute_name_pattern regexp" do
@@ -324,8 +345,9 @@ class ImplementationTest < ActiveSupport::TestCase
         assert_equal "Invalid attribute name \"bar_baz\" does not match regular expression " \
           "#{build_config.partial_attribute_name_pattern.inspect}\n" \
           "On line 1 column 5:\n" \
-          "<foo bar_baz=\"1\">\n" \
-          "     ^^^^^^^", e.message
+          "<foo bar_baz=\"1\">\n     " \
+          "^^^^^^^",
+          e.message
       end
 
       test "single quotes are disallowed when allow_single_quoted_attributes=false" do
@@ -334,10 +356,11 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<foo bar='1'>", config: config)
         end
         assert_kind_of BetterHtml::HtmlError, e.cause
-        assert_equal "Single-quoted attributes are not allowed\n"\
-          "On line 1 column 9:\n"\
-          "<foo bar='1'>\n"\
-          "         ^", e.message
+        assert_equal "Single-quoted attributes are not allowed\n" \
+          "On line 1 column 9:\n" \
+          "<foo bar='1'>\n         " \
+          "^",
+          e.message
       end
 
       test "single quotes are allowed when allow_single_quoted_attributes=true" do
@@ -353,10 +376,11 @@ class ImplementationTest < ActiveSupport::TestCase
           render("<foo bar=1>", config: config)
         end
         assert_kind_of BetterHtml::HtmlError, e.cause
-        assert_equal "Unquoted attribute values are not allowed\n"\
-          "On line 1 column 9:\n"\
-          "<foo bar=1>\n"\
-          "         ^", e.message
+        assert_equal "Unquoted attribute values are not allowed\n" \
+          "On line 1 column 9:\n" \
+          "<foo bar=1>\n         " \
+          "^",
+          e.message
       end
 
       test "unquoted values are allowed when allow_unquoted_attributes=true" do
@@ -415,11 +439,12 @@ class ImplementationTest < ActiveSupport::TestCase
         assert_equal "2 error(s) found in HTML document.\n" \
           "expected whitespace, '>' or '=' after attribute name\n" \
           "On line 1 column 8:\n" \
-          "<foo bar~baz=\"1\">\n" \
-          "        ^^^^^^^^^expected whitespace, '>', attribute name or value\n" \
+          "<foo bar~baz=\"1\">\n        " \
+          "^^^^^^^^^expected whitespace, '>', attribute name or value\n" \
           "On line 1 column 8:\n" \
-          "<foo bar~baz=\"1\">\n" \
-          "        ^^^^^^^^^", e.message
+          "<foo bar~baz=\"1\">\n        " \
+          "^^^^^^^^^",
+          e.message
       end
 
       private
@@ -444,7 +469,7 @@ def render(source, config: build_config, locals: {}, filename: "test.html.erb")
           ActionView::Template::Handlers::ERB.new,
           virtual_path: "partial",
           format: :html,
-          locals: locals.keys
+          locals: locals.keys,
         ).render(ViewContext.with_empty_template_cache.empty, locals)
       ensure
         BetterHtml.config = old_config
diff --git a/test/better_html/helpers_test.rb b/test/better_html/helpers_test.rb
index 4130618..122a087 100644
--- a/test/better_html/helpers_test.rb
+++ b/test/better_html/helpers_test.rb
@@ -26,8 +26,9 @@ class HelpersTest < ActiveSupport::TestCase
       e = assert_raises(ArgumentError) do
         html_attributes("something": 'with "> double quote'.html_safe).to_s
       end
-      assert_equal "The value provided for attribute 'something' contains a `\"` character which is not allowed. "\
-        "Did you call .html_safe without properly escaping this data?", e.message
+      assert_equal "The value provided for attribute 'something' contains a `\"` character which is not allowed. " \
+        "Did you call .html_safe without properly escaping this data?",
+        e.message
     end
 
     test "#html_attributes accepts correctly escaped html_safe values" do
diff --git a/test/better_html/parser_test.rb b/test/better_html/parser_test.rb
index cc00bc4..338967a 100644
--- a/test/better_html/parser_test.rb
+++ b/test/better_html/parser_test.rb
@@ -46,11 +46,15 @@ class ParserTest < ActiveSupport::TestCase
       code = "<![CDATA[ foo <%= bar %> baz ]]>"
       tree = Parser.new(buffer(code))
 
-      assert_equal s(:document,
-        s(:cdata,
+      assert_equal s(
+        :document,
+        s(
+          :cdata,
           " foo ",
           s(:erb, s(:indicator, "="), nil, s(:code, " bar "), nil),
-          " baz ")),
+          " baz ",
+        ),
+      ),
         tree.ast
       assert_equal code, tree.ast.loc.source
     end
@@ -70,11 +74,15 @@ class ParserTest < ActiveSupport::TestCase
     test "consume comment with interpolation" do
       tree = Parser.new(buffer("<!-- foo <%= bar %> baz -->"))
 
-      assert_equal s(:document,
-        s(:comment,
+      assert_equal s(
+        :document,
+        s(
+          :comment,
           " foo ",
           s(:erb, s(:indicator, "="), nil, s(:code, " bar "), nil),
-          " baz ")),
+          " baz ",
+        ),
+      ),
         tree.ast
     end
 
@@ -85,12 +93,21 @@ class ParserTest < ActiveSupport::TestCase
 
     test "tag without name" do
       tree = Parser.new(buffer("foo < bar"))
-      assert_equal s(:document,
+      assert_equal s(
+        :document,
         s(:text, "foo "),
-        s(:tag, nil, nil,
-          s(:tag_attributes,
-            s(:attribute, s(:attribute_name, "bar"), nil, nil)),
-          nil)), tree.ast
+        s(
+          :tag,
+          nil,
+          nil,
+          s(
+            :tag_attributes,
+            s(:attribute, s(:attribute_name, "bar"), nil, nil),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume tag nodes with solidus" do
@@ -113,136 +130,226 @@ class ParserTest < ActiveSupport::TestCase
 
     test "consume tag nodes with interpolation" do
       tree = Parser.new(buffer("<ns:<%= name %>-thing>"))
-      assert_equal s(:document,
-        s(:tag,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
           nil,
           s(:tag_name, "ns:", s(:erb, s(:indicator, "="), nil, s(:code, " name "), nil), "-thing"),
           nil,
-          nil)), tree.ast
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume tag attributes with erb" do
       tree = Parser.new(buffer("<div class=foo <%= erb %> name=bar>"))
-      assert_equal s(:document,
-        s(:tag, nil,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
+          nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "class"),
               s(:equal),
-              s(:attribute_value, "foo")),
-            s(:erb, s(:indicator, "="), nil,
-              s(:code, " erb "), nil),
-            s(:attribute,
+              s(:attribute_value, "foo"),
+            ),
+            s(
+              :erb,
+              s(:indicator, "="),
+              nil,
+              s(:code, " erb "),
+              nil,
+            ),
+            s(
+              :attribute,
               s(:attribute_name, "name"),
               s(:equal),
-              s(:attribute_value, "bar")),),
-          nil)), tree.ast
+              s(:attribute_value, "bar"),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume tag attributes nodes unquoted value" do
       tree = Parser.new(buffer("<div foo=bar>"))
-      assert_equal s(:document,
-        s(:tag, nil,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
+          nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "foo"),
               s(:equal),
-              s(:attribute_value, "bar"))),
-          nil)), tree.ast
+              s(:attribute_value, "bar"),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume attributes without name" do
       tree = Parser.new(buffer("<div 'thing'>"))
-      assert_equal s(:document,
-        s(:tag, nil,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
+          nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               nil,
               nil,
-              s(:attribute_value, s(:quote, "'"), "thing", s(:quote, "'")))),
-          nil)), tree.ast
+              s(:attribute_value, s(:quote, "'"), "thing", s(:quote, "'")),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume tag attributes nodes quoted value" do
       tree = Parser.new(buffer("<div foo=\"bar\">"))
-      assert_equal s(:document,
-        s(:tag, nil,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
+          nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "foo"),
               s(:equal),
-              s(:attribute_value, s(:quote, "\""), "bar", s(:quote, "\"")))),
-          nil)), tree.ast
+              s(:attribute_value, s(:quote, "\""), "bar", s(:quote, "\"")),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume tag attributes nodes interpolation in name and value" do
       tree = Parser.new(buffer("<div data-<%= foo %>=\"some <%= value %> foo\">"))
-      assert_equal s(:document,
-        s(:tag, nil,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
+          nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "data-", s(:erb, s(:indicator, "="), nil, s(:code, " foo "), nil)),
               s(:equal),
-              s(:attribute_value,
+              s(
+                :attribute_value,
                 s(:quote, "\""),
                 "some ",
                 s(:erb, s(:indicator, "="), nil, s(:code, " value "), nil),
                 " foo",
-                s(:quote, "\""),),)),
-          nil)), tree.ast
+                s(:quote, "\""),
+              ),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "consume text nodes" do
       tree = Parser.new(buffer("here is <%= some %> text"))
 
-      assert_equal s(:document,
-        s(:text,
+      assert_equal s(
+        :document,
+        s(
+          :text,
           "here is ",
           s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " text")), tree.ast
+          " text",
+        ),
+      ),
+        tree.ast
     end
 
     test "javascript template parsing works" do
       tree = Parser.new(buffer("here is <%= some %> text"), template_language: :javascript)
 
-      assert_equal s(:document,
-        s(:text,
+      assert_equal s(
+        :document,
+        s(
+          :text,
           "here is ",
           s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " text")), tree.ast
+          " text",
+        ),
+      ),
+        tree.ast
     end
 
     test "javascript template does not consume html tags" do
       tree = Parser.new(buffer("<div <%= some %> />"), template_language: :javascript)
 
-      assert_equal s(:document,
-        s(:text,
+      assert_equal s(
+        :document,
+        s(
+          :text,
           "<div ",
           s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " />")), tree.ast
+          " />",
+        ),
+      ),
+        tree.ast
     end
 
     test "lodash template parsing works" do
       tree = Parser.new(buffer('<div class="[%= foo %]">'), template_language: :lodash)
 
-      assert_equal s(:document,
-        s(:tag,
+      assert_equal s(
+        :document,
+        s(
+          :tag,
           nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "class"),
               s(:equal),
-              s(:attribute_value,
+              s(
+                :attribute_value,
                 s(:quote, "\""),
                 s(:lodash, s(:indicator, "="), s(:code, " foo ")),
-                s(:quote, "\"")))),
-          nil)), tree.ast
+                s(:quote, "\""),
+              ),
+            ),
+          ),
+          nil,
+        ),
+      ),
+        tree.ast
     end
 
     test "nodes are all nested under document" do
@@ -256,25 +363,36 @@ class ParserTest < ActiveSupport::TestCase
         </div>
       HTML
 
-      assert_equal s(:document,
+      assert_equal s(
+        :document,
         s(:text, "some text\n"),
         s(:comment, " a comment "),
-        s(:text,
+        s(
+          :text,
           "\nsome more text\n",
           s(:erb, s(:indicator, "="), nil, s(:code, " an erb tag "), s(:trim)),
-          "\n"),
-        s(:tag,
+          "\n",
+        ),
+        s(
+          :tag,
           nil,
           s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
+          s(
+            :tag_attributes,
+            s(
+              :attribute,
               s(:attribute_name, "class"),
               s(:equal),
-              s(:attribute_value, s(:quote, "\""), "foo", s(:quote, "\"")))),
-          nil),
+              s(:attribute_value, s(:quote, "\""), "foo", s(:quote, "\"")),
+            ),
+          ),
+          nil,
+        ),
         s(:text, "\n  content\n"),
         s(:tag, s(:solidus), s(:tag_name, "div"), nil, nil),
-        s(:text, "\n"),), tree.ast
+        s(:text, "\n"),
+      ),
+        tree.ast
     end
   end
 end
diff --git a/test/better_html/test_helper/safe_erb/tag_interpolation_test.rb b/test/better_html/test_helper/safe_erb/tag_interpolation_test.rb
index 2036ac1..43edff3 100644
--- a/test/better_html/test_helper/safe_erb/tag_interpolation_test.rb
+++ b/test/better_html/test_helper/safe_erb/tag_interpolation_test.rb
@@ -63,7 +63,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "name", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -77,13 +77,13 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "bar", errors[0].location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors[0].message
+            errors[0].message,
           )
 
           assert_equal "baz", errors[1].location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors[1].message
+            errors[1].message,
           )
         end
 
@@ -96,7 +96,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -123,7 +123,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "bar", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -178,7 +178,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe.to_json.html_safe", errors[1].location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors[1].message
+            errors[1].message,
           )
         end
 
@@ -223,7 +223,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "raw unsafe.to_json", errors[1].location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors[1].message
+            errors[1].message,
           )
         end
 
@@ -236,7 +236,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors[0].location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors[0].message
+            errors[0].message,
           )
         end
 
@@ -249,7 +249,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -262,7 +262,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -283,7 +283,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -296,7 +296,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
@@ -309,7 +309,7 @@ class TagInterpolationTest < ActiveSupport::TestCase
           assert_equal "unsafe", errors.first.location.source
           assert_equal(
             "erb interpolation in javascript attribute must be wrapped in safe helper such as '(...).to_json'",
-            errors.first.message
+            errors.first.message,
           )
         end
 
diff --git a/test/better_html/tokenizer/html_erb_test.rb b/test/better_html/tokenizer/html_erb_test.rb
index 8cf22d5..f3fb6a2 100644
--- a/test/better_html/tokenizer/html_erb_test.rb
+++ b/test/better_html/tokenizer/html_erb_test.rb
@@ -13,7 +13,8 @@ class HtmlErbTest < ActiveSupport::TestCase
         assert_attributes ({
           type: :text,
           loc: { begin_pos: 0, end_pos: 14, source: "just some text" },
-        }), scanner.tokens[0]
+        }),
+          scanner.tokens[0]
       end
 
       test "statement" do
@@ -74,7 +75,7 @@ class HtmlErbTest < ActiveSupport::TestCase
           scanner.tokens[5]
         assert_attributes(
           { type: :attribute_quoted_value, loc: { begin_pos: 12, end_pos: 24, source: "your store’s" } },
-          scanner.tokens[6]
+          scanner.tokens[6],
         )
         assert_attributes ({ type: :attribute_quoted_value_end, loc: { begin_pos: 24, end_pos: 25, source: "'" } }),
           scanner.tokens[7]
diff --git a/test/better_html/tokenizer/html_lodash_test.rb b/test/better_html/tokenizer/html_lodash_test.rb
index 3e07e74..ce25256 100644
--- a/test/better_html/tokenizer/html_lodash_test.rb
+++ b/test/better_html/tokenizer/html_lodash_test.rb
@@ -76,10 +76,21 @@ class HtmlLodashTest < ActiveSupport::TestCase
       test "parses out html correctly" do
         scanner = HtmlLodash.new(buffer('<div class="[%= foo %]">'))
         assert_equal 12, scanner.tokens.size
-        assert_equal [:tag_start, :tag_name, :whitespace, :attribute_name,
-                      :equal, :attribute_quoted_value_start,
-                      :lodash_begin, :indicator, :code, :lodash_end,
-                      :attribute_quoted_value_end, :tag_end,], scanner.tokens.map(&:type)
+        assert_equal [
+          :tag_start,
+          :tag_name,
+          :whitespace,
+          :attribute_name,
+          :equal,
+          :attribute_quoted_value_start,
+          :lodash_begin,
+          :indicator,
+          :code,
+          :lodash_end,
+          :attribute_quoted_value_end,
+          :tag_end,
+        ],
+          scanner.tokens.map(&:type)
         assert_equal ["<", "div", " ", "class", "=", "\"", "[%", "=", " foo ", "%]", "\"", ">"],
           scanner.tokens.map(&:loc).map(&:source)
       end
diff --git a/test/dummy/config.ru b/test/dummy/config.ru
index 097cb7b..89bfd0b 100644
--- a/test/dummy/config.ru
+++ b/test/dummy/config.ru
@@ -2,5 +2,5 @@
 
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path("../config/environment", __FILE__)
+require File.expand_path("../config/environment", __FILE__)
 run Rails.application
diff --git a/test/dummy/config/environments/production.rb b/test/dummy/config/environments/production.rb
index bdd9a47..f7012f3 100644
--- a/test/dummy/config/environments/production.rb
+++ b/test/dummy/config/environments/production.rb
@@ -74,7 +74,7 @@
   config.active_support.deprecation = :notify
 
   # Use default logging formatter so that PID and timestamp are not suppressed.
-  config.log_formatter = ::Logger::Formatter.new
+  config.log_formatter = Logger::Formatter.new
 
   # Do not dump schema after migrations.
   config.active_record.dump_schema_after_migration = false
diff --git a/test/dummy/config/initializers/backtrace_silencers.rb b/test/dummy/config/initializers/backtrace_silencers.rb
index d0f0d3b..4b63f28 100644
--- a/test/dummy/config/initializers/backtrace_silencers.rb
+++ b/test/dummy/config/initializers/backtrace_silencers.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Be sure to restart your server when you modify this file.
 
 # You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
diff --git a/test/dummy/config/initializers/inflections.rb b/test/dummy/config/initializers/inflections.rb
index aa7435f..dc84742 100644
--- a/test/dummy/config/initializers/inflections.rb
+++ b/test/dummy/config/initializers/inflections.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Be sure to restart your server when you modify this file.
 
 # Add new inflection rules using the following format. Inflections
diff --git a/test/dummy/config/initializers/mime_types.rb b/test/dummy/config/initializers/mime_types.rb
index 6e1d16f..be6fedc 100644
--- a/test/dummy/config/initializers/mime_types.rb
+++ b/test/dummy/config/initializers/mime_types.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Be sure to restart your server when you modify this file.
 
 # Add new mime types for use in respond_to blocks:
diff --git a/test/html_tokenizer/parser_test.rb b/test/html_tokenizer/parser_test.rb
index 7c1aeb0..bce1f88 100644
--- a/test/html_tokenizer/parser_test.rb
+++ b/test/html_tokenizer/parser_test.rb
@@ -533,17 +533,20 @@ def test_attribute_with_mutlibyte_characters
       assert_equal(data.join, @parser.document)
       assert_equal(data.join.size, @parser.document_length)
       assert_equal(data.join.size, @parser.column_number)
-      assert_equal([
-        [:tag_start, 0, 1, "<"],
-        [:tag_name, 1, 4, "div"],
-        [:whitespace, 4, 5, " "],
-        [:attribute_name, 5, 10, "title"],
-        [:equal, 10, 11, "="],
-        [:attribute_quoted_value_start, 11, 12, "'"],
-        [:attribute_quoted_value, 12, 24, "your store’s"],
-        [:attribute_quoted_value_end, 24, 25, "'"],
-        [:tag_end, 25, 26, ">"],
-      ], tokens)
+      assert_equal(
+        [
+          [:tag_start, 0, 1, "<"],
+          [:tag_name, 1, 4, "div"],
+          [:whitespace, 4, 5, " "],
+          [:attribute_name, 5, 10, "title"],
+          [:equal, 10, 11, "="],
+          [:attribute_quoted_value_start, 11, 12, "'"],
+          [:attribute_quoted_value, 12, 24, "your store’s"],
+          [:attribute_quoted_value_end, 24, 25, "'"],
+          [:tag_end, 25, 26, ">"],
+        ],
+        tokens,
+      )
     end
 
     def test_valid_syntaxes
diff --git a/test/html_tokenizer/tokenizer_test.rb b/test/html_tokenizer/tokenizer_test.rb
index f50c25b..1bfded8 100644
--- a/test/html_tokenizer/tokenizer_test.rb
+++ b/test/html_tokenizer/tokenizer_test.rb
@@ -5,12 +5,18 @@
 module HtmlTokenizer
   class TokenizerTest < Minitest::Test
     def test_closing_tag_without_start_is_text
-      assert_equal([
-        [:text, ">"],
-      ], tokenize(">"))
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "foo"], [:tag_end, ">"], [:text, ">"],
-      ], tokenize("<foo>>"))
+      assert_equal(
+        [
+          [:text, ">"],
+        ],
+        tokenize(">"),
+      )
+      assert_equal(
+        [
+          [:tag_start, "<"], [:tag_name, "foo"], [:tag_end, ">"], [:text, ">"],
+        ],
+        tokenize("<foo>>"),
+      )
     end
 
     def test_tokenize_text
@@ -19,45 +25,64 @@ def test_tokenize_text
     end
 
     def test_namespace_tag_name_multipart
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "foo:"], [:tag_name, "bar"],
-      ], tokenize("<foo:", "bar"))
+      assert_equal(
+        [
+          [:tag_start, "<"], [:tag_name, "foo:"], [:tag_name, "bar"],
+        ],
+        tokenize("<foo:", "bar"),
+      )
     end
 
     def test_tokenize_doctype
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "!DOCTYPE"], [:whitespace, " "],
-        [:attribute_name, "html"], [:tag_end, ">"],
-      ], tokenize("<!DOCTYPE html>"))
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "!DOCTYPE"],
+          [:whitespace, " "],
+          [:attribute_name, "html"],
+          [:tag_end, ">"],
+        ],
+        tokenize("<!DOCTYPE html>"),
+      )
     end
 
     def test_tokenize_multiple_elements
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "div"], [:tag_end, ">"],
-        [:text, " bla "],
-        [:tag_start, "<"], [:tag_name, "strong"], [:tag_end, ">"],
-      ], tokenize("<div> bla <strong>"))
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:tag_end, ">"],
+          [:text, " bla "],
+          [:tag_start, "<"],
+          [:tag_name, "strong"],
+          [:tag_end, ">"],
+        ],
+        tokenize("<div> bla <strong>"),
+      )
     end
 
     def test_tokenize_complex_doctype
       text = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "!DOCTYPE"],
-        [:whitespace, " "],
-        [:attribute_name, "html"],
-        [:whitespace, " "],
-        [:attribute_name, "PUBLIC"],
-        [:whitespace, " "],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "-//W3C//DTD XHTML 1.0 Transitional//EN"],
-        [:attribute_quoted_value_end, "\""],
-        [:whitespace, " "],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"],
-        [:attribute_quoted_value_end, "\""],
-        [:tag_end, ">"],
-      ], tokenize(text))
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "!DOCTYPE"],
+          [:whitespace, " "],
+          [:attribute_name, "html"],
+          [:whitespace, " "],
+          [:attribute_name, "PUBLIC"],
+          [:whitespace, " "],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "-//W3C//DTD XHTML 1.0 Transitional//EN"],
+          [:attribute_quoted_value_end, "\""],
+          [:whitespace, " "],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"],
+          [:attribute_quoted_value_end, "\""],
+          [:tag_end, ">"],
+        ],
+        tokenize(text),
+      )
     end
 
     def test_tokenize_html_comment
@@ -70,11 +95,16 @@ def test_tokenize_comment_with_newlines
       <!-- debug: <%== @unsafe %> -->
       EOF
 
-      assert_equal([
-        [:text, "      "], [:comment_start, "<!--"],
-        [:text, " debug: <%== @unsafe %> "],
-        [:comment_end, "-->"], [:text, "\n"],
-      ], result)
+      assert_equal(
+        [
+          [:text, "      "],
+          [:comment_start, "<!--"],
+          [:text, " debug: <%== @unsafe %> "],
+          [:comment_end, "-->"],
+          [:text, "\n"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_cdata_section
@@ -84,26 +114,57 @@ def test_tokenize_cdata_section
 
     def test_tokenizer_cdata_regression
       result = tokenize("<![CDATA[ foo ", " baz ]]>")
-      assert_equal([[:cdata_start, "<![CDATA["],
-                    [:text, " foo "], [:text, " baz "], [:cdata_end, "]]>"],], result)
+      assert_equal(
+        [
+          [:cdata_start, "<![CDATA["],
+          [:text, " foo "],
+          [:text, " baz "],
+          [:cdata_end, "]]>"],
+        ],
+        result,
+      )
     end
 
     def test_tokenizer_cdata_context
       result = tokenize("<![CDATA[foo]]><")
-      assert_equal([[:cdata_start, "<![CDATA["],
-                    [:text, "foo"], [:cdata_end, "]]>"], [:tag_start, "<"],], result)
+      assert_equal(
+        [
+          [:cdata_start, "<![CDATA["],
+          [:text, "foo"],
+          [:cdata_end, "]]>"],
+          [:tag_start, "<"],
+        ],
+        result,
+      )
     end
 
     def test_tokenizer_comment_regression
       result = tokenize("<!-- foo ", " baz -->")
-      assert_equal([[:comment_start, "<!--"],
-                    [:text, " foo "], [:text, " baz "], [:comment_end, "-->"],], result)
+      assert_equal(
+        [
+          [:comment_start, "<!--"],
+          [:text, " foo "],
+          [:text, " baz "],
+          [:comment_end, "-->"],
+        ],
+        result,
+      )
     end
 
     def test_tokenizer_parse_tag_after_comment_regression
       result = tokenize("<!-- foo -->  <li>")
-      assert_equal([[:comment_start, "<!--"], [:text, " foo "], [:comment_end, "-->"],
-                    [:text, "  "], [:tag_start, "<"], [:tag_name, "li"], [:tag_end, ">"],], result)
+      assert_equal(
+        [
+          [:comment_start, "<!--"],
+          [:text, " foo "],
+          [:comment_end, "-->"],
+          [:text, "  "],
+          [:tag_start, "<"],
+          [:tag_name, "li"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_basic_tag
@@ -128,8 +189,10 @@ def test_tokenize_tag_multipart_name
 
     def test_tokenize_tag_name_ending_with_slash
       result = tokenize("<div/1>")
-      assert_equal([[:tag_start, "<"], [:tag_name, "div"], [:solidus, "/"], [:attribute_name, "1"], [:tag_end, ">"]],
-        result)
+      assert_equal(
+        [[:tag_start, "<"], [:tag_name, "div"], [:solidus, "/"], [:attribute_name, "1"], [:tag_end, ">"]],
+        result,
+      )
     end
 
     def test_tokenize_empty_tag
@@ -149,262 +212,353 @@ def test_tokenize_end_tag
 
     def test_tokenize_tag_attribute_with_double_quote
       result = tokenize('<div foo="bar">')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value_end, "\""],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value_end, "\""],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_unquoted_attributes_separated_with_solidus
       result = tokenize("<div foo=1/bar=2>")
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_unquoted_value, "1/bar=2"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_unquoted_value, "1/bar=2"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_quoted_attributes_separated_with_solidus
       result = tokenize('<div foo="1"/bar="2">')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "1"],
-        [:attribute_quoted_value_end, "\""],
-        [:solidus, "/"],
-        [:attribute_name, "bar"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "2"],
-        [:attribute_quoted_value_end, "\""],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "1"],
+          [:attribute_quoted_value_end, "\""],
+          [:solidus, "/"],
+          [:attribute_name, "bar"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "2"],
+          [:attribute_quoted_value_end, "\""],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_tag_attribute_without_space
       result = tokenize('<div foo="bar"baz>')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value_end, "\""],
-        [:attribute_name, "baz"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value_end, "\""],
+          [:attribute_name, "baz"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_multipart_unquoted_attribute
       result = tokenize("<div foo=", "bar", "baz>")
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_unquoted_value, "bar"],
-        [:attribute_unquoted_value, "baz"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_unquoted_value, "bar"],
+          [:attribute_unquoted_value, "baz"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_quoted_attribute_separately
       result = tokenize("<div foo=", "'bar'", ">")
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "'"],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value_end, "'"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "'"],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value_end, "'"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_quoted_attribute_in_multiple_parts
       result = tokenize("<div foo=", "'bar", "baz'", ">")
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "'"],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value, "baz"],
-        [:attribute_quoted_value_end, "'"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "'"],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value, "baz"],
+          [:attribute_quoted_value_end, "'"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_tag_attribute_with_single_quote
       result = tokenize("<div foo='bar'>")
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "'"],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value_end, "'"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "'"],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value_end, "'"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_tag_attribute_with_no_quotes
       result = tokenize("<div foo=bla bar=blo>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "div"], [:whitespace, " "],
-        [:attribute_name, "foo"], [:equal, "="], [:attribute_unquoted_value, "bla"], [:whitespace, " "],
-        [:attribute_name, "bar"], [:equal, "="], [:attribute_unquoted_value, "blo"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_unquoted_value, "bla"],
+          [:whitespace, " "],
+          [:attribute_name, "bar"],
+          [:equal, "="],
+          [:attribute_unquoted_value, "blo"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_double_equals
       result = tokenize("<div foo=blabar=blo>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "div"], [:whitespace, " "],
-        [:attribute_name, "foo"], [:equal, "="], [:attribute_unquoted_value, "blabar=blo"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_unquoted_value, "blabar=blo"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_closing_tag
       result = tokenize('<div foo="bar" />')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "foo"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "bar"],
-        [:attribute_quoted_value_end, "\""],
-        [:whitespace, " "],
-        [:solidus, "/"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "foo"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "bar"],
+          [:attribute_quoted_value_end, "\""],
+          [:whitespace, " "],
+          [:solidus, "/"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_script_tag
       result = tokenize("<script>foo <b> bar</script>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "script"], [:tag_end, ">"],
-        [:text, "foo "], [:text, "<b"], [:text, "> bar"],
-        [:tag_start, "<"], [:solidus, "/"], [:tag_name, "script"], [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "script"],
+          [:tag_end, ">"],
+          [:text, "foo "],
+          [:text, "<b"],
+          [:text, "> bar"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "script"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_textarea_tag
       result = tokenize("<textarea>hello</textarea>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "textarea"], [:tag_end, ">"],
-        [:text, "hello"],
-        [:tag_start, "<"], [:solidus, "/"], [:tag_name, "textarea"], [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "textarea"],
+          [:tag_end, ">"],
+          [:text, "hello"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "textarea"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_style_tag
       result = tokenize("<style></div></style>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "style"], [:tag_end, ">"],
-        [:text, "</div"], [:text, ">"],
-        [:tag_start, "<"], [:solidus, "/"], [:tag_name, "style"], [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "style"],
+          [:tag_end, ">"],
+          [:text, "</div"],
+          [:text, ">"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "style"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_script_containing_html
       result = tokenize('<script type="text/html">foo <b> bar</script>')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "script"],
-        [:whitespace, " "],
-        [:attribute_name, "type"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "text/html"],
-        [:attribute_quoted_value_end, "\""],
-        [:tag_end, ">"],
-        [:text, "foo "],
-        [:text, "<b"],
-        [:text, "> bar"],
-        [:tag_start, "<"],
-        [:solidus, "/"],
-        [:tag_name, "script"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "script"],
+          [:whitespace, " "],
+          [:attribute_name, "type"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "text/html"],
+          [:attribute_quoted_value_end, "\""],
+          [:tag_end, ">"],
+          [:text, "foo "],
+          [:text, "<b"],
+          [:text, "> bar"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "script"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_end_of_tag_on_newline
-      data = ["\
+      data = [
+        "\
           <div define=\"{credential_96_credential1: new Shopify.ProviderCredentials()}\"
-                  ", "", ">",]
+                  ",
+        "",
+        ">",
+      ]
       result = tokenize(*data)
-      assert_equal([
-        [:text, "          "],
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "define"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "{credential_96_credential1: new Shopify.ProviderCredentials()}"],
-        [:attribute_quoted_value_end, "\""],
-        [:whitespace, "\n                  "],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:text, "          "],
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "define"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "{credential_96_credential1: new Shopify.ProviderCredentials()}"],
+          [:attribute_quoted_value_end, "\""],
+          [:whitespace, "\n                  "],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_multi_part_attribute_name
       result = tokenize("<div data-", "shipping", "-type>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "div"], [:whitespace, " "],
-        [:attribute_name, "data-"], [:attribute_name, "shipping"], [:attribute_name, "-type"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "data-"],
+          [:attribute_name, "shipping"],
+          [:attribute_name, "-type"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_tokenize_attribute_name_with_space_before_equal
       result = tokenize('<a href ="http://www.cra-arc.gc.ca/tx/bsnss/tpcs/gst-tps/menu-eng.html">GST/HST</a>')
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "a"],
-        [:whitespace, " "],
-        [:attribute_name, "href"],
-        [:whitespace, " "],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "\""],
-        [:attribute_quoted_value, "http://www.cra-arc.gc.ca/tx/bsnss/tpcs/gst-tps/menu-eng.html"],
-        [:attribute_quoted_value_end, "\""],
-        [:tag_end, ">"],
-        [:text, "GST/HST"],
-        [:tag_start, "<"],
-        [:solidus, "/"],
-        [:tag_name, "a"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "a"],
+          [:whitespace, " "],
+          [:attribute_name, "href"],
+          [:whitespace, " "],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "\""],
+          [:attribute_quoted_value, "http://www.cra-arc.gc.ca/tx/bsnss/tpcs/gst-tps/menu-eng.html"],
+          [:attribute_quoted_value_end, "\""],
+          [:tag_end, ">"],
+          [:text, "GST/HST"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "a"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_raise_in_block
@@ -421,32 +575,43 @@ def test_raise_in_block
 
     def test_tokenize_end_of_script_regression
       result = tokenize("<script><</script>")
-      assert_equal([
-        [:tag_start, "<"], [:tag_name, "script"], [:tag_end, ">"],
-        [:text, "<"],
-        [:tag_start, "<"], [:solidus, "/"], [:tag_name, "script"], [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "script"],
+          [:tag_end, ">"],
+          [:text, "<"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "script"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     def test_html_with_mutlibyte_characters
       data = "<div title='your store’s'>foo</div>"
       result = tokenize(data)
-      assert_equal([
-        [:tag_start, "<"],
-        [:tag_name, "div"],
-        [:whitespace, " "],
-        [:attribute_name, "title"],
-        [:equal, "="],
-        [:attribute_quoted_value_start, "'"],
-        [:attribute_quoted_value, "your store’s"],
-        [:attribute_quoted_value_end, "'"],
-        [:tag_end, ">"],
-        [:text, "foo"],
-        [:tag_start, "<"],
-        [:solidus, "/"],
-        [:tag_name, "div"],
-        [:tag_end, ">"],
-      ], result)
+      assert_equal(
+        [
+          [:tag_start, "<"],
+          [:tag_name, "div"],
+          [:whitespace, " "],
+          [:attribute_name, "title"],
+          [:equal, "="],
+          [:attribute_quoted_value_start, "'"],
+          [:attribute_quoted_value, "your store’s"],
+          [:attribute_quoted_value_end, "'"],
+          [:tag_end, ">"],
+          [:text, "foo"],
+          [:tag_start, "<"],
+          [:solidus, "/"],
+          [:tag_name, "div"],
+          [:tag_end, ">"],
+        ],
+        result,
+      )
     end
 
     private