better_html 0.0.12 → 1.0.0

data/test/better_html/node_iterator/html_erb_test.rb

@@ -1,116 +0,0 @@
-require 'test_helper'
-
-module BetterHtml
-  class NodeIterator
-    class HtmlErbTest < ActiveSupport::TestCase
-      test "text" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("just some text")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_attributes ({ type: :text, text: 'just some text', code: nil }), token
-        assert_attributes ({ start: 0, stop: 14, line: 1, column: 0 }), token.location
-      end
-
-      test "statement" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("<% statement %>")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_attributes ({ type: :stmt, text: '<% statement %>', code: ' statement ' }), token
-        assert_attributes ({ start: 0, stop: 15, line: 1, column: 0 }), token.location
-      end
-
-      test "expression literal" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("<%= literal %>")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_attributes ({ type: :expr_literal, text: '<%= literal %>', code: ' literal ' }), token
-        assert_attributes ({ start: 0, stop: 14, line: 1, column: 0 }), token.location
-      end
-
-      test "expression escaped" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("<%== escaped %>")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_attributes ({ type: :expr_escaped, text: '<%== escaped %>', code: ' escaped ' }), token
-        assert_attributes ({ start: 0, stop: 15, line: 1, column: 0 }), token.location
-      end
-
-      test "line number for multi-line statements" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("before <% multi\nline %> after")
-        assert_equal 3, scanner.tokens.size
-
-        assert_attributes ({ type: :text, text: 'before ' }), scanner.tokens[0]
-        assert_attributes ({ line: 1 }), scanner.tokens[0].location
-
-        assert_attributes ({ type: :stmt, text: "<% multi\nline %>" }), scanner.tokens[1]
-        assert_attributes ({ line: 1 }), scanner.tokens[1].location
-
-        assert_attributes ({ type: :text, text: " after" }), scanner.tokens[2]
-        assert_attributes ({ line: 2 }), scanner.tokens[2].location
-      end
-
-      test "multi-line statements with trim" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("before\n<% multi\nline -%>\nafter")
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :text, text: "before\n" }), scanner.tokens[0]
-        assert_attributes ({ line: 1 }), scanner.tokens[0].location
-
-        assert_attributes ({ type: :stmt, text: "<% multi\nline %>" }), scanner.tokens[1]
-        assert_attributes ({ line: 2 }), scanner.tokens[1].location
-
-        assert_attributes ({ type: :text, text: "\n" }), scanner.tokens[2]
-        assert_attributes ({ line: 3 }), scanner.tokens[2].location
-
-        assert_attributes ({ type: :text, text: "after" }), scanner.tokens[3]
-        assert_attributes ({ line: 4 }), scanner.tokens[3].location
-      end
-
-      test "multi-line expression with trim" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("before\n<%= multi\nline -%>\nafter")
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :text, text: "before\n" }), scanner.tokens[0]
-        assert_attributes ({ line: 1 }), scanner.tokens[0].location
-
-        assert_attributes ({ type: :expr_literal, text: "<%= multi\nline %>" }), scanner.tokens[1]
-        assert_attributes ({ line: 2 }), scanner.tokens[1].location
-
-        assert_attributes ({ type: :text, text: "\n" }), scanner.tokens[2]
-        assert_attributes ({ line: 3 }), scanner.tokens[2].location
-
-        assert_attributes ({ type: :text, text: "after" }), scanner.tokens[3]
-        assert_attributes ({ line: 4 }), scanner.tokens[3].location
-      end
-
-      test "line counts with comments" do
-        scanner = BetterHtml::NodeIterator::HtmlErb.new("before\n<%# BO$$ Mode %>\nafter")
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :text, text: "before\n" }), scanner.tokens[0]
-        assert_attributes ({ line: 1 }), scanner.tokens[0].location
-
-        assert_attributes ({ type: :stmt, text: "<%# BO$$ Mode %>" }), scanner.tokens[1]
-        assert_attributes ({ line: 2 }), scanner.tokens[1].location
-
-        assert_attributes ({ type: :text, text: "\n" }), scanner.tokens[2]
-        assert_attributes ({ line: 2 }), scanner.tokens[2].location
-
-        assert_attributes ({ type: :text, text: "after" }), scanner.tokens[3]
-        assert_attributes ({ line: 3 }), scanner.tokens[3].location
-      end
-
-      private
-
-      def assert_attributes(attributes, token)
-        attributes.each do |key, value|
-          if value.nil?
-            assert_nil token.send(key)
-          else
-            assert_equal value, token.send(key)
-          end
-        end
-      end
-    end
-  end
-end

