Add Liquid to Ruby compiler for optimized template rendering

This adds a new `compile_to_ruby` method to Liquid::Template that compiles
Liquid templates to pure Ruby code. The compiled code can be eval'd to create
a proc that renders templates without needing the Liquid library at runtime.

## Features

- Compiles all standard Liquid tags: if/unless/case, for, assign, capture,
  cycle, increment/decrement, raw, echo, break/continue, comment, tablerow
- Compiles variable expressions with filter chains to direct Ruby method calls
- Supports static partial inlining ({% render %} and {% include %} with string
  literals are loaded and compiled at compile time)
- Dynamic partial support via runtime callbacks (__render_dynamic__, __include_dynamic__)
- Debug mode with source comments for error tracing (lightweight source map)
- SourceMapper utility to trace runtime errors back to Liquid source

## Optimization Opportunities

The compiled Ruby code has significant performance advantages:

1. No Context object - variables accessed directly from assigns hash
2. No filter invocation overhead - direct Ruby method calls
3. No resource limits tracking - no per-node render score updates
4. No stack-based scoping - uses Ruby's native block scoping
5. Direct string concatenation - no render_to_output_buffer abstraction
6. Native control flow - break/continue use Ruby's throw/catch
7. No to_liquid calls - values used directly
8. No profiling hooks - no profiler overhead
9. No exception rendering - errors propagate naturally

## Usage

```ruby
template = Liquid::Template.parse("Hello, {{ name }}!")
ruby_code = template.compile_to_ruby
render_proc = eval(ruby_code)
result = render_proc.call({ "name" => "World" })
# => "Hello, World!"

# With debug mode for error tracing:
ruby_code = template.compile_to_ruby(debug: true)
```

## Limitations

- Dynamic {% render %} and {% include %} require runtime callback methods
- Custom tags need explicit compiler implementations
- Custom filters must be available at runtime

Author: claude

lib/liquid/compile.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Liquid Ruby Compiler
+#
+# This module provides the ability to compile Liquid templates to pure Ruby code.
+# The compiled code can be eval'd to create a proc that renders the template
+# without needing the Liquid library at runtime.
+#
+# ## Usage
+#
+#   template = Liquid::Template.parse("Hello, {{ name }}!")
+#   ruby_code = template.compile_to_ruby
+#   render_proc = eval(ruby_code)
+#   result = render_proc.call({ "name" => "World" })
+#   # => "Hello, World!"
+#
+# ## Optimization Opportunities
+#
+# The compiled Ruby code has several significant advantages over interpreted Liquid:
+#
+# 1. **No Context Object**: Variables are extracted directly from the assigns hash
+#    and accessed without the Context abstraction layer.
+#
+# 2. **No Filter Invocation Overhead**: Filters are compiled to direct Ruby method
+#    calls rather than going through context.invoke().
+#
+# 3. **No Resource Limits Tracking**: The compiled code doesn't track render
+#    scores, write scores, or assign scores, eliminating per-node overhead.
+#
+# 4. **No Stack-based Scoping**: Ruby's native block scoping is used instead
+#    of manually managing scope stacks.
+#
+# 5. **Direct String Concatenation**: Output is built with direct << operations.
+#
+# 6. **Native Control Flow**: break/continue use Ruby's throw/catch mechanism.
+#
+# 7. **No to_liquid Calls**: Values are used directly without conversion.
+#
+# 8. **No Profiling Hooks**: No profiler overhead in the generated code.
+#
+# 9. **No Exception Rendering**: Errors propagate naturally.
+#
+# ## Limitations
+#
+# - {% render %} and {% include %} tags require runtime support
+# - Custom tags need explicit compiler implementations
+# - Custom filters need to be available at runtime
+#
+module Liquid
+  module Compile
+    autoload :CodeGenerator, 'liquid/compile/code_generator'
+    autoload :RubyCompiler, 'liquid/compile/ruby_compiler'
+    autoload :ExpressionCompiler, 'liquid/compile/expression_compiler'
+    autoload :FilterCompiler, 'liquid/compile/filter_compiler'
+    autoload :VariableCompiler, 'liquid/compile/variable_compiler'
+    autoload :BlockBodyCompiler, 'liquid/compile/block_body_compiler'
+    autoload :ConditionCompiler, 'liquid/compile/condition_compiler'
+    autoload :SourceMapper, 'liquid/compile/source_mapper'
+
+    module Tags
+      autoload :IfCompiler, 'liquid/compile/tags/if_compiler'
+      autoload :UnlessCompiler, 'liquid/compile/tags/unless_compiler'
+      autoload :CaseCompiler, 'liquid/compile/tags/case_compiler'
+      autoload :ForCompiler, 'liquid/compile/tags/for_compiler'
+      autoload :AssignCompiler, 'liquid/compile/tags/assign_compiler'
+      autoload :CaptureCompiler, 'liquid/compile/tags/capture_compiler'
+      autoload :CycleCompiler, 'liquid/compile/tags/cycle_compiler'
+      autoload :IncrementCompiler, 'liquid/compile/tags/increment_compiler'
+      autoload :DecrementCompiler, 'liquid/compile/tags/decrement_compiler'
+      autoload :RawCompiler, 'liquid/compile/tags/raw_compiler'
+      autoload :EchoCompiler, 'liquid/compile/tags/echo_compiler'
+      autoload :BreakCompiler, 'liquid/compile/tags/break_compiler'
+      autoload :ContinueCompiler, 'liquid/compile/tags/continue_compiler'
+      autoload :CommentCompiler, 'liquid/compile/tags/comment_compiler'
+      autoload :TableRowCompiler, 'liquid/compile/tags/tablerow_compiler'
+      autoload :RenderCompiler, 'liquid/compile/tags/render_compiler'
+      autoload :IncludeCompiler, 'liquid/compile/tags/include_compiler'
+      autoload :IfchangedCompiler, 'liquid/compile/tags/ifchanged_compiler'
+    end
+  end
+end

