Switch to aliasing methods

Add new `{% render %}` tag

.rubocop.yml

@@ -2,9 +2,15 @@ inherit_from:
   - .rubocop_todo.yml
   - ./.rubocop_todo.yml
 
+require: rubocop-performance
+
+Performance:
+  Enabled: true
+
 AllCops:
   Exclude:
     - 'performance/shopify/*'
+    - 'vendor/bundle/**/*'
     - 'pkg/**'
 
 Metrics/BlockNesting:
@@ -79,9 +85,6 @@ Style/TrailingCommaInArrayLiteral:
 Style/TrailingCommaInHashLiteral:
   Enabled: false
 
-Layout/IndentHash:
-  EnforcedStyle: consistent
-
 Style/FormatString:
   Enabled: false
 
@@ -106,9 +109,6 @@ Style/RegexpLiteral:
 Style/SymbolLiteral:
   Enabled: false
 
-Performance/Count:
-  Enabled: false
-
 Naming/ConstantName:
   Enabled: false
 

.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2019-04-22 19:11:24 -0400 using RuboCop version 0.53.0.
+# on 2019-08-29 00:43:36 +1000 using RuboCop version 0.74.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -8,16 +8,67 @@
 
 # Offense count: 1
 # Cop supports --auto-correct.
-# Configuration parameters: Include, TreatCommentsAsGroupSeparators.
+# Configuration parameters: TreatCommentsAsGroupSeparators, Include.
 # Include: **/*.gemspec
 Gemspec/OrderedDependencies:
   Exclude:
     - 'liquid.gemspec'
 
+# Offense count: 1
+# Configuration parameters: Include.
+# Include: **/*.gemspec, 
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'liquid.gemspec'
+
+# Offense count: 124
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: with_first_argument, with_fixed_indentation
+Layout/AlignArguments:
+  Enabled: false
+
+# Offense count: 7
+# Cop supports --auto-correct.
+# Configuration parameters: AllowMultipleStyles, EnforcedHashRocketStyle, EnforcedColonStyle, EnforcedLastArgumentHashStyle.
+# SupportedHashRocketStyles: key, separator, table
+# SupportedColonStyles: key, separator, table
+# SupportedLastArgumentHashStyles: always_inspect, always_ignore, ignore_implicit, ignore_explicit
+Layout/AlignHash:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+    - 'lib/liquid/expression.rb'
+    - 'test/unit/context_unit_test.rb'
+
+# Offense count: 6
+# Cop supports --auto-correct.
+Layout/ClosingHeredocIndentation:
+  Exclude:
+    - 'test/integration/tags/for_tag_test.rb'
+
+# Offense count: 27
+# Cop supports --auto-correct.
+Layout/EmptyLineAfterGuardClause:
+  Exclude:
+    - 'lib/liquid/block.rb'
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/lexer.rb'
+    - 'lib/liquid/parser.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/strainer.rb'
+    - 'lib/liquid/tags/for.rb'
+    - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'lib/liquid/utils.rb'
+    - 'lib/liquid/variable.rb'
+    - 'lib/liquid/variable_lookup.rb'
+
 # Offense count: 5
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
-# SupportedStyles: auto_detection, squiggly, active_support, powerpack, unindent
+# SupportedStyles: squiggly, active_support, powerpack, unindent
 Layout/IndentHeredoc:
   Exclude:
     - 'test/integration/tags/for_tag_test.rb'
@@ -32,6 +83,13 @@ Layout/MultilineMethodCallBraceLayout:
     - 'test/integration/error_handling_test.rb'
     - 'test/unit/strainer_unit_test.rb'
 
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: AllowForAlignment.
+Layout/SpaceAroundOperators:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+
 # Offense count: 2
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
@@ -54,27 +112,25 @@ Metrics/AbcSize:
 Metrics/CyclomaticComplexity:
   Max: 13
 
-# Offense count: 112
+# Offense count: 118
-# Configuration parameters: CountComments.
+# Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
   Max: 38
 
-# Offense count: 8
+# Offense count: 9
 Metrics/PerceivedComplexity:
   Max: 11
 
-# Offense count: 52
+# Offense count: 1
-# Configuration parameters: Blacklist.
+# Cop supports --auto-correct.
-# Blacklist: END, (?-mix:EO[A-Z]{1})
+# Configuration parameters: PreferredName.
-Naming/HeredocDelimiterNaming:
+Naming/RescuedExceptionsVariableName:
   Exclude:
-    - 'test/integration/assign_test.rb'
+    - 'lib/liquid/context.rb'
-    - 'test/integration/capture_test.rb'
-    - 'test/integration/trim_mode_test.rb'
 