data/test/better_html/node_iterator/html_lodash_test.rb

@@ -1,132 +0,0 @@
-require 'test_helper'
-
-module BetterHtml
-  class NodeIterator
-    class HtmlLodashTest < ActiveSupport::TestCase
-      test "matches text" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("just some text")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_equal :text, token.type
-        assert_equal "just some text", token.text
-        assert_nil token.code
-        assert_equal 0, token.location.start
-        assert_equal 14, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-      end
-
-      test "matches strings to be escaped" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("[%= foo %]")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_equal :expr_literal, token.type
-        assert_equal "[%= foo %]", token.text
-        assert_equal " foo ", token.code
-        assert_equal 0, token.location.start
-        assert_equal 10, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-      end
-
-      test "matches interpolate" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("[%! foo %]")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_equal :expr_escaped, token.type
-        assert_equal "[%! foo %]", token.text
-        assert_equal " foo ", token.code
-        assert_equal 0, token.location.start
-        assert_equal 10, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-      end
-
-      test "matches statement" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("[% foo %]")
-        assert_equal 1, scanner.tokens.size
-        token = scanner.tokens[0]
-        assert_equal :stmt, token.type
-        assert_equal "[% foo %]", token.text
-        assert_equal " foo ", token.code
-        assert_equal 0, token.location.start
-        assert_equal 9, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-      end
-
-      test "matches text before and after" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("before\n[%= foo %]\nafter")
-        assert_equal 3, scanner.tokens.size
-
-        token = scanner.tokens[0]
-        assert_equal :text, token.type
-        assert_equal "before\n", token.text
-        assert_nil token.code
-        assert_equal 0, token.location.start
-        assert_equal 7, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-
-        token = scanner.tokens[1]
-        assert_equal :expr_literal, token.type
-        assert_equal "[%= foo %]", token.text
-        assert_equal " foo ", token.code
-        assert_equal 7, token.location.start
-        assert_equal 17, token.location.stop
-        assert_equal 2, token.location.line
-        assert_equal 0, token.location.column
-
-        token = scanner.tokens[2]
-        assert_equal :text, token.type
-        assert_equal "\nafter", token.text
-        assert_nil token.code
-        assert_equal 17, token.location.start
-        assert_equal 23, token.location.stop
-        assert_equal 2, token.location.line
-        assert_equal 10, token.location.column
-      end
-
-      test "matches multiple" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new("[% if() { %][%= foo %][% } %]")
-        assert_equal 3, scanner.tokens.size
-
-        token = scanner.tokens[0]
-        assert_equal :stmt, token.type
-        assert_equal "[% if() { %]", token.text
-        assert_equal " if() { ", token.code
-        assert_equal 0, token.location.start
-        assert_equal 12, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 0, token.location.column
-
-        token = scanner.tokens[1]
-        assert_equal :expr_literal, token.type
-        assert_equal "[%= foo %]", token.text
-        assert_equal " foo ", token.code
-        assert_equal 12, token.location.start
-        assert_equal 22, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 12, token.location.column
-
-        token = scanner.tokens[2]
-        assert_equal :stmt, token.type
-        assert_equal "[% } %]", token.text
-        assert_equal " } ", token.code
-        assert_equal 22, token.location.start
-        assert_equal 29, token.location.stop
-        assert_equal 1, token.location.line
-        assert_equal 22, token.location.column
-      end
-
-      test "parses out html correctly" do
-        scanner = BetterHtml::NodeIterator::HtmlLodash.new('<div class="[%= foo %]">')
-        assert_equal 9, scanner.tokens.size
-        assert_equal [:tag_start, :tag_name, :whitespace, :attribute_name,
-          :equal, :attribute_quoted_value_start, :expr_literal,
-          :attribute_quoted_value_end, :tag_end], scanner.tokens.map(&:type)
-        assert_equal ["<", "div", " ", "class", "=", "\"", "[%= foo %]", "\"", ">"], scanner.tokens.map(&:text)
-      end
-    end
-  end
-end

