Expand usage tracking

lib/liquid.rb

@@ -78,10 +78,8 @@ require 'liquid/tokenizer'
 require 'liquid/parse_context'
 require 'liquid/partial_cache'
 require 'liquid/usage'
-require 'liquid/register'
 require 'liquid/static_registers'
 
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
-Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }

lib/liquid/block_body.rb

@@ -154,13 +154,7 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      if node.disabled?(context)
-        output << node.disabled_error_message
-        return
-      end
-      disable_tags(context, node.disabled_tags) do
-        node.render_to_output_buffer(context, output)
-      end
+      node.render_to_output_buffer(context, output)
     rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
       context.handle_error(e, node.line_number)
     rescue ::StandardError => e
@@ -168,11 +162,6 @@ module Liquid
       output << context.handle_error(e, line_number)
     end
 
-    def disable_tags(context, tags, &block)
-      return yield if tags.empty?
-      context.registers[:disabled_tags].disable(tags, &block)
-    end
-
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
       return unless context.resource_limits.reached?

lib/liquid/context.rb

@@ -219,12 +219,16 @@ module Liquid
     def try_variable_find_in_environments(key, raise_on_not_found:)
       @environments.each do |environment|
         found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        Usage.increment("environment_has_a_default_proc") if environment.respond_to?(:default_proc) && environment.default_proc
+        Usage.increment("environment_has_key_but_is_nil") if environment.respond_to?(:key?) && environment.key?(key) && found_variable.nil?
         if !found_variable.nil? || @strict_variables && raise_on_not_found
           return found_variable
         end
       end
       @static_environments.each do |environment|
         found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        Usage.increment("static_environment_has_a_default_proc") if environment.respond_to?(:default_proc) && environment.default_proc
+        Usage.increment("static_environment_has_key_but_is_nil") if environment.respond_to?(:key?) && environment.key?(key) && found_variable.nil?
         if !found_variable.nil? || @strict_variables && raise_on_not_found
           return found_variable
         end

lib/liquid/locales/en.yml

@@ -25,5 +25,3 @@
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
-    disabled:
-      tag: "usage is not allowed in this context"

lib/liquid/register.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Register
-  end
-end

lib/liquid/registers/disabled_tags.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-module Liquid
-  class DisabledTags < Register
-    def initialize
-      @disabled_tags = {}
-    end
-
-    def disabled?(tag)
-      @disabled_tags.key?(tag) && @disabled_tags[tag] > 0
-    end
-
-    def disable(tags)
-      tags.each(&method(:increment))
-      yield
-    ensure
-      tags.each(&method(:decrement))
-    end
-
-    private
-
-    def increment(tag)
-      @disabled_tags[tag] ||= 0
-      @disabled_tags[tag] += 1
-    end
-
-    def decrement(tag)
-      @disabled_tags[tag] -= 1
-    end
-  end
-
-  Template.add_register(:disabled_tags, DisabledTags.new)
-end

lib/liquid/standardfilters.rb

@@ -193,23 +193,6 @@ module Liquid
       end
     end
 
-    # Sort elements of an array in numeric order
-    # provide optional property with which to sort an array of hashes or drops
-    def sort_numeric(input, property = nil)
-      ary = InputIterator.new(input)
-      if property.nil?
-        ary.sort do |a, b|
-          Utils.to_number(a) <=> Utils.to_number(b)
-        end
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort do |a, b|
-          Utils.to_number(a[property]) <=> Utils.to_number(b[property])
-        end
-      end
-    end
-
     # Remove duplicate elements from an array
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
@@ -440,7 +423,6 @@ module Liquid
 
     def default(input, default_value = '')
       if !input || input.respond_to?(:empty?) && input.empty?
-        Usage.increment("default_filter_received_false_value") if input == false # See https://github.com/Shopify/liquid/issues/1127
         default_value
       else
         input

lib/liquid/tag.rb

@@ -13,15 +13,7 @@ module Liquid
         tag
       end
 
-      def disable_tags(*tags)
-        disabled_tags.push(*tags)
-      end
-
       private :new
-
-      def disabled_tags
-        @disabled_tags ||= []
-      end
     end
 
     def initialize(tag_name, markup, parse_context)
@@ -46,14 +38,6 @@ module Liquid
       ''
     end
 
-    def disabled?(context)
-      context.registers[:disabled_tags].disabled?(tag_name)
-    end
-
-    def disabled_error_message
-      "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
-    end
-
     # For backwards compatibility with custom tags. In a future release, the semantics
     # of the `render_to_output_buffer` method will become the default and the `render`
     # method will be removed.
@@ -65,9 +49,5 @@ module Liquid
     def blank?
       false
     end
-
-    def disabled_tags
-      self.class.disabled_tags
-    end
   end
 end

lib/liquid/tags/render.rb

@@ -4,8 +4,6 @@ module Liquid
   class Render < Tag
     SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
 
-    disable_tags "include"
-
     attr_reader :template_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
@@ -24,10 +22,6 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      render_tag(context, output)
-    end
-
-    def render_tag(context, output)
       # Though we evaluate this here we will only ever parse it as a string literal.
       template_name = context.evaluate(@template_name_expr)
       raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name

lib/liquid/template.rb

@@ -92,14 +92,6 @@ module Liquid
         @tags ||= TagRegistry.new
       end
 