-# Offense count: 23
+# Offense count: 20
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
-# AllowedNames: io, id
+# AllowedNames: io, id, to, by, on, in, at, ip, db
 Naming/UncommunicativeMethodParamName:
   Exclude:
     - 'example/server/example_servlet.rb'
@@ -82,15 +138,23 @@ Naming/UncommunicativeMethodParamName:
     - 'lib/liquid/context.rb'
     - 'lib/liquid/standardfilters.rb'
     - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/utils.rb'
     - 'lib/liquid/variable.rb'
     - 'test/integration/filter_test.rb'
     - 'test/integration/standard_filter_test.rb'
-    - 'test/integration/tags/for_tag_test.rb'
     - 'test/integration/template_test.rb'
     - 'test/unit/condition_unit_test.rb'
 
-# Offense count: 12
+# Offense count: 5
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: inline, group
+Style/AccessModifierDeclarations:
+  Exclude:
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/tag.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'test/unit/strainer_unit_test.rb'
+
+# Offense count: 10
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
 # SupportedStyles: prefer_alias, prefer_alias_method
@@ -117,15 +181,9 @@ Style/ConditionalAssignment:
     - 'lib/liquid/errors.rb'
 
 # Offense count: 1
-Style/DateTime:
-  Exclude:
-    - 'test/unit/context_unit_test.rb'
-
-# Offense count: 2
 # Cop supports --auto-correct.
 Style/EmptyCaseCondition:
   Exclude:
-    - 'lib/liquid/block_body.rb'
     - 'lib/liquid/lexer.rb'
 
 # Offense count: 5
@@ -163,6 +221,13 @@ Style/FormatStringToken:
     - 'test/integration/filter_test.rb'
     - 'test/integration/hash_ordering_test.rb'
 
+# Offense count: 106
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: always, never
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
 # Offense count: 14
 # Configuration parameters: MinBodyLength.
 Style/GuardClause:
@@ -180,6 +245,13 @@ Style/GuardClause:
     - 'lib/liquid/variable.rb'
     - 'test/unit/tokenizer_unit_test.rb'
 
+# Offense count: 53
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: literals, strict
+Style/MutableConstant:
+  Enabled: false
+
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, MinBodyLength.
@@ -188,9 +260,9 @@ Style/Next:
   Exclude:
     - 'lib/liquid/tags/for.rb'
 
-# Offense count: 4
+# Offense count: 13
 # Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, EnforcedStyle.
+# Configuration parameters: AutoCorrect, EnforcedStyle, IgnoredMethods.
 # SupportedStyles: predicate, comparison
 Style/NumericPredicate:
   Exclude:
@@ -199,6 +271,8 @@ Style/NumericPredicate:
     - 'lib/liquid/forloop_drop.rb'
     - 'lib/liquid/standardfilters.rb'
     - 'lib/liquid/tablerowloop_drop.rb'
+    - 'test/integration/standard_filter_test.rb'
+    - 'test/integration/template_test.rb'
 
 # Offense count: 14
 # Cop supports --auto-correct.
@@ -216,6 +290,16 @@ Style/RedundantSelf:
   Exclude:
     - 'lib/liquid/strainer.rb'
 
+# Offense count: 3
+# Cop supports --auto-correct.
+# Configuration parameters: ConvertCodeThatCanStartToReturnNil, Whitelist.
+# Whitelist: present?, blank?, presence, try, try!
+Style/SafeNavigation:
+  Exclude:
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/strainer.rb'
+    - 'lib/liquid/tokenizer.rb'
+
 # Offense count: 9
 # Cop supports --auto-correct.
 # Configuration parameters: AllowAsExpressionSeparator.
@@ -253,8 +337,9 @@ Style/WhileUntilModifier:
   Exclude:
     - 'lib/liquid/tags/case.rb'
 
-# Offense count: 648
+# Offense count: 665
-# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
 Metrics/LineLength:
   Max: 294

.travis.yml

@@ -1,31 +1,30 @@
 language: ruby
+cache: bundler
 
 rvm:
-  - 2.1
-  - 2.2
-  - 2.3
   - 2.4
   - 2.5
+  - &latest_ruby 2.6
+  - 2.7
   - ruby-head
   - jruby-head
-#  - rbx-2
+  - truffleruby
-
-sudo: false
-
-addons:
-  apt:
-    packages:
-    - libgmp3-dev
 
 matrix:
+  include:
+    - rvm: *latest_ruby
+      script: bundle exec rake memory_profile:run
+      name: Profiling Memory Usage
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: truffleruby
 
