Add specs for current_value= setter with all edge cases

Author: schbol

lib/bindable/binding.rb

@@ -49,5 +49,42 @@ def evaluate(obj)
         end
       end
     end
+
+    # Set the current value by traversing the path and updating the final location
+    def current_value=(new_value)
+      old_root = @watch_obj.root_value
+
+      # Navigate to the parent and set the value at the final step
+      parent = @watch_obj.instance_variable_get(:@values)
+      path_steps = @path.dup
+
+      # If path is empty, can't set at root
+      return new_value if path_steps.empty?
+
+      # Navigate to the parent of the final step
+      while path_steps.length > 1
+        step = path_steps.shift
+        case step[:type]
+        when :property
+          parent = parent[step[:key]]
+        when :index
+          parent = parent[step[:index]]
+        end
+      end
+
+      # Apply the final step to set the value
+      final_step = path_steps.first
+      case final_step[:type]
+      when :property
+        # For hash/object properties, use []= directly
+        parent[final_step[:key]] = new_value
+      when :index
+        # For array indices, use []=
+        parent[final_step[:index]] = new_value
+      end
+
+      @watch_obj.notify_change(old_root)
+      new_value
+    end
   end
 end

lib/bindable/value.rb

@@ -20,39 +20,7 @@ def current_value
 
     # Set the current value by traversing the path and updating the final location
     def current_value=(new_value)
-      old_root = @watch_obj.root_value
-
-      # Navigate to the parent and set the value at the final step
-      parent = @watch_obj.instance_variable_get(:@values)
-      path_steps = @path.dup
-
-      # If path is empty, can't set at root
-      return new_value if path_steps.empty?
-
-      # Navigate to the parent of the final step
-      while path_steps.length > 1
-        step = path_steps.shift
-        case step[:type]
-        when :property
-          parent = parent[step[:key]]
-        when :index
-          parent = parent[step[:index]]
-        end
-      end
-
-      # Apply the final step to set the value
-      final_step = path_steps.first
-      case final_step[:type]
-      when :property
-        # For hash/object properties, use []= directly
-        parent[final_step[:key]] = new_value
-      when :index
-        # For array indices, use []=
-        parent[final_step[:index]] = new_value
-      end
-
-      @watch_obj.notify_change(old_root)
-      new_value
+      bind.current_value = new_value
     end
 
     # Delegate all methods to the underlying value, but handle mutations

spec/support/shared_examples.rb

@@ -198,6 +198,167 @@
     end
   end
 
+  describe 'current_value= setter' do
+    it 'sets value on simple property and triggers watchers' do
+      watch.count = 5
+      binding = watch.count.bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 10
+      expect(values).to eq([[5, 10]])
+      expect(watch.count).to eq(10)
+    end
+
+    it 'sets value on hash key and triggers watchers' do
+      watch.data = { name: 'Alice', age: 30 }
+      binding = watch.data[:age].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 31
+      expect(values).to eq([[30, 31]])
+      expect(watch.data[:age]).to eq(31)
+    end
+
+    it 'sets value on array index and triggers watchers' do
+      watch.list = [1, 2, 3]
+      binding = watch.list[1].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 99
+      expect(values).to eq([[2, 99]])
+      expect(watch.list).to eq([1, 99, 3])
+    end
+
+    it 'sets value on deeply nested hash path' do
+      watch.data = { users: [{ name: 'Alice', age: 30 }] }
+      binding = watch.data[:users][0][:age].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 35
+      expect(values).to eq([[30, 35]])
+      expect(watch.data[:users][0][:age]).to eq(35)
+    end
+
+    it 'sets value on deeply nested array path' do
+      watch.matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+      binding = watch.matrix[1][2].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 99
+      expect(values).to eq([[6, 99]])
+      expect(watch.matrix[1][2]).to eq(99)
+    end
+
+    it 'sets value on mixed hash/array path' do
+      watch.data = { items: [{ id: 1, count: 5 }, { id: 2, count: 10 }] }
+      binding = watch.data[:items][1][:count].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 20
+      expect(values).to eq([[10, 20]])
+      expect(watch.data[:items][1][:count]).to eq(20)
+    end
+
+    it 'triggers multiple watchers when setting value' do
+      watch.value = 1
+      binding = watch.value.bind
+
+      values1 = []
+      values2 = []
+      binding.watch { |old, new| values1 << [old, new] }
+      binding.watch { |old, new| values2 << [old, new] }
+
+      binding.current_value = 5
+      expect(values1).to eq([[1, 5]])
+      expect(values2).to eq([[1, 5]])
+    end
+
+    it 'does not trigger when setting to same value' do
+      watch.value = 42
+      binding = watch.value.bind
+
+      triggered = false
+      binding.watch { |_old, _new| triggered = true }
+
+      binding.current_value = 42
+      expect(triggered).to be false
+    end
+
+    it 'handles setting nil value' do
+      watch.value = 'something'
+      binding = watch.value.bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = nil
+      expect(values).to eq([['something', nil]])
+      expect(watch.value).to be_nil
+    end
+
+    it 'handles setting value from nil' do
+      watch.value = nil
+      binding = watch.value.bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 'something'
+      expect(values).to eq([[nil, 'something']])
+      expect(watch.value).to eq('something')
+    end
+
+    it 'sets complex objects as values' do
+      watch.data = { config: { timeout: 30 } }
+      binding = watch.data[:config].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      new_config = { timeout: 60, retries: 3 }
+      binding.current_value = new_config
+      expect(values).to eq([[{ timeout: 30 }, new_config]])
+      expect(watch.data[:config]).to eq(new_config)
+    end
+
+    it 'works with array element after mutations' do
+      watch.items = [10, 20, 30]
+      binding = watch.items[0].bind
+
+      values = []
+      binding.watch { |old, new| values << [old, new] }
+
+      binding.current_value = 100
+      expect(values).to eq([[10, 100]])
+      expect(watch.items).to eq([100, 20, 30])
+
+      watch.items.push(40)
+      binding.current_value = 200
+      expect(values).to eq([[10, 100], [100, 200]])
+      expect(watch.items).to eq([200, 20, 30, 40])
+    end
+
+    it 'returns the new value when setting' do
+      watch.value = 1
+      binding = watch.value.bind
+
+      result = binding.current_value = 42
+      expect(result).to eq(42)
+    end
+  end
+
   describe 'integration with Ruby collections' do
     it 'works as array index' do
       watch.index = 2