Add to_hash for ResourceLimits for serialization

lib/liquid/block.rb

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

lib/liquid/block_body.rb

@@ -99,18 +99,6 @@ 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,12 +33,6 @@ 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)
@@ -76,20 +70,6 @@ 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,8 +8,6 @@ module Liquid
       'empty'.freeze => :empty?
     }
 
-    INVERTED_LITERALS = LITERALS.invert
-
     def self.parse(markup)
       if LITERALS.key?(markup)
         LITERALS[markup]
@@ -31,18 +29,5 @@ 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,9 +18,5 @@ 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/resource_limits.rb

@@ -19,5 +19,11 @@ module Liquid
     def reset
       @render_length = @render_score = @assign_score = 0
     end
+
+    def to_hash
+      instance_variables.each_with_object({}) do |key, hash|
+        hash[key.to_s[1..-1].to_sym] = instance_variable_get(key)
+      end
+    end
   end
 end

lib/liquid/tag.rb

@@ -24,10 +24,7 @@ module Liquid
     end
 
     def raw
-      tag = @tag_name.strip
+      "#{@tag_name} #{@markup}"
-      markup = @markup.strip
-      tag << " #{markup}" unless markup.empty?
-      tag
     end
 
     def name
@@ -41,9 +38,5 @@ module Liquid
     def blank?
       false
     end
-
-    def format
-      "{% #{raw} %}"
-    end
   end
 end

lib/liquid/tags/assign.rb

@@ -35,10 +35,6 @@ 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,10 +32,6 @@ 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)
-      @initial_body = body = BlockBody.new
+      body = BlockBody.new
       while more = parse_body(body, tokens)
         body = @blocks.last.attachment
       end
@@ -53,21 +53,6 @@ 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,7 +21,6 @@ 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
@@ -44,15 +43,6 @@ 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,21 +129,6 @@ module Liquid
       result
     end
 
-    def format
-      args = [Expression.format(@collection_name)]
-      args << "reversed" if @reversed
-      args << "limit: #{Expression.format(@limit)}" if @limit
-      args << "offset: " << (@from == :continue ? 'continue' : Expression.format(@from)) if @from
-
-      out = "{% for #{@variable_name} in #{args.join(' ')} %}"
-      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,25 +48,6 @@ 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

@@ -70,21 +70,6 @@ module Liquid
       end
     end
 
-    def format
-      segments = [@tag_name, Expression.format(@template_name_expr)]
-
-      if @variable_name_expr
-        segments << "with"
-        segments << Expression.format(@variable_name_expr)
-      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,10 +24,6 @@ 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,12 +66,6 @@ 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,28 +28,6 @@ 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,7 +14,6 @@ module Liquid
 
       name = lookups.shift
       if name =~ SQUARE_BRACKETED
-        @name_expression = true
         name = Expression.parse($1)
       end
       @name = name
@@ -72,20 +71,6 @@ 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

test/integration/formatter_test.rb