-install:
+branches:
-  - bundle install
+  only:
-
+    - master
-script: bundle exec rake
+    - gh-pages
+    - /.*-stable/
 
 notifications:
   disable: true

Gemfile

@@ -8,16 +8,18 @@ gemspec
 group :benchmark, :test do
   gem 'benchmark-ips'
   gem 'memory_profiler'
+  gem 'terminal-table'
 
-  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ } do
+  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
     gem 'stackprof'
   end
 end
 
 group :test do
-  gem 'rubocop', '~> 0.53.0'
+  gem 'rubocop', '~> 0.74.0', require: false
+  gem 'rubocop-performance', require: false
 
-  platform :mri do
+  platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '9168659de45d6d576fce30c735f857e597fa26f6'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'liquid-tag'
   end
 end

Rakefile

@@ -19,8 +19,10 @@ task :warn_test do
 end
 
 task :rubocop do
-  require 'rubocop/rake_task'
+  if RUBY_ENGINE == 'ruby'
-  RuboCop::RakeTask.new
+    require 'rubocop/rake_task'
+    RuboCop::RakeTask.new
+  end
 end
 
 desc 'runs test suite with both strict and lax parsers'
@@ -32,8 +34,8 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  if RUBY_ENGINE == 'ruby'
+  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-    ENV['LIQUID-C'] = '1'
+    ENV['LIQUID_C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
     Rake::Task['base_test'].reenable

lib/liquid.rb

@@ -74,7 +74,13 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
+require 'liquid/partial_cache'
+require 'liquid/usage'
 
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+
+# Load all usage tracking
+#
+Dir["#{__dir__}/liquid/usages/*.rb"].each { |f| require f }

lib/liquid/block_body.rb

@@ -1,6 +1,7 @@
 module Liquid
   class BlockBody
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
     ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
     WhitespaceOrNothing = /\A\s*\z/
     TAGSTART = "{%".freeze
@@ -13,8 +14,42 @@ module Liquid
       @blank = true
     end
 
-    def parse(tokenizer, parse_context)
+    def parse(tokenizer, parse_context, &block)
       parse_context.line_number = tokenizer.line_number
+
+      if tokenizer.for_liquid_tag
+        parse_for_liquid_tag(tokenizer, parse_context, &block)
+      else
+        parse_for_document(tokenizer, parse_context, &block)
+      end
+    end
+
+    private def parse_for_liquid_tag(tokenizer, parse_context)
+      while token = tokenizer.shift
+        unless token.empty? || token =~ WhitespaceOrNothing
+          unless token =~ LiquidTagToken
+            # line isn't empty but didn't match tag syntax, yield and let the
+            # caller raise a syntax error
+            return yield token, token
+          end
+          tag_name = $1
+          markup = $2
+          unless tag = registered_tags[tag_name]
+            # end parsing if we reach an unknown tag and let the caller decide
+            # determine how to proceed
+            return yield tag_name, markup
+          end
+          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+          @blank &&= new_tag.blank?
+          @nodelist << new_tag
+        end
+        parse_context.line_number = tokenizer.line_number
+      end
+
+      yield nil, nil
+    end
+
+    private def parse_for_document(tokenizer, parse_context, &block)
       while token = tokenizer.shift
         next if token.empty?
         case
@@ -23,9 +58,20 @@ module Liquid
           unless token =~ FullToken
             raise_missing_tag_terminator(token, parse_context)
           end
-          tag_name = $1
+          tag_name = $2
-          markup = $2
+          markup = $4
-          # fetch the tag from registered blocks
+
+          if parse_context.line_number
+            # newlines inside the tag should increase the line number,
+            # particularly important for multiline {% liquid %} tags
+            parse_context.line_number += $1.count("\n".freeze) + $3.count("\n".freeze)
+          end
+
+          if tag_name == 'liquid'.freeze
+            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
+            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
+          end
+
           unless tag = registered_tags[tag_name]
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed

lib/liquid/context.rb

@@ -12,17 +12,25 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+    # rubocop:disable Metrics/ParameterLists
-      @environments     = [environments].flatten
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
-      @scopes           = [(outer_scope || {})]
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
-      @registers        = registers
+    end
-      @errors           = []
+
-      @partial          = false
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
-      @strict_variables = false
+      @environments        = [environments].flatten
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @static_environments = [static_environments].flatten.map(&:freeze).freeze
+      @scopes              = [(outer_scope || {})]
+      @registers           = registers
+      @static_registers    = static_registers.freeze
+      @errors              = []
+      @partial             = false
+      @strict_variables    = false
+      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @base_scope_depth    = 0
       squash_instance_assigns_with_environments
 
       @this_stack_used = false
@@ -36,6 +44,7 @@ module Liquid
       @filters = []
       @global_filter = nil
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def warnings
       @warnings ||= []
@@ -89,7 +98,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope = {})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
+      check_overflow
     end
 
     # Merge a hash of variables in the current local scope
