Add isolated subcontexts

An isolated subcontext inherits the environment, filters,
and static registers of its supercontext, but with a fresh
(isolated) scope.

This will pave the way for adding the `render` tag, which renders
templates in such a subcontext.

lib/liquid/context.rb

@@ -12,13 +12,18 @@ 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
     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)
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers)
+    end
+
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {})
       @environments     = [environments].flatten
       @scopes           = [(outer_scope || {})]
       @registers        = registers
+      @static_registers = static_registers.tap(&:freeze)
       @errors           = []
       @partial          = false
       @strict_variables = false
@@ -126,6 +131,19 @@ 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
+      Context.build(
+        environments: environments,
+        resource_limits: resource_limits,
+        static_registers: static_registers
+      ).tap do |subcontext|
+        subcontext.exception_renderer = exception_renderer
+        subcontext.add_filters(@filters)
+      end
+    end
+
     def clear_instance_assigns
       @scopes[0] = {}
     end

lib/liquid/tags/render.rb

@@ -0,0 +1,89 @@
+module Liquid
+  #
+  # TODO: docs
+  #
+  class Render < Tag
+    Syntax = /(#{QuotedFragment}+)/o
+
+    attr_reader :template_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
+      if 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
+
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
+      end
+    end
+
+    def parse(_tokens)
+    end
+
+    def render_to_output_buffer(context, output)
+      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)
+
+      inner_context = Context.new
+      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)
+      
+      # TODO: Put into a new #isolated_stack method in Context?
+      inner_context.errors.each { |e| context.errors << e }
+
+      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
+        [
+          @node.template_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+
+  Template.register_tag('render'.freeze, Render)
+end