dotsync 0.1.26 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89c25a6529e3557dc1383f3facf677f0775053d7db53863b7cc61a5b44d13b11
-  data.tar.gz: 1cfadbe1c539923fb6bf9c27eafde24beeab527feeaadf2b88d997d762f972b4
+  metadata.gz: 492eda1f730e490322f6ff7fe85fd3fb91a1bd337f191f13d9574d63a5a9a326
+  data.tar.gz: f797e4c6a06258d312c3264be88cda022cb02f8053ed31159de54ce585ef9e3a
 SHA512:
-  metadata.gz: 2b7012240c48cd7b9d84cf8e20d54efa913fd08324720b08d270db0c39e46f87a1f63f124e6d562d06ab2bef7f0fd017bb686e666b40866fc89eceae831de1bf
-  data.tar.gz: 87f03124b8dc8cad8c3588d3391858414ac0a577416c7a227465702a081c8de9fa36648e5eb5c642ba9b6beae81c19043259c25b536a634cd3bfcd3b83a7cfc9
+  metadata.gz: 0d9bd4948c5d7de46e30443ca19ae4fabfc8d0caf3410b2a5e8bb519c8dc27384e032c06db32bd2a9bad041f6642707e8223f4affad58aa540cde4e277663b77
+  data.tar.gz: f20438f023966222c67f1a5397dfa8110d0d1cf4985fe67a82f0f8cbe615a9b25bdb88db176db33f1a0bf5109dccb1c5cce4889d74ab259dbd8bdd6e1716c2cf

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.2.0] - 2025-02-06
+
+**New Features:**
+- Add `--diff-content` CLI option to display git-like unified diff output for modified files
+  - Shows actual content changes without needing external tools like `nvim -d`
+  - Color-coded output: blue for additions, red for deletions, cyan for hunk headers
+  - Automatically skips binary files
+  - Works with both `push` and `pull` commands
+
+**Performance Optimizations:**
+- Add parallel processing for mapping operations
+  - New `Dotsync::Parallel` utility module with thread-pool based execution
+  - Diff computation runs in parallel across multiple mappings
+  - File transfers execute concurrently for independent mappings
+  - Thread-safe error collection and reporting
+- Add directory pruning optimization
+  - New `should_prune_directory?` method for early-exit during traversal
+  - Skips entire directory subtrees that are ignored or outside inclusion lists
+  - Reduces filesystem operations for large excluded directories
+
 ## [0.1.26] - 2025-01-11
 
 **Breaking Changes:**

data/Gemfile.lock

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

data/exe/dotsync

@@ -51,6 +51,7 @@ opt_parser = OptionParser.new do |opts|
       --only-config         Show only the config section
       --only-mappings       Show only the mappings section
       -v, --verbose         Force showing all available information
+      --diff-content        Show git-like content diff for modified files
       --trace               Show full error backtraces (for debugging)
       --version             Show version number
       -h, --help            Show this help message
@@ -112,6 +113,10 @@ opt_parser = OptionParser.new do |opts|
     options[:verbose] = true
   end
 
+  opts.on("--diff-content", "Show git-like content diff for modified files") do
+    options[:diff_content] = true
+  end
+
   opts.on("--trace", "Show full error backtraces (for debugging)") do
     options[:trace] = true
   end

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

@@ -62,7 +62,7 @@ module Dotsync
       logger.log("")
     end
 
-    def show_differences
+    def show_differences(diff_content: false)
       info("Differences:", icon: :diff)
       differs.flat_map(&:additions).sort.each do |path|
         logger.log("#{Icons.diff_created}#{path}", color: Colors.diff_additions)
@@ -75,31 +75,45 @@ module Dotsync
       end
       logger.log("  No differences") unless has_differences?
       logger.log("")
+
+      show_content_diffs if diff_content && has_modifications?
+    end
+
+    def show_content_diffs
+      info("Content Differences:", icon: :diff)
+      modification_pairs.each do |pair|
+        Dotsync::ContentDiff.new(pair[:src], pair[:dest], logger).display
+      end
     end
 
     def transfer_mappings
-      valid_mappings.each do |mapping|
+      errors = []
+      mutex = Mutex.new
+
+      Dotsync::Parallel.each(valid_mappings) do |mapping|
         Dotsync::FileTransfer.new(mapping).transfer
       rescue Dotsync::PermissionError => e