@@ -126,6 +135,25 @@ module Liquid
       @this_stack_used = old_stack_used
     end
 
+    # Creates a new context inheriting resource limits, filters, environment etc.,
+    # but with an isolated scope.
+    def new_isolated_subcontext
+      check_overflow
+
+      Context.build(
+        resource_limits: resource_limits,
+        static_environments: static_environments,
+        static_registers: static_registers
+      ).tap do |subcontext|
+        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.exception_renderer = exception_renderer
+        subcontext.filters = @filters
+        subcontext.strainer = nil
+        subcontext.errors = errors
+        subcontext.warnings = warnings
+      end
+    end
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -164,25 +192,13 @@ module Liquid
       # This was changed from find() to find_index() because this is a very hot
       # path and find_index() is optimized in MRI to reduce object allocation
       index = @scopes.find_index { |s| s.key?(key) }
-      scope = @scopes[index] if index
 
-      variable = nil
+      variable = if index
-
+        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
-      if scope.nil?
+      else
-        @environments.each do |e|
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
-          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
-          # When lookup returned a value OR there is no value but the lookup also did not raise
-          # then it is the value we are looking for.
-          if !variable.nil? || @strict_variables && raise_on_not_found
-            scope = e
-            break
-          end
-        end
       end
 
-      scope ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
-
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
@@ -203,8 +219,38 @@ module Liquid
       end
     end
 
+    protected
+
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+
     private
 
+    attr_reader :base_scope_depth
+
+    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)
+        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)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      nil
+    end
+
+    def check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if overflow?
+    end
+
+    def overflow?
+      base_scope_depth + @scopes.length > Block::MAX_DEPTH
+    end
+
     def internal_error
       # raise and catch to set backtrace and cause on exception
       raise Liquid::InternalError, 'internal'

lib/liquid/locales/en.yml

@@ -22,5 +22,6 @@
       tag_never_closed: "'%{block_name}' tag was never closed"
       meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+      render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"

lib/liquid/partial_cache.rb

@@ -0,0 +1,18 @@
+module Liquid
+  class PartialCache
+    def self.load(template_name, context:, parse_context:)
+      cached_partials = (context.registers[:cached_partials] ||= {})
+      cached = cached_partials[template_name]
+      return cached if cached
+
+      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
+      source = file_system.read_template_file(template_name)
+      parse_context.partial = true
+
+      partial = Liquid::Template.parse(source, parse_context)
+      cached_partials[template_name] = partial
+    ensure
+      parse_context.partial = false
+    end
+  end
+end

lib/liquid/tag.rb

@@ -5,8 +5,8 @@ module Liquid
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokenizer, options)
+      def parse(tag_name, markup, tokenizer, parse_context)
-        tag = new(tag_name, markup, options)
+        tag = new(tag_name, markup, parse_context)
         tag.parse(tokenizer)
         tag
       end

lib/liquid/tags/assign.rb

@@ -10,6 +10,10 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
+    def self.syntax_error_translation_key
+      "errors.syntax.assign".freeze
+    end
+
     attr_reader :to, :from
 
     def initialize(tag_name, markup, options)
@@ -18,7 +22,7 @@ module Liquid
         @to = $1
         @from = Variable.new($2, options)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new(options[:locale].t(self.class.syntax_error_translation_key))
       end
     end
 

lib/liquid/tags/echo.rb

@@ -0,0 +1,24 @@
+module Liquid
+  # Echo outputs an expression
+  #
+  #   {% echo monkey %}
+  #   {% echo user.name %}
+  #
+  # This is identical to variable output syntax, like {{ foo }}, but works
+  # inside {% liquid %} tags. The full syntax is supported, including filters:
+  #
+  #   {% echo user | link %}
+  #
+  class Echo < Tag
+    def initialize(tag_name, markup, parse_context)
+      super
+      @variable = Variable.new(markup, parse_context)
+    end
+
+    def render(context)
+      @variable.render_to_output_buffer(context, '')
+    end
+  end
+
+  Template.register_tag('echo'.freeze, Echo)
+end

lib/liquid/tags/include.rb

@@ -46,7 +46,12 @@ module Liquid
       template_name = context.evaluate(@template_name_expr)
       raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
 
