dotsync 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98beade2b2482ee27ecf6843e8f4f214fd81a0070c06d661213bce4c80e2d57a
-  data.tar.gz: b512b8ad21fe3966b40d0f09fbffe7a67f90a3a2f784b703e3892113bd9992f0
+  metadata.gz: bc1ccae4ba1b2bdaf065236e1485938a8c547ffdee68dd20aadf6d178ccf7cb5
+  data.tar.gz: 0c9fd5df972d3375ffe7ff1ab6a5429cf3f8b8fe76fde9ed6ed29899efdca802
 SHA512:
-  metadata.gz: 7b533ef15747bc2c19f7f6675961b1d025954e691e595a29a863b673d99229a99972215f888554bc7ef2508930e10ab4457420a23f0fe05464f39a07f028cd59
-  data.tar.gz: e39af50f1673a26cc825f64fe6416cc7ec9db39ed5d03bb652e781f7cf93e2db6f46a7d5eb8e7e1aa019ee2b49b7fd551ce53af8514e27637342b97eacf85745
+  metadata.gz: 25921bff0c90dbe95be3c4e05a627de73540619023b805277cdf63be18cf670b96dd0ed239328ecd97449d66616b62aad58404296c2dbe16351e722af7846bd5
+  data.tar.gz: 3ba8b41dacfcd5bd122a862f2887609f39024dc9cada9301dd524227019303ec9c154f3d2377bf53f599a1a57534ba1dac7d5aa377b28233e76180ca74ede399

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.4.6] - 2026-04-07
+
+### Changed
+
+- Maximize cached diff reuse to eliminate redundant directory traversals (#43)
+  - Build source index during first source walk in `DirectoryDiffer`, removing duplicate `build_source_index` traversal
+  - Pass pre-computed removal paths from diff to `FileTransfer`, skipping second destination scan in force mode
+  - Add `removal_rel_paths` field to `Diff` model to carry relative paths for `FileTransfer`
+  - Skip `show_orphan_preview` directory scan in display phase when no differences exist
+
 ## [0.4.5] - 2026-04-07
 
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dotsync (0.4.5)
+    dotsync (0.4.6)
       fileutils (~> 1.7.3)
       find (~> 0.2.0)
       listen (~> 3.9.0)

data/lib/dotsync/actions/concerns/mappings_transfer.rb

@@ -94,7 +94,7 @@ module Dotsync
 
       show_content_diffs if diff_content && has_modifications?
 
-      show_orphan_preview if respond_to?(:manifests_xdg_data_home, true)
+      show_orphan_preview if has_differences? && respond_to?(:manifests_xdg_data_home, true)
     end
 
     def show_content_diffs
@@ -115,13 +115,14 @@ module Dotsync
       mutex = Mutex.new
 
       # Only transfer mappings that have actual differences (uses cached diffs)
-      changed_mappings = valid_mappings.each_with_index.filter_map do |mapping, idx|
-        mapping if differs[idx].any?
+      changed_pairs = valid_mappings.each_with_index.filter_map do |mapping, idx|
+        [mapping, differs[idx]] if differs[idx].any?
       end
 
       # Process mappings in parallel - each mapping is independent
-      Dotsync::Parallel.each(changed_mappings) do |mapping|
-        Dotsync::FileTransfer.new(mapping).transfer
+      Dotsync::Parallel.each(changed_pairs) do |mapping, diff|
+        removals = diff.removal_rel_paths.map { |rel| File.join(mapping.dest, rel) }
+        Dotsync::FileTransfer.new(mapping, removals: removals).transfer
       rescue Dotsync::PermissionError => e
         mutex.synchronize { errors << ["Permission denied: #{e.message}", "Try: chmod +w <path> or check file permissions"] }
       rescue Dotsync::DiskFullError => e

data/lib/dotsync/models/diff.rb

@@ -3,13 +3,14 @@
 module Dotsync
   # Represents the differences between two directories
   class Diff
-    attr_reader :additions, :modifications, :removals, :modification_pairs
+    attr_reader :additions, :modifications, :removals, :modification_pairs, :removal_rel_paths
 
-    def initialize(additions: [], modifications: [], removals: [], modification_pairs: [])
+    def initialize(additions: [], modifications: [], removals: [], modification_pairs: [], removal_rel_paths: [])
       @additions = additions
       @modifications = modifications
       @removals = removals
       @modification_pairs = modification_pairs
+      @removal_rel_paths = removal_rel_paths
     end
 
     def any?

data/lib/dotsync/utils/directory_differ.rb

@@ -11,11 +11,11 @@ module Dotsync
   #
   # This class implements several optimizations to handle large directory trees efficiently:
   #
-  # 1. **Pre-indexed source tree** (see #build_source_index)
-  #    Instead of calling File.exist? for each destination file (disk I/O per file),
-  #    we build a Set of all source paths upfront. Checking Set#include? is O(1) in memory
-  #    vs O(1) disk I/O, which is orders of magnitude faster for large trees.
-  #    Impact: ~100x faster for directories with thousands of files.
+  # 1. **Source index built during first walk** (see #diff_mapping_directories)
+  #    The source tree walk that finds additions/modifications also builds a Set of all
+  #    source paths. In force mode, this Set enables O(1) lookups during the destination
+  #    walk — replacing per-file File.exist? calls (disk I/O) with hash lookups (memory).
+  #    Impact: ~100x faster for directories with thousands of files, single source traversal.
   #
   # 2. **Early directory pruning with Find.prune** (see #diff_mapping_directories)
   #    When an `only` filter is configured, we prune entire directory subtrees that
@@ -58,6 +58,12 @@ module Dotsync
         modification_pairs = []
         removals = []
 
+        # OPTIMIZATION: Build the source index during the first walk.
+        # This Set is used in force mode for O(1) lookups during the destination walk,
+        # replacing per-file File.exist? calls (disk I/O) with hash lookups (memory).
+        # Building it here avoids a second traversal of the source tree.
+        source_index = Set.new
+
         # Walk the source tree to find additions and modifications.
         # Uses bidirectional_include? with Find.prune to skip directories
         # that are outside the `only` filter, avoiding unnecessary traversal.
@@ -72,6 +78,8 @@ module Dotsync
             next
           end
 
+          source_index << src_path
+
           dest_path = File.join(mapping_dest, rel_path)
 
           if !File.exist?(dest_path)
@@ -86,11 +94,6 @@ module Dotsync
 
         # In force mode, also find files in destination that don't exist in source (removals).
         if force?
-          # OPTIMIZATION: Pre-index source tree into a Set for O(1) lookups.
-          # This replaces per-file File.exist? calls (disk I/O) with hash lookups (memory).
-          # For a destination with thousands of files, this is orders of magnitude faster.
-          source_index = build_source_index
-
           Find.find(mapping_dest) do |dest_path|
             rel_path = dest_path.sub(/^#{Regexp.escape(mapping_dest)}\/?/, "")
             next if rel_path.empty?
@@ -118,11 +121,16 @@ module Dotsync
         filtered_modifications = filter_ignores(modifications)
         modification_pairs = modification_pairs.select { |pair| filtered_modifications.include?(pair[:rel_path]) }
 
+        filtered_removals = filter_ignores(removals)
+
         additions = relative_to_absolute(filter_ignores(additions), mapping_original_dest)
         modifications = relative_to_absolute(filtered_modifications, mapping_original_dest)
-        removals = relative_to_absolute(filter_ignores(removals), mapping_original_dest)
+        removals = relative_to_absolute(filtered_removals, mapping_original_dest)
 
-        Dotsync::Diff.new(additions: additions, modifications: modifications, removals: removals, modification_pairs: modification_pairs)
+        Dotsync::Diff.new(
+          additions: additions, modifications: modifications, removals: removals,
+          modification_pairs: modification_pairs, removal_rel_paths: filtered_removals
+        )
       end
 
       def diff_mapping_files
@@ -140,26 +148,6 @@ module Dotsync
         Dotsync::Diff.new(additions: additions, modifications: modifications, modification_pairs: modification_pairs)
       end
 
-      # Builds a Set of all source paths for O(1) existence checks.
-      #
-      # This is used during the destination walk (force mode) to check if a destination
-      # file exists in the source. Using a Set avoids repeated File.exist? calls,
-      # replacing disk I/O with memory lookups.
-      #
-      # @return [Set<String>] Set of absolute source paths
-      def build_source_index
-        index = Set.new
-        Find.find(mapping_src) do |src_path|
-          # Apply the same pruning logic as the main source walk
-          unless @mapping.bidirectional_include?(src_path)
-            Find.prune
-            next
-          end
-          index << src_path
-        end
-        index
-      end
-
       def filter_ignores(all_paths)
         return all_paths unless ignores.any?
         all_paths.reject do |path|

data/lib/dotsync/utils/file_transfer.rb

@@ -5,17 +5,17 @@ module Dotsync
     # Initializes a new FileTransfer instance
     #
     # @param mapping [Dotsync::Mapping] the mapping object containing source, destination, force, and ignore details
-    # @option mapping [String] :src the source directory path
-    # @option mapping [String] :dest the destination directory path
-    # @option mapping [Boolean] :force? optional flag to force actions
-    # @option mapping [Array<String>] :ignores optional list of files/directories to ignore
-    def initialize(mapping)
+    # @param removals [Array<String>, nil] pre-computed absolute paths to remove in force mode.
+    #   When provided (from cached diff), skips the destination tree traversal in cleanup_folder.
+    #   When nil, falls back to scanning the destination tree (used by backup transfers).
+    def initialize(mapping, removals: nil)
       @mapping = mapping
       @src = mapping.src
       @dest = mapping.dest
       @force = mapping.force?
       @inclusions = mapping.inclusions || []
       @ignores = mapping.ignores || []
+      @removals = removals
     end
 
     def transfer
@@ -43,7 +43,13 @@ module Dotsync
         end
         transfer_file(@src, target_dest)
       else
-        cleanup_folder(@dest) if @force
+        if @force
+          if @removals
+            remove_precomputed_files
+          else
+            cleanup_folder(@dest)
+          end
+        end
         transfer_folder(@src, @dest)
       end
     end
@@ -131,6 +137,28 @@ module Dotsync
         end
       end
 
+      # Removes files using pre-computed removal paths from the cached diff,
+      # avoiding a full destination tree traversal. After deleting files, walks
+      # up to clean empty parent directories.
+      def remove_precomputed_files
+        dest_expanded = File.expand_path(@dest)
+
+        @removals.each do |path|
+          next unless File.file?(path)
+
+          FileUtils.rm(path)
+
+          # Clean up empty parent directories up to the destination root
+          dir = File.dirname(path)
+          while dir != dest_expanded && dir.start_with?(dest_expanded)
+            break unless Dir.empty?(dir)
+
+            FileUtils.rmdir(dir)
+            dir = File.dirname(dir)
+          end
+        end
+      end
+
       def cleanup_folder(target_dir)
         target_dir = File.expand_path(target_dir)
 

data/lib/dotsync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dotsync
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotsync
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - David Sáenz