Refactor ResourceLimits to use a struct

Switch ResourceLimits to a Struct for more compact
data representation and cleaner initialization logic.

.ruby-version

@@ -1 +1 @@
-3.4.1
+3.4.3

lib/liquid/resource_limits.rb

@@ -1,61 +1,53 @@
 # frozen_string_literal: true
 
 module Liquid
-  class ResourceLimits
+  class ResourceLimits < Struct.new(:render_length_limit, :render_score_limit, :assign_score_limit, :render_score, :assign_score, :reached_limit, :last_capture_length, keyword_init: true)
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
-      reset
-    end
-
     def increment_render_score(amount)
-      @render_score += amount
+      self.render_score ||= 0
-      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+      self.render_score += amount
+      raise_limits_reached if render_score_limit && render_score > render_score_limit
     end
 
     def increment_assign_score(amount)
-      @assign_score += amount
+      self.assign_score ||= 0
-      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+      self.assign_score += amount
+      raise_limits_reached if assign_score_limit && assign_score > assign_score_limit
     end
 
     # update either render_length or assign_score based on whether or not the writes are captured
     def increment_write_score(output)
-      if (last_captured = @last_capture_length)
+      if (last_captured = last_capture_length)
         captured = output.bytesize
         increment = captured - last_captured
-        @last_capture_length = captured
+        self.last_capture_length = captured
         increment_assign_score(increment)
-      elsif @render_length_limit && output.bytesize > @render_length_limit
+      elsif render_length_limit && output.bytesize > render_length_limit
         raise_limits_reached
       end
     end
 
     def raise_limits_reached
-      @reached_limit = true
+      self.reached_limit = true
       raise MemoryError, "Memory limits exceeded"
     end
 
     def reached?
-      @reached_limit
+      reached_limit
     end
 
     def reset
-      @reached_limit = false
+      self.reached_limit = false
-      @last_capture_length = nil
+      self.last_capture_length = nil
-      @render_score = @assign_score = 0
+      self.render_score = self.assign_score = 0
     end
 
     def with_capture
-      old_capture_length = @last_capture_length
+      old_capture_length = last_capture_length
       begin
-        @last_capture_length = 0
+        self.last_capture_length = 0
         yield
       ensure
-        @last_capture_length = old_capture_length
+        self.last_capture_length = old_capture_length
       end
     end
   end