-      partial = load_cached_partial(template_name, context)
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
       context_variable_name = template_name.split('/'.freeze).last
 
       variable = if @variable_name_expr
@@ -83,35 +88,9 @@ module Liquid
       output
     end
 
-    private
-
     alias_method :parse_context, :options
     private :parse_context
 
-    def load_cached_partial(template_name, context)
-      cached_partials = context.registers[:cached_partials] || {}
-
-      if cached = cached_partials[template_name]
-        return cached
-      end
-      source = read_template_from_file_system(context)
-      begin
-        parse_context.partial = true
-        partial = Liquid::Template.parse(source, parse_context)
-      ensure
-        parse_context.partial = false
-      end
-      cached_partials[template_name] = partial
-      context.registers[:cached_partials] = cached_partials
-      partial
-    end
-
-    def read_template_from_file_system(context)
-      file_system = context.registers[:file_system] || Liquid::Template.file_system
-
-      file_system.read_template_file(context.evaluate(@template_name_expr))
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/increment.rb

@@ -23,6 +23,7 @@ module Liquid
     def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
+
       output << value.to_s
       output
     end

lib/liquid/tags/render.rb

@@ -0,0 +1,54 @@
+module Liquid
+  class Render < Tag
+    Syntax = /(#{QuotedString})#{QuotedFragment}*/o
+
+    attr_reader :template_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
+      raise SyntaxError.new(options[:locale].t("errors.syntax.render".freeze)) unless markup =~ Syntax
+
+      template_name = $1
+
+      @template_name_expr = Expression.parse(template_name)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = Expression.parse(value)
+      end
+    end
+
+    def render_to_output_buffer(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.new(options[:locale].t("errors.argument.include")) unless template_name
+
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
+      inner_context = context.new_isolated_subcontext
+      inner_context.template_name = template_name
+      inner_context.partial = true
+      @attributes.each do |key, value|
+        inner_context[key] = context.evaluate(value)
+      end
+      partial.render_to_output_buffer(inner_context, output)
+
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+
+  Template.register_tag('render'.freeze, Render)
+end

lib/liquid/tokenizer.rb

@@ -1,25 +1,31 @@
 module Liquid
   class Tokenizer
-    attr_reader :line_number
+    attr_reader :line_number, :for_liquid_tag
 
-    def initialize(source, line_numbers = false)
+    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
       @source = source
-      @line_number = line_numbers ? 1 : nil
+      @line_number = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
       @tokens = tokenize
     end
 
     def shift
-      token = @tokens.shift
+      token = @tokens.shift or return
-      @line_number += token.count("\n") if @line_number && token
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
       token
     end
 
     private
 
     def tokenize
-      @source = @source.source if @source.respond_to?(:source)
       return [] if @source.to_s.empty?
 
+      return @source.split("\n") if @for_liquid_tag
+
       tokens = @source.split(TemplateParser)
 
       # removes the rogue empty element at the beginning of the array

lib/liquid/usage.rb

@@ -0,0 +1,23 @@
+module Liquid
+  # Usage is used to store
+  class Usage
+    @messages = {}
+    class << self
+      def enable
+        Liquid::Context.send(:alias_method, :try_variable_find_in_environments, :try_variable_find_in_environments_usage)
+      end
+
+      def disable
+        Liquid::Context.send(:alias_method, :try_variable_find_in_environments, :try_variable_find_in_environments_original)
+      end
+
+      def track(message)
+        @messages[message] = true
+      end
+
+      def results
+        @messages
+      end
+    end
+  end
+end

lib/liquid/usages/try_variables.rb

@@ -0,0 +1,26 @@
+module Liquid
+  class Context
+    alias try_variable_find_in_environments_original try_variable_find_in_environments
+
+    def try_variable_find_in_environments_usage(key, raise_on_not_found:)
+      Usage.track("Using try_variable_find_in_environment")
+      @environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+
+        Usage.track("try_variable_find_in_environment reports Nil but responds to key") if environment.key?(key)
+      end
+      @static_environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+
+        Usage.track("try_variable_find_in_environment reports Nil but responds to key") if environment.key?(key)
+      end
+      nil
+    end
+  end
+end

lib/liquid/usages/usage_enabled.rb

@@ -0,0 +1 @@
+Liquid::Usage.track("Usage is enabled")

liquid.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.1.0"
+  s.required_ruby_version     = ">= 2.4.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")

performance/memory_profile.rb

@@ -2,25 +2,62 @@
 
 require 'benchmark/ips'
 require 'memory_profiler'
+require 'terminal-table'
 require_relative 'theme_runner'
 
-def profile(phase, &block)
+class Profiler
-  puts
+  LOG_LABEL   = "Profiling: ".rjust(14).freeze
-  puts "#{phase}:"
+  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
-  puts
 
-  report = MemoryProfiler.report(&block)
+  def self.run
+    puts
+    yield new
+  end
 
-  report.pretty_print(
+  def initialize
-    color_output: true,
+    @allocated = []
-    scale_bytes: true,
+    @retained  = []
-    detailed_report: true
+    @headings  = []
-  )
+  end
+
+  def profile(phase, &block)
+    print LOG_LABEL
+    print "#{phase}.. ".ljust(10)
+    report = MemoryProfiler.report(&block)
+    puts 'Done.'
+    @headings  << phase.capitalize
+    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
+    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
+
+    return if ENV['CI']
+
+    require 'fileutils'
+    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
+    FileUtils.mkdir_p(REPORTS_DIR)
+    report.pretty_print(to_file: report_file, scale_bytes: true)
+  end
+
+  def tabulate
+    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
+      t << @allocated.unshift('Total allocated')
+      t << @retained.unshift('Total retained')
+    end
+
+    puts
+    puts table
+    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
+  end
+
+  def sanitize(string)
+    string.downcase.gsub(/[\W]/, '-').squeeze('-')
+  end
 end
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 
-profiler = ThemeRunner.new
+runner = ThemeRunner.new
-
+Profiler.run do |x|
-profile("Parsing") { profiler.compile }
+  x.profile('parse') { runner.compile }
-profile("Rendering") { profiler.render }
+  x.profile('render') { runner.render }
+  x.tabulate
+end

test/integration/tags/echo_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class EchoTest < Minitest::Test
+  include Liquid
+
+  def test_echo_outputs_its_input
+    assert_template_result('BAR', <<~LIQUID, { 'variable-name' => 'bar' })
+      {%- echo variable-name | upcase -%}
+    LIQUID
+  end
+end

test/integration/tags/liquid_tag_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class LiquidTagTest < Minitest::Test
+  include Liquid
+
+  def test_liquid_tag
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        echo array | join: " "
+      -%}
+    LIQUID
+
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        for value in array
+          echo value
+          unless forloop.last
+            echo " "
+          endunless
+        endfor
+      -%}
+    LIQUID
+
+    assert_template_result('4 8 12 6', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        for value in array
+          assign double_value = value | times: 2
+          echo double_value | times: 2
+          unless forloop.last
+            echo " "
+          endunless
+        endfor
+
+        echo " "
+        echo double_value
+      -%}
+    LIQUID
+
+    assert_template_result('abc', <<~LIQUID)
+      {%- liquid echo "a" -%}
+      b
+      {%- liquid echo "c" -%}
+    LIQUID
+  end
+
+  def test_liquid_tag_errors
+    assert_match_syntax_error("syntax error (line 1): Unknown tag 'error'", <<~LIQUID)
+      {%- liquid error no such tag -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 7): Unknown tag 'error'", <<~LIQUID)
+      {{ test }}
+
+      {%-
+      liquid
+        for value in array
+
+          error no such tag
+        endfor
+      -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 2): Unknown tag '!!! the guards are vigilant'", <<~LIQUID)
+      {%- liquid
+        !!! the guards are vigilant
+      -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 4): 'for' tag was never closed", <<~LIQUID)
+      {%- liquid
+        for value in array
+          echo 'forgot to close the for tag'
+      -%}
+    LIQUID
+  end
+
+  def test_line_number_is_correct_after_a_blank_token
+    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n\n error %}")
+    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n  \n error %}")
+  end
+
+  def test_cannot_open_blocks_living_past_a_liquid_tag
+    assert_match_syntax_error("syntax error (line 3): 'if' tag was never closed", <<~LIQUID)
+      {%- liquid
+        if true
+      -%}
+      {%- endif -%}
+    LIQUID
+  end
+
+  def test_quirk_can_close_blocks_created_before_a_liquid_tag
+    assert_template_result("42", <<~LIQUID)
+      {%- if true -%}
+      42
+      {%- liquid endif -%}
+    LIQUID
+  end
+
+  def test_liquid_tag_in_raw
+    assert_template_result("{% liquid echo 'test' %}\n", <<~LIQUID)
+      {% raw %}{% liquid echo 'test' %}{% endraw %}
+    LIQUID
+  end
+end

