better_html 0.0.8 → 0.0.9

data/lib/better_html/test_helper/safe_lodash_tester.rb

@@ -1,10 +1,8 @@
-require_relative 'safety_tester_base'
+require 'better_html/test_helper/safety_error'
 
 module BetterHtml
   module TestHelper
     module SafeLodashTester
-      include SafetyTesterBase
-
       SAFETY_TIPS = <<-EOF
 -----------
 
@@ -32,7 +30,11 @@ EOF
 
         message = ""
         tester.errors.each do |error|
-          message << format_safety_error(data, error)
+          message << <<~EOL
+            On line #{error.location.line}
+            #{error.message}
+            #{error.location.line_source_with_underline}\n
+          EOL
         end
 
         message << SAFETY_TIPS
@@ -52,8 +54,8 @@ EOF
           validate!
         end
 
-        def add_error(token, message)
-          @errors.add(SafetyTesterBase::SafetyError.new(token, message))
+        def add_error(message, location:)
+          @errors.add(SafetyError.new(message, location: location))
         end
 
         def validate!
@@ -63,8 +65,10 @@ EOF
               validate_element(node)
 
               if node.name == 'script' && !node.closing?
-                add_error(node.name_parts.first,
-                  "No script tags allowed nested in lodash templates")
+                add_error(
+                  "No script tags allowed nested in lodash templates",
+                  location: node.name_parts.first.location
+                )
               end
             when BetterHtml::NodeIterator::CData, BetterHtml::NodeIterator::Comment
               validate_no_statements(node)
@@ -85,7 +89,10 @@ EOF
               when :expr_literal
                 validate_tag_expression(element, attribute.name, token)
               when :expr_escaped
-                add_error(token, "lodash interpolation with '[%!' inside html attribute is never safe")
+                add_error(
+                  "lodash interpolation with '[%!' inside html attribute is never safe",
+                  location: token.location
+                )
               end
             end
           end
@@ -93,8 +100,11 @@ EOF
 
         def validate_tag_expression(node, attr_name, value_token)
           if javascript_attribute_name?(attr_name) && !lodash_safe_javascript_expression?(value_token.code.strip)
-            add_error(value_token, "lodash interpolation in javascript attribute "\
-              "`#{attr_name}` must call `JSON.stringify(#{value_token.code.strip})`")
+            add_error(
+              "lodash interpolation in javascript attribute "\
+              "`#{attr_name}` must call `JSON.stringify(#{value_token.code.strip})`",
+              location: value_token.location
+            )
           end
         end
 
@@ -113,7 +123,10 @@ EOF
         end
 
         def add_no_statement_error(node, token)
-          add_error(token, "javascript statement not allowed here; did you mean '[%=' ?")
+          add_error(
+            "javascript statement not allowed here; did you mean '[%=' ?",
+            location: token.location
+          )
         end
       end
     end

data/lib/better_html/test_helper/safety_error.rb

@@ -0,0 +1,12 @@
+module BetterHtml
+  module TestHelper
+    class SafetyError < InterpolatorError
+      attr_reader :location
+
+      def initialize(message, location:)
+        @location = location
+        super(message)
+      end
+    end
+  end
+end

data/lib/better_html/version.rb

@@ -1,3 +1,3 @@
 module BetterHtml
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/test/better_html/node_iterator/location_test.rb

@@ -0,0 +1,36 @@
+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/test_helper/ruby_expr_test.rb

@@ -5,201 +5,278 @@ module BetterHtml
   module TestHelper
     class RubyExprTest < ActiveSupport::TestCase
       test "simple call" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "instance call" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo.bar")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal 's(:send, nil, :foo)', expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "instance call with arguments" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(x).bar")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal "s(:send, nil, :foo,\n  s(:send, nil, :x))", expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "instance call with parenthesis" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "(foo).bar")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("(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
+        assert_equal "s(:begin,\n  s(:send, nil, :foo))", expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "instance call with parenthesis 2" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "(foo)")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("(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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "command call" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo bar")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal '[s(:send, nil, :bar)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "command call with block" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo bar do")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal '[s(:send, nil, :bar)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "call with parameters" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar)")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal '[s(:send, nil, :bar)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "instance call with parameters" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo.bar(baz, x)")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal 's(:send, nil, :foo)', expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal '[s(:send, nil, :baz), s(:send, nil, :x)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "call with parameters with if conditional modifier" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar) if something?")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal '[s(:send, nil, :bar)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "call with parameters with unless conditional modifier" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "foo(bar) unless something?")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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
+        assert_equal :foo, expr.calls.first.method
+        assert_equal '[s(:send, nil, :bar)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "expression call in ternary" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "something? ? foo : bar")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("something? ? foo : bar")
         assert_equal 2, expr.calls.size