-        logger.error("Permission denied: #{e.message}")
-        logger.info("Try: chmod +w <path> or check file permissions")
+        mutex.synchronize { errors << ["Permission denied: #{e.message}", "Try: chmod +w <path> or check file permissions"] }
       rescue Dotsync::DiskFullError => e
-        logger.error("Disk full: #{e.message}")
-        logger.info("Free up disk space and try again")
+        mutex.synchronize { errors << ["Disk full: #{e.message}", "Free up disk space and try again"] }
       rescue Dotsync::SymlinkError => e
-        logger.error("Symlink error: #{e.message}")
-        logger.info("Check that symlink target exists and is accessible")
+        mutex.synchronize { errors << ["Symlink error: #{e.message}", "Check that symlink target exists and is accessible"] }
       rescue Dotsync::TypeConflictError => e
-        logger.error("Type conflict: #{e.message}")
-        logger.info("Cannot overwrite directory with file or vice versa")
+        mutex.synchronize { errors << ["Type conflict: #{e.message}", "Cannot overwrite directory with file or vice versa"] }
       rescue Dotsync::FileTransferError => e
-        logger.error("File transfer failed: #{e.message}")
+        mutex.synchronize { errors << ["File transfer failed: #{e.message}", nil] }
+      end
+
+      # Report all errors after parallel execution
+      errors.each do |error_msg, info_msg|
+        logger.error(error_msg)
+        logger.info(info_msg) if info_msg
       end
     end
 
     private
       def differs
-        @differs ||= valid_mappings.map do |mapping|
+        @differs ||= Dotsync::Parallel.map(valid_mappings) do |mapping|
           Dotsync::DirectoryDiffer.new(mapping).diff
         end
       end
@@ -108,6 +122,14 @@ module Dotsync
         differs.any? { |differ| differ.any? }
       end
 
+      def has_modifications?
+        differs.any? { |differ| differ.modifications.any? }
+      end
+
+      def modification_pairs
+        differs.flat_map(&:modification_pairs)
+      end
+
       def confirm_action
         total_changes = differs.sum { |diff| diff.additions.size + diff.modifications.size + diff.removals.size }
         logger.log("")

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

@@ -12,7 +12,8 @@ module Dotsync
         mappings_legend: !(quiet || options[:no_legend] || options[:no_mappings] || options[:only_diff]),
         mappings: !(quiet || options[:no_mappings] || options[:only_diff]),
         differences_legend: !(quiet || options[:no_legend] || options[:no_diff_legend] || options[:no_diff] || options[:only_config] || options[:only_mappings]),
-        differences: !(quiet || options[:no_diff] || options[:only_mappings] || options[:only_config])
+        differences: !(quiet || options[:no_diff] || options[:only_mappings] || options[:only_config]),
+        diff_content: options[:diff_content] || false
       }
 
       if verbose

data/lib/dotsync/actions/pull_action.rb

@@ -15,7 +15,7 @@ module Dotsync
       show_mappings_legend if output_sections[:mappings_legend]
       show_mappings if output_sections[:mappings]
       show_differences_legend if has_differences? && output_sections[:differences_legend]
-      show_differences if output_sections[:differences]
+      show_differences(diff_content: output_sections[:diff_content]) if output_sections[:differences]
 
       return unless options[:apply]
 

data/lib/dotsync/actions/push_action.rb

@@ -13,7 +13,7 @@ module Dotsync
       show_mappings_legend if output_sections[:mappings_legend]
       show_mappings if output_sections[:mappings]
       show_differences_legend if has_differences? && output_sections[:differences_legend]
-      show_differences if output_sections[:differences]
+      show_differences(diff_content: output_sections[:diff_content]) if output_sections[:differences]
 
       return unless options[:apply]
 

data/lib/dotsync/loaders/pull_loader.rb

@@ -11,6 +11,8 @@ require "terminal-table"
 require_relative "../utils/file_transfer"
 require_relative "../utils/directory_differ"
 require_relative "../utils/config_cache"
+require_relative "../utils/content_diff"
+require_relative "../utils/parallel"
 
 # Models
 require_relative "../models/mapping"

data/lib/dotsync/loaders/push_loader.rb

@@ -11,6 +11,8 @@ require "terminal-table"
 require_relative "../utils/file_transfer"
 require_relative "../utils/directory_differ"
 require_relative "../utils/config_cache"
+require_relative "../utils/content_diff"
+require_relative "../utils/parallel"
 
 # Models
 require_relative "../models/mapping"