test/integration/tags/render_tag_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class RenderTagTest < Minitest::Test
+  include Liquid
+
+  def test_render_with_no_arguments
+    Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
+    assert_template_result 'rendered content', '{% render "source" %}'
+  end
+
+  def test_render_tag_looks_for_file_system_in_registers_first
+    file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
+    assert_equal 'from register file system',
+      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system })
+  end
+
+  def test_render_passes_named_arguments_into_inner_scope
+    Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
+    assert_template_result 'My Product', '{% render "product", inner_product: outer_product %}',
+      'outer_product' => { 'title' => 'My Product' }
+  end
+
+  def test_render_accepts_literals_as_arguments
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
+    assert_template_result '123', '{% render "snippet", price: 123 %}'
+  end
+
+  def test_render_accepts_multiple_named_arguments
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
+    assert_template_result '1 2', '{% render "snippet", one: 1, two: 2 %}'
+  end
+
+  def test_render_does_not_inherit_parent_scope_variables
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
+    assert_template_result '', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}'
+  end
+
+  def test_render_does_not_inherit_variable_with_same_name_as_snippet
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
+    assert_template_result '', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}"
+  end
+
+  def test_render_sets_the_correct_template_name_for_errors
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+    with_taint_mode :error do
+      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+      template.render(context)
+
+      assert_equal [Liquid::TaintedError], template.errors.map(&:class)
+      assert_equal 'snippet', template.errors.first.template_name
+    end
+  end
+
+  def test_render_sets_the_correct_template_name_for_warnings
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+    with_taint_mode :warn do
+      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+      template.render(context)
+
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal 'snippet', context.warnings.first.template_name
+    end
+  end
+
+  def test_render_does_not_mutate_parent_scope
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
+    assert_template_result '', "{% render 'snippet' %}{{ inner }}"
+  end
+
+  def test_nested_render_tag
+    Liquid::Template.file_system = StubFileSystem.new(
+      'one' => "one {% render 'two' %}",
+      'two' => 'two'
+    )
+    assert_template_result 'one two', "{% render 'one' %}"
+  end
+
+  def test_recursively_rendered_template_does_not_produce_endless_loop
+    Liquid::Template.file_system = StubFileSystem.new('loop' => '{% render "loop" %}')
+
+    assert_raises Liquid::StackLevelError do
+      Template.parse('{% render "loop" %}').render!
+    end
+  end
+
+  def test_includes_and_renders_count_towards_the_same_recursion_limit
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop_render' => '{% render "loop_include" %}',
+      'loop_include' => '{% include "loop_render" %}'
+    )
+
+    assert_raises Liquid::StackLevelError  do
+      Template.parse('{% render "loop_include" %}').render!
+    end
+  end
+
+  def test_dynamically_choosen_templates_are_not_allowed
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'should not be rendered')
+
+    assert_raises Liquid::SyntaxError do
+      Liquid::Template.parse("{% assign name = 'snippet' %}{% render name %}")
+    end
+  end
+
+  def test_include_tag_caches_second_read_of_same_partial
+    file_system = StubFileSystem.new('snippet' => 'echo')
+    assert_equal 'echoecho',
+      Template.parse('{% render "snippet" %}{% render "snippet" %}')
+              .render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.file_read_count
+  end
+
+  def test_render_tag_doesnt_cache_partials_across_renders
+    file_system = StubFileSystem.new('snippet' => 'my message')
+
+    assert_equal 'my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.file_read_count
+
+    assert_equal 'my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
+    assert_equal 2, file_system.file_read_count
+  end
+
+  def test_render_tag_within_if_statement
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
+    assert_template_result 'my message', '{% if true %}{% render "snippet" %}{% endif %}'
+  end
+
+  def test_break_through_render
+    Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
+    assert_template_result '1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}'
+    assert_template_result '112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}'
+  end
+
+  def test_increment_is_isolated_between_renders
+    Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
+    assert_template_result '010', '{% increment %}{% increment %}{% render "incr" %}'
+  end
+
+  def test_decrement_is_isolated_between_renders
+    Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
+    assert_template_result '-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}'
+  end
+end