lib/liquid/compile/block_body_compiler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Compile
+    # BlockBodyCompiler compiles a BlockBody (a list of nodes) to Ruby code.
+    #
+    # A BlockBody contains:
+    # - String literals (text to output)
+    # - Variable expressions ({{ ... }})
+    # - Tags ({% ... %})
+    class BlockBodyCompiler
+      # Compile a BlockBody to Ruby code
+      # @param body [Liquid::BlockBody] The block body
+      # @param compiler [RubyCompiler] The main compiler instance
+      # @param code [CodeGenerator] The code generator
+      def self.compile(body, compiler, code)
+        return if body.nil?
+
+        nodelist = body.nodelist
+        return if nodelist.nil? || nodelist.empty?
+
+        nodelist.each do |node|
+          compile_node(node, compiler, code)
+        end
+      end
+
+      # Compile a single node
+      def self.compile_node(node, compiler, code)
+        case node
+        when String
+          compile_string(node, code)
+        when Variable
+          VariableCompiler.compile(node, compiler, code)
+        when Tag
+          compiler.send(:compile_tag, node, code)
+        else
+          raise CompileError, "Unknown node type in BlockBody: #{node.class}"
+        end
+      end
+
+      private
+
+      def self.compile_string(str, code)
+        return if str.empty?
+        code.line "__output__ << #{str.inspect}"
+      end
+    end
+  end
+end

lib/liquid/compile/code_generator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Compile
+    # CodeGenerator provides a clean interface for building Ruby code strings
+    # with proper indentation and formatting.
+    class CodeGenerator
+      INDENT_SIZE = 2
+
+      def initialize
+        @lines = []
+        @indent_level = 0
+      end
+
+      # Add a line of code at the current indentation level
+      # @param text [String] The code to add
+      def line(text)
+        @lines << ("  " * @indent_level) + text
+      end
+
+      # Add a blank line
+      def blank_line
+        @lines << ""
+      end
+
+      # Add multiple lines (useful for multi-line strings)
+      # @param text [String] Multi-line string to add
+      def lines(text)
+        text.each_line do |l|
+          line(l.chomp)
+        end
+      end
+
+      # Increase indentation for a block
+      def indent
+        @indent_level += 1
+        yield
+        @indent_level -= 1
+      end
+
+      # Get the current indentation string
+      def current_indent
+        "  " * @indent_level
+      end
+
+      # Add raw code without indentation adjustment
+      def raw(text)
+        @lines << text
+      end
+
+      # Convert to final Ruby code string
+      def to_s
+        @lines.join("\n")
+      end
+
+      # Generate an inline expression (doesn't add to lines, returns string)
+      # @param expr [String] The expression
+      # @return [String] The expression wrapped appropriately
+      def self.inline(expr)
+        expr
+      end
+
+      # Generate a string literal
+      # @param str [String] The string to escape
+      # @return [String] Ruby string literal
+      def self.string_literal(str)
+        str.inspect
+      end
+
+      # Generate a safe variable name from a Liquid variable name
+      # @param name [String] The Liquid variable name
+      # @return [String] A safe Ruby variable name
+      def self.safe_var_name(name)
+        # Replace invalid characters with underscores
+        safe = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+        # Ensure it starts with a letter or underscore
+        safe = "_#{safe}" if safe =~ /\A\d/
+        safe
+      end
+    end
+  end
+end

