Fix lock file updates when restoring dependencies (#49)

* Fix lock file updates when restoring dependencies

When swap-deps restores original dependencies, the lock files
(Gemfile.lock and package-lock.json) were not properly updated
to reflect the restored versions. This caused them to retain
references to local paths even after restore.

Changes:
- For Bundler: Use `bundle update` for specific gems during restore
  to force re-resolution from rubygems
- For npm: Remove package-lock.json before install to force
  re-resolution from npm registry

This ensures lock files are properly updated when restoring from
local/path dependencies back to registry versions.

Author: justin808

lib/demo_scripts/gem_swapper.rb

@@ -713,6 +713,7 @@ def swap_package_json(package_json_path)
     end
     # rubocop:enable Metrics/AbcSize
 
+    # rubocop:disable Metrics/MethodLength
     def restore_demo(demo_path)
       restored = 0
       gemfile_path = File.join(demo_path, 'Gemfile')
@@ -733,12 +734,17 @@ def restore_demo(demo_path)
       end
 
       if restored.positive?
-        run_bundle_install(demo_path) if File.exist?(gemfile_path)
-        run_npm_install(demo_path) if File.exist?(package_json_path)
+        bundle_success = File.exist?(gemfile_path) ? run_bundle_install(demo_path, for_restore: true) : true
+        npm_success = File.exist?(package_json_path) ? run_npm_install(demo_path, for_restore: true) : true
+
+        unless bundle_success && npm_success
+          warn '  ⚠️  Warning: Some dependency installations failed. Check the errors above.'
+        end
       end
 
       restored
     end
+    # rubocop:enable Metrics/MethodLength
 
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def backup_file(file_path)
@@ -808,27 +814,100 @@ def write_file(file_path, content)
       end
     end
 
-    def run_bundle_install(demo_path)
+    def find_supported_gems_in_gemfile(demo_path)
+      gemfile_content = File.read(File.join(demo_path, 'Gemfile'))
+      SUPPORTED_GEMS.select do |gem_name|
+        # Match: gem 'name' or gem "name" at line start (avoiding false matches in comments)
+        # Note: Regex compilation per gem is negligible for our 3 supported gems
+        gemfile_content.match?(/^\s*gem\s+["']#{Regexp.escape(gem_name)}["']/)
+      end
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def run_bundle_install(demo_path, for_restore: false)
       return if dry_run
 
-      puts '  Running bundle install...'
-      success = Dir.chdir(demo_path) do
-        system('bundle', 'install', '--quiet')
+      if for_restore
+        # For restore, we need to update the gems to fetch from rubygems
+        # This ensures Gemfile.lock is properly updated
+        puts '  Running bundle update (to restore gem sources)...'
+
+        gems_to_update = find_supported_gems_in_gemfile(demo_path)
+
+        if gems_to_update.empty?
+          # No supported gems found in Gemfile - this might indicate they were never swapped
+          # or the Gemfile structure is unexpected
+          puts '  ⚠️  No swapped gems detected in Gemfile. Running standard bundle install...'
+          success = Dir.chdir(demo_path) do
+            system('bundle', 'install', '--quiet')
+          end
+        else
+          puts "  Updating gems: #{gems_to_update.join(', ')}" if verbose
+          success = Dir.chdir(demo_path) do
+            # Update specific gems to pull from rubygems
+            result = system('bundle', 'update', *gems_to_update, '--quiet')
+            warn '  ⚠️  ERROR: Failed to update gems. Lock file may be inconsistent.' unless result
+            result
+          end
+        end
+      else
+        puts '  Running bundle install...'
+        success = Dir.chdir(demo_path) do
+          system('bundle', 'install', '--quiet')
+        end
       end
 
-      warn '  ⚠️  Warning: bundle install failed' unless success
+      warn '  ⚠️  ERROR: bundle command failed' unless success
+      success
     end
+    # rubocop:enable Metrics/MethodLength
 
-    def run_npm_install(demo_path)
+    # rubocop:disable Metrics/MethodLength
+    def run_npm_install(demo_path, for_restore: false)
       return if dry_run
 
-      puts '  Running npm install...'
-      success = Dir.chdir(demo_path) do
-        system('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null')
+      if for_restore
+        # For restore, we need to regenerate package-lock.json from package.json
+        # to fetch from npm registry instead of local file: paths
+        puts '  Running npm install (regenerating lock file)...'
+
+        package_lock_path = File.join(demo_path, 'package-lock.json')
+        package_lock_backup = "#{package_lock_path}.backup"
+
+        # Atomically move package-lock.json to backup to avoid race conditions
+        begin
+          File.rename(package_lock_path, package_lock_backup)
+          puts '  Moved package-lock.json to backup for regeneration' if verbose
+        rescue Errno::ENOENT
+          # File doesn't exist, which is fine - nothing to backup
+          puts '  No package-lock.json found to backup' if verbose
+        end
+
+        success = Dir.chdir(demo_path) do
+          # Use npm install to regenerate package-lock.json from package.json
+          # Don't use npm ci since we just deleted package-lock.json
+          system('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null')
+        end
+
+        if success
+          # Remove backup on success
+          FileUtils.rm_f(package_lock_backup)
+        elsif File.exist?(package_lock_backup)
+          # Restore backup on failure
+          FileUtils.mv(package_lock_backup, package_lock_path)
+          warn '  ⚠️  ERROR: npm install failed. Restored original package-lock.json'
+        end
+      else
+        puts '  Running npm install...'
+        success = Dir.chdir(demo_path) do
+          system('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null')
+        end
       end
 
-      warn '  ⚠️  Warning: npm install failed' unless success
+      warn '  ⚠️  ERROR: npm install failed' unless success
+      success
     end
+    # rubocop:enable Metrics/MethodLength
 
     def build_local_packages!
       return if dry_run

spec/demo_scripts/gem_swapper_spec.rb

@@ -721,4 +721,120 @@
       end.to output(//).to_stdout
     end
   end
+
+  describe '#run_bundle_install with restore' do
+    let(:demo_path) { '/path/to/demo' }
+    let(:gemfile_path) { File.join(demo_path, 'Gemfile') }
+
+    before do
+      allow(swapper).to receive(:dry_run).and_return(false)
+    end
+
+    context 'when for_restore is true' do
+      it 'runs bundle update for supported gems' do
+        gemfile_content = <<~GEMFILE
+          gem 'rails'
+          gem 'shakapacker', '~> 9.0'
+          gem 'react_on_rails'
+        GEMFILE
+
+        allow(File).to receive(:read).with(gemfile_path).and_return(gemfile_content)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system)
+          .with('bundle', 'update', 'shakapacker', 'react_on_rails', '--quiet').and_return(true)
+
+        result = swapper.send(:run_bundle_install, demo_path, for_restore: true)
+        expect(result).to be true
+      end
+
+      it 'falls back to bundle install when no supported gems found' do
+        gemfile_content = "gem 'rails'\ngem 'pg'"
+
+        allow(File).to receive(:read).with(gemfile_path).and_return(gemfile_content)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system).with('bundle', 'install', '--quiet').and_return(true)
+
+        swapper.send(:run_bundle_install, demo_path, for_restore: true)
+      end
+
+      it 'returns false and warns on failure' do
+        gemfile_content = "gem 'shakapacker'"
+
+        allow(File).to receive(:read).with(gemfile_path).and_return(gemfile_content)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system).with('bundle', 'update', 'shakapacker', '--quiet').and_return(false)
+        expect(swapper).to receive(:warn).with(/ERROR: Failed to update gems/)
+        expect(swapper).to receive(:warn).with(/ERROR: bundle command failed/)
+
+        result = swapper.send(:run_bundle_install, demo_path, for_restore: true)
+        expect(result).to be false
+      end
+    end
+
+    context 'when for_restore is false' do
+      it 'runs regular bundle install' do
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system).with('bundle', 'install', '--quiet').and_return(true)
+
+        swapper.send(:run_bundle_install, demo_path, for_restore: false)
+      end
+    end
+  end
+
+  describe '#run_npm_install with restore' do
+    let(:demo_path) { '/path/to/demo' }
+    let(:package_lock_path) { File.join(demo_path, 'package-lock.json') }
+    let(:package_lock_backup) { "#{package_lock_path}.backup" }
+
+    before do
+      allow(swapper).to receive(:dry_run).and_return(false)
+    end
+
+    context 'when for_restore is true' do
+      it 'backs up and removes package-lock.json before install' do
+        expect(File).to receive(:rename).with(package_lock_path, package_lock_backup)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system)
+          .with('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null').and_return(true)
+        expect(FileUtils).to receive(:rm_f).with(package_lock_backup)
+
+        swapper.send(:run_npm_install, demo_path, for_restore: true)
+      end
+
+      it 'restores backup on failure' do
+        allow(File).to receive(:exist?).with(package_lock_backup).and_return(true)
+        expect(File).to receive(:rename).with(package_lock_path, package_lock_backup)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system)
+          .with('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null').and_return(false)
+        expect(FileUtils).to receive(:mv).with(package_lock_backup, package_lock_path)
+        expect(swapper).to receive(:warn).with(/ERROR: npm install failed/)
+        expect(swapper).to receive(:warn).with(/ERROR: npm install failed/)
+
+        swapper.send(:run_npm_install, demo_path, for_restore: true)
+      end
+
+      it 'handles missing package-lock.json gracefully' do
+        expect(File).to receive(:rename)
+          .with(package_lock_path, package_lock_backup)
+          .and_raise(Errno::ENOENT)
+        expect(FileUtils).to receive(:rm_f).with(package_lock_backup)
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system)
+          .with('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null').and_return(true)
+
+        swapper.send(:run_npm_install, demo_path, for_restore: true)
+      end
+    end
+
+    context 'when for_restore is false' do
+      it 'runs regular npm install' do
+        expect(Dir).to receive(:chdir).with(demo_path).and_yield
+        expect(swapper).to receive(:system)
+          .with('npm', 'install', '--silent', out: '/dev/null', err: '/dev/null').and_return(true)
+
+        swapper.send(:run_npm_install, demo_path, for_restore: false)
+      end
+    end
+  end
 end