test/integration/usages/try_variables_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class TryVariablesUsageTest < Minitest::Test
+  include Liquid
+
+  def test_test_usages
+    Usage.enable
+    template = Template.parse(%({{test}}))
+    assert_equal 'worked', template.render!('test' => 'worked')
+    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal true, Usage.results["Using try_variable_find_in_environment"]
+    Usage.disable
+  end
+end

test/integration/usages/usage_enabled_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class UsageEnabledUsageTest < Minitest::Test
+  include Liquid
+
+  def test_live_usages
+    assert_equal true, Usage.results["Usage is enabled"]
+  end
+end

test/test_helper.rb

@@ -14,7 +14,7 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
 end
 Liquid::Template.error_mode = mode
 
-if ENV['LIQUID-C'] == '1'
+if ENV['LIQUID_C'] == '1'
   puts "-- LIQUID C"
   require 'liquid/c'
 end
@@ -37,18 +37,18 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
+      assert_equal expected, Template.parse(template, line_numbers: true).render!(assigns), message
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
       return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
 
-      assert_match expected, Template.parse(template).render!(assigns), message
+      assert_match expected, Template.parse(template, line_numbers: true).render!(assigns), message
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template).render(assigns)
+        Template.parse(template, line_numbers: true).render(assigns)
       end
       assert_match match, exception.message
     end