lib/liquid/compile/condition_compiler.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Compile
+    # ConditionCompiler compiles Liquid conditions to Ruby boolean expressions.
+    #
+    # Handles:
+    # - Simple truthiness: {% if variable %}
+    # - Comparisons: {% if a == b %}, {% if a > b %}
+    # - Logical operators: {% if a and b %}, {% if a or b %}
+    # - Special checks: {% if a == blank %}, {% if a == empty %}
+    class ConditionCompiler
+      # Operator mappings from Liquid to Ruby
+      OPERATORS = {
+        '==' => '==',
+        '!=' => '!=',
+        '<>' => '!=',
+        '<' => '<',
+        '>' => '>',
+        '<=' => '<=',
+        '>=' => '>=',
+        'contains' => :contains,
+      }.freeze
+
+      # Compile a Condition to a Ruby boolean expression
+      # @param condition [Liquid::Condition] The condition
+      # @param compiler [RubyCompiler] The main compiler instance
+      # @return [String] Ruby code expression that evaluates to true/false
+      def self.compile(condition, compiler)
+        if condition.is_a?(ElseCondition)
+          return "true"
+        end
+
+        compile_condition_chain(condition, compiler)
+      end
+
+      private
+
+      def self.compile_condition_chain(condition, compiler)
+        # Compile the current condition
+        current = compile_single_condition(condition, compiler)
+
+        # Check for chained conditions (and/or)
+        if condition.child_condition
+          child = compile_condition_chain(condition.child_condition, compiler)
+          child_relation = condition.send(:child_relation)
+
+          case child_relation
+          when :and
+            "(#{current} && #{child})"
+          when :or
+            "(#{current} || #{child})"
+          else
+            current
+          end
+        else
+          current
+        end
+      end
+
+      def self.compile_single_condition(condition, compiler)
+        left = condition.left
+        op = condition.operator
+        right = condition.right
+
+        # If no operator, just check truthiness
+        if op.nil?
+          left_expr = ExpressionCompiler.compile(left, compiler)
+          return "__truthy__(#{left_expr})"
+        end
+
+        # Compile left and right expressions
+        left_expr = compile_condition_value(left, compiler)
+        right_expr = compile_condition_value(right, compiler)
+
+        # Handle special operators
+        case OPERATORS[op]
+        when :contains
+          compile_contains(left_expr, right_expr, compiler)
+        when '=='
+          compile_equality(left, right, left_expr, right_expr, compiler)
+        when '!='
+          "!(#{compile_equality(left, right, left_expr, right_expr, compiler)})"
+        else
+          # Standard comparison
+          ruby_op = OPERATORS[op] || op
+          "(#{left_expr} #{ruby_op} #{right_expr} rescue false)"
+        end
+      end
+
+      def self.compile_condition_value(expr, compiler)
+        if expr.is_a?(Condition::MethodLiteral)
+          # For blank/empty checks, we return a special marker
+          # The equality handler will deal with this
+          ":__method_literal_#{expr.method_name}__"
+        else
+          ExpressionCompiler.compile(expr, compiler)
+        end
+      end
+
+      def self.compile_equality(left, right, left_expr, right_expr, compiler)
+        # Handle blank/empty method literals
+        if left.is_a?(Condition::MethodLiteral)
+          method_name = left.method_name
+          "(#{right_expr}.respond_to?(:#{method_name}) ? #{right_expr}.#{method_name} : nil)"
+        elsif right.is_a?(Condition::MethodLiteral)
+          method_name = right.method_name
+          "(#{left_expr}.respond_to?(:#{method_name}) ? #{left_expr}.#{method_name} : nil)"
+        else
+          "(#{left_expr} == #{right_expr})"
+        end
+      end
+
+      def self.compile_contains(left_expr, right_expr, compiler)
+        # The contains operator checks if left includes right
+        # For strings, right is converted to a string
+        "(lambda { |left, right| " \
+          "return false if left.nil? || right.nil? || !left.respond_to?(:include?); " \
+          "right = right.to_s if left.is_a?(String); " \
+          "left.include?(right) rescue false " \
+          "}.call(#{left_expr}, #{right_expr}))"
+      end
+    end
+  end
+end