@@ -1,172 +0,0 @@
-require 'test_helper'
-
-class FormatterTest < Minitest::Test
-  def assert_format(expected, src)
-    with_error_mode(:lax) do
-      src_ast = Liquid::Template.parse(src).root
-      assert_equal expected, src_ast.format
-
-      fmt_ast = Liquid::Template.parse(src_ast.format).root
-      assert_equal expected, fmt_ast.format
-    end
-  end
-
-  def test_filters
-    assert_format '{{ a | b: foo, c: "foo" }}', '{{a|b:foo,c:"foo"}}'
-    assert_format '{{ page.attribs.title | downcase }}', "{{page.attribs['title' ]|   downcase}}"
-    assert_format '{{ page.attribs["t.i.t.l.e"] | downcase }}', "{{page.attribs['t.i.t.l.e']  | downcase }}"
-    assert_format '{{ page.attribs["t&tle"] | downcase }}', "{{page.attribs['t&tle']  | downcase }}"
-  end
-
-  def test_conditionals
-    src = <<-eof
-      {% if true && !!%}
-        cats
-      {% elsif a  or  (b and  c) && d%}
-        dogs
-      {% endif %}
-
-      {%unless  something%}
-        cats
-      {% endunless%}
-    eof
-
-    expected = <<-eof
-      {% if true %}
-        cats
-      {% elsif a or b and c %}
-        dogs
-      {% endif %}
-
-      {% unless something %}
-        cats
-      {% endunless %}
-    eof
-
-    assert_format expected, src
-
-    src = <<-eof
-      {%case  var asdf $$^$ %}
-      {% when true%}
-        w
-      {% else%}
-        e
-      {%endcase  %}
-    eof
-
-    expected = <<-eof
-      {% case var %}
-      {% when true %}
-        w
-      {% else %}
-        e
-      {% endcase %}
-    eof
-
-    assert_format expected, src
-  end
-
-  def test_comments
-    assert_format "{% comment %} hunter2 {% endcomment %}", "{%comment   %} hunter2 {%   endcomment ^ %}"
-  end
-
-  def test_assigns
-    assert_format '{% assign foo = "monkey" %}', "{%assign foo  ='monkey' ^ %}"
-  end
-
-  def test_looping
-    src = <<-eof
-      {% for i in (1..10) %}
-        cat
-        {%ifchanged%}{{i}}{% endifchanged  %}
-        {%  continue%}
-      {% else %}
-        dog
-        {%break  %}
-      {% endfor %}
-    eof
-
-    expected = <<-eof
-      {% for i in (1..10) %}
-        cat
-        {% ifchanged %}{{ i }}{% endifchanged %}
-        {% continue %}
-      {% else %}
-        dog
-        {% break %}
-      {% endfor %}
-    eof
-
-    assert_format expected, src
-
-    src = "{% tablerow n in numbers cols:3  offset : 1 limit:6%} {{n}} {% endtablerow %}"
-    expected = "{% tablerow n in numbers cols: 3, offset: 1, limit: 6 %} {{ n }} {% endtablerow %}"
-    assert_format expected, src
-  end
-
-  def test_capture
-    assert_format "{% capture foo %} foo {% endcapture %}", "{%capture  foo  %} foo {%endcapture%}"
-  end
-
-  def test_cycle
-    assert_format '{% cycle "red", 2.8, "green", 1 %}', "{% cycle 'red',2.8,'green',1 %}"
-  end
-
-  def test_augment
-    assert_format "{% decrement foo %}{% increment foo %}", "{%  decrement  foo%}{%increment  foo   %}"
-  end
-
-  def test_raw
-    assert_format "{% raw %} foo {% endraw %}", "{%raw !!%} foo {%endraw foo%}"
-  end
-
-  def test_include
-    src = <<-eof
-      {% include 'foo' %}
-      {% include 'foo' !!! why! %}
-      {% include 'foo' with bar %}
-      {% include 'foo' with bar baz: z  qux:f %}
-      {% include 'foo' baz: z  qux:f %}
-    eof
-
-    expected = <<-eof
-      {% include "foo" %}
-      {% include "foo" %}
-      {% include "foo" with bar %}
-      {% include "foo" with bar baz: z, qux: f %}
-      {% include "foo" baz: z, qux: f %}
-    eof
-
-    assert_format expected, src
-  end
-
-  def test_quirks
-    src = <<-eof
-      {% if a == 'foo' or (b == 'bar' and c == 'baz') or false %} YES {% endif %}
-      {% if true && false %} YES {% endif %}
-      {% if false || true %} YES {% endif %}
-      {{ 'hi there' | split$$$:' ' | first }}""
-      {{ 'X' | downcase) }}
-      {{ 'hi there' | split:"t"" | reverse | first}}
-      {{ 'hi there' | split:"t"" | remove:"i" | first}}
-      {% for i in (1...5) %}{{ i }}{% endfor %}
-      {{test |a|b|}}
-      {{|test|}}
-    eof
-
-    expected = <<-eof
-      {% if a == "foo" or b == "bar" and c == "baz" or false %} YES {% endif %}
-      {% if true %} YES {% endif %}
-      {% if false %} YES {% endif %}
-      {{ "hi there" | split: " " | first }}""
-      {{ "X" | downcase }}
-      {{ "hi there" | split: "t" | reverse | first }}
-      {{ "hi there" | split: "t" | first }}
-      {% for i in (1..5) %}{{ i }}{% endfor %}
-      {{ test | a | b }}
-      {{ test }}
-    eof
-
-    assert_format expected, src
-  end
-end

test/integration/tags/table_row_test.rb

@@ -57,7 +57,7 @@ class TableRowTest < Minitest::Test
 
   def test_offset_and_limit
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:3, offset:1, limit:6%} {{n}} {% endtablerow %}',
+                           '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
                            'numbers' => [0,1,2,3,4,5,6,7])
   end
 end

test/integration/template_test.rb

@@ -181,6 +181,16 @@ class TemplateTest < Minitest::Test
     assert context.resource_limits.render_length > 0
   end
 
+  def test_resource_limits_serialization
+    t = Template.parse("{% if true %}aaaa{% endif %}")
+    t.resource_limits.render_score_limit = 50
+    t.resource_limits.render_length_limit = 50
+    t.resource_limits.assign_score_limit = 50
+
+    expected = {render_score: 0, render_length: 0, assign_score: 0, render_score_limit: 50, render_length_limit: 50, assign_score_limit: 50}
+    assert_equal expected, t.resource_limits.to_hash
+  end
+
   def test_can_use_drop_as_context
     t = Template.new
     t.registers['lulz'] = 'haha'