diff --git a/Cargo.lock b/Cargo.lock index aed4cf9..1ea51b6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3619,6 +3619,7 @@ dependencies = [ "serde_json", "sha1 0.11.0", "sha2 0.11.1", + "shell-words", "thiserror 2.0.21", "tokio", "tracing", @@ -4805,6 +4806,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "shell-words" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77" + [[package]] name = "shlex" version = "2.0.1" diff --git a/Cargo.toml b/Cargo.toml index d52722f..9384d01 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,6 +39,8 @@ tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } directories = "6" ignore = "0.4" +# Command lines typed into Preferences, split and shown the way a shell would. +shell-words = "1" sha2 = "0.11" # Google Takeout exports are zip sets; the importer reads their central # directories and streams entries out without extracting to disk first. diff --git a/crates/pdfs-cli/src/main.rs b/crates/pdfs-cli/src/main.rs index c4b86eb..b91c447 100644 --- a/crates/pdfs-cli/src/main.rs +++ b/crates/pdfs-cli/src/main.rs @@ -751,6 +751,32 @@ enum ConflictCmd { }, } +/// `pdfs sync ignore`: the patterns in `ignore_patterns`, for every synced +/// folder. A folder's own rules are in its `.pdfsignore`. +#[derive(Subcommand, Debug)] +enum IgnoreCmd { + /// List the patterns every synced folder leaves out. + List, + /// Leave out files matching a gitignore-style pattern, e.g. `*.db` or `build/`. + Add { + /// The pattern; end it with `/` to match folders only. + pattern: String, + }, + /// Stop leaving out files matching a pattern. + Remove { + /// The pattern, as `sync ignore list` shows it. + pattern: String, + }, + /// Go back to the built-in patterns. + Reset, + /// Say whether a file in a synced folder is synced, and which pattern decides. + Check { + /// A file or folder inside a synced folder. + #[arg(value_hint = ValueHint::AnyPath)] + path: PathBuf, + }, +} + #[derive(Subcommand)] enum SyncCmd { /// Add a local folder to this machine's device and upload its contents. @@ -849,6 +875,11 @@ enum SyncCmd { #[arg(add = ArgValueCandidates::new(complete::queue_id))] id: Option, }, + /// Show or change the patterns every synced folder leaves out, or check a path. + Ignore { + #[command(subcommand)] + action: IgnoreCmd, + }, /// Switch a folder between full-copy sync and on-demand (FUSE, no local storage). Mode { /// Synced-folder id (from `sync list`). @@ -1324,6 +1355,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> { SyncCmd::Issues => return cmd_sync_issues(), SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest), SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down), + SyncCmd::Ignore { action } => return cmd_sync_ignore(action), SyncCmd::Discard { id, yes } => { if !yes { confirm(&format!( @@ -3699,6 +3731,104 @@ fn cmd_sync_limit(up: Option, down: Option) -> Result<()> { })?) } +fn cmd_sync_ignore(action: IgnoreCmd) -> Result<()> { + use pdfs_core::syncignore::{ + DEFAULT_IGNORE_PATTERNS, IgnoreRules, RuleSource, Verdict, check_pattern, + }; + let dirs = AppDirs::new()?; + let defaults: Vec = DEFAULT_IGNORE_PATTERNS + .iter() + .map(|p| (*p).to_string()) + .collect(); + // A list equal to the built-in one is stored as unset, so it follows the + // built-in list in later releases, as Preferences does. + let change = |edit: &dyn Fn(&mut Vec)| -> Result<()> { + dirs.update_config(|config| { + let mut list = config.resolved_ignore_patterns(); + edit(&mut list); + config.ignore_patterns = (list != defaults).then_some(list); + })?; + // The next pass picks the change up anyway; this only hurries it. + let _ = control_request(CtlRequest::SyncNow { id: None }); + Ok(()) + }; + match action { + IgnoreCmd::List => { + let config = dirs.load_config(); + let list = config.resolved_ignore_patterns(); + if list.is_empty() { + println!("No patterns: every file is synced."); + } + for pattern in list { + if DEFAULT_IGNORE_PATTERNS.contains(&pattern.as_str()) { + println!("{pattern} (built in)"); + } else { + println!("{pattern}"); + } + } + } + IgnoreCmd::Add { pattern } => { + let pattern = pattern.trim().to_string(); + if let Err(e) = check_pattern(&pattern) { + bail!("not a valid pattern: {e}"); + } + change(&|list| { + if !list.contains(&pattern) { + list.push(pattern.clone()); + } + })?; + } + IgnoreCmd::Remove { pattern } => { + let list = dirs.load_config().resolved_ignore_patterns(); + if !list.contains(&pattern) { + bail!("`{pattern}` is not in the list; see `pdfs sync ignore list`"); + } + change(&|list| list.retain(|p| *p != pattern))?; + } + IgnoreCmd::Reset => change(&|list| *list = defaults.clone())?, + IgnoreCmd::Check { path } => { + let path = std::path::absolute(&path)?; + let folders = match control_request(CtlRequest::ListSyncFolders)? { + CtlResponse::SyncFolders { items } => items, + CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)), + other => bail!("unexpected reply: {other:?}"), + }; + let Some(folder) = folders + .iter() + .filter(|f| path.starts_with(&f.local_path)) + .max_by_key(|f| f.local_path.len()) + else { + bail!("{} is not in a synced folder", path.display()); + }; + if folder.mode != "mirror" { + println!( + "{} is online only; patterns apply only to folders kept on this computer.", + folder.local_path + ); + return Ok(()); + } + let root = PathBuf::from(&folder.local_path); + let rel = path.strip_prefix(&root).unwrap_or(&path).to_string_lossy(); + let globals = dirs.load_config().resolved_ignore_patterns(); + let rules = IgnoreRules::load(&root, &globals); + let source = |source: &RuleSource| match source { + RuleSource::AllFolders => "the patterns for all synced folders".to_string(), + RuleSource::ThisFolder => format!("{}/.pdfsignore", root.display()), + }; + match rules.explain(&rel, path.is_dir()) { + Verdict::Synced => println!("Synced: no pattern matches it."), + Verdict::Excluded { pattern, source: s } => { + println!("Not synced: excluded by `{pattern}` in {}.", source(&s)) + } + Verdict::Included { pattern, source: s } => { + println!("Synced: `{pattern}` in {} includes it again.", source(&s)) + } + } + } + } + Ok(()) +} + /// How long the oldest write may wait to upload before `diagnose` calls it /// out. Under a day it is a slow link or a big file; past it, something is /// holding the queue. @@ -4646,6 +4776,21 @@ mod login_wait_tests { Command::ImportGooglePhotos { resume: true, .. } )); assert!(Cli::try_parse_from(["pdfs", "import-google-photos"]).is_err()); + } + + #[test] + fn sync_ignore_takes_a_pattern_that_looks_like_an_option_after_dashes() { + let cli = Cli::try_parse_from(["pdfs", "sync", "ignore", "add", "--", "-temp*"]).unwrap(); + assert!(matches!( + cli.command, + Command::Sync { + action: SyncCmd::Ignore { + action: IgnoreCmd::Add { ref pattern } + } + } if pattern == "-temp*" + )); + assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "add"]).is_err()); + assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "reset"]).is_ok()); assert!( Cli::try_parse_from(["pdfs", "import-google-photos", "--resume", "a.zip"]).is_err() ); diff --git a/crates/pdfs-core/Cargo.toml b/crates/pdfs-core/Cargo.toml index fae467b..9deceea 100644 --- a/crates/pdfs-core/Cargo.toml +++ b/crates/pdfs-core/Cargo.toml @@ -20,6 +20,7 @@ thiserror.workspace = true tracing.workspace = true directories.workspace = true ignore.workspace = true +shell-words.workspace = true sha2.workspace = true sha1.workspace = true zip.workspace = true diff --git a/crates/pdfs-core/src/config.rs b/crates/pdfs-core/src/config.rs index 30ca326..84d1224 100644 --- a/crates/pdfs-core/src/config.rs +++ b/crates/pdfs-core/src/config.rs @@ -407,6 +407,116 @@ fn refuse_to_replace_unreadable(path: &Path) -> Result<()> { } } +/// [`AppDirs::load_config`] for the file at `path`. +fn load_config_at(path: &Path) -> AppConfig { + if path.exists() { + match std::fs::read_to_string(path) + .map_err(Error::from) + .and_then(|content| serde_json::from_str::(&content).map_err(Error::from)) + { + Ok(config) => return config, + Err(e) => { + // Preserve the original bytes for diagnosis/recovery. In + // particular, never replace a truncated config with defaults + // and silently lose mount, device, or ignore settings. + // `save_config` refuses to write over it for the same reason. + tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it"); + return AppConfig::default(); + } + } + } + + let default_config = AppConfig::default(); + if let Err(e) = save_config_at(path, &default_config) { + tracing::warn!(path = %path.display(), error = %e, "could not write the default config"); + } + default_config +} + +/// [`AppDirs::save_config`] for the file at `path`. +fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> { + refuse_to_replace_unreadable(path)?; + let parent = path + .parent() + .ok_or_else(|| Error::Other("configuration path has no parent".into()))?; + std::fs::create_dir_all(parent)?; + let nonce = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|duration| duration.as_nanos()) + .unwrap_or(0); + let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id())); + use std::os::unix::fs::OpenOptionsExt as _; + let mut file = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .mode(0o600) + .open(&tmp)?; + use std::io::Write as _; + file.write_all(&serde_json::to_vec_pretty(config)?)?; + file.sync_all()?; + std::fs::rename(&tmp, path)?; + std::fs::File::open(parent)?.sync_all()?; + Ok(()) +} + +/// [`AppDirs::update_config`] for the file at `path`. +fn update_config_at(path: &Path, change: impl FnOnce(&mut AppConfig) -> R) -> Result { + let _lock = lock_config(path)?; + // Refuse before reading: an unreadable file loads as defaults, and the + // change must not be applied to those. + refuse_to_replace_unreadable(path)?; + let mut config = load_config_at(path); + let out = change(&mut config); + save_config_at(path, &config)?; + Ok(out) +} + +/// How long [`lock_config`] waits for another writer. A change holds the lock +/// for one small read and write; anything longer is a stuck process, and the +/// setting is better reported as not saved than waited on forever. +const CONFIG_LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(5); + +/// Take the lock that orders changes to the config file at `path`, held until +/// the returned file is dropped. +/// +/// A separate `config.json.lock`, never the config file itself: that file is +/// replaced by a rename on every save, so a lock on it would guard a file +/// nobody reads any more. +fn lock_config(path: &Path) -> Result { + use std::os::fd::AsRawFd as _; + use std::os::unix::fs::OpenOptionsExt as _; + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + let mut name = path.as_os_str().to_owned(); + name.push(".lock"); + let file = std::fs::OpenOptions::new() + .create(true) + .read(true) + .write(true) + .truncate(false) + .mode(0o600) + .open(PathBuf::from(name))?; + let deadline = std::time::Instant::now() + CONFIG_LOCK_WAIT; + loop { + // SAFETY: `file` owns the descriptor and outlives the call. + if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0 { + return Ok(file); + } + let e = std::io::Error::last_os_error(); + if e.raw_os_error() != Some(libc::EWOULDBLOCK) { + return Err(Error::Io(e)); + } + if std::time::Instant::now() >= deadline { + return Err(Error::Other(format!( + "{} is being changed by another process; try again", + path.display() + ))); + } + std::thread::sleep(std::time::Duration::from_millis(10)); + } +} + /// Resolved XDG locations for state, cache, and the default mountpoint. pub struct AppDirs { dirs: ProjectDirs, @@ -426,65 +536,33 @@ impl AppDirs { /// Load config from disk, creating default if missing. pub fn load_config(&self) -> AppConfig { - let path = self.config_path(); - if path.exists() { - match std::fs::read_to_string(&path) - .map_err(Error::from) - .and_then(|content| { - serde_json::from_str::(&content).map_err(Error::from) - }) { - Ok(config) => return config, - Err(e) => { - // Preserve the original bytes for diagnosis/recovery. In - // particular, never replace a truncated config with defaults - // and silently lose mount, device, or ignore settings. - // `save_config` refuses to write over it for the same reason. - tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it"); - return AppConfig::default(); - } - } - } - - let default_config = AppConfig::default(); - if let Err(e) = self.save_config(&default_config) { - tracing::warn!(path = %path.display(), error = %e, "could not write the default config"); - } - default_config + load_config_at(&self.config_path()) } /// Persist `config` to [`config_path`](Self::config_path), creating the - /// config dir if missing. The Settings page calls this after editing the - /// cache budget or mountpoint; the daemon re-reads the file on its next mount. + /// config dir if missing. /// - /// Refuses while the file on disk does not parse. Every caller loads, - /// changes one field and saves, and [`load_config`](Self::load_config) - /// gives defaults for a file it cannot read, so the first change after - /// the file was damaged wrote defaults over the mountpoint, the device and - /// the ignore rules the user had (`docs/BUGS.md` B223). + /// Refuses while the file on disk does not parse: [`load_config`](Self::load_config) + /// gives defaults for a file it cannot read, so the first change after the + /// file was damaged would write defaults over the mountpoint, the device + /// and the ignore rules the user had (`docs/BUGS.md` B223). + /// + /// Writes the whole file. To change a setting, use + /// [`update_config`](Self::update_config), which does not lose another + /// process's change. pub fn save_config(&self, config: &AppConfig) -> Result<()> { - let path = self.config_path(); - refuse_to_replace_unreadable(&path)?; - let parent = path - .parent() - .ok_or_else(|| Error::Other("configuration path has no parent".into()))?; - std::fs::create_dir_all(parent)?; - let nonce = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map(|duration| duration.as_nanos()) - .unwrap_or(0); - let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id())); - use std::os::unix::fs::OpenOptionsExt as _; - let mut file = std::fs::OpenOptions::new() - .write(true) - .create_new(true) - .mode(0o600) - .open(&tmp)?; - use std::io::Write as _; - file.write_all(&serde_json::to_vec_pretty(config)?)?; - file.sync_all()?; - std::fs::rename(&tmp, &path)?; - std::fs::File::open(parent)?.sync_all()?; - Ok(()) + save_config_at(&self.config_path(), config) + } + + /// Change settings in place: read the file, apply `change`, write it back, + /// all under a lock, and return what `change` returned. + /// + /// The app, the tray and the daemon each write the file. Without the lock, + /// two of them changing different settings at once both read the old file, + /// and the one that wrote last undid the other's change (`docs/BUGS.md` + /// B292). + pub fn update_config(&self, change: impl FnOnce(&mut AppConfig) -> R) -> Result { + update_config_at(&self.config_path(), change) } /// This machine's id (e.g. ~/.config/proton-drive-linux/machine-id). See @@ -682,6 +760,64 @@ mod tests { std::fs::metadata(p).unwrap().permissions().mode() & 0o777 } + /// Two writers changing different settings at once both keep their change + /// (`docs/BUGS.md` B292). + #[test] + fn concurrent_changes_to_different_settings_are_all_kept() { + let dir = std::env::temp_dir().join(format!( + "pdfs-cfg-race-{}-{:?}", + std::process::id(), + std::thread::current().id() + )); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("config.json"); + + let a = { + let path = path.clone(); + std::thread::spawn(move || { + for i in 1..=100u64 { + update_config_at(&path, |c| c.upload_limit = Some(i)).unwrap(); + } + }) + }; + let b = { + let path = path.clone(); + std::thread::spawn(move || { + for i in 1..=100u64 { + update_config_at(&path, |c| c.download_limit = Some(i)).unwrap(); + } + }) + }; + a.join().unwrap(); + b.join().unwrap(); + + let config = load_config_at(&path); + assert_eq!(config.upload_limit, Some(100)); + assert_eq!(config.download_limit, Some(100)); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn a_change_is_never_applied_over_an_unreadable_config() { + let dir = std::env::temp_dir().join(format!( + "pdfs-cfg-update-guard-{}-{:?}", + std::process::id(), + std::thread::current().id() + )); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("config.json"); + std::fs::write(&path, br#"{"mountpoint": "/home/me/Pro"#).unwrap(); + + assert!(update_config_at(&path, |c| c.tray_hidden = true).is_err()); + assert_eq!( + std::fs::read(&path).unwrap(), + br#"{"mountpoint": "/home/me/Pro"# + ); + let _ = std::fs::remove_dir_all(&dir); + } + /// A damaged config must not be replaced by defaults the next time a /// setting changes (`docs/BUGS.md` B223). #[test] diff --git a/crates/pdfs-core/src/opener.rs b/crates/pdfs-core/src/opener.rs index c21d477..0617dad 100644 --- a/crates/pdfs-core/src/opener.rs +++ b/crates/pdfs-core/src/opener.rs @@ -206,26 +206,23 @@ pub fn reap(mut child: std::process::Child) { }); } -/// [`open`] with the policy from the user's `config.json`, read once per -/// process. For callers that open the occasional path and have no reason to -/// carry a policy around; long-lived windows should hold their own copy. +/// [`open`] with the policy from the user's `config.json`, read again on +/// every call: the file is small, a path is opened by hand, and a rule changed +/// in Preferences then applies to the next file opened, without a restart. pub fn open_default(path: &Path, is_dir: bool) { - open(default_policy(), path, is_dir); + open(&default_policy(), path, is_dir); } /// [`open_default`] matching the rules against `name` — see /// [`OpenWith::command_for_named`]. pub fn open_default_named(path: &Path, name: &str, is_dir: bool) { - open_named(default_policy(), path, name, is_dir); + open_named(&default_policy(), path, name, is_dir); } -fn default_policy() -> &'static OpenWith { - static POLICY: std::sync::OnceLock = std::sync::OnceLock::new(); - POLICY.get_or_init(|| { - crate::config::AppDirs::new() - .map(|dirs| dirs.load_config().resolved_open_with()) - .unwrap_or_default() - }) +fn default_policy() -> OpenWith { + crate::config::AppDirs::new() + .map(|dirs| dirs.load_config().resolved_open_with()) + .unwrap_or_default() } /// `$PDFS_TERMINAL`, then `$TERMINAL`, then the first [`KNOWN_TERMINALS`] entry @@ -266,6 +263,33 @@ fn with_exec_flag(program: &str) -> Vec { argv } +/// Split a command line typed by the user into argv, the way a shell would: +/// quotes keep spaces, nothing is expanded. `None` for an unclosed quote. +pub fn parse_command(line: &str) -> Option> { + shell_words::split(line).ok() +} + +/// Show `argv` as one line that [`parse_command`] turns back into it. +pub fn format_command(argv: &[String]) -> String { + shell_words::join(argv) +} + +/// Whether the program `argv` starts with can be found: an absolute or +/// relative path to a file, or a name on `PATH`. A `$VAR` program counts as +/// found, since it is looked up only when a file is opened. +pub fn command_available(argv: &[String]) -> bool { + let Some(program) = argv.first() else { + return false; + }; + if program.starts_with('$') { + return true; + } + if program.contains('/') { + return Path::new(program).is_file(); + } + on_path(program) +} + fn on_path(program: &str) -> bool { let Some(path) = std::env::var_os("PATH") else { return false; @@ -703,4 +727,24 @@ mod tests { // Unknown terminals get the near-universal `-e`. assert_eq!(with_exec_flag("mystery-term"), vec!["mystery-term", "-e"]); } + + #[test] + fn a_typed_command_line_round_trips() { + let argv = parse_command("alacritty -e 'my editor' --flag").unwrap(); + assert_eq!(argv, ["alacritty", "-e", "my editor", "--flag"]); + assert_eq!(parse_command(&format_command(&argv)).unwrap(), argv); + assert_eq!(parse_command("nvim 'unclosed"), None); + assert_eq!(parse_command(" ").unwrap(), Vec::::new()); + } + + #[test] + fn a_command_is_available_when_its_program_is() { + assert!(command_available(&["sh".to_string()])); + assert!(command_available(&["$EDITOR".to_string()])); + assert!(!command_available(&[])); + assert!(!command_available( + &["pdfs-no-such-program-xyz".to_string()] + )); + assert!(!command_available(&["/nonexistent/program".to_string()])); + } } diff --git a/crates/pdfs-core/src/syncignore.rs b/crates/pdfs-core/src/syncignore.rs index 35c8d5e..87dfb06 100644 --- a/crates/pdfs-core/src/syncignore.rs +++ b/crates/pdfs-core/src/syncignore.rs @@ -30,6 +30,11 @@ use ignore::gitignore::{Gitignore, GitignoreBuilder}; /// them. Version-control metadata, dependency and build trees, editor /// leftovers, and OS turds — none of which belong on Drive, all of which are /// large or rewritten constantly. +/// +/// The second half is what Nextcloud, Dropbox and Syncthing leave out as well: +/// files a desktop, a file system or a program in the middle of a write leaves +/// behind, never anything a person made. Every one is in a test, next to a real +/// file of a similar name that must stay synced. pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[ ".git/", ".hg/", @@ -43,6 +48,23 @@ pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[ "*.tmp", ".DS_Store", "Thumbs.db", + // Folder settings of Windows and KDE's Dolphin. + "desktop.ini", + ".directory", + // Trash folders and file-system leftovers: a file deleted while open on a + // FUSE or NFS mount lives on under one of these names until it is closed. + ".Trash-*/", + ".Trashes/", + ".Spotlight-V100/", + ".fuse_hidden*", + ".nfs*", + // Downloads and saves still being written. + "*.part", + "*.crdownload", + "*.kate-swp", + // Office lock files: LibreOffice's `.~lock.#`, Microsoft Office's `~$`. + ".~lock.*#", + "~$*", ]; /// Suffixes that mean a file is incomplete *by construction*: only the program @@ -119,6 +141,149 @@ pub fn is_scratch_name(name: &str) -> bool { /// Filenames accepted as a folder's ignore file, in precedence order. const IGNORE_FILE_NAMES: &[&str] = &[".pdfsignore", ".protonignore"]; +/// Whether `line` is a rule [`IgnoreRules::load`] accepts: a pattern, a +/// comment or a blank line. The error says what is wrong with it. +pub fn check_pattern(line: &str) -> Result<(), String> { + GitignoreBuilder::new("/") + .add_line(None, line) + .map(|_| ()) + .map_err(|e| e.to_string()) +} + +/// The lines of an ignore file that [`IgnoreRules::load`] would skip, by line +/// number (from 1), with what is wrong with each. +pub fn check_rules(text: &str) -> Vec<(usize, String)> { + text.lines() + .enumerate() + .filter_map(|(i, line)| check_pattern(line).err().map(|e| (i + 1, e))) + .collect() +} + +/// A synced folder's own ignore file, read so it can be edited and written +/// back. See [`FolderRules::read`]. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FolderRules { + /// The file the rules are in: the one in use, or `.pdfsignore` when there + /// is none yet. + pub path: std::path::PathBuf, + /// The rules as read; empty when there is no file. `None` means there was + /// no file, which [`write`](Self::write) checks is still so. + pub text: Option, +} + +/// Why [`FolderRules::write`] did not write. +#[derive(Debug)] +pub enum WriteRulesError { + /// The file changed after it was read, for example by an edit on another + /// computer that sync brought in. The rules on disk are the new ones. + Changed, + /// Reading or writing failed. + Io(std::io::Error), +} + +impl std::fmt::Display for WriteRulesError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Changed => f.write_str("the file changed since it was opened"), + Self::Io(e) => e.fmt(f), + } + } +} + +impl std::error::Error for WriteRulesError {} + +impl From for WriteRulesError { + fn from(e: std::io::Error) -> Self { + Self::Io(e) + } +} + +impl FolderRules { + /// Read the ignore file of the folder at `root`, the same one + /// [`IgnoreRules::load`] uses. + pub fn read(root: &Path) -> std::io::Result { + for name in IGNORE_FILE_NAMES { + let path = root.join(name); + match std::fs::read_to_string(&path) { + Ok(text) => { + return Ok(Self { + path, + text: Some(text), + }); + } + Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue, + Err(e) => return Err(e), + } + } + // Like `load`, a missing folder reads as one without rules; the write + // is what fails then. + Ok(Self { + path: root.join(IGNORE_FILE_NAMES[0]), + text: None, + }) + } + + /// Replace the rules with `text`, unless the file changed since it was + /// read. Rules that are all blank remove the file, so a folder never keeps + /// an empty one around. + /// + /// Written to a temporary file and renamed over the old one, so the sync + /// pass reading the rules at the same moment sees the old ones or the new + /// ones, never half of them. + pub fn write(&self, text: &str) -> Result<(), WriteRulesError> { + let now = match std::fs::read_to_string(&self.path) { + Ok(now) => Some(now), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => None, + Err(e) => return Err(e.into()), + }; + if now != self.text { + return Err(WriteRulesError::Changed); + } + if text.trim().is_empty() { + return match std::fs::remove_file(&self.path) { + Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e.into()), + _ => Ok(()), + }; + } + let Some(name) = self.path.file_name() else { + return Err(std::io::Error::other("the rules path has no file name").into()); + }; + let mut tmp_name = std::ffi::OsString::from("."); + tmp_name.push(name); + tmp_name.push(format!(".tmp-{}", std::process::id())); + let tmp = self.path.with_file_name(tmp_name); + let mut body = text.to_string(); + if !body.ends_with('\n') { + body.push('\n'); + } + let written = std::fs::write(&tmp, body).and_then(|()| std::fs::rename(&tmp, &self.path)); + if written.is_err() { + let _ = std::fs::remove_file(&tmp); + } + Ok(written?) + } +} + +/// Where a rule that decided about a path came from. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum RuleSource { + /// The rules for every synced folder (`ignore_patterns`). + AllFolders, + /// The folder's own ignore file. + ThisFolder, +} + +/// What the rules say about one path, and which rule says it. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Verdict { + /// No rule matches: the path is synced. + Synced, + /// Left out by `pattern`. `pattern` may name a folder the path is in. + Excluded { pattern: String, source: RuleSource }, + /// A rule excluded it, and a later `!pattern` brought it back. + Included { pattern: String, source: RuleSource }, +} + /// Compiled ignore rules for one synced folder. pub struct IgnoreRules { matcher: Option, @@ -161,6 +326,27 @@ impl IgnoreRules { } } + /// [`load`](Self::load) with `text` standing in for the folder's ignore + /// file, for showing what rules being edited would do before they are + /// saved. + pub fn with_folder_text(root: &Path, globals: &[String], text: &str) -> Self { + let mut builder = GitignoreBuilder::new(root); + let mut any = false; + for pattern in globals { + any |= builder.add_line(None, pattern).is_ok(); + } + let file = root.join(IGNORE_FILE_NAMES[0]); + for line in text.lines() { + any |= builder.add_line(Some(file.clone()), line).is_ok(); + } + if !any { + return Self { matcher: None }; + } + Self { + matcher: builder.build().ok(), + } + } + /// Rules matching nothing, for callers with no folder context. pub fn empty() -> Self { Self { matcher: None } @@ -207,6 +393,50 @@ impl IgnoreRules { } } +impl IgnoreRules { + /// What the rules say about `rel`, and which rule decides, the way + /// [`is_ignored`](Self::is_ignored) decides it. + pub fn explain(&self, rel: &str, is_dir: bool) -> Verdict { + let Some(matcher) = &self.matcher else { + return Verdict::Synced; + }; + let rel = rel.trim_matches('/'); + if rel.is_empty() { + return Verdict::Synced; + } + let source = |glob: &ignore::gitignore::Glob| match glob.from() { + Some(_) => RuleSource::ThisFolder, + None => RuleSource::AllFolders, + }; + let mut prefix = String::new(); + let mut parts = rel.split('/').peekable(); + while let Some(part) = parts.next() { + if !prefix.is_empty() { + prefix.push('/'); + } + prefix.push_str(part); + let last = parts.peek().is_none(); + let as_dir = if last { is_dir } else { true }; + match matcher.matched(&prefix, as_dir) { + ignore::Match::Ignore(glob) => { + return Verdict::Excluded { + pattern: glob.original().to_string(), + source: source(glob), + }; + } + ignore::Match::Whitelist(glob) if last => { + return Verdict::Included { + pattern: glob.original().to_string(), + source: source(glob), + }; + } + _ => {} + } + } + Verdict::Synced + } +} + impl std::fmt::Debug for IgnoreRules { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("IgnoreRules") @@ -255,6 +485,160 @@ mod tests { std::fs::write(root.join(name), body).unwrap(); } + #[test] + fn the_added_defaults_leave_out_clutter_but_not_look_alikes() { + let dir = TempDir::new(); + let rules = IgnoreRules::load(dir.path(), &globals()); + for (clutter, is_dir) in [ + ("desktop.ini", false), + ("Photos/.directory", false), + (".Trash-1000", true), + (".Trashes", true), + (".Spotlight-V100", true), + (".fuse_hidden0000001a00000002", false), + (".nfs000000000123abcd", false), + ("movie.mkv.part", false), + ("setup.exe.crdownload", false), + ("notes.txt.kate-swp", false), + (".~lock.report.odt#", false), + ("~$budget.xlsx", false), + ] { + assert!(rules.is_ignored(clutter, is_dir), "{clutter}"); + } + for kept in [ + "Desktop/notes.txt", + "directory.txt", + "Trash-talk.md", + "nfs-setup.md", + "parts.csv", + "part.txt", + "report.odt", + "budget.xlsx", + ] { + assert!(!rules.is_ignored(kept, false), "{kept}"); + } + } + + #[test] + fn a_bad_pattern_is_reported_with_its_line() { + assert!(check_pattern("*.db").is_ok()); + assert!(check_pattern("# a comment").is_ok()); + assert!(check_pattern("").is_ok()); + assert!(check_pattern("*.{jpg,png").is_err()); + assert!(check_pattern("[z-a]").is_err()); + let bad = check_rules("*.log\n{oops\nbuild/\n"); + assert_eq!(bad.len(), 1); + assert_eq!(bad[0].0, 2); + } + + #[test] + fn explain_names_the_rule_and_where_it_came_from() { + let dir = TempDir::new(); + write(dir.path(), ".pdfsignore", "*.db\n!keep.tmp\n"); + let rules = IgnoreRules::load(dir.path(), &globals()); + assert_eq!( + rules.explain("data/cache.db", false), + Verdict::Excluded { + pattern: "*.db".into(), + source: RuleSource::ThisFolder + } + ); + assert_eq!( + rules.explain("app/node_modules/x/index.js", false), + Verdict::Excluded { + pattern: "node_modules/".into(), + source: RuleSource::AllFolders + } + ); + assert_eq!( + rules.explain("keep.tmp", false), + Verdict::Included { + pattern: "!keep.tmp".into(), + source: RuleSource::ThisFolder + } + ); + assert_eq!(rules.explain("src/main.rs", false), Verdict::Synced); + // `explain` and `is_ignored` never disagree. + for (path, is_dir) in [ + ("data/cache.db", false), + ("keep.tmp", false), + ("x.tmp", false), + ] { + assert_eq!( + rules.is_ignored(path, is_dir), + matches!(rules.explain(path, is_dir), Verdict::Excluded { .. }), + "{path}" + ); + } + } + + #[test] + fn rules_being_edited_explain_like_the_saved_ones() { + let dir = TempDir::new(); + let text = "*.db\n!keep.db\n"; + write(dir.path(), ".pdfsignore", text); + let saved = IgnoreRules::load(dir.path(), &globals()); + let edited = IgnoreRules::with_folder_text(dir.path(), &globals(), text); + for path in ["a.db", "keep.db", "node_modules/x", "src/x.rs"] { + assert_eq!( + saved.explain(path, false), + edited.explain(path, false), + "{path}" + ); + } + } + + #[test] + fn folder_rules_are_written_back_and_removed_when_blank() { + let dir = TempDir::new(); + let rules = FolderRules::read(dir.path()).unwrap(); + assert_eq!(rules.text, None); + assert_eq!(rules.path, dir.path().join(".pdfsignore")); + rules.write("*.db").unwrap(); + assert_eq!( + std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(), + "*.db\n" + ); + assert!(IgnoreRules::load(dir.path(), &[]).is_ignored("x.db", false)); + + let rules = FolderRules::read(dir.path()).unwrap(); + rules.write(" \n").unwrap(); + assert!(!dir.path().join(".pdfsignore").exists()); + } + + #[test] + fn folder_rules_keep_the_file_name_in_use() { + let dir = TempDir::new(); + write(dir.path(), ".protonignore", "old/\n"); + let rules = FolderRules::read(dir.path()).unwrap(); + assert_eq!(rules.path, dir.path().join(".protonignore")); + rules.write("new/\n").unwrap(); + assert!(!dir.path().join(".pdfsignore").exists()); + assert_eq!( + std::fs::read_to_string(dir.path().join(".protonignore")).unwrap(), + "new/\n" + ); + } + + #[test] + fn folder_rules_changed_elsewhere_are_not_written_over() { + let dir = TempDir::new(); + write(dir.path(), ".pdfsignore", "a/\n"); + let rules = FolderRules::read(dir.path()).unwrap(); + write(dir.path(), ".pdfsignore", "b/\n"); + assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed))); + assert_eq!( + std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(), + "b/\n" + ); + + // A file that appeared after an empty read counts as a change too. + let dir = TempDir::new(); + let rules = FolderRules::read(dir.path()).unwrap(); + write(dir.path(), ".pdfsignore", "b/\n"); + assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed))); + } + #[test] fn no_rules_at_all_ignores_nothing() { let dir = TempDir::new(); diff --git a/crates/pdfs-fuse/src/control.rs b/crates/pdfs-fuse/src/control.rs index 34dfa7c..0db3cf0 100644 --- a/crates/pdfs-fuse/src/control.rs +++ b/crates/pdfs-fuse/src/control.rs @@ -1320,11 +1320,9 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U core.cache.set_budget(bytes); // Persist so the next mount keeps the new cap. Best-effort: a config // write failure is reported but the live cap is already applied. - match AppDirs::new().map(|dirs| { - let mut cfg = dirs.load_config(); - cfg.cache_budget = Some(bytes); - dirs.save_config(&cfg) - }) { + match AppDirs::new() + .map(|dirs| dirs.update_config(|cfg| cfg.cache_budget = Some(bytes))) + { Ok(Ok(())) => { core.touch_profile(); CtlResponse::Ok { @@ -1344,10 +1342,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // Persisted like the cache budget: best-effort, the live caps are // already applied. match AppDirs::new().map(|dirs| { - let mut cfg = dirs.load_config(); - cfg.upload_limit = Some(upload); - cfg.download_limit = Some(download); - dirs.save_config(&cfg) + dirs.update_config(|cfg| { + cfg.upload_limit = Some(upload); + cfg.download_limit = Some(download); + }) }) { Ok(Ok(())) => CtlResponse::Ok { message: format!( diff --git a/crates/pdfs-fuse/src/devices.rs b/crates/pdfs-fuse/src/devices.rs index 20b602e..1e3ef7e 100644 --- a/crates/pdfs-fuse/src/devices.rs +++ b/crates/pdfs-fuse/src/devices.rs @@ -123,9 +123,7 @@ pub(crate) fn sync_root_reserved() -> pdfs_core::syncroot::Reserved { pub(crate) fn set_adopted_device_uid(uid: Option<&str>) -> CoreResult<()> { let dirs = pdfs_core::config::AppDirs::new() .map_err(|e| CoreError::internal(format!("config dirs: {e}")))?; - let mut cfg = dirs.load_config(); - cfg.device_uid = uid.map(|u| u.to_string()); - dirs.save_config(&cfg) + dirs.update_config(|cfg| cfg.device_uid = uid.map(|u| u.to_string())) .map_err(|e| CoreError::internal(format!("write config: {e}"))) } diff --git a/crates/pdfs-gui/src/app/main.rs b/crates/pdfs-gui/src/app/main.rs index 559a169..99e2da4 100644 --- a/crates/pdfs-gui/src/app/main.rs +++ b/crates/pdfs-gui/src/app/main.rs @@ -26,6 +26,8 @@ use pages::photo_viewer::*; use pages::photos::*; use pages::places::*; use pages::places_map::*; +use pages::preferences_apps::*; +use pages::preferences_sync::*; use pages::shared::*; use pages::shared_by_me::*; use pages::status::*; @@ -39,6 +41,7 @@ use widgets::compat::*; use widgets::crumb::*; use widgets::details::*; use widgets::file_list::*; +use widgets::ignore_dialog::*; use widgets::menu::*; use widgets::photo_drag::*; use widgets::player::*; @@ -307,6 +310,18 @@ fn sync_view(page: &str) -> Option<&'static str> { } } +/// The Preferences page a `--page` name opens: "preferences" and +/// "preferences-" followed by the page's name. +fn preferences_page(page: &str) -> Option<&'static str> { + match page { + "preferences" | "preferences-general" => Some("general"), + "preferences-sync" => Some("sync"), + "preferences-apps" => Some("apps"), + "preferences-storage" => Some("storage"), + _ => None, + } +} + /// The Photos view a `--page` name opens, and whether Places shows its map: /// "albums", "places" and "places-map". Other names are stack pages. fn photos_view(page: &str) -> Option<(u32, bool)> { @@ -710,6 +725,8 @@ fn build_window(app: &adw::Application) { &main_widgets.purge_button, &main_widgets.mountpoint_button, ); + wire_sync_prefs(&ui, main_widgets.sync_prefs); + wire_apps_prefs(&ui, main_widgets.apps_prefs); wire_sidebar(&ui); wire_browser(&ui); wire_bulk( @@ -868,12 +885,10 @@ fn save_window_state(ui: &Ui, window: &adw::ApplicationWindow) { height, maximized: window.is_maximized(), }; - let mut config = ui.dirs.load_config(); - if config.window == state { + if ui.dirs.load_config().window == state { return; } - config.window = state; - if let Err(e) = ui.dirs.save_config(&config) { + if let Err(e) = ui.dirs.update_config(|config| config.window = state) { tracing::warn!("cannot save the window size: {e}"); } } @@ -1471,7 +1486,10 @@ fn install_launch_actions(ui: &Rc, app: &adw::Application, window: &adw::App show_login(&ui_page); return; } - if let Some(view) = sync_view(page) { + if let Some(name) = preferences_page(page) { + ui_page.status.prefs.set_visible_page_name(name); + ui_page.status.prefs.present(ui_window(&ui_page).as_ref()); + } else if let Some(view) = sync_view(page) { ui_page.locations.views.set_visible_child_name(view); ui_page.stack.set_visible_child_name("locations"); } else if let Some((view, map)) = photos_view(page) { @@ -2055,6 +2073,15 @@ mod tests { assert_eq!(sync_view("locations"), None); } + #[test] + fn a_page_name_can_open_a_preferences_page() { + assert_eq!(preferences_page("preferences"), Some("general")); + assert_eq!(preferences_page("preferences-sync"), Some("sync")); + assert_eq!(preferences_page("preferences-apps"), Some("apps")); + assert_eq!(preferences_page("preferences-storage"), Some("storage")); + assert_eq!(preferences_page("sync"), None); + } + /// One file of a shot, for the group-switch tests. fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem { PhotoItem { diff --git a/crates/pdfs-gui/src/app/pages/browser.rs b/crates/pdfs-gui/src/app/pages/browser.rs index 18ce6ec..36cb539 100644 --- a/crates/pdfs-gui/src/app/pages/browser.rs +++ b/crates/pdfs-gui/src/app/pages/browser.rs @@ -1431,9 +1431,11 @@ fn save_icon_size(ui: &Rc, size: i32) { let ui_save = ui.clone(); let source = glib::timeout_add_local_once(Duration::from_millis(500), move || { ui_save.browser.zoom_save.borrow_mut().take(); - let mut config = ui_save.dirs.load_config(); - config.files_view.icon_size = ui_save.browser.view.get().icon_size; - if let Err(e) = ui_save.dirs.save_config(&config) { + let icon_size = ui_save.browser.view.get().icon_size; + if let Err(e) = ui_save + .dirs + .update_config(|config| config.files_view.icon_size = icon_size) + { tracing::warn!("cannot save the icon size: {e}"); } }); @@ -1464,9 +1466,7 @@ pub(crate) fn set_files_view(ui: &Rc, view: FilesView) { return; } apply_files_view(ui, view); - let mut config = ui.dirs.load_config(); - config.files_view = view; - if let Err(e) = ui.dirs.save_config(&config) { + if let Err(e) = ui.dirs.update_config(|config| config.files_view = view) { toast_error(ui, &gettext("Couldn't save the view"), &e.to_string()); } if (old.sort, old.descending, old.folders_first) diff --git a/crates/pdfs-gui/src/app/pages/locations.rs b/crates/pdfs-gui/src/app/pages/locations.rs index b6cf862..1c9b573 100644 --- a/crates/pdfs-gui/src/app/pages/locations.rs +++ b/crates/pdfs-gui/src/app/pages/locations.rs @@ -1498,6 +1498,7 @@ fn folder_mode_label(ondemand: bool) -> String { /// synced folder's menu. fn add_device_items(ui: &Rc, menu: &mut ActionMenu, spec: &MountSpec, id: i64) { if spec.mode != MountMode::OnDemand { + let ui_ignore = ui.clone(); // A paused folder skips its passes, so Sync now would do nothing. if !spec.paused { let ui = ui.clone(); @@ -1516,6 +1517,14 @@ fn add_device_items(ui: &Rc, menu: &mut ActionMenu, spec: &MountSpec, id: i6 menu.item(&gettext("Sync From Scratch…"), move || { confirm_reset_sync_folder(&ui, id, &path) }); + // Only a synced copy has local files for the rules to leave out. + if spec.mode == MountMode::Mirror { + let ui = ui_ignore; + let root = PathBuf::from(&spec.local_path); + menu.item(&gettext("Excluded Files…"), move || { + present_ignore_dialog(&ui, id, root.clone()) + }); + } menu.section(); } let ui = ui.clone(); diff --git a/crates/pdfs-gui/src/app/pages/mod.rs b/crates/pdfs-gui/src/app/pages/mod.rs index b89ef4e..27550d9 100644 --- a/crates/pdfs-gui/src/app/pages/mod.rs +++ b/crates/pdfs-gui/src/app/pages/mod.rs @@ -12,6 +12,8 @@ pub(crate) mod photo_viewer; pub(crate) mod photos; pub(crate) mod places; pub(crate) mod places_map; +pub(crate) mod preferences_apps; +pub(crate) mod preferences_sync; pub(crate) mod shared; pub(crate) mod shared_by_me; pub(crate) mod status; diff --git a/crates/pdfs-gui/src/app/pages/photos.rs b/crates/pdfs-gui/src/app/pages/photos.rs index 7d3016b..5699eda 100644 --- a/crates/pdfs-gui/src/app/pages/photos.rs +++ b/crates/pdfs-gui/src/app/pages/photos.rs @@ -2129,16 +2129,17 @@ fn save_photos_view(ui: &Rc) { let ui_save = ui.clone(); let source = glib::timeout_add_local_once(Duration::from_millis(500), move || { ui_save.gallery.zoom_save.borrow_mut().take(); - let mut config = ui_save.dirs.load_config(); let view = PhotosView { row_height: Some(ui_save.gallery.row_height.get()), square: ui_save.gallery.square.get(), }; - if config.photos_view == view { + if ui_save.dirs.load_config().photos_view == view { return; } - config.photos_view = view; - if let Err(e) = ui_save.dirs.save_config(&config) { + if let Err(e) = ui_save + .dirs + .update_config(|config| config.photos_view = view) + { tracing::warn!("cannot save the Photos view: {e}"); } }); diff --git a/crates/pdfs-gui/src/app/pages/preferences_apps.rs b/crates/pdfs-gui/src/app/pages/preferences_apps.rs new file mode 100644 index 0000000..5cb34a9 --- /dev/null +++ b/crates/pdfs-gui/src/app/pages/preferences_apps.rs @@ -0,0 +1,606 @@ +//! Preferences → Apps: which program opens which file (`open_with`) and how +//! the search launcher shows itself (`prompt`). +//! +//! Neither involves the service. The app and the search launcher read both +//! again each time they open something, so a change applies to the next file +//! opened or the next search. + +use crate::*; +use pdfs_core::menu::{PromptConfig, PromptMode}; +use pdfs_core::opener::{ + OpenRule, OpenWith, command_available, format_command, parse_command, resolve_terminal, +}; + +/// The widgets of the Apps page, built with the rest of the dialog and wired +/// once the app's state exists. +pub(crate) struct AppsPrefs { + pub(crate) page: adw::PreferencesPage, + rules: adw::PreferencesGroup, + add_rule: gtk4::Button, + other_row: adw::EntryRow, + terminal_row: adw::EntryRow, + mode_row: adw::ComboRow, + menu_row: adw::EntryRow, + prompt_terminal_row: adw::EntryRow, + limit_row: adw::SpinRow, + icons_row: adw::SwitchRow, +} + +/// The launcher modes in the order the combo row lists them. +const MODES: [PromptMode; 3] = [PromptMode::Gtk, PromptMode::Dmenu, PromptMode::Fzf]; + +/// The file classes a rule can name, with what the dialog calls them. +fn classes() -> [(&'static str, String); 6] { + [ + ("@text", gettext("Text")), + ("@document", gettext("Documents")), + ("@image", gettext("Images")), + ("@media", gettext("Audio and Video")), + ("@dir", gettext("Folders")), + ("@any", gettext("Everything")), + ] +} + +pub(crate) fn build_apps_prefs() -> AppsPrefs { + let add_rule = gtk4::Button::builder() + .label(gettext("Add Rule…")) + .valign(gtk4::Align::Center) + .build(); + add_rule.add_css_class("flat"); + let rules = adw::PreferencesGroup::builder() + .title(gettext("Open Files With")) + .description(gettext( + "For files opened from Proton Drive and the search launcher. The first rule that matches a file decides; other files open in their default app.", + )) + .header_suffix(&add_rule) + .build(); + + let other_row = adw::EntryRow::builder() + .title(gettext("Other files (empty: default app)")) + .show_apply_button(true) + .build(); + other_row.add_css_class("monospace"); + let terminal_row = adw::EntryRow::builder() + .title(terminal_title()) + .show_apply_button(true) + .build(); + terminal_row.add_css_class("monospace"); + let other = adw::PreferencesGroup::new(); + other.add(&other_row); + other.add(&terminal_row); + + let mode_row = adw::ComboRow::builder() + .title(gettext("Opens as")) + .model(>k4::StringList::new(&[ + &gettext("Window"), + &gettext("Your Launcher"), + &gettext("fzf in a Terminal"), + ])) + .build(); + let menu_row = adw::EntryRow::builder() + .title(gettext("Launcher command (empty: find one)")) + .show_apply_button(true) + .build(); + menu_row.add_css_class("monospace"); + let prompt_terminal_row = adw::EntryRow::builder() + .title(terminal_title()) + .show_apply_button(true) + .build(); + prompt_terminal_row.add_css_class("monospace"); + let limit_row = adw::SpinRow::builder() + .title(gettext("Results shown")) + .adjustment(>k4::Adjustment::new( + pdfs_core::menu::DEFAULT_MENU_LIMIT as f64, + 5.0, + 500.0, + 5.0, + 25.0, + 0.0, + )) + .build(); + let icons_row = adw::SwitchRow::builder() + .title(gettext("Show icons")) + .subtitle(gettext("When the launcher can show them")) + .build(); + let launcher = adw::PreferencesGroup::builder() + .title(gettext("Search Launcher")) + .description(gettext( + "How “pdfs-prompt” shows search results, for example from a keyboard shortcut. Your launcher can be any program that reads choices like dmenu, such as rofi, wofi, fuzzel or bemenu.", + )) + .build(); + launcher.add(&mode_row); + launcher.add(&menu_row); + launcher.add(&prompt_terminal_row); + launcher.add(&limit_row); + launcher.add(&icons_row); + + let page = adw::PreferencesPage::builder() + .title(gettext("Apps")) + .name("apps") + .icon_name("application-x-executable-symbolic") + .build(); + page.add(&rules); + page.add(&other); + page.add(&launcher); + AppsPrefs { + page, + rules, + add_rule, + other_row, + terminal_row, + mode_row, + menu_row, + prompt_terminal_row, + limit_row, + icons_row, + } +} + +/// "Terminal", naming the one used when the row is left empty. +fn terminal_title() -> String { + match resolve_terminal() { + // Translators: {terminal} is a terminal command line such as "foot -e". + Some(found) => gettext_f( + "Terminal (empty: {terminal})", + &[("terminal", &format_command(&found))], + ), + None => gettext("Terminal"), + } +} + +/// Shared by every handler of the page. +struct Apps { + ui: Rc, + widgets: AppsPrefs, + rule_rows: RefCell>, +} + +/// Fill the page from the config and connect its controls. +pub(crate) fn wire_apps_prefs(ui: &Rc, widgets: AppsPrefs) { + let apps = Rc::new(Apps { + ui: ui.clone(), + widgets, + rule_rows: RefCell::default(), + }); + let config = ui.dirs.load_config(); + let open_with = config.resolved_open_with(); + let prompt = config.resolved_prompt(); + let w = &apps.widgets; + + let suppress = ui.status.settings_suppress.replace(true); + paint_rules(&apps, &open_with); + w.other_row + .set_text(&format_command(open_with.default.as_deref().unwrap_or(&[]))); + w.terminal_row.set_text(&format_command( + open_with.terminal.as_deref().unwrap_or(&[]), + )); + let mode = prompt.resolved_mode(); + w.mode_row + .set_selected(MODES.iter().position(|m| *m == mode).unwrap_or_default() as u32); + w.menu_row + .set_text(&format_command(prompt.menu.as_deref().unwrap_or(&[]))); + w.prompt_terminal_row + .set_text(&format_command(prompt.terminal.as_deref().unwrap_or(&[]))); + w.limit_row.set_value(prompt.resolved_menu_limit() as f64); + w.icons_row.set_active(prompt.resolved_menu_icons()); + show_mode_rows(w, mode); + ui.status.settings_suppress.set(suppress); + + let a = apps.clone(); + w.add_rule + .connect_clicked(move |_| edit_rule(&a, None, OpenRule::default())); + + // Command lines: checked as typed, saved on apply. Empty means "unset". + connect_command_row(&apps, &w.other_row, |config, argv| { + open_with_of(config).default = argv; + }); + connect_command_row(&apps, &w.terminal_row, |config, argv| { + open_with_of(config).terminal = argv; + }); + connect_command_row(&apps, &w.menu_row, |config, argv| { + prompt_of(config).menu = argv; + }); + connect_command_row(&apps, &w.prompt_terminal_row, |config, argv| { + prompt_of(config).terminal = argv; + }); + + let a = apps.clone(); + w.mode_row.connect_selected_notify(move |row| { + if a.ui.status.settings_suppress.get() { + return; + } + let mode = MODES + .get(row.selected() as usize) + .copied() + .unwrap_or_default(); + show_mode_rows(&a.widgets, mode); + save(&a, move |config| { + prompt_of(config).mode = (mode != PromptMode::default()).then_some(mode); + }); + }); + let a = apps.clone(); + w.limit_row.connect_value_notify(move |row| { + if a.ui.status.settings_suppress.get() { + return; + } + let limit = row.value().round() as usize; + save(&a, move |config| { + prompt_of(config).menu_limit = + (limit != pdfs_core::menu::DEFAULT_MENU_LIMIT).then_some(limit); + }); + }); + let a = apps.clone(); + w.icons_row.connect_active_notify(move |row| { + if a.ui.status.settings_suppress.get() { + return; + } + let on = row.is_active(); + save(&a, move |config| { + prompt_of(config).menu_icons = (!on).then_some(false) + }); + }); +} + +/// Show only the rows the chosen launcher mode uses. +fn show_mode_rows(w: &AppsPrefs, mode: PromptMode) { + w.menu_row.set_visible(mode == PromptMode::Dmenu); + w.icons_row.set_visible(mode == PromptMode::Dmenu); + w.prompt_terminal_row.set_visible(mode == PromptMode::Fzf); + w.limit_row.set_visible(mode != PromptMode::Gtk); +} + +/// The `open_with` section, created when absent. +fn open_with_of(config: &mut pdfs_core::config::AppConfig) -> &mut OpenWith { + config.open_with.get_or_insert_with(OpenWith::default) +} + +/// The `prompt` section, created when absent. +fn prompt_of(config: &mut pdfs_core::config::AppConfig) -> &mut PromptConfig { + config.prompt.get_or_insert_with(PromptConfig::default) +} + +/// Save a change, then drop sections left at their defaults so the file only +/// holds what the user chose. Says whether it saved. +fn save(apps: &Rc, change: impl FnOnce(&mut pdfs_core::config::AppConfig)) -> bool { + let saved = apps.ui.dirs.update_config(|config| { + change(config); + if config.open_with.as_ref() == Some(&OpenWith::default()) { + config.open_with = None; + } + if config.prompt.as_ref() == Some(&PromptConfig::default()) { + config.prompt = None; + } + config.resolved_open_with() + }); + match saved { + Ok(open_with) => { + paint_rules(apps, &open_with); + true + } + Err(e) => { + prefs_toast( + &apps.ui, + &gettext_f( + "{what}: {detail}", + &[ + ("what", &gettext("Couldn't save the setting")), + ("detail", &e.to_string()), + ], + ), + ); + false + } + } +} + +/// Check a command line as it is typed, and save it when applied. +fn connect_command_row( + apps: &Rc, + row: &adw::EntryRow, + store: impl Fn(&mut pdfs_core::config::AppConfig, Option>) + 'static, +) { + row.connect_changed(|row| mark_command(row, false)); + let a = apps.clone(); + row.connect_apply(move |row| { + let Some(argv) = parse_command(&row.text()) else { + prefs_toast(&a.ui, &gettext("A quote is not closed in the command")); + return; + }; + if !argv.is_empty() && !command_available(&argv) { + prefs_toast( + &a.ui, + // Translators: {program} is a program name such as "nvim". + &gettext_f( + "“{program}” isn't installed; saved anyway", + &[("program", &argv[0])], + ), + ); + } + let argv = (!argv.is_empty()).then_some(argv); + save(&a, |config| store(config, argv)); + mark_command(row, true); + }); +} + +/// Mark a command line that doesn't parse as an error, and, once `applied`, +/// one whose program isn't found as a warning. +fn mark_command(row: &adw::EntryRow, applied: bool) { + row.remove_css_class("error"); + row.remove_css_class("warning"); + match parse_command(&row.text()) { + None => row.add_css_class("error"), + Some(argv) if applied && !argv.is_empty() && !command_available(&argv) => { + row.add_css_class("warning") + } + Some(_) => {} + } +} + +/// Show the rules, one row each, in the order they are tried. +fn paint_rules(apps: &Rc, open_with: &OpenWith) { + let group = &apps.widgets.rules; + for row in apps.rule_rows.borrow_mut().drain(..) { + group.remove(&row); + } + let count = open_with.rules.len(); + if count == 0 { + let row = adw::ActionRow::builder() + .title(gettext("No rules: every file opens in its default app")) + .build(); + row.add_css_class("dim-label"); + group.add(&row); + apps.rule_rows.borrow_mut().push(row); + return; + } + let names = classes(); + for (index, rule) in open_with.rules.iter().enumerate() { + let patterns: Vec = rule + .patterns + .iter() + .map(|p| { + names + .iter() + .find(|(class, _)| class == p) + .map_or_else(|| p.clone(), |(_, name)| name.clone()) + }) + .collect(); + let command = format_command(&rule.command); + let subtitle = if rule.terminal { + // Translators: {command} is a command line such as "nvim". + gettext_f("{command}, in a terminal", &[("command", &command)]) + } else { + command + }; + let row = adw::ActionRow::builder() + .title(patterns.join(", ")) + .subtitle(subtitle) + .use_markup(false) + .activatable(true) + .build(); + if !command_available(&rule.command) { + let warning = gtk4::Image::builder() + .icon_name("dialog-warning-symbolic") + // Translators: {program} is a program name such as "nvim". + .tooltip_text(gettext_f( + "“{program}” isn't installed", + &[("program", rule.command.first().map_or("", String::as_str))], + )) + .build(); + warning.add_css_class("warning"); + row.add_prefix(&warning); + } + let up = rule_button("go-up-symbolic", &gettext("Move Up"), index > 0); + let down = rule_button("go-down-symbolic", &gettext("Move Down"), index + 1 < count); + let remove = rule_button("user-trash-symbolic", &gettext("Remove"), true); + let a = apps.clone(); + up.connect_clicked(move |_| { + save(&a, |config| { + open_with_of(config).rules.swap(index - 1, index) + }); + }); + let a = apps.clone(); + down.connect_clicked(move |_| { + save(&a, |config| { + open_with_of(config).rules.swap(index, index + 1) + }); + }); + let a = apps.clone(); + remove.connect_clicked(move |_| { + save(&a, |config| { + let rules = &mut open_with_of(config).rules; + if index < rules.len() { + rules.remove(index); + } + }); + }); + row.add_suffix(&up); + row.add_suffix(&down); + row.add_suffix(&remove); + let a = apps.clone(); + let rule = rule.clone(); + row.connect_activated(move |_| edit_rule(&a, Some(index), rule.clone())); + group.add(&row); + apps.rule_rows.borrow_mut().push(row); + } +} + +fn rule_button(icon: &str, tooltip: &str, sensitive: bool) -> gtk4::Button { + let button = gtk4::Button::builder() + .icon_name(icon) + .tooltip_text(tooltip) + .valign(gtk4::Align::Center) + .sensitive(sensitive) + .build(); + button.add_css_class("flat"); + button +} + +/// Split a typed pattern list into patterns, dropping empty ones. +fn split_patterns(text: &str) -> Vec { + text.split(',') + .map(str::trim) + .filter(|p| !p.is_empty()) + .map(str::to_string) + .collect() +} + +/// Edit one rule, or a new one when `index` is `None`, in a dialog over the +/// Preferences. +fn edit_rule(apps: &Rc, index: Option, rule: OpenRule) { + let patterns_row = adw::EntryRow::builder() + .title(gettext("Files, such as *.md, *.txt")) + .text(rule.patterns.join(", ")) + .build(); + patterns_row.add_css_class("monospace"); + let chips = gtk4::FlowBox::builder() + .selection_mode(gtk4::SelectionMode::None) + .column_spacing(6) + .row_spacing(6) + .max_children_per_line(6) + .margin_top(6) + .build(); + for (class, name) in classes() { + let chip = gtk4::Button::builder().label(&name).build(); + chip.add_css_class("pill"); + chip.add_css_class("small"); + let row = patterns_row.clone(); + chip.connect_clicked(move |_| { + let mut list = split_patterns(&row.text()); + if !list.iter().any(|p| p == class) { + list.push(class.to_string()); + } + row.set_text(&list.join(", ")); + }); + chips.insert(&chip, -1); + } + let command_row = adw::EntryRow::builder() + .title(gettext("Command, such as nvim or code --wait")) + .text(format_command(&rule.command)) + .build(); + command_row.add_css_class("monospace"); + let terminal_row = adw::SwitchRow::builder() + .title(gettext("Run in a terminal")) + .subtitle(gettext("For programs that run in a terminal, such as vim")) + .active(rule.terminal) + .build(); + let hint = gtk4::Label::builder() + .wrap(true) + .xalign(0.0) + .margin_top(6) + .build(); + hint.add_css_class("caption"); + hint.add_css_class("dim-label"); + + let group = adw::PreferencesGroup::new(); + group.add(&patterns_row); + let files = adw::PreferencesGroup::builder() + .description(gettext("Or pick kinds of files:")) + .build(); + files.add(&chips); + let program = adw::PreferencesGroup::new(); + program.add(&command_row); + program.add(&terminal_row); + program.add(&hint); + let page = adw::PreferencesPage::new(); + page.add(&group); + page.add(&files); + page.add(&program); + + let cancel = gtk4::Button::with_label(&gettext("Cancel")); + let save_button = gtk4::Button::with_label(&gettext("Save")); + save_button.add_css_class("suggested-action"); + let header = adw::HeaderBar::builder() + .show_start_title_buttons(false) + .show_end_title_buttons(false) + .build(); + header.pack_start(&cancel); + header.pack_end(&save_button); + let view = adw::ToolbarView::new(); + view.add_top_bar(&header); + view.set_content(Some(&page)); + let dialog = adw::Dialog::builder() + .title(if index.is_some() { + gettext("Edit Rule") + } else { + gettext("New Rule") + }) + .content_width(480) + .child(&view) + .build(); + + // Save only a rule that matches something and runs something. + let check = { + let (patterns_row, command_row, save_button, hint) = ( + patterns_row.clone(), + command_row.clone(), + save_button.clone(), + hint.clone(), + ); + move || { + let patterns = split_patterns(&patterns_row.text()); + let argv = parse_command(&command_row.text()); + command_row.remove_css_class("error"); + hint.set_text(""); + match &argv { + None => { + command_row.add_css_class("error"); + hint.set_text(&gettext("A quote is not closed in the command.")); + } + Some(argv) if !argv.is_empty() && !command_available(argv) => { + hint.set_text(&gettext_f( + "“{program}” isn't installed.", + &[("program", &argv[0])], + )); + } + Some(_) => {} + } + save_button + .set_sensitive(!patterns.is_empty() && argv.is_some_and(|argv| !argv.is_empty())); + } + }; + check(); + let c = check.clone(); + patterns_row.connect_changed(move |_| c()); + command_row.connect_changed(move |_| check()); + + let d = dialog.clone(); + cancel.connect_clicked(move |_| { + d.close(); + }); + let (a, d) = (apps.clone(), dialog.clone()); + save_button.connect_clicked(move |_| { + let Some(command) = parse_command(&command_row.text()) else { + return; + }; + let rule = OpenRule { + patterns: split_patterns(&patterns_row.text()), + command, + terminal: terminal_row.is_active(), + }; + let saved = save(&a, move |config| { + let rules = &mut open_with_of(config).rules; + match index { + Some(i) if i < rules.len() => rules[i] = rule, + _ => rules.push(rule), + } + }); + if saved { + d.close(); + } + }); + dialog.present(Some(&apps.ui.status.prefs)); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn typed_patterns_are_split_on_commas() { + assert_eq!( + split_patterns(" *.md, @text ,, notes-*.txt "), + ["*.md", "@text", "notes-*.txt"] + ); + assert!(split_patterns(" , ").is_empty()); + } +} diff --git a/crates/pdfs-gui/src/app/pages/preferences_sync.rs b/crates/pdfs-gui/src/app/pages/preferences_sync.rs new file mode 100644 index 0000000..0ff49bb --- /dev/null +++ b/crates/pdfs-gui/src/app/pages/preferences_sync.rs @@ -0,0 +1,347 @@ +//! Preferences → Sync: the patterns every synced folder leaves out +//! (`ignore_patterns`) and what the conflict sweep may do (`conflict_sweep`). +//! +//! Both live in `config.json`. The daemon reads the patterns again on every +//! sync pass, so a change here is followed by a Sync Now and applies at once; +//! the sweep mode is read when the service starts, so a change offers a +//! restart, as the mountpoint does. + +use crate::*; +use pdfs_core::config::SweepMode; +use pdfs_core::syncignore::{DEFAULT_IGNORE_PATTERNS, check_pattern}; + +/// The widgets of the Sync page, built with the rest of the dialog and wired +/// once the app's state exists. +pub(crate) struct SyncPrefs { + pub(crate) page: adw::PreferencesPage, + patterns: adw::PreferencesGroup, + add_row: adw::EntryRow, + reset: gtk4::Button, + sweep_row: adw::ComboRow, + /// Whether the built-in patterns are shown, kept across repaints. + builtin_expanded: Cell, +} + +/// The sweep modes in the order the combo row lists them. +const SWEEP_MODES: [SweepMode; 3] = [SweepMode::Report, SweepMode::Enforce, SweepMode::Off]; + +pub(crate) fn build_sync_prefs() -> SyncPrefs { + let reset = gtk4::Button::builder() + .label(gettext("Reset")) + .tooltip_text(gettext("Use the built-in patterns again")) + .valign(gtk4::Align::Center) + .build(); + reset.add_css_class("flat"); + let patterns = adw::PreferencesGroup::builder() + .title(gettext("Excluded Files")) + .description(gettext( + "Files and folders matching these patterns are not synced in any synced folder. Use * for any characters, end a pattern with / to match folders only, and start it with ! to include something again. Excluding never deletes anything from Proton Drive.", + )) + .header_suffix(&reset) + .build(); + let add_row = adw::EntryRow::builder() + .title(gettext("Add Pattern")) + .show_apply_button(true) + .build(); + add_row.add_css_class("monospace"); + patterns.add(&add_row); + + let sweep_row = adw::ComboRow::builder() + .title(gettext("Identical conflict copies")) + .subtitle(gettext( + "A copy made when a file changed in two places, found to be the same as the file", + )) + .model(>k4::StringList::new(&[ + &gettext("Report Only"), + &gettext("Move to Trash"), + &gettext("Off"), + ])) + .build(); + let conflicts = adw::PreferencesGroup::builder() + .title(gettext("Conflict Copies")) + .build(); + conflicts.add(&sweep_row); + + let page = adw::PreferencesPage::builder() + .title(gettext("Sync")) + .name("sync") + .icon_name("pdfs-sync-symbolic") + .build(); + page.add(&patterns); + page.add(&conflicts); + SyncPrefs { + page, + patterns, + add_row, + reset, + sweep_row, + builtin_expanded: Cell::new(false), + } +} + +/// Fill the page from the config and connect its controls. +pub(crate) fn wire_sync_prefs(ui: &Rc, widgets: SyncPrefs) { + let widgets = Rc::new(widgets); + let rows: Rc>> = Rc::default(); + let config = ui.dirs.load_config(); + paint_patterns(ui, &widgets, &rows, &config); + + let mode = config.conflict_sweep.unwrap_or_default(); + let suppress = ui.status.settings_suppress.replace(true); + widgets.sweep_row.set_selected( + SWEEP_MODES + .iter() + .position(|m| *m == mode) + .unwrap_or_default() as u32, + ); + ui.status.settings_suppress.set(suppress); + + widgets.add_row.connect_changed(|row| { + let text = row.text(); + if text.trim().is_empty() || check_pattern(text.trim()).is_ok() { + row.remove_css_class("error"); + } else { + row.add_css_class("error"); + } + }); + let (ui_add, w_add, rows_add) = (ui.clone(), widgets.clone(), rows.clone()); + widgets.add_row.connect_apply(move |row| { + let pattern = row.text().trim().to_string(); + if pattern.is_empty() { + return; + } + if let Err(e) = check_pattern(&pattern) { + tracing::debug!(%pattern, error = %e, "not a valid ignore pattern"); + prefs_toast( + &ui_add, + // Translators: {pattern} is what the user typed as a pattern. + &gettext_f( + "“{pattern}” isn't a valid pattern", + &[("pattern", &pattern)], + ), + ); + return; + } + let added = change_patterns(&ui_add, &w_add, &rows_add, |list| { + if !list.contains(&pattern) { + list.push(pattern.clone()); + } + }); + if added { + row.set_text(""); + } + }); + + let (ui_reset, w_reset, rows_reset) = (ui.clone(), widgets.clone(), rows.clone()); + widgets.reset.connect_clicked(move |_| { + let (ui, w, rows) = (ui_reset.clone(), w_reset.clone(), rows_reset.clone()); + confirm_destructive( + &ui_reset.status.prefs, + &gettext("Reset Excluded Files?"), + &gettext("Your own patterns are removed, and the built-in ones apply again."), + &gettext("Reset"), + move || { + change_patterns(&ui, &w, &rows, |list| { + *list = default_patterns(); + }); + }, + ); + }); + + let ui_sweep = ui.clone(); + widgets.sweep_row.connect_selected_notify(move |row| { + if ui_sweep.status.settings_suppress.get() { + return; + } + let Some(mode) = SWEEP_MODES.get(row.selected() as usize).copied() else { + return; + }; + let stored = (mode != SweepMode::default()).then_some(mode); + match ui_sweep + .dirs + .update_config(|config| config.conflict_sweep = stored) + { + Ok(()) => offer_restart(&ui_sweep), + Err(e) => prefs_toast( + &ui_sweep, + &gettext_f( + "{what}: {detail}", + &[ + ("what", &gettext("Couldn't save the setting")), + ("detail", &e.to_string()), + ], + ), + ), + } + }); +} + +fn default_patterns() -> Vec { + DEFAULT_IGNORE_PATTERNS + .iter() + .map(|p| (*p).to_string()) + .collect() +} + +/// Apply `edit` to the patterns in effect and save them, then show them and +/// have every synced folder sync with them. A list equal to the built-in one +/// is saved as "unset", so it follows the built-in list in later releases. +/// Says whether it saved. +fn change_patterns( + ui: &Rc, + widgets: &Rc, + rows: &Rc>>, + edit: impl FnOnce(&mut Vec), +) -> bool { + let saved = ui.dirs.update_config(|config| { + let mut list = config.resolved_ignore_patterns(); + edit(&mut list); + config.ignore_patterns = (list != default_patterns()).then_some(list); + config.clone() + }); + match saved { + Ok(config) => { + paint_patterns(ui, widgets, rows, &config); + // Best effort: the next pass picks the change up anyway. + let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: None }); + true + } + Err(e) => { + prefs_toast( + ui, + &gettext_f( + "{what}: {detail}", + &[ + ("what", &gettext("Couldn't save the patterns")), + ("detail", &e.to_string()), + ], + ), + ); + false + } + } +} + +/// Show the patterns in effect below the entry row: the user's own one row +/// each, then the built-in ones folded into one row, since they are many and +/// rarely changed. +fn paint_patterns( + ui: &Rc, + widgets: &Rc, + rows: &Rc>>, + config: &pdfs_core::config::AppConfig, +) { + for row in rows.borrow_mut().drain(..) { + widgets.patterns.remove(&row); + } + widgets + .reset + .set_sensitive(config.ignore_patterns.is_some()); + let list = config.resolved_ignore_patterns(); + let (builtin, own): (Vec, Vec) = list + .into_iter() + .partition(|p| DEFAULT_IGNORE_PATTERNS.contains(&p.as_str())); + for pattern in own { + let row = pattern_row(ui, widgets, rows, pattern); + widgets.patterns.add(&row); + rows.borrow_mut().push(row.upcast()); + } + // Every built-in pattern, on or off, so one turned off can be turned on + // again without losing the user's own. + let on = builtin.len(); + let total = DEFAULT_IGNORE_PATTERNS.len(); + let expander = adw::ExpanderRow::builder() + .title(gettext("Built-in patterns")) + // Translators: {on} and {total} are numbers of patterns. + .subtitle(gettext_f( + "{on} of {total} on: version control, dependency and build folders, and what editors, downloads and systems leave behind", + &[("on", &on.to_string()), ("total", &total.to_string())], + )) + .expanded(widgets.builtin_expanded.get()) + .build(); + let w = widgets.clone(); + expander.connect_expanded_notify(move |row| w.builtin_expanded.set(row.is_expanded())); + for pattern in DEFAULT_IGNORE_PATTERNS { + let row = adw::SwitchRow::builder() + .title(format!("{}", glib::markup_escape_text(pattern))) + .use_markup(true) + .active(builtin.iter().any(|p| p == pattern)) + .build(); + let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone()); + row.connect_active_notify(move |row| { + let active = row.is_active(); + // Repainting replaces this row; let the switch finish first. + let (ui, w, r) = (ui.clone(), w.clone(), r.clone()); + glib::idle_add_local_once(move || { + change_patterns(&ui, &w, &r, move |list| { + list.retain(|p| p != pattern); + if active { + list.push((*pattern).to_string()); + } + }); + }); + }); + expander.add_row(&row); + } + widgets.patterns.add(&expander); + rows.borrow_mut().push(expander.upcast()); +} + +/// One pattern, in monospace, with a button that removes it. +fn pattern_row( + ui: &Rc, + widgets: &Rc, + rows: &Rc>>, + pattern: String, +) -> adw::ActionRow { + let row = adw::ActionRow::builder() + .title(format!("{}", glib::markup_escape_text(&pattern))) + .use_markup(true) + .build(); + let remove = gtk4::Button::builder() + .icon_name("user-trash-symbolic") + .tooltip_text(gettext("Remove")) + .valign(gtk4::Align::Center) + .build(); + remove.add_css_class("flat"); + let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone()); + remove.connect_clicked(move |_| { + let pattern = pattern.clone(); + change_patterns(&ui, &w, &r, move |list| list.retain(|p| *p != pattern)); + }); + row.add_suffix(&remove); + row +} + +/// The sweep mode is read when the service starts; offer that restart. +fn offer_restart(ui: &Rc) { + let confirm = adw::AlertDialog::builder() + .heading(gettext("Restart Proton Drive?")) + .body(gettext( + "The new setting applies after Proton Drive restarts.", + )) + .build(); + confirm.add_response("later", &gettext("Later")); + confirm.add_response("restart", &gettext("Restart Now")); + confirm.set_response_appearance("restart", adw::ResponseAppearance::Suggested); + confirm.set_default_response(Some("restart")); + confirm.set_close_response("later"); + let ui_restart = ui.clone(); + confirm.connect_response(None, move |_, resp| { + if resp == "restart" { + restart_service_then(&ui_restart, |_| {}); + } + }); + confirm.present(Some(&ui.status.prefs)); +} + +/// A toast on the Preferences dialog, which covers the window's own toasts. +pub(crate) fn prefs_toast(ui: &Rc, message: &str) { + ui.status.prefs.add_toast( + adw::Toast::builder() + .title(message) + .use_markup(false) + .timeout(6) + .build(), + ); +} diff --git a/crates/pdfs-gui/src/app/pages/status.rs b/crates/pdfs-gui/src/app/pages/status.rs index 0176ee2..2a82564 100644 --- a/crates/pdfs-gui/src/app/pages/status.rs +++ b/crates/pdfs-gui/src/app/pages/status.rs @@ -169,6 +169,9 @@ pub(crate) struct MainWidgets { pub(crate) tray_row: adw::SwitchRow, pub(crate) update_row: adw::SwitchRow, pub(crate) language_row: adw::ComboRow, + /// Preferences → Sync and → Apps, wired once the app's state exists. + pub(crate) sync_prefs: SyncPrefs, + pub(crate) apps_prefs: AppsPrefs, } /// Build the two surfaces that replaced the old Settings page: @@ -267,6 +270,7 @@ pub(crate) fn build_main_page() -> MainWidgets { let general = adw::PreferencesPage::builder() .title(gettext("General")) + .name("general") .icon_name("preferences-system-symbolic") .build(); general.add(&startup_group); @@ -335,6 +339,7 @@ pub(crate) fn build_main_page() -> MainWidgets { let storage = adw::PreferencesPage::builder() .title(gettext("Storage")) + .name("storage") .icon_name("drive-harddisk-symbolic") .build(); storage.add(&storage_group); @@ -343,7 +348,11 @@ pub(crate) fn build_main_page() -> MainWidgets { let prefs = adw::PreferencesDialog::builder() .search_enabled(false) .build(); + let sync_prefs = build_sync_prefs(); + let apps_prefs = build_apps_prefs(); prefs.add(&general); + prefs.add(&sync_prefs.page); + prefs.add(&apps_prefs.page); prefs.add(&storage); // ---- Sidebar footer @@ -463,6 +472,8 @@ pub(crate) fn build_main_page() -> MainWidgets { tray_row, update_row, language_row, + sync_prefs, + apps_prefs, } } @@ -678,9 +689,10 @@ pub(crate) fn wire_settings( let rows = list.model.n_items(); list.model.items_changed(0, rows, rows); } - let mut config = ui_theme.dirs.load_config(); - config.proton_theme = Some(on); - if let Err(e) = ui_theme.dirs.save_config(&config) { + if let Err(e) = ui_theme + .dirs + .update_config(|config| config.proton_theme = Some(on)) + { toast_error( &ui_theme, &gettext("Couldn't save the theme"), @@ -700,9 +712,7 @@ pub(crate) fn wire_settings( .gallery .places_map .set_online(on, ui_map.dirs.cache_dir()); - let mut config = ui_map.dirs.load_config(); - config.online_map = on; - if let Err(e) = ui_map.dirs.save_config(&config) { + if let Err(e) = ui_map.dirs.update_config(|config| config.online_map = on) { toast_error( &ui_map, &gettext("Couldn't save the map setting"), @@ -717,9 +727,10 @@ pub(crate) fn wire_settings( if ui_update.status.settings_suppress.get() { return; } - let mut config = ui_update.dirs.load_config(); - config.update_check = row.is_active(); - if let Err(e) = ui_update.dirs.save_config(&config) { + if let Err(e) = ui_update + .dirs + .update_config(|config| config.update_check = row.is_active()) + { toast_error( &ui_update, &gettext("Couldn't save the update setting"), @@ -739,9 +750,10 @@ pub(crate) fn wire_settings( return; } let show = row.is_active(); - let mut config = ui_tray.dirs.load_config(); - config.tray_hidden = !show; - if let Err(e) = ui_tray.dirs.save_config(&config) { + if let Err(e) = ui_tray + .dirs + .update_config(|config| config.tray_hidden = !show) + { toast_error( &ui_tray, &gettext("Couldn't save the tray setting"), @@ -763,9 +775,9 @@ pub(crate) fn wire_settings( if ui_language.status.settings_suppress.get() { return; } - let mut config = ui_language.dirs.load_config(); - config.language = language_at(row.selected()).map(str::to_string); - if let Err(e) = ui_language.dirs.save_config(&config) { + if let Err(e) = ui_language.dirs.update_config(|config| { + config.language = language_at(row.selected()).map(str::to_string) + }) { toast_error( &ui_language, &gettext("Couldn't save the language"), @@ -864,9 +876,10 @@ fn use_mountpoint(ui: &Rc, path: &std::path::Path) { let path_str = path.display().to_string(); // Persist the choice to config so the next mount uses it. - let mut config = ui.dirs.load_config(); - config.mountpoint = Some(path_str.clone()); - if let Err(e) = ui.dirs.save_config(&config) { + if let Err(e) = ui + .dirs + .update_config(|config| config.mountpoint = Some(path_str.clone())) + { toast_error(ui, &gettext("Couldn't save the folder"), &e.to_string()); return; } diff --git a/crates/pdfs-gui/src/app/update.rs b/crates/pdfs-gui/src/app/update.rs index b364757..cab063d 100644 --- a/crates/pdfs-gui/src/app/update.rs +++ b/crates/pdfs-gui/src/app/update.rs @@ -82,10 +82,10 @@ pub(crate) fn start_update_checks(ui: &Rc) { match fetch_latest().await { Ok(latest) => { checked = Some(unix_now()); - let mut config = ui.dirs.load_config(); - config.update_last_checked = checked; - config.update_latest = latest; - if let Err(e) = ui.dirs.save_config(&config) { + if let Err(e) = ui.dirs.update_config(|config| { + config.update_last_checked = checked; + config.update_latest = latest; + }) { tracing::warn!("update check: cannot save the result: {e}"); } show_latest(&ui); diff --git a/crates/pdfs-gui/src/app/widgets/ignore_dialog.rs b/crates/pdfs-gui/src/app/widgets/ignore_dialog.rs new file mode 100644 index 0000000..f7c52c5 --- /dev/null +++ b/crates/pdfs-gui/src/app/widgets/ignore_dialog.rs @@ -0,0 +1,342 @@ +//! The Excluded Files dialog of one synced folder: its own `.pdfsignore`, +//! edited as text, with a check of what the rules do to a path. +//! +//! The file sits in the synced folder and syncs like any other file, so it can +//! change on another computer while it is open here. Saving checks for that +//! and asks, rather than writing over the other edit. + +use crate::*; +use pdfs_core::syncignore::{FolderRules, IgnoreRules, RuleSource, Verdict, WriteRulesError}; + +/// Open the dialog for the synced folder `id` at `root`. +pub(crate) fn present_ignore_dialog(ui: &Rc, id: i64, root: PathBuf) { + let root_display = tilde_path(&root.display().to_string()); + let intro = gtk4::Label::builder() + // Translators: {folder} is a local folder path such as ~/Projects. + .label(gettext_f( + "Patterns for {folder} only, one per line, on top of the ones for all synced folders. Lines starting with # are comments.", + &[("folder", &root_display)], + )) + .wrap(true) + .xalign(0.0) + .build(); + let text = gtk4::TextView::builder() + .monospace(true) + .wrap_mode(gtk4::WrapMode::WordChar) + .top_margin(8) + .bottom_margin(8) + .left_margin(8) + .right_margin(8) + .sensitive(false) + .build(); + let scroller = gtk4::ScrolledWindow::builder() + .child(&text) + .min_content_height(180) + .vexpand(true) + .build(); + scroller.add_css_class("card"); + let problems = gtk4::Label::builder() + .wrap(true) + .xalign(0.0) + .visible(false) + .build(); + problems.add_css_class("error"); + + let check_row = adw::EntryRow::builder() + .title(gettext("Check a path in the folder")) + .build(); + let verdict = gtk4::Label::builder() + .wrap(true) + .xalign(0.0) + .margin_top(6) + .build(); + verdict.add_css_class("dim-label"); + let check_group = adw::PreferencesGroup::new(); + check_group.add(&check_row); + + let all_folders = gtk4::Button::builder() + .label(gettext("Patterns for All Folders…")) + .halign(gtk4::Align::Start) + .build(); + all_folders.add_css_class("flat"); + + let body = gtk4::Box::new(gtk4::Orientation::Vertical, 12); + body.set_margin_top(12); + body.set_margin_bottom(18); + body.set_margin_start(18); + body.set_margin_end(18); + body.append(&intro); + body.append(&scroller); + body.append(&problems); + body.append(&check_group); + body.append(&verdict); + body.append(&all_folders); + + let cancel = gtk4::Button::with_label(&gettext("Cancel")); + let save = gtk4::Button::with_label(&gettext("Save")); + save.add_css_class("suggested-action"); + save.set_sensitive(false); + let header = adw::HeaderBar::builder() + .show_start_title_buttons(false) + .show_end_title_buttons(false) + .build(); + header.pack_start(&cancel); + header.pack_end(&save); + let toasts = adw::ToastOverlay::new(); + toasts.set_child(Some(&body)); + let view = adw::ToolbarView::new(); + view.add_top_bar(&header); + view.set_content(Some(&toasts)); + let dialog = adw::Dialog::builder() + .title(gettext("Excluded Files")) + .content_width(560) + .content_height(560) + .child(&view) + .build(); + + // What was read, so the save can tell whether the file changed since. + let loaded: Rc>> = Rc::default(); + let globals = Rc::new(ui.dirs.load_config().resolved_ignore_patterns()); + + let show_verdict = { + let (text, check_row, verdict, root, globals) = ( + text.clone(), + check_row.clone(), + verdict.clone(), + root.clone(), + globals.clone(), + ); + move || { + let typed = check_row.text(); + let typed = typed.trim(); + if typed.is_empty() { + verdict.set_text(""); + return; + } + let path = Path::new(typed); + let rel = path.strip_prefix(&root).unwrap_or(path); + let rel = rel.to_string_lossy(); + let rel = rel.trim_start_matches('/'); + let is_dir = typed.ends_with('/') || root.join(rel).is_dir(); + let rules = IgnoreRules::with_folder_text(&root, &globals, &buffer_text(&text)); + verdict.set_text(&verdict_text(&rules.explain(rel, is_dir))); + } + }; + let on_text = { + let (problems, save, show_verdict) = (problems.clone(), save.clone(), show_verdict.clone()); + move |text: &str| { + let bad = pdfs_core::syncignore::check_rules(text); + problems.set_visible(!bad.is_empty()); + if let Some((line, _)) = bad.first() { + problems.set_text(&ngettext_f( + "Line {line} isn't a valid pattern.", + "Line {line} and {more} more aren't valid patterns.", + bad.len() as u64, + &[ + ("line", &line.to_string()), + ("more", &(bad.len() - 1).to_string()), + ], + )); + } + save.set_sensitive(bad.is_empty()); + show_verdict(); + } + }; + let on_text_changed = on_text.clone(); + text.buffer() + .connect_changed(move |buffer| on_text_changed(&buffer_text_of(buffer))); + check_row.connect_changed(move |_| show_verdict()); + + let d = dialog.clone(); + cancel.connect_clicked(move |_| { + d.close(); + }); + let (ui_all, d) = (ui.clone(), dialog.clone()); + all_folders.connect_clicked(move |_| { + d.close(); + let prefs = &ui_all.status.prefs; + prefs.set_visible_page_name("sync"); + prefs.present(ui_window(&ui_all).as_ref()); + }); + + // Read off the main thread: the folder may be on a slow disk. + let reader = { + let (text, loaded, root, toasts) = + (text.clone(), loaded.clone(), root.clone(), toasts.clone()); + move || { + let (text, loaded, root, toasts) = + (text.clone(), loaded.clone(), root.clone(), toasts.clone()); + glib::spawn_future_local(async move { + let read = gio::spawn_blocking(move || FolderRules::read(&root)) + .await + .unwrap_or_else(|_| Err(std::io::Error::other("the read did not finish"))); + match read { + Ok(rules) => { + text.buffer().set_text(rules.text.as_deref().unwrap_or("")); + text.set_sensitive(true); + *loaded.borrow_mut() = Some(rules); + } + Err(e) => dialog_toast( + &toasts, + &gettext_f( + "{what}: {detail}", + &[ + ("what", &gettext("Couldn't read the patterns")), + ("detail", &e.to_string()), + ], + ), + ), + } + }); + } + }; + reader(); + + let (ui_save, d) = (ui.clone(), dialog.clone()); + save.connect_clicked(move |_| { + let Some(rules) = loaded.borrow().clone() else { + return; + }; + write_rules( + &ui_save, + &d, + &toasts, + id, + rules, + buffer_text(&text), + reader.clone(), + ); + }); + + dialog.present(ui_window(ui).as_ref()); +} + +/// Save `body` over `rules`, then close and sync the folder. When the file +/// changed since it was read, ask whether to load the other version or to +/// replace it; `reload` reads the file into the dialog again. +fn write_rules( + ui: &Rc, + dialog: &adw::Dialog, + toasts: &adw::ToastOverlay, + id: i64, + rules: FolderRules, + body: String, + reload: impl Fn() + Clone + 'static, +) { + let (ui, dialog, toasts) = (ui.clone(), dialog.clone(), toasts.clone()); + glib::spawn_future_local(async move { + let to_write = rules.clone(); + let text = body.clone(); + let written = gio::spawn_blocking(move || to_write.write(&text)) + .await + .unwrap_or_else(|_| { + Err(WriteRulesError::Io(std::io::Error::other( + "the write did not finish", + ))) + }); + match written { + Ok(()) => { + dialog.close(); + toast(&ui, &gettext("Excluded files saved")); + let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: Some(id) }); + } + Err(WriteRulesError::Changed) => { + let ask = adw::AlertDialog::builder() + .heading(gettext("Patterns Changed Elsewhere")) + .body(gettext( + "The patterns of this folder changed while you edited them, for example on another computer. Load the other version, or replace it with yours?", + )) + .build(); + ask.add_response("cancel", &gettext("Cancel")); + ask.add_response("reload", &gettext("Load Other Version")); + ask.add_response("replace", &gettext("Replace")); + ask.set_response_appearance("replace", adw::ResponseAppearance::Destructive); + ask.set_default_response(Some("cancel")); + ask.set_close_response("cancel"); + let (ui, d, t) = (ui.clone(), dialog.clone(), toasts.clone()); + ask.connect_response(None, move |_, response| match response { + "reload" => reload(), + "replace" => { + // Read the other version only as the base to check + // against, then write over it. + let (ui, d, t, body, reload) = ( + ui.clone(), + d.clone(), + t.clone(), + body.clone(), + reload.clone(), + ); + let root = rules.path.parent().map(Path::to_path_buf); + glib::spawn_future_local(async move { + let Some(root) = root else { return }; + let read = gio::spawn_blocking(move || FolderRules::read(&root)) + .await + .ok() + .and_then(Result::ok); + if let Some(current) = read { + write_rules(&ui, &d, &t, id, current, body, reload); + } + }); + } + _ => {} + }); + ask.present(Some(&dialog)); + } + Err(WriteRulesError::Io(e)) => dialog_toast( + &toasts, + &gettext_f( + "{what}: {detail}", + &[ + ("what", &gettext("Couldn't save the patterns")), + ("detail", &e.to_string()), + ], + ), + ), + } + }); +} + +/// Say what the rules do to the path being checked. +fn verdict_text(verdict: &Verdict) -> String { + match verdict { + Verdict::Synced => gettext("Synced: no pattern matches it."), + // Translators: {pattern} is an ignore pattern such as *.log. + Verdict::Excluded { + pattern, + source: RuleSource::ThisFolder, + } => gettext_f( + "Not synced: excluded by “{pattern}” above.", + &[("pattern", pattern)], + ), + Verdict::Excluded { + pattern, + source: RuleSource::AllFolders, + } => gettext_f( + "Not synced: excluded by “{pattern}” in the patterns for all folders.", + &[("pattern", pattern)], + ), + Verdict::Included { pattern, .. } => gettext_f( + "Synced: “{pattern}” includes it again.", + &[("pattern", pattern)], + ), + } +} + +fn buffer_text(view: >k4::TextView) -> String { + buffer_text_of(&view.buffer()) +} + +fn buffer_text_of(buffer: >k4::TextBuffer) -> String { + let (start, end) = buffer.bounds(); + buffer.text(&start, &end, false).to_string() +} + +fn dialog_toast(toasts: &adw::ToastOverlay, message: &str) { + toasts.add_toast( + adw::Toast::builder() + .title(message) + .use_markup(false) + .timeout(6) + .build(), + ); +} diff --git a/crates/pdfs-gui/src/app/widgets/mod.rs b/crates/pdfs-gui/src/app/widgets/mod.rs index d6d60b5..78cded0 100644 --- a/crates/pdfs-gui/src/app/widgets/mod.rs +++ b/crates/pdfs-gui/src/app/widgets/mod.rs @@ -2,6 +2,7 @@ pub(crate) mod compat; pub(crate) mod crumb; pub(crate) mod details; pub(crate) mod file_list; +pub(crate) mod ignore_dialog; pub(crate) mod menu; pub(crate) mod photo_drag; pub(crate) mod player; diff --git a/crates/pdfs-gui/src/main.rs b/crates/pdfs-gui/src/main.rs index 8471f79..ea754ae 100644 --- a/crates/pdfs-gui/src/main.rs +++ b/crates/pdfs-gui/src/main.rs @@ -398,12 +398,10 @@ fn open_manager(args: &[&str]) { /// Remember that the user hid the icon, so the next login's autostart and the /// app both leave it away, then exit. fn hide_tray() { - if let Ok(dirs) = AppDirs::new() { - let mut config = dirs.load_config(); - config.tray_hidden = true; - if let Err(e) = dirs.save_config(&config) { - tracing::warn!("hide tray icon: {e}"); - } + if let Ok(dirs) = AppDirs::new() + && let Err(e) = dirs.update_config(|config| config.tray_hidden = true) + { + tracing::warn!("hide tray icon: {e}"); } std::process::exit(0); } diff --git a/crates/pdfs-gui/tests/icon_names.rs b/crates/pdfs-gui/tests/icon_names.rs index d61e1ab..be37f59 100644 --- a/crates/pdfs-gui/tests/icon_names.rs +++ b/crates/pdfs-gui/tests/icon_names.rs @@ -24,6 +24,7 @@ const STOCK: &[&str] = &[ // GTK's built-in icons "info-outline-symbolic", // Adwaita + "application-x-executable-symbolic", "audio-x-generic-symbolic", "checkbox-checked-symbolic", "checkbox-symbolic", diff --git a/docs/BUGS.md b/docs/BUGS.md index 3e499db..e58ea2e 100644 --- a/docs/BUGS.md +++ b/docs/BUGS.md @@ -306,6 +306,7 @@ a live account since. | Entry | Title | |---|---| +| [B292](#b292--two-programs-changing-settings-at-once-lose-one-of-the-changes) | Two programs changing settings at once lose one of the changes | | [B290](#b290--reopening-the-database-right-after-closing-it-can-be-refused-as-another-daemon) | Reopening the database right after closing it can be refused as another daemon | | [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for | | [B258](#b258--journalctl--p-warning-shows-nothing-whatever-the-daemon-logged) | `journalctl -p warning` shows nothing, whatever the daemon logged | @@ -394,6 +395,34 @@ a live account since. Newest first. +### B292 — Two programs changing settings at once lose one of the changes + +**Status:** Fixed + +**Found:** 2026-11-15, reading every writer of `config.json` while adding settings to Preferences. + +**Where:** `crates/pdfs-core/src/config.rs`, `AppDirs::save_config` and its callers in the app, +the tray and the daemon + +**Repro:** Change the cache size in Preferences (the daemon writes `cache_budget`) while the app +saves the window size or the tray hides itself. Both read the file before either wrote it, and +the one that wrote last puts the other setting back. Not seen in the field; the window is a few +milliseconds, but more settings in the app make it more likely. + +**Cause:** Every writer loaded the file, changed one field and wrote the whole file back, with +nothing ordering them. The atomic rename kept the file whole, not the changes. + +**Fix:** `AppDirs::update_config` reads, changes and writes under an `flock` on +`config.json.lock`, and every writer goes through it. It refuses an unreadable file before +applying the change (B223). A lock held longer than 5 seconds is reported as an error instead of +waited on. + +**Verified:** `cargo test -p pdfs-core config::tests` on 2026-11-15, +`concurrent_changes_to_different_settings_are_all_kept` and +`a_change_is_never_applied_over_an_unreadable_config`. + +--- + ### B291 — On Fedora 45's oo7, every saved sign-in is lost at the next reboot **Status:** Fixed, not verified live diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 10d69ee..6f10330 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -18,6 +18,27 @@ Existing folders stay device backups. Older builds cannot open the upgraded data ### Added +- **Excluded files, opening files and the search launcher in Preferences** (#99). Settings that + could only be changed in `config.json` now have a place in the app: + - **Sync → Excluded Files**: the patterns every synced folder leaves out. Add your own, such as + `*.db` or `build/`, and turn each built-in pattern on or off. A change applies at once. + - **Sync → Conflict Copies**: whether identical conflict copies are only reported, moved to the + trash, or not looked for. + - **Apps → Open Files With**: which program opens which kind of file, in order, optionally in a + terminal, for example `nvim` for text files. A change applies to the next file opened. + - **Apps → Search Launcher**: whether `pdfs-prompt` opens its own window, your dmenu-style + launcher (rofi, wofi, fuzzel, bemenu) or fzf in a terminal. + + Each synced folder kept on this computer has **Excluded Files…** in its menu on the Sync page, + for its own `.pdfsignore`. It checks every line as you type, tells you whether a path is synced + and which pattern decides, and asks before replacing rules that changed on another computer + meanwhile. `pdfs sync ignore list|add|remove|reset|check` does the same from a terminal. + `pdfs-app --page preferences-sync` (or `-apps`, `-storage`, plain `preferences`) opens + Preferences at that page. +- **More clutter left out of synced folders by default**: `desktop.ini`, `.directory`, trash + folders, `.fuse_hidden*` and `.nfs*` leftovers, partial downloads (`*.part`, `*.crdownload`), + Kate swap files and office lock files. This only changes folders where you never set your own + list. Leaving a file out never deletes its copy on Proton Drive. - **Sync a local folder with a folder you already have in My files** (#67, #77). `pdfs sync attach ~/Work --to Work` keeps `~/Work` an ordinary local folder and syncs it both ways with My files/Work. The first sync uploads files that are only on this computer, downloads @@ -146,6 +167,9 @@ Existing folders stay device backups. Older builds cannot open the upgraded data ### Fixed +- **Two programs changing settings at once no longer lose one of the changes** (B292). The app, + the tray and the service now change `config.json` under a lock, so for example a new cache + size saved by the service and the window size saved by the app both stay. - **Resuming a Google Photos import no longer fails at once** (#94, B286, B287). A photo upload that was cut short left a draft behind, and every later run stopped with `check for existing photos: serialization error: invalid type: null`. Such drafts are now diff --git a/docs/CLI.md b/docs/CLI.md index 8a4d4ea..521cf17 100644 --- a/docs/CLI.md +++ b/docs/CLI.md @@ -119,6 +119,10 @@ commands are for scripts and for cases where the mount is not available. | `pdfs sync reset ID` | Forget what a synced folder synced before and compare it with Proton Drive again. A file on one side only is copied to the other, and a file that differs keeps both versions. Nothing is deleted. | | `pdfs sync pause [--for 1h] [--folder ID]` | Pause uploads and synced folders. Reading files keeps working. `--for` ends the pause by itself (`30m`, `1h`, `2d`). | | `pdfs sync resume [--folder ID]` | Resume after a pause. | +| `pdfs sync ignore list` | Print the patterns every synced folder leaves out. Built-in ones are marked. | +| `pdfs sync ignore add PATTERN` / `remove PATTERN` | Leave out, or stop leaving out, files matching a gitignore-style pattern such as `*.db` or `build/`. A pattern starting with `-` goes after `--`. | +| `pdfs sync ignore reset` | Use the built-in patterns again. | +| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. | | `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. | | `pdfs sync queue` | List changes that have not reached Proton Drive yet. | | `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. | diff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.md index 1f3fd27..8a46abc 100644 --- a/docs/CONFIGURATION.md +++ b/docs/CONFIGURATION.md @@ -44,9 +44,13 @@ the [security model](SECURITY_MODEL.md#what-is-kept-on-this-computer). ## `config.json` The file is created with defaults on first start. Every key is optional; a missing key takes its -default. Edit it while the app is closed, then restart the service +default. Most keys can be changed in the app, under **Preferences** (the "In app" column below). +To edit the file by hand, close the app first, then restart the service (`systemctl --user restart proton-drive.service`) for service settings to apply. +The app, the tray and the service each change the file under a lock (`config.json.lock` next to +it), so two of them changing different settings at once both keep their change. + An unreadable file is never overwritten: the programs log an error and run with defaults until you fix it. @@ -80,9 +84,9 @@ fix it. | `cache_budget` | bytes | 5 GiB | Storage → Cache | Soft limit for cached content. `0` means unlimited. Available-offline files do not count against it | | `upload_limit` | bytes/s | none | General → Network | Shared cap for all uploads. `0` or `null` means none | | `download_limit` | bytes/s | none | General → Network | Shared cap for all downloads, reads from the mount included | -| `ignore_patterns` | list | see below | — | Global ignore rules for synced folders | +| `ignore_patterns` | list | see below | Sync → Excluded Files | Global ignore rules for synced folders | | `device_uid` | string | none | Computers → Continue This Backup Here… or Sync With This Computer… | The computer this machine syncs into. Unset means "match by hostname" | -| `conflict_sweep` | `off` / `report` / `enforce` | `report` | — | See [`conflict_sweep`](#conflict_sweep) | +| `conflict_sweep` | `off` / `report` / `enforce` | `report` | Sync → Conflict Copies | See [`conflict_sweep`](#conflict_sweep) | | `local_first` | bool | `true` | — | See [`local_first`](#local_first) | | `language` | gettext code | system | General → Appearance | Language of the app, tray and prompt, such as `de` or `pt_BR` | | `proton_theme` | bool | follow system | General → Appearance | Proton's colours instead of the system theme | @@ -93,8 +97,8 @@ fix it. | `update_latest` | version | none | — | The latest release the update check found | | `files_view` | object | grid, by name | My files view menu | `list`, `sort` (`name`, `size`, `modified`), `descending`, `folders_first` | | `window` | object | 980 × 680 | Resizing the app window | `width`, `height` (the unmaximized size), `maximized` | -| `open_with` | object | `xdg-open` | — | See [`open_with`](#open_with) | -| `prompt` | object | built-in window | — | See [`prompt`](#prompt) | +| `open_with` | object | `xdg-open` | Apps → Open Files With | See [`open_with`](#open_with) | +| `prompt` | object | built-in window | Apps → Search Launcher | See [`prompt`](#prompt) | `app_version` and `user_agent` identify the client to Proton. When the keys are absent, the client sends its own release (`external-drive-linux@-stable`, `proton-drive-linux/`). @@ -109,10 +113,14 @@ Gitignore-style rules applied to every synced folder, in addition to each folder ```json [".git/", ".hg/", ".svn/", "node_modules/", "target/", ".venv/", "__pycache__/", - "*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db"] + "*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db", + "desktop.ini", ".directory", ".Trash-*/", ".Trashes/", ".Spotlight-V100/", + ".fuse_hidden*", ".nfs*", "*.part", "*.crdownload", "*.kate-swp", ".~lock.*#", "~$*"] ``` -Set it to `[]` to turn the defaults off. See +Preferences → Sync → Excluded Files edits this list, and `pdfs sync ignore` does the same from +a terminal. A list equal to the defaults is saved as absent, so it follows the defaults of later +releases. Set it to `[]` to turn the defaults off. See [Synced folders](SYNCED_FOLDERS.md#excluding-files-with-pdfsignore) for how excluding behaves. ### `conflict_sweep` diff --git a/docs/LAUNCHER_AND_TRAY.md b/docs/LAUNCHER_AND_TRAY.md index 4022f34..af31c3c 100644 --- a/docs/LAUNCHER_AND_TRAY.md +++ b/docs/LAUNCHER_AND_TRAY.md @@ -69,9 +69,10 @@ windowrulev2 = center, class:^(pdfs-prompt)$ bind = SUPER, space, exec, pdfs-prompt --fzf ``` -To make `--dmenu` or `--fzf` the default without changing your shortcut, set `prompt.mode` in -`config.json` (see [Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the -built-in window. +To make `--dmenu` or `--fzf` the default without changing your shortcut, pick it in +**Preferences → Apps → Search Launcher**, or set `prompt.mode` in `config.json` (see +[Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the built-in window. +Which program opens a file you pick is set under **Preferences → Apps → Open Files With**. ## Tray diff --git a/docs/SYNCED_FOLDERS.md b/docs/SYNCED_FOLDERS.md index 65a33ee..e56f3fd 100644 --- a/docs/SYNCED_FOLDERS.md +++ b/docs/SYNCED_FOLDERS.md @@ -100,10 +100,32 @@ apply together: !important.log ``` -2. The `ignore_patterns` list in `config.json`, for every synced folder (see - [Configuration](CONFIGURATION.md#ignore_patterns)). When you have not set it, it skips - `.git/`, `.hg/`, `.svn/`, `node_modules/`, `target/`, `.venv/`, `__pycache__/`, `*~`, - `*.swp`, `*.tmp`, `.DS_Store` and `Thumbs.db`. +2. The patterns for every synced folder: **Preferences → Sync → Excluded Files** in the app, or + `ignore_patterns` in `config.json` (see [Configuration](CONFIGURATION.md#ignore_patterns)). + Built in are version control (`.git/`, `.hg/`, `.svn/`), dependency and build folders + (`node_modules/`, `target/`, `.venv/`, `__pycache__/`), and what editors, downloads and other + systems leave behind (`*~`, `*.swp`, `*.tmp`, `*.part`, `*.crdownload`, `*.kate-swp`, office + lock files, `.DS_Store`, `Thumbs.db`, `desktop.ini`, `.directory`, trash folders, `.nfs*` and + `.fuse_hidden*`). Each built-in pattern can be turned off on its own. + +To edit a folder's own rules in the app, open the **Sync** page, then **Folders**, and pick +**Excluded Files…** in the folder's menu. It checks every line as you type, and **Check a path** +tells you whether a file is synced and which pattern decides. If the file changed meanwhile, for +example on another computer, it asks before replacing that version. + +From a terminal: + +```bash +pdfs sync ignore list # the patterns for every synced folder +pdfs sync ignore add '*.db' # leave out files ending in .db +pdfs sync ignore remove '*.db' +pdfs sync ignore reset # back to the built-in patterns +pdfs sync ignore check ~/Projects/app/node_modules +``` + +The rules apply to folders kept on this computer. Files you save into `~/ProtonDrive` itself or into +an online-only folder are always uploaded, except download and editor scratch files, which wait for +their final name. Rules are read again on every sync pass. Excluding never deletes anything: a file that becomes excluded is no longer synced, and its copy on Proton Drive stays. diff --git a/docs/USER_GUIDE.md b/docs/USER_GUIDE.md index dad46f7..e756eef 100644 --- a/docs/USER_GUIDE.md +++ b/docs/USER_GUIDE.md @@ -53,6 +53,8 @@ The app uses these words, and so do these pages: | Page | Settings | |---|---| | **General** | Start on login · Proton Drive folder location · upload and download limits · Proton theme, street map for Places, tray icon · language · check for updates | +| **Sync** | Files and folders every synced folder leaves out · what happens to identical conflict copies | +| **Apps** | Which program opens which kind of file · how the search launcher opens | | **Storage** | Cache size limit · clear the cache · files kept available offline | The account menu shows the storage you use and holds **Sign Out…**. Settings that are not in the diff --git a/po/POTFILES.in b/po/POTFILES.in index 585cfa1..d6b2a1b 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -13,6 +13,8 @@ crates/pdfs-gui/src/app/pages/photo_viewer.rs crates/pdfs-gui/src/app/pages/photos.rs crates/pdfs-gui/src/app/pages/places.rs crates/pdfs-gui/src/app/pages/places_map.rs +crates/pdfs-gui/src/app/pages/preferences_apps.rs +crates/pdfs-gui/src/app/pages/preferences_sync.rs crates/pdfs-gui/src/app/pages/shared.rs crates/pdfs-gui/src/app/pages/shared_by_me.rs crates/pdfs-gui/src/app/pages/status.rs @@ -23,6 +25,7 @@ crates/pdfs-gui/src/app/update.rs crates/pdfs-gui/src/app/widgets/compat.rs crates/pdfs-gui/src/app/widgets/details.rs crates/pdfs-gui/src/app/widgets/file_list.rs +crates/pdfs-gui/src/app/widgets/ignore_dialog.rs crates/pdfs-gui/src/app/widgets/menu.rs crates/pdfs-gui/src/app/widgets/player.rs crates/pdfs-gui/src/app/widgets/share_dialog.rs diff --git a/po/de.po b/po/de.po index 0ff0a83..2c7be9e 100644 --- a/po/de.po +++ b/po/de.po @@ -5,7 +5,7 @@ msgid "" msgstr "" "Project-Id-Version: proton-drive-linux 2.1.0\n" "Report-Msgid-Bugs-To: https://github.com/narrrl/proton-drive-linux/issues\n" -"POT-Creation-Date: 2026-11-15 16:54+0100\n" +"POT-Creation-Date: 2026-11-15 22:52+0100\n" "PO-Revision-Date: 2026-09-23 12:00+0200\n" "Last-Translator: Proton Drive for Linux contributors\n" "Language-Team: German\n" @@ -31,7 +31,7 @@ msgstr[1] "vor {n} Min." #. Translators: strftime format for the time a photo was taken, shown on its tile, such as "14:05". #: crates/pdfs-gui/src/app/dates.rs:44 #: crates/pdfs-gui/src/app/pages/activity.rs:840 -#: crates/pdfs-gui/src/app/pages/photos.rs:3714 +#: crates/pdfs-gui/src/app/pages/photos.rs:3715 msgid "%H:%M" msgstr "%H:%M" @@ -57,88 +57,94 @@ msgstr "%-d. %b %Y" msgid "%A, %B %-d, %Y, %H:%M" msgstr "%A, %-d. %B %Y, %H:%M" -#: crates/pdfs-gui/src/app/main.rs:881 +#: crates/pdfs-gui/src/app/main.rs:917 #: crates/pdfs-gui/src/app/pages/activity_text.rs:543 #: crates/pdfs-gui/src/app/pages/browser.rs:473 #: crates/pdfs-gui/src/app/pages/browser.rs:880 #: crates/pdfs-gui/src/app/pages/browser.rs:1254 #: crates/pdfs-gui/src/app/pages/browser.rs:2239 #: crates/pdfs-gui/src/app/pages/browser.rs:2318 -#: crates/pdfs-gui/src/app/pages/locations.rs:1721 +#: crates/pdfs-gui/src/app/pages/locations.rs:1730 #: crates/pdfs-gui/src/app/pages/shared_by_me.rs:252 #: crates/pdfs-gui/src/app/pages/trash.rs:191 crates/pdfs-gui/src/prompt.rs:171 msgid "My files" msgstr "Meine Dateien" -#: crates/pdfs-gui/src/app/main.rs:882 crates/pdfs-gui/src/app/main.rs:1552 +#: crates/pdfs-gui/src/app/main.rs:918 crates/pdfs-gui/src/app/main.rs:1599 #: crates/pdfs-gui/src/app/pages/albums.rs:636 #: crates/pdfs-gui/src/app/pages/photos.rs:929 #: crates/pdfs-gui/src/app/pages/places.rs:473 msgid "Photos" msgstr "Fotos" -#: crates/pdfs-gui/src/app/main.rs:885 +#: crates/pdfs-gui/src/app/main.rs:921 #: crates/pdfs-gui/src/app/pages/shared.rs:168 #: crates/pdfs-gui/src/app/pages/shared.rs:493 msgid "Shared with me" msgstr "Mit mir geteilt" -#: crates/pdfs-gui/src/app/main.rs:890 +#: crates/pdfs-gui/src/app/main.rs:926 #: crates/pdfs-gui/src/app/pages/shared_by_me.rs:120 msgid "Shared by me" msgstr "Von mir geteilt" -#: crates/pdfs-gui/src/app/main.rs:893 +#: crates/pdfs-gui/src/app/main.rs:929 #: crates/pdfs-gui/src/app/pages/devices.rs:140 #: crates/pdfs-gui/src/app/pages/devices.rs:505 msgid "Computers" msgstr "Computer" -#: crates/pdfs-gui/src/app/main.rs:894 +#: crates/pdfs-gui/src/app/main.rs:930 #: crates/pdfs-gui/src/app/pages/trash.rs:101 msgid "Trash" msgstr "Papierkorb" #. Translators: sidebar entry for the page listing this computer's synced folders. -#: crates/pdfs-gui/src/app/main.rs:896 +#: crates/pdfs-gui/src/app/main.rs:932 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:66 msgid "Sync" msgstr "Synchronisierung" #. Translators: a failed action's toast. {what} says what failed, such as #. "Couldn't rename"; {detail} is the reason, usually untranslated text #. from the mount service. -#: crates/pdfs-gui/src/app/main.rs:1246 +#: crates/pdfs-gui/src/app/main.rs:1282 #: crates/pdfs-gui/src/app/pages/photo_viewer.rs:915 +#: crates/pdfs-gui/src/app/pages/preferences_apps.rs:284 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:168 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:213 #: crates/pdfs-gui/src/app/pages/takeout.rs:891 +#: crates/pdfs-gui/src/app/widgets/ignore_dialog.rs:182 +#: crates/pdfs-gui/src/app/widgets/ignore_dialog.rs:288 #, rust-format msgid "{what}: {detail}" msgstr "{what}: {detail}" -#: crates/pdfs-gui/src/app/main.rs:1269 +#: crates/pdfs-gui/src/app/main.rs:1305 msgid "You're offline" msgstr "Keine Internetverbindung" -#: crates/pdfs-gui/src/app/main.rs:1270 +#: crates/pdfs-gui/src/app/main.rs:1306 msgid "That's not there any more" msgstr "Das ist nicht mehr vorhanden" -#: crates/pdfs-gui/src/app/main.rs:1271 +#: crates/pdfs-gui/src/app/main.rs:1307 msgid "You don't have access to that" msgstr "Kein Zugriff darauf" -#: crates/pdfs-gui/src/app/main.rs:1272 +#: crates/pdfs-gui/src/app/main.rs:1308 msgid "Something changed this first" msgstr "Etwas anderes hat dies zuerst geändert" -#: crates/pdfs-gui/src/app/main.rs:1273 +#: crates/pdfs-gui/src/app/main.rs:1309 msgid "Your Proton Drive is full" msgstr "Das Proton Drive ist voll" -#: crates/pdfs-gui/src/app/main.rs:1360 +#: crates/pdfs-gui/src/app/main.rs:1396 msgid "Proton Drive for Linux" msgstr "Proton Drive for Linux" -#: crates/pdfs-gui/src/app/main.rs:1368 +#: crates/pdfs-gui/src/app/main.rs:1404 msgid "" "Files-on-demand Proton Drive for the Linux desktop.\n" "\n" @@ -150,23 +156,23 @@ msgstr "" "Inoffizieller Client – nicht mit Proton AG verbunden, von Proton AG " "unterstützt oder befürwortet." -#: crates/pdfs-gui/src/app/main.rs:1373 +#: crates/pdfs-gui/src/app/main.rs:1409 msgid "Source Code" msgstr "Quellcode" -#: crates/pdfs-gui/src/app/main.rs:1377 +#: crates/pdfs-gui/src/app/main.rs:1413 msgid "Proton Terms of Service" msgstr "Nutzungsbedingungen von Proton" -#: crates/pdfs-gui/src/app/main.rs:1381 +#: crates/pdfs-gui/src/app/main.rs:1417 msgid "Proton Privacy Policy" msgstr "Datenschutzerklärung von Proton" -#: crates/pdfs-gui/src/app/main.rs:1386 +#: crates/pdfs-gui/src/app/main.rs:1422 msgid "Disclaimer" msgstr "Haftungsausschluss" -#: crates/pdfs-gui/src/app/main.rs:1390 +#: crates/pdfs-gui/src/app/main.rs:1426 msgid "" "This is an unofficial, community-built client. It is not affiliated with, " "endorsed by, or supported by Proton AG.\n" @@ -191,7 +197,7 @@ msgstr "" "bereitgestellt. Daten, deren Verlust nicht hinnehmbar ist, sollten " "zusätzlich gesichert werden." -#: crates/pdfs-gui/src/app/main.rs:1398 +#: crates/pdfs-gui/src/app/main.rs:1434 msgid "" "Places are named with data from GeoNames, licensed under GeoNames, lizenziert unter CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -211,7 +217,7 @@ msgstr "" "href=\"https://www.naturalearthdata.com/\">Natural Earth gezeichnet, die " "gemeinfrei sind." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, licensed under CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -208,7 +214,7 @@ msgstr "" "\">Natural Earth land outlines and country borders, which are in the " "public domain." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, con licencia CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -209,7 +215,7 @@ msgstr "" "fronteras de países de Natural " "Earth, que son de dominio público." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, sous licence CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -210,7 +216,7 @@ msgstr "" "frontières des pays de Natural " "Earth, qui sont dans le domaine public." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, con licenza CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -208,7 +214,7 @@ msgstr "" "confini nazionali di Natural " "Earth, che sono di pubblico dominio." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, gelicentieerd onder CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -209,7 +215,7 @@ msgstr "" "href=\"https://www.naturalearthdata.com/\">Natural Earth, die in het " "publieke domein vallen." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the \n" "Language-Team: LANGUAGE \n" @@ -34,7 +34,7 @@ msgstr[1] "" #. Translators: strftime format for the time a photo was taken, shown on its tile, such as "14:05". #: crates/pdfs-gui/src/app/dates.rs:44 #: crates/pdfs-gui/src/app/pages/activity.rs:840 -#: crates/pdfs-gui/src/app/pages/photos.rs:3714 +#: crates/pdfs-gui/src/app/pages/photos.rs:3715 msgid "%H:%M" msgstr "" @@ -60,88 +60,94 @@ msgstr "" msgid "%A, %B %-d, %Y, %H:%M" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:881 +#: crates/pdfs-gui/src/app/main.rs:917 #: crates/pdfs-gui/src/app/pages/activity_text.rs:543 #: crates/pdfs-gui/src/app/pages/browser.rs:473 #: crates/pdfs-gui/src/app/pages/browser.rs:880 #: crates/pdfs-gui/src/app/pages/browser.rs:1254 #: crates/pdfs-gui/src/app/pages/browser.rs:2239 #: crates/pdfs-gui/src/app/pages/browser.rs:2318 -#: crates/pdfs-gui/src/app/pages/locations.rs:1721 +#: crates/pdfs-gui/src/app/pages/locations.rs:1730 #: crates/pdfs-gui/src/app/pages/shared_by_me.rs:252 #: crates/pdfs-gui/src/app/pages/trash.rs:191 crates/pdfs-gui/src/prompt.rs:171 msgid "My files" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:882 crates/pdfs-gui/src/app/main.rs:1552 +#: crates/pdfs-gui/src/app/main.rs:918 crates/pdfs-gui/src/app/main.rs:1599 #: crates/pdfs-gui/src/app/pages/albums.rs:636 #: crates/pdfs-gui/src/app/pages/photos.rs:929 #: crates/pdfs-gui/src/app/pages/places.rs:473 msgid "Photos" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:885 +#: crates/pdfs-gui/src/app/main.rs:921 #: crates/pdfs-gui/src/app/pages/shared.rs:168 #: crates/pdfs-gui/src/app/pages/shared.rs:493 msgid "Shared with me" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:890 +#: crates/pdfs-gui/src/app/main.rs:926 #: crates/pdfs-gui/src/app/pages/shared_by_me.rs:120 msgid "Shared by me" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:893 +#: crates/pdfs-gui/src/app/main.rs:929 #: crates/pdfs-gui/src/app/pages/devices.rs:140 #: crates/pdfs-gui/src/app/pages/devices.rs:505 msgid "Computers" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:894 +#: crates/pdfs-gui/src/app/main.rs:930 #: crates/pdfs-gui/src/app/pages/trash.rs:101 msgid "Trash" msgstr "" #. Translators: sidebar entry for the page listing this computer's synced folders. -#: crates/pdfs-gui/src/app/main.rs:896 +#: crates/pdfs-gui/src/app/main.rs:932 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:66 msgid "Sync" msgstr "" #. Translators: a failed action's toast. {what} says what failed, such as #. "Couldn't rename"; {detail} is the reason, usually untranslated text #. from the mount service. -#: crates/pdfs-gui/src/app/main.rs:1246 +#: crates/pdfs-gui/src/app/main.rs:1282 #: crates/pdfs-gui/src/app/pages/photo_viewer.rs:915 +#: crates/pdfs-gui/src/app/pages/preferences_apps.rs:284 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:168 +#: crates/pdfs-gui/src/app/pages/preferences_sync.rs:213 #: crates/pdfs-gui/src/app/pages/takeout.rs:891 +#: crates/pdfs-gui/src/app/widgets/ignore_dialog.rs:182 +#: crates/pdfs-gui/src/app/widgets/ignore_dialog.rs:288 #, rust-format msgid "{what}: {detail}" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1269 +#: crates/pdfs-gui/src/app/main.rs:1305 msgid "You're offline" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1270 +#: crates/pdfs-gui/src/app/main.rs:1306 msgid "That's not there any more" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1271 +#: crates/pdfs-gui/src/app/main.rs:1307 msgid "You don't have access to that" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1272 +#: crates/pdfs-gui/src/app/main.rs:1308 msgid "Something changed this first" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1273 +#: crates/pdfs-gui/src/app/main.rs:1309 msgid "Your Proton Drive is full" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1360 +#: crates/pdfs-gui/src/app/main.rs:1396 msgid "Proton Drive for Linux" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1368 +#: crates/pdfs-gui/src/app/main.rs:1404 msgid "" "Files-on-demand Proton Drive for the Linux desktop.\n" "\n" @@ -149,23 +155,23 @@ msgid "" "AG." msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1373 +#: crates/pdfs-gui/src/app/main.rs:1409 msgid "Source Code" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1377 +#: crates/pdfs-gui/src/app/main.rs:1413 msgid "Proton Terms of Service" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1381 +#: crates/pdfs-gui/src/app/main.rs:1417 msgid "Proton Privacy Policy" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1386 +#: crates/pdfs-gui/src/app/main.rs:1422 msgid "Disclaimer" msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1390 +#: crates/pdfs-gui/src/app/main.rs:1426 msgid "" "This is an unofficial, community-built client. It is not affiliated with, " "endorsed by, or supported by Proton AG.\n" @@ -178,21 +184,21 @@ msgid "" "of any data you cannot afford to lose." msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1398 +#: crates/pdfs-gui/src/app/main.rs:1434 msgid "" "Places are named with data from GeoNames, licensed under CC BY 4.0." msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " "public domain." msgstr "" -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames udostępnionych na licencji CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -212,7 +218,7 @@ msgstr "" "www.naturalearthdata.com/\">Natural Earth, które należą do domeny " "publicznej." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the GeoNames, licensed under GeoNames, licenciados sob CC BY 4.0." -#: crates/pdfs-gui/src/app/main.rs:1406 +#: crates/pdfs-gui/src/app/main.rs:1442 msgid "" "The places map is drawn from Natural Earth land outlines and country borders, which are in the " @@ -208,7 +214,7 @@ msgstr "" "fronteiras de países do Natural Earth, que são de domínio público." -#: crates/pdfs-gui/src/app/main.rs:1414 +#: crates/pdfs-gui/src/app/main.rs:1450 msgid "" "The street map, when turned on, comes from OpenFreeMap in the &2; exit 2; } + [[ ",$all,$extra," == *",$shot,"* ]] || { echo "no screenshot called $shot" >&2; exit 2; } done for tool in cage grim wlr-randr magick dbus-run-session gnome-keyring-daemon cargo curl; do command -v "$tool" >/dev/null || { echo "$tool is required" >&2; exit 2; } @@ -185,7 +189,15 @@ cat >"$root/config/proton-drive-linux/config.json" <<'EOF' "tray_hidden": true, "update_check": false, "online_map": false, - "files_view": { "list": false } + "files_view": { "list": false }, + "ignore_patterns": [".git/", "node_modules/", "target/", "*~", "*.swp", ".DS_Store", + "*.iso", "build/", "*.sqlite-wal"], + "open_with": { + "rules": [ + { "match": ["@text", "*.md"], "command": ["nvim"], "terminal": true }, + { "match": ["@image"], "command": ["loupe"] } + ] + } } EOF