From 1ab26199ad6d212bb137980e9740420deed9db80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?David=20S=C3=A1enz?= Date: Sun, 22 Mar 2026 16:10:38 +0100 Subject: [PATCH] Fix backup to respect only/ignore filters via FileTransfer reuse (#37) Backup was copying entire destination directories ignoring the mapping's only/ignore filters, causing permission crashes on restricted files (e.g. .git objects) and wasting disk space. Replaced cp_r_regular_files with FileTransfer reuse by creating a backup mapping that preserves the original filters. Co-Authored-By: Claude Opus 4.6 (1M context) --- lib/dotsync/actions/pull_action.rb | 27 ++--- spec/dotsync/actions/pull_action_spec.rb | 127 +++++++++++++++++++++++ 2 files changed, 135 insertions(+), 19 deletions(-) diff --git a/lib/dotsync/actions/pull_action.rb b/lib/dotsync/actions/pull_action.rb index b2ca92c..6566c21 100644 --- a/lib/dotsync/actions/pull_action.rb +++ b/lib/dotsync/actions/pull_action.rb @@ -62,30 +62,19 @@ def create_backup if File.file?(mapping.src) FileUtils.cp(mapping.dest, backup_path) else - cp_r_regular_files(mapping.dest, backup_path) + backup_mapping = Dotsync::Mapping.new( + "src" => mapping.dest, + "dest" => backup_path, + "only" => mapping.original_only, + "ignore" => mapping.original_ignores, + "force" => false + ) + Dotsync::FileTransfer.new(backup_mapping).transfer end end true end - # Recursively copy a directory, skipping sockets, FIFOs, and device files. - # FileUtils.cp_r fails on macOS when socket paths exceed the 104-byte limit. - def cp_r_regular_files(src, dest) - FileUtils.mkdir_p(dest) - Dir.each_child(src) do |entry| - src_entry = File.join(src, entry) - dest_entry = File.join(dest, entry) - if File.symlink?(src_entry) - FileUtils.rm_f(dest_entry) - FileUtils.ln_s(File.readlink(src_entry), dest_entry) - elsif File.directory?(src_entry) - cp_r_regular_files(src_entry, dest_entry) - elsif File.file?(src_entry) - FileUtils.cp(src_entry, dest_entry, preserve: true) - end - end - end - def purge_old_backups backups = Dir[File.join(backups_root, "*")].sort.reverse if backups.size > 10 diff --git a/spec/dotsync/actions/pull_action_spec.rb b/spec/dotsync/actions/pull_action_spec.rb index 0c01e53..015f13c 100644 --- a/spec/dotsync/actions/pull_action_spec.rb +++ b/spec/dotsync/actions/pull_action_spec.rb @@ -67,6 +67,7 @@ let(:color_diff_updated) { Dotsync::Colors.diff_modifications } before do + allow(Dotsync::FileTransfer).to receive(:new).and_call_original allow(Dotsync::FileTransfer).to receive(:new).with(mappings[0]).and_return(file_transfer1) allow(Dotsync::FileTransfer).to receive(:new).with(mappings[1]).and_return(file_transfer2) allow(file_transfer1).to receive(:transfer) @@ -372,6 +373,132 @@ end end end + + context "with only filter" do + let(:filtered_src) { File.join(src, "filtered_src") } + let(:filtered_dest) { File.join(dest, "filtered_dest") } + let(:mapping1) do + Dotsync::Mapping.new( + "src" => filtered_src, + "dest" => filtered_dest, + "only" => ["settings.json", "commands"], + "force" => true + ) + end + let(:mappings) { [mapping1] } + + before do + require "timecop" + Timecop.freeze(2025, 2, 1) + FileUtils.mkdir_p(filtered_src) + FileUtils.mkdir_p(filtered_dest) + FileUtils.mkdir_p(backups_root) + + # Create files matching the only filter + File.write(File.join(filtered_src, "settings.json"), "src settings") + File.write(File.join(filtered_dest, "settings.json"), "dest settings") + FileUtils.mkdir_p(File.join(filtered_src, "commands")) + FileUtils.mkdir_p(File.join(filtered_dest, "commands")) + File.write(File.join(filtered_src, "commands", "cmd1"), "src cmd1") + File.write(File.join(filtered_dest, "commands", "cmd1"), "dest cmd1") + + # Create files NOT matching the only filter (should be excluded from backup) + FileUtils.mkdir_p(File.join(filtered_dest, "plugins", "marketplace", ".git", "objects")) + File.write(File.join(filtered_dest, "plugins", "marketplace", ".git", "objects", "abc123"), "git object") + File.write(File.join(filtered_dest, "workspace.json"), "workspace data") + end + + it "only backs up files matching the only filter" do + subject + + timestamp = Time.now.strftime("%Y%m%d%H%M%S") + backup_dir = File.join(backups_root, timestamp) + expect(Dir.exist?(backup_dir)).to eq(true) + expect(File.read(File.join(backup_dir, "filtered_dest", "settings.json"))).to eq("dest settings") + expect(File.read(File.join(backup_dir, "filtered_dest", "commands", "cmd1"))).to eq("dest cmd1") + expect(File.exist?(File.join(backup_dir, "filtered_dest", "plugins"))).to eq(false) + expect(File.exist?(File.join(backup_dir, "filtered_dest", "workspace.json"))).to eq(false) + end + end + + context "with ignore filter" do + let(:ignored_src) { File.join(src, "ignored_src") } + let(:ignored_dest) { File.join(dest, "ignored_dest") } + let(:mapping1) do + Dotsync::Mapping.new( + "src" => ignored_src, + "dest" => ignored_dest, + "ignore" => ["lazy-lock.json"], + "force" => true + ) + end + let(:mappings) { [mapping1] } + + before do + require "timecop" + Timecop.freeze(2025, 2, 1) + FileUtils.mkdir_p(ignored_src) + FileUtils.mkdir_p(ignored_dest) + FileUtils.mkdir_p(backups_root) + + File.write(File.join(ignored_src, "init.lua"), "src init") + File.write(File.join(ignored_dest, "init.lua"), "dest init") + File.write(File.join(ignored_dest, "lazy-lock.json"), "lock data") + end + + it "excludes ignored files from backup" do + subject + + timestamp = Time.now.strftime("%Y%m%d%H%M%S") + backup_dir = File.join(backups_root, timestamp) + expect(Dir.exist?(backup_dir)).to eq(true) + expect(File.read(File.join(backup_dir, "ignored_dest", "init.lua"))).to eq("dest init") + expect(File.exist?(File.join(backup_dir, "ignored_dest", "lazy-lock.json"))).to eq(false) + end + end + + context "with only filter and permission-restricted files outside filter" do + let(:restricted_src) { File.join(src, "restricted_src") } + let(:restricted_dest) { File.join(dest, "restricted_dest") } + let(:mapping1) do + Dotsync::Mapping.new( + "src" => restricted_src, + "dest" => restricted_dest, + "only" => ["settings.json"] + ) + end + let(:mappings) { [mapping1] } + let(:restricted_file) { File.join(restricted_dest, "plugins", ".git", "objects", "abc123") } + + before do + require "timecop" + Timecop.freeze(2025, 2, 1) + FileUtils.mkdir_p(restricted_src) + FileUtils.mkdir_p(restricted_dest) + FileUtils.mkdir_p(backups_root) + + File.write(File.join(restricted_src, "settings.json"), "src settings") + File.write(File.join(restricted_dest, "settings.json"), "dest settings") + + # Create permission-restricted file outside the only filter + FileUtils.mkdir_p(File.dirname(restricted_file)) + File.write(restricted_file, "restricted content") + File.chmod(0o000, restricted_file) + end + + after do + File.chmod(0o644, restricted_file) if File.exist?(restricted_file) + end + + it "does not crash and only backs up filtered files" do + expect { subject }.not_to raise_error + + timestamp = Time.now.strftime("%Y%m%d%H%M%S") + backup_dir = File.join(backups_root, timestamp) + expect(File.read(File.join(backup_dir, "restricted_dest", "settings.json"))).to eq("dest settings") + expect(File.exist?(File.join(backup_dir, "restricted_dest", "plugins"))).to eq(false) + end + end end context "orphan cleanup" do