Initial recursive AST formatting

lib/liquid/block.rb

@@ -57,6 +57,10 @@ module Liquid
       @block_delimiter ||= "end#{block_name}"
     end
 
+    def format
+      "{% #{block_name} %}#{@body.format}{% #{block_delimiter} %}"
+    end
+
     protected
 
     def parse_body(body, tokens)

lib/liquid/block_body.rb

@@ -99,6 +99,18 @@ module Liquid
       output.join
     end
 
+    def format
+      @nodelist.map do |node|
+        if node.is_a?(Variable)
+          "{{ #{node.format} }}"
+        elsif node.is_a?(Tag)
+          node.format
+        else
+          node
+        end
+      end.join
+    end
+
     private
 
     def render_token(token, context)

lib/liquid/condition.rb

@@ -33,6 +33,12 @@ module Liquid
       @right = right
       @child_relation  = nil
       @child_condition = nil
+
+      if right && right.is_a?(VariableLookup) && right.name.nil?
+        # Strip blank variable lookups resulting from cases like:
+        # {% if foo && bar %}
+        @right = nil
+      end
     end
 
     def evaluate(context = Context.new)
@@ -70,6 +76,20 @@ module Liquid
       "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
     end
 
+    def format
+      out = if operator.nil?
+        Expression.format(left)
+      else
+        "#{Expression.format(left)} #{operator} #{Expression.format(right)}"
+      end
+
+      if @child_relation
+        "#{out} #{@child_relation.to_s} #{@child_condition.format}"
+      else
+        out
+      end
+    end
+
     private
 
     def equal_variables(left, right)

lib/liquid/expression.rb

@@ -8,6 +8,8 @@ module Liquid
       'empty'.freeze => :empty?
     }
 
+    INVERTED_LITERALS = LITERALS.invert
+
     def self.parse(markup)
       if LITERALS.key?(markup)
         LITERALS[markup]
@@ -29,5 +31,18 @@ module Liquid
       end
     end
 
+    def self.format(value)
+      if INVERTED_LITERALS.key?(value)
+        INVERTED_LITERALS[value].dup
+      elsif value.is_a?(VariableLookup) || value.is_a?(RangeLookup)
+        value.format
+      elsif value.is_a?(String)
+        "\"#{value}\""
+      elsif value.is_a?(Range)
+        "(#{value.to_s})"
+      else
+        value.to_s
+      end
+    end
   end
 end

lib/liquid/range_lookup.rb

@@ -18,5 +18,9 @@ module Liquid
     def evaluate(context)
       context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
     end
+
+    def format
+      "(#{Expression.format(@start_obj)}..#{Expression.format(@end_obj)})"
+    end
   end
 end

lib/liquid/tag.rb

@@ -38,5 +38,13 @@ module Liquid
     def blank?
       false
     end
+
+    def format
+      tag = @tag_name.strip
+      markup = @markup.strip
+      tag << " #{markup}" unless markup.empty?
+
+      "{% #{tag} %}"
+    end
   end
 end

lib/liquid/tags/assign.rb

@@ -35,6 +35,10 @@ module Liquid
     def blank?
       true
     end
+
+    def format
+      "{% assign #{@to} = #{@from.format} %}"
+    end
   end
 
   Template.register_tag('assign'.freeze, Assign)

lib/liquid/tags/capture.rb

@@ -32,6 +32,10 @@ module Liquid
     def blank?
       true
     end
+
+    def format
+      "{% #{block_name} #{@to} %}#{@body.format}{% #{block_delimiter} %}"
+    end
   end
 
   Template.register_tag('capture'.freeze, Capture)

lib/liquid/tags/case.rb

@@ -15,7 +15,7 @@ module Liquid
     end
 
     def parse(tokens)
-      body = BlockBody.new
+      @initial_body = body = BlockBody.new
       while more = parse_body(body, tokens)
         body = @blocks.last.attachment
       end
@@ -53,6 +53,21 @@ module Liquid
       end
     end
 
+    def format
+      out = "{% case #{Expression.format(@left)} %}#{@initial_body.format}"
+
+      @blocks.each do |block|
+        if block.else?
+          out << "{% else %}"
+        else
+          out << "{% when #{Expression.format(block.right)} %}"
+        end
+        out << block.attachment.format
+      end
+
+      out + "{% endcase %}"
+    end
+
     private
 
     def record_when_condition(markup)

lib/liquid/tags/cycle.rb

@@ -21,6 +21,7 @@ module Liquid
       when NamedSyntax
         @variables = variables_from_string($2)
         @name = Expression.parse($1)