+        refute_predicate expr, :static_value?
 
-        assert_nil expr.calls.first.instance
-        assert_equal "foo", expr.calls.first.method
-        assert_nil expr.calls.first.arguments
+        assert_nil expr.calls[0].instance
+        assert_equal :foo, expr.calls[0].method
+        assert_equal [], expr.calls[0].arguments
 
-        assert_nil expr.calls.last.instance
-        assert_equal "bar", expr.calls.last.method
-        assert_nil expr.calls.last.arguments
+        assert_nil expr.calls[1].instance
+        assert_equal :bar, expr.calls[1].method
+        assert_equal [], expr.calls[1].arguments
       end
 
       test "expression call with args in ternary" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: "something? ? foo(x) : bar(x)")
+        expr = BetterHtml::TestHelper::RubyExpr.parse("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[0].instance
+        assert_equal :foo, expr.calls[0].method
+        assert_equal '[s(:send, nil, :x)]', expr.calls[0].arguments.inspect
 
-        assert_nil expr.calls.last.instance
-        assert_equal "bar", expr.calls.last.method
-        assert_equal [[:vcall, [:@ident, "x", [1, 26]]]], expr.calls.last.arguments
+        assert_nil expr.calls[1].instance
+        assert_equal :bar, expr.calls[1].method
+        assert_equal '[s(:send, nil, :x)]', expr.calls[1].arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "string without interpolation" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo"')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('"foo"')
         assert_equal 0, expr.calls.size
+        assert_predicate expr, :static_value?
       end
 
       test "string with interpolation" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo #{bar}"')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('"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
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "ternary in string with interpolation" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '"foo #{foo? ? bar : baz}"')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('"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_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
 
         assert_nil expr.calls.last.instance
-        assert_equal "baz", expr.calls.last.method
-        assert_nil expr.calls.last.arguments
+        assert_equal :baz, expr.calls.last.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "assignment to variable" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'x = foo.bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('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
+        assert_equal 's(:send, nil, :foo)', expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "assignment to variable with command call" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'raw x = foo.bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('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
+        assert_equal :raw, expr.calls.first.method
+        assert_equal "[s(:lvasgn, :x,\n  s(:send,\n    s(:send, nil, :foo), :bar))]", expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
       end
 
       test "assignment with instance call" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '(x = foo).bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('(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
+        assert_equal "s(:begin,\n  s(:lvasgn, :x,\n    s(:send, nil, :foo)))", expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "assignment to multiple variables" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'x, y = foo.bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('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
+        assert_equal 's(:send, nil, :foo)', expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       end
 
       test "safe navigation operator" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: 'foo&.bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('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
+        assert_equal 's(:send, nil, :foo)', expr.calls[0].instance.inspect
+        assert_equal :bar, expr.calls[0].method
+        assert_equal [], expr.calls[0].arguments
+        refute_predicate expr, :static_value?
       end
 
       test "instance variable" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '@foo')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('@foo')
         assert_equal 0, expr.calls.size
+        refute_predicate expr, :static_value?
       end
 
       test "instance method on variable" do
-        expr = BetterHtml::TestHelper::RubyExpr.new(code: '@foo.bar')
+        expr = BetterHtml::TestHelper::RubyExpr.parse('@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
+        assert_equal 's(:ivar, :@foo)', expr.calls.first.instance.inspect
+        assert_equal :bar, expr.calls.first.method
+        assert_equal [], expr.calls.first.arguments
+        refute_predicate expr, :static_value?
       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
+        expr = BetterHtml::TestHelper::RubyExpr.parse('local_assigns[:text_class] if local_assigns[:text_class]')
+        assert_equal 1, expr.calls.size
+        assert_equal 's(:send, nil, :local_assigns)', expr.calls.first.instance.inspect
+        assert_equal :[], expr.calls.first.method
+        assert_equal '[s(:sym, :text_class)]', expr.calls.first.arguments.inspect
+        refute_predicate expr, :static_value?
+      end
+
+      test "static_value? for ivar" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('@foo')
+        refute_predicate expr, :static_value?
+      end
+
+      test "static_value? for str" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse("'str'")
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? for int" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse("1")
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? for bool" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse("true")
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? for nil" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse("nil")
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? for dstr without interpolate" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('"str"')
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? for dstr with interpolate" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('"str #{foo}"')
+        refute_predicate expr, :static_value?
+      end
+
+      test "static_value? with safe ternary" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('foo ? \'a\' : \'b\'')
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? with safe conditional" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('\'foo\' if bar?')
+        assert_predicate expr, :static_value?
+      end
+
+      test "static_value? with safe assignment" do
+        expr = BetterHtml::TestHelper::RubyExpr.parse('x = \'foo\'')
+        assert_predicate expr, :static_value?
       end
     end
   end