@@ -121,3 +121,17 @@ class ErrorDrop < Liquid::Drop
     raise Exception, 'exception'
   end
 end
+
+class StubFileSystem
+  attr_reader :file_read_count
+
+  def initialize(values)
+    @file_read_count = 0
+    @values = values
+  end
+
+  def read_template_file(template_path)
+    @file_read_count += 1
+    @values.fetch(template_path)
+  end
+end

test/unit/context_unit_test.rb

@@ -468,11 +468,79 @@ class ContextUnitTest < Minitest::Test
     assert_equal 'hi filtered', context.apply_global_filter('hi')
   end
 
+  def test_static_environments_are_read_with_lower_priority_than_environments
+    context = Context.build(
+      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
+      environments: { 'shadowed' => 'dynamic' }
+    )
+
+    assert_equal 'dynamic', context['shadowed']
+    assert_equal 'static', context['unshadowed']
+  end
+
   def test_apply_global_filter_when_no_global_filter_exist
     context = Context.new
     assert_equal 'hi', context.apply_global_filter('hi')
   end
 
+  def test_new_isolated_subcontext_does_not_inherit_variables
+    super_context = Context.new
+    super_context['my_variable'] = 'some value'
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_nil subcontext['my_variable']
+  end
+
+  def test_new_isolated_subcontext_inherits_static_environment
+    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_equal 'my value', subcontext['my_environment_value']
+  end
+
+  def test_new_isolated_subcontext_inherits_resource_limits
+    resource_limits = ResourceLimits.new({})
+    super_context = Context.new({}, {}, {}, false, resource_limits)
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal resource_limits, subcontext.resource_limits
+  end
+
+  def test_new_isolated_subcontext_inherits_exception_renderer
+    super_context = Context.new
+    super_context.exception_renderer = ->(_e) { 'my exception message' }
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal 'my exception message', subcontext.handle_error(Liquid::Error.new)
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
+    registers = {
+      my_register: :my_value
+    }
+    super_context = Context.new({}, {}, registers)
+    subcontext = super_context.new_isolated_subcontext
+    assert_nil subcontext.registers[:my_register]
+  end
+
+  def test_new_isolated_subcontext_inherits_static_registers
+    super_context = Context.build(static_registers: { my_register: :my_value })
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal :my_value, subcontext.static_registers[:my_register]
+  end
+
+  def test_new_isolated_subcontext_inherits_filters
+    my_filter = Module.new do
+      def my_filter(*)
+        'my filter result'
+      end
+    end
+
+    super_context = Context.new
+    super_context.add_filters([my_filter])
+    subcontext = super_context.new_isolated_subcontext
+    template = Template.parse('{{ 123 | my_filter }}')
+    assert_equal 'my filter result', template.render(subcontext)
+  end
+
   private
 
   def assert_no_object_allocations

test/unit/partial_cache_unit_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class PartialCacheUnitTest < Minitest::Test
+  def test_uses_the_file_system_register_if_present
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body')
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal 'my partial body', partial.render
+  end
+
+  def test_reads_from_the_file_system_only_once_per_file
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context,
+        parse_context: Liquid::ParseContext.new
+      )
+    end
+
+    assert_equal 1, file_system.file_read_count
+  end
+
+  def test_cache_state_is_stored_per_context
+    parse_context = Liquid::ParseContext.new
+    shared_file_system = StubFileSystem.new(
+      'my_partial' => 'my shared value'
+    )
+    context_one = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system
+      }
+    )
+    context_two = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system
+      }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context_one,
+        parse_context: parse_context
+      )
+    end
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context_two,
+      parse_context: parse_context
+    )
+
+    assert_equal 2, shared_file_system.file_read_count
+  end
+
+  def test_cache_is_not_broken_when_a_different_parse_context_is_used
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value one')
+    )
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value two')
+    )
+
+    # Technically what we care about is that the file was parsed twice,
+    # but measuring file reads is an OK proxy for this.
+    assert_equal 1, file_system.file_read_count
+  end
+end