+        @named = true
       when SimpleSyntax
         @variables = variables_from_string(markup)
         @name = @variables.to_s
@@ -43,6 +44,15 @@ module Liquid
       end
     end
 
+    def format
+      formatted_vars = @variables.map { |v| Expression.format(v) }.join(', ')
+      if @named
+        "{% cycle #{Expression.format(@name)}: #{formatted_vars} %}"
+      else
+        "{% cycle #{formatted_vars} %}"
+      end
+    end
+
     private
 
     def variables_from_string(markup)

lib/liquid/tags/for.rb

@@ -129,6 +129,16 @@ module Liquid
       result
     end
 
+    def format
+      out = "{% for #{@variable_name} in #{Expression.format(@collection_name)} %}"
+      out << @for_block.format
+      if @else_block
+        out << "{% else %}"
+        out << @else_block.format
+      end
+      out + "{% endfor %}"
+    end
+
     protected
 
     def lax_parse(markup)

lib/liquid/tags/if.rb

@@ -48,6 +48,25 @@ module Liquid
       end
     end
 
+    def format
+      out = ""
+      first_condition = true
+
+      @blocks.each do |block|
+        if block.else?
+          out << "{% else %}"
+        elsif first_condition
+          out << "{% #{block_name} #{block.format} %}"
+          first_condition = false
+        else
+          out << "{% elsif #{block.format} %}"
+        end
+        out << block.attachment.format
+      end
+
+      out + "{% #{block_delimiter} %}"
+    end
+
     private
 
       def push_block(tag, markup)

lib/liquid/tags/include.rb

@@ -25,6 +25,7 @@ module Liquid
         template_name = $1
         variable_name = $3
 
+        @has_with_clause = !variable_name.nil?
         @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
         @template_name_expr = Expression.parse(template_name)
         @attributes = {}
@@ -70,6 +71,21 @@ module Liquid
       end
     end
 
+    def format
+      segments = [@tag_name, Expression.format(@template_name)]
+
+      if @has_with_clause
+        segments << "with"
+        segments << Expression.format(@variable_name)
+      end
+
+      unless @attributes.empty?
+        segments << @attributes.map { |k, v| "#{k}: #{Expression.format(v)}" }.join(", ")
+      end
+
+      "{% #{segments.join(' ')} %}"
+    end
+
     private
       def load_cached_partial(context)
         cached_partials = context.registers[:cached_partials] || {}

lib/liquid/tags/raw.rb

@@ -24,6 +24,10 @@ module Liquid
     def blank?
       @body.empty?
     end
+
+    def format
+      "{% #{block_name} %}#{@body}{% #{block_delimiter} %}"
+    end
   end
 
   Template.register_tag('raw'.freeze, Raw)

lib/liquid/tags/table_row.rb

@@ -66,6 +66,12 @@ module Liquid
       result << "</tr>\n"
       result
     end
+
+    def format
+      tag_main = "#{block_name} #{@variable_name} in #{Expression.format(@collection_name)}"
+      args = @attributes.map { |k, v| "#{k}: #{Expression.format(v)}" }.join(", ")
+      "{% #{tag_main} #{args} %}#{@body.format}{% #{block_delimiter} %}"
+    end
   end
 
   Template.register_tag('tablerow'.freeze, TableRow)

lib/liquid/variable.rb

@@ -28,6 +28,28 @@ module Liquid
       @markup
     end
 
+    def format
+      out = Expression.format(@name)
+
+      @filters.each do |filter|
+        out << " | "
+        out << filter[0]
+
+        args = filter[1].map { |arg| Expression.format(arg) }
+
+        if filter.size > 2
+          args += filter[2].map { |key, arg| "#{key}: #{Expression.format(arg)}" }
+        end
+
+        unless args.empty?
+          out << ": "
+          out << args.join(', ')
+        end
+      end
+
+      out
+    end
+
     def markup_context(markup)
       "in \"{{#{markup}}}\""
     end

lib/liquid/variable_lookup.rb

@@ -14,6 +14,7 @@ module Liquid
 
       name = lookups.shift
       if name =~ SQUARE_BRACKETED
+        @name_expression = true
         name = Expression.parse($1)
       end
       @name = name
@@ -71,6 +72,20 @@ module Liquid
       self.class == other.class && self.state == other.state
     end
 
+    def format
+      out = @name_expression ? Expression.format(@name) : @name.dup
+
+      @lookups.each do |lookup|
+        if lookup.is_a?(String) && lookup =~ /^#{VariableSegment}+$/
+          out << ".#{lookup}"
+        else
+          out << "[#{Expression.format(lookup)}]"
+        end
+      end
+
+      out
+    end
+
     protected
 
     def state