data/test/better_html/node_iterator/location_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-require 'better_html/test_helper/safe_erb_tester'
-
-module BetterHtml
-  class NodeIterator
-    class LocationTest < ActiveSupport::TestCase
-      test "location without line and column" do
-        loc = Location.new("foo\nbar\nbaz", 9, 10)
-
-        assert_equal "a", loc.source
-        assert_equal 3, loc.line
-        assert_equal 1, loc.column
-      end
-
-      test "line_source_with_underline" do
-        loc = Location.new("ui_helper(foo)", 10, 13)
-
-        assert_equal "foo", loc.source
-        assert_equal <<~EOL.strip, loc.line_source_with_underline
-          ui_helper(foo)
-                    ^^^
-        EOL
-      end
-
-      test "line_source_with_underline removes empty spaces" do
-        loc = Location.new("   \t   ui_helper(foo)", 17, 20)
-
-        assert_equal "foo", loc.source
-        assert_equal <<~EOL.strip, loc.line_source_with_underline
-          ui_helper(foo)
-                    ^^^
-        EOL
-      end
-    end
-  end
-end

data/test/better_html/node_iterator_test.rb

@@ -1,221 +0,0 @@
-require 'test_helper'
-
-module BetterHtml
-  class NodeIteratorTest < ActiveSupport::TestCase
-    test "consume cdata nodes" do
-      tree = BetterHtml::NodeIterator.new("<![CDATA[ foo ]]>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::CData, tree.nodes.first.class
-      assert_equal [" foo "], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "unterminated cdata nodes are consumed until end" do
-      tree = BetterHtml::NodeIterator.new("<![CDATA[ foo")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::CData, tree.nodes.first.class
-      assert_equal [" foo"], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "consume cdata with interpolation" do
-      tree = BetterHtml::NodeIterator.new("<![CDATA[ foo <%= bar %> baz ]]>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::CData, tree.nodes.first.class
-      assert_equal [" foo ", "<%= bar %>", " baz "], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "consume comment nodes" do
-      tree = BetterHtml::NodeIterator.new("<!-- foo -->")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Comment, tree.nodes.first.class
-      assert_equal [" foo "], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "unterminated comment nodes are consumed until end" do
-      tree = BetterHtml::NodeIterator.new("<!-- foo")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Comment, tree.nodes.first.class
-      assert_equal [" foo"], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "consume comment with interpolation" do
-      tree = BetterHtml::NodeIterator.new("<!-- foo <%= bar %> baz -->")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Comment, tree.nodes.first.class
-      assert_equal [" foo ", "<%= bar %>", " baz "], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "consume tag nodes" do
-      tree = BetterHtml::NodeIterator.new("<div>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["div"], tree.nodes.first.name_parts.map(&:text)
-      assert_equal false, tree.nodes.first.self_closing?
-    end
-
-    test "consume tag nodes with solidus" do
-      tree = BetterHtml::NodeIterator.new("</div>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["div"], tree.nodes.first.name_parts.map(&:text)
-      assert_equal true, tree.nodes.first.closing?
-    end
-
-    test "sets self_closing when appropriate" do
-      tree = BetterHtml::NodeIterator.new("<div/>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["div"], tree.nodes.first.name_parts.map(&:text)
-      assert_equal true, tree.nodes.first.self_closing?
-    end
-
-    test "consume tag nodes until name ends" do
-      tree = BetterHtml::NodeIterator.new("<div/>")
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["div"], tree.nodes.first.name_parts.map(&:text)
-
-      tree = BetterHtml::NodeIterator.new("<div ")
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["div"], tree.nodes.first.name_parts.map(&:text)
-    end
-
-    test "consume tag nodes with interpolation" do
-      tree = BetterHtml::NodeIterator.new("<ns:<%= name %>-thing>")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Element, tree.nodes.first.class
-      assert_equal ["ns:", "<%= name %>", "-thing"], tree.nodes.first.name_parts.map(&:text)
-    end
-
-    test "consume tag attributes nodes unquoted value" do
-      tree = BetterHtml::NodeIterator.new("<div foo=bar>")
-
-      assert_equal 1, tree.nodes.size
-      tag = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, tag.class
-      assert_equal 1, tag.attributes.size
-      attribute = tag.attributes.first
-      assert_equal BetterHtml::NodeIterator::Attribute, attribute.class
-      assert_equal ["foo"], attribute.name_parts.map(&:text)
-      assert_equal ["bar"], attribute.value_parts.map(&:text)
-    end
-
-    test "consume attributes without name" do
-      tree = BetterHtml::NodeIterator.new("<div 'thing'>")
-
-      assert_equal 1, tree.nodes.size
-      tag = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, tag.class
-      assert_equal 1, tag.attributes.size
-      attribute = tag.attributes.first
-      assert_equal BetterHtml::NodeIterator::Attribute, attribute.class
-      assert_predicate attribute.name, :empty?
-      assert_equal ["'", "thing", "'"], attribute.value_parts.map(&:text)
-    end
-
-    test "consume tag attributes nodes quoted value" do
-      tree = BetterHtml::NodeIterator.new("<div foo=\"bar\">")
-
-      assert_equal 1, tree.nodes.size
-      tag = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, tag.class
-      assert_equal 1, tag.attributes.size
-      attribute = tag.attributes.first
-      assert_equal BetterHtml::NodeIterator::Attribute, attribute.class
-      assert_equal ["foo"], attribute.name_parts.map(&:text)
-      assert_equal ['"', "bar", '"'], attribute.value_parts.map(&:text)
-    end
-
-    test "consume tag attributes nodes interpolation in name and value" do
-      tree = BetterHtml::NodeIterator.new("<div data-<%= foo %>=\"some <%= value %> foo\">")
-
-      assert_equal 1, tree.nodes.size
-      tag = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, tag.class
-      assert_equal 1, tag.attributes.size
-      attribute = tag.attributes.first
-      assert_equal BetterHtml::NodeIterator::Attribute, attribute.class
-      assert_equal ["data-", "<%= foo %>"], attribute.name_parts.map(&:text)
-      assert_equal ['"', "some ", "<%= value %>", " foo", '"'], attribute.value_parts.map(&:text)
-    end
-
-    test "attributes can be accessed through [] on Element object" do
-      tree = BetterHtml::NodeIterator.new("<div foo=\"bar\">")
-
-      assert_equal 1, tree.nodes.size
-      element = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, element.class
-      assert_equal 1, element.attributes.size
-      assert_nil element['nonexistent']
-      refute_nil attribute = element['foo']
-      assert_equal BetterHtml::NodeIterator::Attribute, attribute.class
-    end
-
-    test "attribute values can be read unescaped" do
-      tree = BetterHtml::NodeIterator.new("<div foo=\"&lt;&quot;&gt;\">")
-
-      element = tree.nodes.first
-      assert_equal 1, element.attributes.size
-      attribute = element['foo']
-      assert_equal '<">', attribute.unescaped_value
-    end
-
-    test "attribute values does not unescape stuff inside erb" do
-      tree = BetterHtml::NodeIterator.new("<div foo=\"&lt;<%= &gt; %>&gt;\">")
-
-      element = tree.nodes.first
-      assert_equal 1, element.attributes.size
-      attribute = element['foo']
-      assert_equal '<<%= &gt; %>>', attribute.unescaped_value
-    end
-
-    test "consume text nodes" do
-      tree = BetterHtml::NodeIterator.new("here is <%= some %> text")
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Text, tree.nodes.first.class
-      assert_equal ["here is ", "<%= some %>", " text"], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "javascript template parsing works" do
-      tree = BetterHtml::NodeIterator.new("here is <%= some %> text", template_language: :javascript)
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Text, tree.nodes.first.class
-      assert_equal ["here is ", "<%= some %>", " text"], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "javascript template does not consume html tags" do
-      tree = BetterHtml::NodeIterator.new("<div <%= some %> />", template_language: :javascript)
-
-      assert_equal 1, tree.nodes.size
-      assert_equal BetterHtml::NodeIterator::Text, tree.nodes.first.class
-      assert_equal ["<div ", "<%= some %>", " />"], tree.nodes.first.content_parts.map(&:text)
-    end
-
-    test "lodash template parsing works" do
-      tree = BetterHtml::NodeIterator.new('<div class="[%= foo %]">', template_language: :lodash)
-
-      assert_equal 1, tree.nodes.size
-      node = tree.nodes.first
-      assert_equal BetterHtml::NodeIterator::Element, node.class
-      assert_equal "div", node.name
-      assert_equal 1, node.attributes.size
-      attribute = node.attributes.first
-      assert_equal "class", attribute.name
-      assert_equal [:attribute_quoted_value_start, :expr_literal,
-        :attribute_quoted_value_end], attribute.value_parts.map(&:type)
-      assert_equal ["\"", "[%= foo %]", "\""], attribute.value_parts.map(&:text)
-    end
-  end
-end