data/lib/dotsync/models/diff.rb

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

data/lib/dotsync/models/mapping.rb

@@ -140,6 +140,16 @@ module Dotsync
       ignore?(path) || !include?(path)
     end
 
+    # Returns true if a directory can be entirely skipped during destination walks.
+    # A directory should be pruned if:
+    # 1. It's ignored, OR
+    # 2. It has inclusions AND the path is neither included nor a parent of any inclusion
+    def should_prune_directory?(path)
+      return true if ignore?(path)
+      return false unless has_inclusions?
+      !bidirectional_include?(path)
+    end
+
     private
       def has_ignores?
         @original_ignores.any?

data/lib/dotsync/utils/content_diff.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Dotsync
+  class ContentDiff
+    COLORS = {
+      header: 103,       # Purple for file headers
+      hunk: 36,          # Cyan for @@ lines
+      addition: 34,      # Blue for added lines (consistent with diff_additions)
+      deletion: 88,      # Red for removed lines (consistent with diff_removals)
+      context: 240       # Gray for context lines
+    }.freeze
+
+    def initialize(src_path, dest_path, logger)
+      @src_path = src_path
+      @dest_path = dest_path
+      @logger = logger
+    end
+
+    def display
+      return unless displayable?
+
+      diff_output = generate_diff
+      return if diff_output.empty?
+
+      display_header
+      colorize_and_display(diff_output)
+    end
+
+    private
+      def displayable?
+        text_file?(@src_path) && text_file?(@dest_path)
+      end
+
+      def text_file?(path)
+        return false unless File.file?(path)
+
+        # Check if file appears to be text by reading first few bytes
+        begin
+          sample = File.read(path, 8192) || ""
+          # Binary files typically contain null bytes
+          !sample.include?("\x00")
+        rescue StandardError
+          false
+        end
+      end
+
+      def generate_diff
+        # Use system diff with unified format
+        # diff returns exit code 1 when files differ, so we can't use backticks directly
+        output = `diff -u "#{@dest_path}" "#{@src_path}" 2>/dev/null`
+        output.lines.drop(2).join # Drop the first two header lines, we'll add our own
+      rescue StandardError
+        ""
+      end
+
+      def display_header
+        @logger.log("--- #{@dest_path}", color: COLORS[:header])
+        @logger.log("+++ #{@src_path}", color: COLORS[:header])
+      end
+
+      def colorize_and_display(diff_output)
+        diff_output.each_line do |line|
+          color = line_color(line)
+          @logger.log(line.chomp, color: color)
+        end
+        @logger.log("")
+      end
+
+      def line_color(line)
+        case line[0]
+        when "+"
+          COLORS[:addition]
+        when "-"
+          COLORS[:deletion]
+        when "@"
+          COLORS[:hunk]
+        else
+          COLORS[:context]
+        end
+      end
+  end
+end

data/lib/dotsync/utils/directory_differ.rb

@@ -31,6 +31,7 @@ module Dotsync
       def diff_mapping_directories
         additions = []
         modifications = []
+        modification_pairs = []
         removals = []
 
         Find.find(mapping_src) do |src_path|
@@ -48,6 +49,7 @@ module Dotsync
           elsif File.file?(src_path) && File.file?(dest_path)
             if files_differ?(src_path, dest_path)
               modifications << rel_path
+              modification_pairs << { rel_path: rel_path, src: src_path, dest: dest_path }
             end
           end
         end
@@ -59,6 +61,12 @@ module Dotsync
 
             src_path = File.join(mapping_src, rel_path)
 
+            # Prune entire directory trees that are outside the inclusion list or ignored
+            if File.directory?(dest_path) && @mapping.should_prune_directory?(src_path)
+              Find.prune
+              next
+            end
+
             next if @mapping.skip?(src_path)
 
             if !File.exist?(src_path)
@@ -67,21 +75,29 @@ module Dotsync
           end
         end
 
+        filtered_modifications = filter_ignores(modifications)
+        modification_pairs = modification_pairs.select { |pair| filtered_modifications.include?(pair[:rel_path]) }
+
         additions = relative_to_absolute(filter_ignores(additions), mapping_original_dest)
-        modifications = relative_to_absolute(filter_ignores(modifications), mapping_original_dest)
+        modifications = relative_to_absolute(filtered_modifications, mapping_original_dest)
         removals = relative_to_absolute(filter_ignores(removals), mapping_original_dest)
 