-      def add_register(name, klass)
-        registers[name.to_sym] = klass
-      end
-
-      def registers
-        @registers ||= {}
-      end
-
       def error_mode
         @error_mode ||= :lax
       end
@@ -199,26 +191,18 @@ module Liquid
 
       output = nil
 
-      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
-
       case args.last
       when Hash
         options = args.pop
         output = options[:output] if options[:output]
 
-        options[:registers]&.each do |key, register|
-          context_register[key] = register
-        end
+        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
 
         apply_options_to_context(context, options)
       when Module, Array
         context.add_filters(args.pop)
       end
 
-      Template.registers.each do |key, register|
-        context_register[key] = register
-      end
-
       # Retrying a render resets resource usage
       context.resource_limits.reset
 

lib/liquid/variable.rb

@@ -104,14 +104,6 @@ module Liquid
       output
     end
 
-    def disabled?(_context)
-      false
-    end
-
-    def disabled_tags
-      []
-    end
-
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)

test/integration/registers/disabled_tags_test.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DisabledTagsTest < Minitest::Test
-  include Liquid
-
-  class DisableRaw < Block
-    disable_tags "raw"
-  end
-
-  class DisableRawEcho < Block
-    disable_tags "raw", "echo"
-  end
-
-  def test_disables_raw
-    with_custom_tag('disable', DisableRaw) do
-      assert_template_result 'raw usage is not allowed in this contextfoo', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
-    end
-  end
-
-  def test_disables_echo_and_raw
-    with_custom_tag('disable', DisableRawEcho) do
-      assert_template_result 'raw usage is not allowed in this contextecho usage is not allowed in this context', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
-    end
-  end
-end

test/integration/standard_filter_test.rb

@@ -198,12 +198,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
   end
 
-  def test_sort_numeric
-    assert_equal ['1', '2', '3', '10'], @filters.sort_numeric(['10', '3', '2', '1'])
-    assert_equal [{ "a" => '1' }, { "a" => '2' }, { "a" => '3' }, { "a" => '10' }],
-      @filters.sort_numeric([{ "a" => '10' }, { "a" => '3' }, { "a" => '1' }, { "a" => '2' }], "a")
-  end
-
   def test_sort_with_nils
     assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1])
     assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }, {}], @filters.sort([{ "a" => 4 }, { "a" => 3 }, {}, { "a" => 1 }, { "a" => 2 }], "a")
@@ -298,10 +292,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [], @filters.sort_natural([], "a")
   end
 
-  def test_sort_numeric_empty_array
-    assert_equal [], @filters.sort_numeric([], "a")
-  end
-
   def test_sort_natural_invalid_property
     foo = [
       [1],

test/integration/tags/render_tag_test.rb

@@ -89,12 +89,14 @@ class RenderTagTest < Minitest::Test
     end
   end
 
-  def test_sub_contexts_count_towards_the_same_recursion_limit
+  def test_includes_and_renders_count_towards_the_same_recursion_limit
     Liquid::Template.file_system = StubFileSystem.new(
-      'loop_render' => '{% render "loop_render" %}',
+      'loop_render' => '{% render "loop_include" %}',
+      'loop_include' => '{% include "loop_render" %}'
     )
-    assert_raises Liquid::StackLevelError do
-      Template.parse('{% render "loop_render" %}').render!
+
+    assert_raises Liquid::StackLevelError  do
+      Template.parse('{% render "loop_include" %}').render!
     end
   end
 
@@ -146,23 +148,4 @@ class RenderTagTest < Minitest::Test
     Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
     assert_template_result '-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}'
   end
-
-  def test_includes_will_not_render_inside_render_tag
-    Liquid::Template.file_system = StubFileSystem.new(
-      'foo' => 'bar',
-      'test_include' => '{% include "foo" %}'
-    )
-
-    assert_template_result 'include usage is not allowed in this context', '{% render "test_include" %}'
-  end
-
-  def test_includes_will_not_render_inside_nested_sibling_tags
-    Liquid::Template.file_system = StubFileSystem.new(
-      'foo' => 'bar',
-      'nested_render_with_sibling_include' => '{% render "test_include" %}{% include "foo" %}',
-      'test_include' => '{% include "foo" %}'
-    )
-
-    assert_template_result 'include usage is not allowed in this contextinclude usage is not allowed in this context', '{% render "nested_render_with_sibling_include" %}'
-  end
 end

test/unit/registers/disabled_tags_unit_test.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DisabledTagsUnitTest < Minitest::Test
-  include Liquid
-
-  def test_disables_tag_specified
-    register = DisabledTags.new
-    register.disable(%w(foo bar)) do
-      assert_equal true, register.disabled?("foo")
-      assert_equal true, register.disabled?("bar")
-      assert_equal false, register.disabled?("unknown")
-    end
-  end
-
-  def test_disables_nested_tags
-    register = DisabledTags.new
-    register.disable(["foo"]) do
-      register.disable(["foo"]) do
-        assert_equal true, register.disabled?("foo")
-        assert_equal false, register.disabled?("bar")
-      end
-      register.disable(["bar"]) do
-        assert_equal true, register.disabled?("foo")
-        assert_equal true, register.disabled?("bar")
-        register.disable(["foo"]) do
-          assert_equal true, register.disabled?("foo")
-          assert_equal true, register.disabled?("bar")
-        end
-      end
-      assert_equal true, register.disabled?("foo")
-      assert_equal false, register.disabled?("bar")
-    end
-  end
-end