`3289b39`

fix: Keep Both copies to unique path instead of renaming original

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 3289b390a73da61c1614fd090c594efc33673baf
Parents: 8dc3328
Tree: e000f8d

3 changed files

Status	File	+	-
M	`garfield/src/app.rs`	2	21
M	`garfield/src/core/mod.rs`	1	1
M	`garfield/src/core/operations.rs`	8	4

garfield/src/app.rsmodified

      dest_dir: PathBuf,
      /// Files that conflict (exist in destination).
      conflicts: Vec<PathBuf>,
 -    /// Current conflict index being resolved.
 -    current_conflict: usize,
+ }
  impl App {
                      operation: op,
                      dest_dir,
                      conflicts,
 -                    current_conflict: 0,
                  });
                  return;
+             }
                  // Perform the copy/move with the unique name
                  let result = match pending.operation {
                      ClipboardOperation::Copy => {
 -                        if conflict_file.is_dir() {
 -                            // For directories, copy then rename to unique name
 -                            match garfield::core::copy_path(&conflict_file, &pending.dest_dir) {
 -                                Ok(copied_path) => {
 -                                    // Rename to unique name if different
 -                                    if copied_path != final_dest {
 -                                        std::fs::rename(&copied_path, &final_dest)
 -                                            .map(|_| final_dest.clone())
 -                                            .or(Ok(copied_path))
 -                                    } else {
 -                                        Ok(copied_path)
 -                                    }
 -                                }
 -                                Err(e) => Err(e),
 -                            }
 -                        } else {
 -                            std::fs::copy(&conflict_file, &final_dest).map(|_| final_dest.clone())
 -                        }
 +                        // Copy directly to the unique destination path
 +                        garfield::core::copy_to_path(&conflict_file, &final_dest)
+                     }
                      ClipboardOperation::Cut => {
                          std::fs::rename(&conflict_file, &final_dest).map(|_| final_dest.clone())

garfield/src/core/mod.rsmodified

  };
  pub use history::History;
  pub use operations::{
 -    copy_files, copy_path, create_directory, delete_files, delete_path,
 +    copy_files, copy_path, copy_to_path, create_directory, delete_files, delete_path,
      make_unique_name, move_files, move_path, rename_path, OperationResult,
  };
  pub use trash::{empty_trash, restore_from_trash, trash_file, trash_files, trash_dir};

garfield/src/core/operations.rsmodified

+     }
+ }
 -/// Copy a file or directory to a destination.
 +/// Copy a file or directory to a destination directory (uses source filename).
  pub fn copy_path(source: &Path, dest_dir: &Path) -> io::Result<PathBuf> {
      let file_name = source.file_name().ok_or_else(|| {
          io::Error::new(io::ErrorKind::InvalidInput, "Invalid source path")
      })?;
      let dest = dest_dir.join(file_name);
 +    copy_to_path(source, &dest)
 +}
 +/// Copy a file or directory to a specific destination path.
 +pub fn copy_to_path(source: &Path, dest: &Path) -> io::Result<PathBuf> {
      if source.is_dir() {
 -        copy_dir_recursive(source, &dest)?;
 +        copy_dir_recursive(source, dest)?;
      } else {
 -        fs::copy(source, &dest)?;
 +        fs::copy(source, dest)?;
+     }
 -    Ok(dest)
 +    Ok(dest.to_path_buf())
+ }
  /// Copy a directory recursively.