-        Dotsync::Diff.new(additions: additions, modifications: modifications, removals: removals)
+        Dotsync::Diff.new(additions: additions, modifications: modifications, removals: removals, modification_pairs: modification_pairs)
       end
 
       def diff_mapping_files
-        Dotsync::Diff.new.tap do |diff|
-          if @mapping.file_present_in_src_only?
-            diff.additions << @mapping.original_dest
-          elsif @mapping.file_changed?
-            diff.modifications << @mapping.original_dest
-          end
+        additions = []
+        modifications = []
+        modification_pairs = []
+
+        if @mapping.file_present_in_src_only?
+          additions << @mapping.original_dest
+        elsif @mapping.file_changed?
+          modifications << @mapping.original_dest
+          modification_pairs << { rel_path: File.basename(@mapping.original_dest), src: @mapping.src, dest: @mapping.dest }
         end
+
+        Dotsync::Diff.new(additions: additions, modifications: modifications, modification_pairs: modification_pairs)
       end
 
       def filter_ignores(all_paths)

data/lib/dotsync/utils/parallel.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Dotsync
+  # Simple thread-based parallel execution for independent operations.
+  # Uses a configurable thread pool to process items concurrently.
+  module Parallel
+    # Default number of threads (matches typical CPU core count)
+    DEFAULT_THREADS = 4
+
+    # Executes a block for each item in the collection using parallel threads.
+    # Returns results in the same order as the input collection.
+    #
+    # @param items [Array] Collection of items to process
+    # @param threads [Integer] Number of parallel threads (default: 4)
+    # @yield [item] Block to execute for each item
+    # @return [Array] Results in same order as input
+    #
+    # @example
+    #   results = Dotsync::Parallel.map(urls, threads: 8) do |url|
+    #     fetch(url)
+    #   end
+    def self.map(items, threads: DEFAULT_THREADS, &block)
+      return [] if items.empty?
+      return items.map(&block) if items.size == 1
+
+      # Limit threads to item count
+      thread_count = [threads, items.size].min
+
+      # Create indexed work items
+      work_queue = Queue.new
+      items.each_with_index { |item, idx| work_queue << [idx, item] }
+
+      # Results array (pre-sized for thread safety with index assignment)
+      results = Array.new(items.size)
+      mutex = Mutex.new
+      errors = []
+
+      # Spawn worker threads
+      workers = thread_count.times.map do
+        Thread.new do
+          loop do
+            idx, item = work_queue.pop(true) rescue break
+            begin
+              results[idx] = yield(item)
+            rescue => e
+              mutex.synchronize { errors << e }
+            end
+          end
+        end
+      end
+
+      # Wait for completion
+      workers.each(&:join)
+
+      # Re-raise first error if any occurred
+      raise errors.first unless errors.empty?
+
+      results
+    end
+
+    # Executes a block for each item in parallel, ignoring return values.
+    # Useful for side-effect operations like file transfers.
+    #
+    # @param items [Array] Collection of items to process
+    # @param threads [Integer] Number of parallel threads (default: 4)
+    # @yield [item] Block to execute for each item
+    def self.each(items, threads: DEFAULT_THREADS, &block)
+      map(items, threads: threads, &block)
+      nil
+    end
+  end
+end

data/lib/dotsync/version.rb

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

data/lib/dotsync.rb

@@ -31,6 +31,7 @@ require_relative "dotsync/utils/file_transfer"
 require_relative "dotsync/utils/directory_differ"
 require_relative "dotsync/utils/version_checker"
 require_relative "dotsync/utils/config_cache"
+require_relative "dotsync/utils/parallel"
 
 # Models
 require_relative "dotsync/models/mapping"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotsync
 version: !ruby/object:Gem::Version
-  version: 0.1.26
+  version: 0.2.0
 platform: ruby
 authors:
 - David Sáenz
@@ -334,9 +334,11 @@ files:
 - lib/dotsync/runner.rb
 - lib/dotsync/tasks/actions.rake
 - lib/dotsync/utils/config_cache.rb
+- lib/dotsync/utils/content_diff.rb
 - lib/dotsync/utils/directory_differ.rb
 - lib/dotsync/utils/file_transfer.rb
 - lib/dotsync/utils/logger.rb
+- lib/dotsync/utils/parallel.rb
 - lib/dotsync/utils/path_utils.rb
 - lib/dotsync/utils/version_checker.rb
 - lib/dotsync/version.rb