fix: lints

spec/tracker_spec.lua

@@ -58,66 +58,66 @@ describe('Signal', function()
 
   describe('Signal:map', function()
     it('should transform the signal value', function()
-      local signal = Signal:new(5)
-      local mapped_signal = signal:map(function(value) return value * 2 end)
+      local test_signal = Signal:new(5)
+      local mapped_signal = test_signal:map(function(value) return value * 2 end)
 
       assert.is.equal(mapped_signal:get(), 10) -- Initial transformation
-      signal:set(10)
+      test_signal:set(10)
       assert.is.equal(mapped_signal:get(), 20) -- Updated transformation
     end)
 
     it('should handle empty transformations', function()
-      local signal = Signal:new(nil)
-      local mapped_signal = signal:map(function(value) return value or 'default' end)
+      local test_signal = Signal:new(nil)
+      local mapped_signal = test_signal:map(function(value) return value or 'default' end)
 
       assert.is.equal(mapped_signal:get(), 'default') -- Return default
-      signal:set 'new value'
+      test_signal:set 'new value'
       assert.is.equal(mapped_signal:get(), 'new value') -- Return new value
     end)
   end)
 
   describe('Signal:filter', function()
     it('should only emit values that pass the filter', function()
-      local signal = Signal:new(5)
-      local filtered_signal = signal:filter(function(value) return value > 10 end)
+      local test_signal = Signal:new(5)
+      local filtered_signal = test_signal:filter(function(value) return value > 10 end)
 
       assert.is.equal(filtered_signal:get(), nil) -- Initial value should not pass
-      signal:set(15)
+      test_signal:set(15)
       assert.is.equal(filtered_signal:get(), 15) -- Now filtered
-      signal:set(8)
+      test_signal:set(8)
       assert.is.equal(filtered_signal:get(), 15) -- Does not pass the filter
     end)
 
     it('should handle empty initial values', function()
-      local signal = Signal:new(nil)
-      local filtered_signal = signal:filter(function(value) return value ~= nil end)
+      local test_signal = Signal:new(nil)
+      local filtered_signal = test_signal:filter(function(value) return value ~= nil end)
 
       assert.is.equal(filtered_signal:get(), nil) -- Should be nil
-      signal:set(10)
+      test_signal:set(10)
       assert.is.equal(filtered_signal:get(), 10) -- Should pass now
     end)
   end)
 
   describe('create_memo', function()
     it('should compute a derived value and update when dependencies change', function()
-      local signal = Signal:new(2)
-      local memoized_signal = tracker.create_memo(function() return signal:get() * 2 end)
+      local test_signal = Signal:new(2)
+      local memoized_signal = tracker.create_memo(function() return test_signal:get() * 2 end)
 
       assert.is.equal(memoized_signal:get(), 4) -- Initially compute 2 * 2
 
-      signal:set(3)
+      test_signal:set(3)
       assert.is.equal(memoized_signal:get(), 6) -- Update to 3 * 2 = 6
 
-      signal:set(5)
+      test_signal:set(5)
       assert.is.equal(memoized_signal:get(), 10) -- Update to 5 * 2 = 10
     end)
 
     it('should not recompute if the dependencies do not change', function()
       local call_count = 0
-      local signal = Signal:new(10)
+      local test_signal = Signal:new(10)
       local memoized_signal = tracker.create_memo(function()
         call_count = call_count + 1
-        return signal:get() + 1
+        return test_signal:get() + 1
       end)
 
       assert.is.equal(memoized_signal:get(), 11) -- Compute first value
@@ -126,11 +126,11 @@ describe('Signal', function()
       memoized_signal:get() -- Call again, should use memoized value
       assert.is.equal(call_count, 1) -- Still should only be one call
 
-      signal:set(10) -- Set the same value
+      test_signal:set(10) -- Set the same value
       assert.is.equal(memoized_signal:get(), 11)
       assert.is.equal(call_count, 2)
 
-      signal:set(20)
+      test_signal:set(20)
       assert.is.equal(memoized_signal:get(), 21)
       assert.is.equal(call_count, 3)
     end)
@@ -138,31 +138,31 @@ describe('Signal', function()
 
   describe('create_effect', function()
     it('should track changes and execute callback', function()
-      local signal = Signal:new(5)
+      local test_signal = Signal:new(5)
       local call_count = 0
 
       tracker.create_effect(function()
-        signal:get() -- track as a dependency
+        test_signal:get() -- track as a dependency
         call_count = call_count + 1
       end)
 
       assert.is.equal(call_count, 1)
-      signal:set(10)
+      test_signal:set(10)
       assert.is.equal(call_count, 2)
     end)
 
     it('should clean up signals and not call after dispose', function()
-      local signal = Signal:new(5)
+      local test_signal = Signal:new(5)
       local call_count = 0
 
       local unsubscribe = tracker.create_effect(function()
         call_count = call_count + 1
-        return signal:get() * 2
+        return test_signal:get() * 2
       end)
 
       assert.is.equal(call_count, 1) -- Initially calls
       unsubscribe() -- Unsubscribe the effect
-      signal:set(10) -- Update signal value
+      test_signal:set(10) -- Update signal value
       assert.is.equal(call_count, 1) -- Callback should not be called again
     end)
   end)