better_html 0.0.3

data/test/better_html/helpers_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class BetterHtml::HelpersTest < ActiveSupport::TestCase
+  include BetterHtml::Helpers
+
+  test "html_attributes return a HtmlAttributes object" do
+    assert_equal BetterHtml::HtmlAttributes, html_attributes(foo: "bar").class
+  end
+
+  test "html_attributes are formatted as string" do
+    assert_equal 'foo="bar" baz="qux"',
+      html_attributes(foo: "bar", baz: "qux").to_s
+  end
+
+  test "html_attributes keys cannot contain invalid characters" do
+    e = assert_raises(ArgumentError) do
+      html_attributes("invalid key": "bar", baz: "qux").to_s
+    end
+    assert_equal "Attribute names must match the pattern /\\A[a-zA-Z0-9\\-\\:]+\\z/", e.message
+  end
+
+  test "#html_attributes does not accept incorrectly escaped html_safe values" do
+    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
+  end
+
+  test "#html_attributes accepts correctly escaped html_safe values" do
+    assert_equal 'something="with &quot;&gt; double quote"',
+      html_attributes('something': CGI.escapeHTML('with "> double quote').html_safe).to_s
+  end
+
+  test "#html_attributes escapes non-html_safe values" do
+    assert_equal 'something="with &quot;&gt; double quote"',
+      html_attributes('something': 'with "> double quote').to_s
+  end
+
+  test "#html_attributes accepts nil values as value-less attributes" do
+    assert_equal 'data-thing data-other-thing',
+      html_attributes('data-thing': nil, 'data-other-thing': nil).to_s
+  end
+
+  test "#html_attributes empty string value is output" do
+    assert_equal 'data-thing="" data-other-thing=""',
+      html_attributes('data-thing': "", 'data-other-thing': "").to_s
+  end
+end

data/test/better_html/node_iterator/html_lodash_test.rb

@@ -0,0 +1,132 @@
+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_test.rb

@@ -0,0 +1,221 @@
+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

data/test/better_html/test_helper/ruby_expr_test.rb

@@ -0,0 +1,206 @@
+require 'test_helper'
+require 'better_html/test_helper/ruby_expr'
+
+module BetterHtml
+  module TestHelper
+    class RubyExprTest < ActiveSupport::TestCase
+      test "simple call" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "instance call" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo.bar")
+        assert_equal 1, expr.calls.size
+        assert_equal [:vcall, [:@ident, "foo", [1, 0]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "instance call with arguments" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(x).bar")
+        assert_equal 1, expr.calls.size
+        assert_equal [:method_add_arg, [:fcall, [:@ident, "foo", [1, 0]]], [:arg_paren, [:args_add_block, [[:vcall, [:@ident, "x", [1, 4]]]], false]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "instance call with parenthesis" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "(foo).bar")
+        assert_equal 1, expr.calls.size
+        assert_equal [:paren, [[:vcall, [:@ident, "foo", [1, 1]]]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "instance call with parenthesis 2" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "(foo)")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "command call" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo bar")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "bar", [1, 4]]]], expr.calls.first.arguments
+      end
+
+      test "command call with block" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo bar do")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "bar", [1, 4]]]], expr.calls.first.arguments
+      end
+
+      test "call with parameters" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar)")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "bar", [1, 4]]]], expr.calls.first.arguments
+      end
+
+      test "instance call with parameters" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo.bar(baz, x)")
+        assert_equal 1, expr.calls.size
+        assert_equal [:vcall, [:@ident, "foo", [1, 0]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "baz", [1, 8]]], [:vcall, [:@ident, "x", [1, 13]]]], expr.calls.first.arguments
+      end
+
+      test "call with parameters with if conditional modifier" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar) if something?")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "bar", [1, 4]]]], expr.calls.first.arguments
+      end
+
+      test "call with parameters with unless conditional modifier" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar) unless something?")
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "bar", [1, 4]]]], expr.calls.first.arguments
+      end
+
+      test "expression call in ternary" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "something? ? foo : bar")
+        assert_equal 2, expr.calls.size
+
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+
+        assert_nil expr.calls.last.instance
+        assert_equal "bar", expr.calls.last.method
+        assert_nil expr.calls.last.arguments
+      end
+
+      test "expression call with args in ternary" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: "something? ? foo(x) : bar(x)")
+        assert_equal 2, expr.calls.size
+
+        assert_nil expr.calls.first.instance
+        assert_equal "foo", expr.calls.first.method
+        assert_equal [[:vcall, [:@ident, "x", [1, 17]]]], expr.calls.first.arguments
+
+        assert_nil expr.calls.last.instance
+        assert_equal "bar", expr.calls.last.method
+        assert_equal [[:vcall, [:@ident, "x", [1, 26]]]], expr.calls.last.arguments
+      end
+
+      test "string without interpolation" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo"')
+        assert_equal 0, expr.calls.size
+      end
+
+      test "string with interpolation" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo #{bar}"')
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "ternary in string with interpolation" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo #{foo? ? bar : baz}"')
+        assert_equal 2, expr.calls.size
+
+        assert_nil expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+
+        assert_nil expr.calls.last.instance
+        assert_equal "baz", expr.calls.last.method
+        assert_nil expr.calls.last.arguments
+      end
+
+      test "assignment to variable" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'x = foo.bar')
+        assert_equal 1, expr.calls.size
+        assert_equal [:vcall, [:@ident, "foo", [1, 4]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "assignment to variable with command call" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'raw x = foo.bar')
+        assert_equal 1, expr.calls.size
+        assert_nil expr.calls.first.instance
+        assert_equal "raw", expr.calls.first.method
+        assert_equal [[:assign, [:var_field, [:@ident, "x", [1, 4]]], [:call, [:vcall, [:@ident, "foo", [1, 8]]], :".", [:@ident, "bar", [1, 12]]]]], expr.calls.first.arguments
+      end
+
+      test "assignment with instance call" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '(x = foo).bar')
+        assert_equal 1, expr.calls.size
+        assert_equal [:paren, [[:assign, [:var_field, [:@ident, "x", [1, 1]]], [:vcall, [:@ident, "foo", [1, 5]]]]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "assignment to multiple variables" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'x, y = foo.bar')
+        assert_equal 1, expr.calls.size
+        assert_equal [:vcall, [:@ident, "foo", [1, 7]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "safe navigation operator" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'foo&.bar')
+        assert_equal 1, expr.calls.size
+        assert_equal [:vcall, [:@ident, "foo", [1, 0]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "instance variable" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '@foo')
+        assert_equal 0, expr.calls.size
+      end
+
+      test "instance method on variable" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: '@foo.bar')
+        assert_equal 1, expr.calls.size
+        assert_equal [:var_ref, [:@ivar, "@foo", [1, 0]]], expr.calls.first.instance
+        assert_equal "bar", expr.calls.first.method
+        assert_nil expr.calls.first.arguments
+      end
+
+      test "index into array" do
+        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'local_assigns[:text_class] if local_assigns[:text_class]')
+        assert_equal 0, expr.calls.size
+      end
+    end
+  end
+end