diff --git a/crates/app/src/action.rs b/crates/app/src/action.rs index 6dfa0ad..089bd1f 100644 --- a/crates/app/src/action.rs +++ b/crates/app/src/action.rs @@ -20,6 +20,7 @@ use crate::effects::{Effect, FileOp}; use crate::history::HistoryEntry; use crate::settings::Settings; use crate::state::*; +use crate::strings as txt; #[derive(Debug)] pub enum Action { @@ -281,7 +282,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { let src = f.request_source(0).unwrap_or("").to_string(); new_tab(state, r, None, src); } - None => state.set_error("No request in that text"), + None => state.set_error(txt::msg::NO_REQUEST_IN_TEXT), } } @@ -296,10 +297,10 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { req.name = t.request.name.clone(); } edit(state, id, |r| *r = req); - state.set_info("Imported the curl command"); + state.set_info(txt::msg::CURL_IMPORTED); } Err(e) => { - state.set_error(format!("Could not import curl command: {e}")); + state.set_error(txt::msg::curl_import_failed(e)); edit(state, id, |r| r.url = url); } } @@ -352,8 +353,8 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { t.request = r; t.source_error = None; } - 0 => t.source_error = Some("No request line found".into()), - n => t.source_error = Some(format!("The source must contain exactly one request (found {n})")), + 0 => t.source_error = Some(txt::msg::NO_REQUEST_LINE.into()), + n => t.source_error = Some(txt::msg::not_one_request(n)), } } } @@ -380,7 +381,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { if let Some(t) = state.tab_mut(id) { if let Some(f) = t.in_flight.take() { f.cancel.cancel(); - t.error = Some("Cancelled".into()); + t.error = Some(txt::msg::CANCELLED.into()); } } } @@ -448,11 +449,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { .iter() .find(|c| root.starts_with(&c.root) || c.root.starts_with(&root)) { - state.set_error(format!( - "{} overlaps the open collection {}; close that one first", - root.display(), - other.root.display() - )); + state.set_error(txt::msg::overlaps(root.display(), other.root.display())); return fx; } state.settings.add_recent(root.clone()); @@ -500,7 +497,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { state.active_collection = Some(root); } } - Action::CollectionLoaded(Err(e)) => state.set_error(format!("Could not open the collection: {e}")), + Action::CollectionLoaded(Err(e)) => state.set_error(txt::msg::collection_failed(e)), Action::CollectionLoaded(Ok(c)) => collection_loaded(state, c, &mut fx), Action::EnvironmentsLoaded { root, result } => { if let Some(c) = state.collection_mut(&root) { @@ -548,11 +545,11 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { }; let path = dir.join(name); if state.collection_of(&path).is_some_and(|c| c.files.contains_key(&path)) { - state.set_error(format!("{} already exists", path.display())); + state.set_error(txt::msg::already_exists(path.display())); return fx; } let req = Request { - title: Some("New request".into()), + title: Some(txt::common::NEW_REQUEST.into()), ..Request::default() }; let text = render_request(&req, "\n"); @@ -564,7 +561,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { let Some(f) = file_of(state, &file) else { return fx }; let n = f.request_count(); let req = Request { - title: Some(unique_title(f, "New request")), + title: Some(unique_title(f, txt::common::NEW_REQUEST)), ..Request::default() }; let text = f.insert_request(None, &req); @@ -613,10 +610,10 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { let Some(src) = f.request_source(index) else { return fx }; let orig = f.request(index).cloned().unwrap_or_default(); // Re-title the copy so its key is unique. - let base = orig.display_name().unwrap_or("Request").to_string(); + let base = orig.display_name().unwrap_or(txt::names::REQUEST).to_string(); let mut copy = HttpFile::parse(src.to_string()); let mut r = copy.request(0).cloned().unwrap_or_default(); - r.title = Some(unique_title(f, &format!("{base} copy"))); + r.title = Some(unique_title(f, &txt::names::copy_of(&base))); r.name = r.name.as_ref().map(|_| slug_name(r.title.as_deref().unwrap())); if let Some(t) = copy.replace_request(0, &r) { copy = HttpFile::parse(t); @@ -724,8 +721,8 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { .unwrap_or("http".into()); let dir = path.parent().map(Path::to_path_buf).unwrap_or_default(); let taken = |p: &PathBuf| state.collection_of(p).is_some_and(|c| c.files.contains_key(p)); - let copy = std::iter::once(dir.join(format!("{stem} copy.{ext}"))) - .chain((2..).map(|n| dir.join(format!("{stem} copy {n}.{ext}")))) + let copy = std::iter::once(dir.join(txt::names::file_copy(&stem, &ext))) + .chain((2..).map(|n| dir.join(txt::names::file_copy_n(&stem, n, &ext)))) .find(|p| !taken(p)) .unwrap(); fx.push(file_ops(state, vec![FileOp::Write(copy.clone(), text.clone())], true)); @@ -801,7 +798,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { dirty: false, }); } else { - state.set_error("Open a collection folder first; environments live next to the .http files"); + state.set_error(txt::msg::NEED_COLLECTION_FOR_ENVS); } } Action::EnvEditorChanged(e) => state.env_editor = Some(e), @@ -850,9 +847,9 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { ) { Ok(r) => { fx.push(Effect::CopyToClipboard(to_curl(&r))); - state.set_info("Copied as curl"); + state.set_info(txt::msg::COPIED_CURL); } - Err(e) => state.set_error(format!("Cannot build the curl command: {e}")), + Err(e) => state.set_error(txt::msg::curl_failed(e)), } } Action::CopyAsHttp(id) => { @@ -863,7 +860,7 @@ pub fn update(state: &mut AppState, action: Action) -> Vec { t.source.clone() }; fx.push(Effect::CopyToClipboard(text)); - state.set_info("Copied as .http"); + state.set_info(txt::msg::COPIED_HTTP); } Action::ImportPostman => fx.push(Effect::PickPostmanImport), Action::PostmanImported { root, files, warnings } => { @@ -1065,7 +1062,7 @@ fn send(state: &mut AppState, id: TabId, fx: &mut Vec) { if let Some(e) = &t.source_error { let e = e.clone(); if let Some(t) = state.tab_mut(id) { - t.error = Some(format!("Fix the source first: {e}")); + t.error = Some(txt::msg::fix_source(e)); } return; } @@ -1426,7 +1423,10 @@ fn unique_title(f: &HttpFile, base: &str) -> String { if !taken(base) { return base.to_string(); } - (2..).map(|n| format!("{base} {n}")).find(|t| !taken(t)).unwrap() + (2..) + .map(|n| txt::names::numbered(base, n)) + .find(|t| !taken(t)) + .unwrap() } fn slug_name(title: &str) -> String { @@ -1621,23 +1621,23 @@ fn apply_consolidation(state: &mut AppState, plan: ConsolidateAuth, fx: &mut Vec settings.auth = FolderAuth::Header(target.clone()); ops.push(FileOp::Write(folder::settings_path(&plan.dir), settings.to_json())); c.folders.insert(plan.dir.clone(), settings); - msg.push(format!("set the folder auth to `{target}`")); + msg.push(txt::consolidate::set_folder(target)); } } if dropped > 0 { - msg.push(format!("{dropped} request(s) now inherit it")); + msg.push(txt::consolidate::dropped(dropped)); } if pinned > 0 { - msg.push(format!("{pinned} request(s) keep their auth explicitly")); + msg.push(txt::consolidate::pinned(pinned)); } if !plan.skipped_dirty.is_empty() { - msg.push(format!("{} with unsaved edits skipped", plan.skipped_dirty.len())); + msg.push(txt::consolidate::skipped(plan.skipped_dirty.len())); } if !ops.is_empty() { fx.push(Effect::FileOps { ops, rescan: None }); } if msg.is_empty() { - state.set_info("Auth: nothing to change"); + state.set_info(txt::consolidate::NOTHING_TO_CHANGE); } else { let mut text = msg.join(", "); text[..1].make_ascii_uppercase(); @@ -1649,7 +1649,7 @@ fn save(state: &mut AppState, id: TabId, fx: &mut Vec) { let Some(t) = state.tab(id) else { return }; if let Some(e) = &t.source_error { let e = e.clone(); - state.set_error(format!("Cannot save: {e}")); + state.set_error(txt::msg::cannot_save(e)); return; } let Some(origin) = t.origin.clone() else { @@ -1657,11 +1657,11 @@ fn save(state: &mut AppState, id: TabId, fx: &mut Vec) { return; }; let Some(f) = file_of(state, &origin.file) else { - state.set_error(format!("{} is not loaded", origin.file.display())); + state.set_error(txt::msg::not_loaded(origin.file.display())); return; }; let Some(index) = f.find(&origin.key) else { - state.set_error("The request is no longer in its file; use Save As"); + state.set_error(txt::msg::NO_LONGER_IN_FILE); return; }; let new_text = if t.source_authoritative { diff --git a/crates/app/src/effects.rs b/crates/app/src/effects.rs index 0e7e3e4..109c899 100644 --- a/crates/app/src/effects.rs +++ b/crates/app/src/effects.rs @@ -20,6 +20,7 @@ use crate::action::Action; use crate::history::{self, HistoryEntry}; use crate::settings::Settings; use crate::state::{prepare_body, TabId}; +use crate::strings as txt; #[derive(Debug, Clone, PartialEq, Eq)] pub enum FileOp { @@ -166,7 +167,7 @@ impl Runner { self.handle.spawn(async move { let settings = match tokio::fs::read_to_string(paths.settings_file()).await { Ok(text) => Settings::from_toml(&text).unwrap_or_else(|e| { - out.send(Action::Error(format!("settings.toml: {e}"))); + out.send(Action::Error(txt::msg::settings_file(e))); Settings::default() }), Err(_) => Settings::default(), @@ -278,15 +279,15 @@ impl Runner { let existing = tokio::fs::read_to_string(&path).await.unwrap_or_default(); let text = format!("{existing}{}", env::gitignore_addition(&existing)); match tokio::fs::write(&path, text).await { - Ok(()) => out.send(Action::Info(format!("Added {} to .gitignore", env::PRIVATE_FILE))), - Err(e) => out.send(Action::Error(format!("{}: {e}", path.display()))), + Ok(()) => out.send(Action::Info(txt::msg::added_to_gitignore(env::PRIVATE_FILE))), + Err(e) => out.send(Action::Error(txt::msg::file_error(path.display(), e))), } }); } Effect::PickCollectionFolder => { self.handle.spawn(async move { if let Some(dir) = rfd::AsyncFileDialog::new() - .set_title("Open collection folder") + .set_title(txt::pick::OPEN_COLLECTION) .pick_folder() .await { @@ -297,8 +298,8 @@ impl Runner { Effect::PickSaveTarget(tab) => { self.handle.spawn(async move { if let Some(f) = rfd::AsyncFileDialog::new() - .set_title("Save request to .http file") - .add_filter("HTTP request files", &["http", "rest"]) + .set_title(txt::pick::SAVE_REQUEST) + .add_filter(txt::pick::HTTP_FILTER, &["http", "rest"]) .set_file_name("requests.http") .save_file() .await @@ -312,7 +313,7 @@ impl Runner { Effect::PickBodyFile(tab) => { self.handle.spawn(async move { if let Some(f) = rfd::AsyncFileDialog::new() - .set_title("Request body file") + .set_title(txt::pick::BODY_FILE) .pick_file() .await { @@ -323,8 +324,8 @@ impl Runner { Effect::PickCaFile => { self.handle.spawn(async move { if let Some(f) = rfd::AsyncFileDialog::new() - .set_title("CA certificate bundle (PEM)") - .add_filter("PEM", &["pem", "crt", "cer"]) + .set_title(txt::pick::CA_FILE) + .add_filter(txt::pick::PEM_FILTER, &["pem", "crt", "cer"]) .pick_file() .await { @@ -335,15 +336,15 @@ impl Runner { Effect::PickPostmanImport => { self.handle.spawn(async move { let Some(coll) = rfd::AsyncFileDialog::new() - .set_title("Postman collection (v2.1) to import") - .add_filter("Postman collection", &["json"]) + .set_title(txt::pick::POSTMAN_FILE) + .add_filter(txt::pick::POSTMAN_FILTER, &["json"]) .pick_file() .await else { return; }; let Some(out_dir) = rfd::AsyncFileDialog::new() - .set_title("Folder to write the .http files to") + .set_title(txt::pick::IMPORT_TARGET) .pick_folder() .await else { @@ -357,14 +358,14 @@ impl Runner { files, warnings, }), - Err(e) => out.send(Action::Error(format!("Postman import failed: {e}"))), + Err(e) => out.send(Action::Error(txt::msg::postman_failed(e))), } }); } Effect::SaveResponseBody { body, suggested_name } => { self.handle.spawn(async move { let Some(f) = rfd::AsyncFileDialog::new() - .set_title("Save response body") + .set_title(txt::pick::SAVE_RESPONSE) .set_file_name(&suggested_name) .save_file() .await @@ -377,8 +378,8 @@ impl Runner { BodyStore::TempFile(p) => tokio::fs::copy(&**p, &path).await.map(|_| ()), }; match r { - Ok(()) => out.send(Action::Info(format!("Saved {}", path.display()))), - Err(e) => out.send(Action::Error(format!("{}: {e}", path.display()))), + Ok(()) => out.send(Action::Info(txt::msg::saved(path.display()))), + Err(e) => out.send(Action::Error(txt::msg::file_error(path.display(), e))), } }); } @@ -414,7 +415,7 @@ impl Runner { self.handle.spawn(async move { let _ = tokio::fs::create_dir_all(&paths.config_dir).await; if let Err(e) = tokio::fs::write(paths.settings_file(), s.to_toml()).await { - out.send(Action::Error(format!("Could not save settings: {e}"))); + out.send(Action::Error(txt::msg::settings_save_failed(e))); } }); } @@ -443,13 +444,13 @@ impl Runner { Ok(w) => w, Err(e) => { self.outbox - .send(Action::Error(format!("Cannot watch {}: {e}", root.display()))); + .send(Action::Error(txt::msg::cannot_watch(root.display(), e))); return; } }; if let Err(e) = watcher.watch(&root, RecursiveMode::Recursive) { self.outbox - .send(Action::Error(format!("Cannot watch {}: {e}", root.display()))); + .send(Action::Error(txt::msg::cannot_watch(root.display(), e))); return; } watchers.insert(root.clone(), watcher); @@ -536,18 +537,18 @@ async fn run_file_op(op: &FileOp) -> Result<(), String> { Ok(()) => tokio::fs::rename(&tmp, p).await, Err(e) => Err(e), } - .map_err(|e| format!("{}: {e}", p.display())) + .map_err(|e| txt::msg::file_error(p.display(), e)) } FileOp::Delete(p) => tokio::fs::remove_file(p) .await - .map_err(|e| format!("{}: {e}", p.display())), + .map_err(|e| txt::msg::file_error(p.display(), e)), FileOp::Rename(a, b) => { if tokio::fs::try_exists(b).await.unwrap_or(false) { - return Err(format!("{} already exists", b.display())); + return Err(txt::msg::already_exists(b.display())); } tokio::fs::rename(a, b) .await - .map_err(|e| format!("{}: {e}", a.display())) + .map_err(|e| txt::msg::file_error(a.display(), e)) } }; tracing::debug!(?op, ok = r.is_ok(), "file op"); @@ -560,7 +561,7 @@ async fn import_postman(coll: &Path, out_dir: &Path) -> Result<(usize, Vec String { if dir == self.root { - format!("the collection “{}”", self.name()) + txt::names::collection(self.name()) } else { - format!("the folder {}", self.relative(dir).display()) + txt::names::folder(self.relative(dir).display()) } } } @@ -342,7 +343,7 @@ impl Tab { } let url = self.request.url.trim(); if url.is_empty() { - "New request".into() + txt::common::NEW_REQUEST.into() } else { let short: String = url.chars().take(40).collect(); if url.chars().count() > 40 { diff --git a/crates/app/src/strings.rs b/crates/app/src/strings.rs new file mode 100644 index 0000000..0ac54a5 --- /dev/null +++ b/crates/app/src/strings.rs @@ -0,0 +1,646 @@ +//! Every user-visible string in the app, in one place. +//! +//! Fixed text is a `const`; text with values in it is a function returning a +//! `String`. Grouped by where it shows up. Protocol values (header names, +//! content types) and file formats are not UI strings and stay in the code. + +/// Glyphs used as button labels and markers. +pub mod icon { + pub const CLOSE: &str = "×"; + pub const ADD: &str = "+"; + pub const RELOAD: &str = "⟳"; + pub const MORE: &str = "…"; + pub const DIRTY: &str = " •"; + pub const IN_FLIGHT: &str = " ⏳"; + pub const WARNING: &str = " ⚠"; + pub const FOLDER: &str = "📁"; + pub const FILE: &str = "📄"; + pub const SHOW: &str = "👁"; + pub const HIDE: &str = "🙈"; + pub const MASKED: &str = "••••••••"; + pub const MASKED_SHORT: &str = "••••"; + pub const BULLET: &str = "•"; + pub const NONE: &str = "—"; +} + +/// Words used in many places. +pub mod common { + pub const APP_NAME: &str = "reqlite"; + pub const OK: &str = "OK"; + pub const CANCEL: &str = "Cancel"; + pub const SAVE: &str = "Save"; + pub const CLOSE: &str = "Close"; + pub const CLEAR: &str = "Clear"; + pub const DELETE: &str = "Delete"; + pub const OPEN: &str = "Open"; + pub const RENAME: &str = "Rename…"; + pub const REMOVE: &str = "Remove"; + pub const APPLY: &str = "Apply"; + pub const DISMISS: &str = "Dismiss"; + pub const NONE: &str = "None"; + pub const ALL: &str = "All"; + pub const TEXT: &str = "Text"; + pub const FILE: &str = "File"; + pub const NAME: &str = "Name"; + pub const VALUE: &str = "Value"; + pub const SYSTEM: &str = "System"; + pub const RELOAD_FROM_DISK: &str = "Reload from disk"; + pub const NEW_REQUEST: &str = "New request"; + pub const RENAME_REQUEST: &str = "Rename request"; + pub const NEW_HTTP_FILE: &str = "New .http file"; + pub const OPEN_COLLECTION_FOLDER: &str = "Open collection folder…"; + pub const ENVIRONMENT_LABEL: &str = "Environment:"; + pub const NO_AUTH: &str = "no auth"; + + /// A bulleted list item. + pub fn bullet(item: impl std::fmt::Display) -> String { + format!("{} {item}", super::icon::BULLET) + } + + /// `n request` / `n requests`. + pub fn requests(n: usize) -> String { + format!("{n} request{}", if n == 1 { "" } else { "s" }) + } +} + +/// The menu bar, status bar and welcome screen. +pub mod main { + pub const FILE: &str = "File"; + pub const NEW_TAB: &str = "New tab Ctrl+T"; + pub const RECENT_COLLECTIONS: &str = "Recent collections"; + pub const NONE_YET: &str = "None yet"; + pub const SAVE: &str = "Save Ctrl+S"; + pub const CLOSE_ALL_TABS: &str = "Close all tabs Ctrl+Shift+W"; + pub const IMPORT_POSTMAN: &str = "Import Postman collection…"; + pub const SETTINGS: &str = "Settings…"; + pub const QUIT: &str = "Quit"; + pub const VIEW: &str = "View"; + pub const HISTORY: &str = "History"; + pub const COOKIES: &str = "Cookies"; + pub const QUICK_OPEN: &str = "Quick open… Ctrl+P"; + pub const HELP: &str = "Help"; + pub const ABOUT: &str = "About and shortcuts"; + + pub const EDIT_ENVS: &str = "Edit…"; + pub const EDIT_ENVS_HOVER: &str = "Edit environments"; + pub const NO_ENVIRONMENT: &str = "No environment"; + pub const ENV_OWNER_HOVER: &str = "The collection of the active tab, or the one last clicked in the sidebar"; + pub fn collection_environment(collection: &str) -> String { + format!("{collection} environment:") + } + + pub const ORPHANED: &str = "This request is no longer in its file. Save writes it to a file you pick."; + + pub const READY: &str = "Ready"; + pub fn in_flight(n: usize) -> String { + format!("{n} in flight") + } + + pub const WELCOME: &str = "Send HTTP requests and keep them as .http files."; + pub const WELCOME_NEW_REQUEST: &str = "New request (Ctrl+T)"; + pub const WELCOME_OPEN_FOLDER: &str = "Open a collection folder…"; + pub const WELCOME_TIP: &str = "Tip: paste a curl command into the URL bar to import it."; +} + +/// The tab bar. +pub mod tabs { + pub const CLOSE_OTHERS: &str = "Close others"; + pub const CLOSE_ALL: &str = "Close all"; + pub const CLOSE_HOVER: &str = "Close (Ctrl+W)"; + pub const NEW_TAB_HOVER: &str = "New tab (Ctrl+T)"; +} + +/// The URL bar and request editor. +pub mod request { + pub const URL_HINT: &str = "Enter a URL, or paste a curl command"; + pub const CANCEL_HOVER: &str = "Stop the request"; + pub const SEND: &str = "Send"; + pub const SEND_HOVER: &str = "Send (Ctrl+Enter)"; + pub const SAVE_DIRTY: &str = "Save •"; + pub const SAVE_HOVER: &str = "Save to the .http file (Ctrl+S)"; + pub const COPY_AS_CURL: &str = "Copy as curl"; + pub const COPY_AS_HTTP: &str = "Copy as .http"; + pub const FOLLOW_REDIRECTS: &str = "Follow redirects"; + + pub fn params_tab(n: usize) -> String { + format!("Params ({n})") + } + pub fn headers_tab(n: usize) -> String { + format!("Headers ({n})") + } + pub const BODY_TAB: &str = "Body"; + pub const BODY_TAB_SET: &str = "Body •"; + pub const AUTH_TAB: &str = "Auth"; + pub const SOURCE_TAB: &str = "Source"; + pub const SOURCE_TAB_ERROR: &str = "Source ⚠"; + + pub const KEY: &str = "Key"; + pub const ADD_PARAMETER: &str = "Add parameter"; + pub const PARAMS_NOTE: &str = "Parameters are kept in the URL, exactly as typed."; + pub const ADD_HEADER: &str = "Add header"; + pub const DISABLED_HEADER_HOVER: &str = "Disabled headers are kept as `# Name: value` comments"; + + pub const SOURCE_NOTE: &str = + "The request as it is stored in the .http file. Comments and response handlers are kept; scripts are never run."; +} + +/// The request body editor. +pub mod body { + pub const MULTIPART_FORM: &str = "Multipart form"; + pub const NO_BODY: &str = "This request has no body."; + pub const CONTENT_TYPE_LABEL: &str = "Content-Type:"; + pub const JSON: &str = "JSON"; + pub const XML: &str = "XML"; + pub const FORM: &str = "Form"; + pub const FORMAT: &str = "Format"; + pub const FORMAT_HOVER: &str = "Pretty-print the JSON"; + pub fn too_large(kb: usize) -> String { + format!( + "The body is {kb} KB, too large to edit here. Edit it in the .http file, or move it to a file (`< ./body.json`)." + ) + } + pub const FILE_LABEL: &str = "File:"; + pub const BROWSE: &str = "Browse…"; + pub const SUBSTITUTE: &str = "Replace {{variables}} in the file (`<@`)"; + pub const RELATIVE_PATHS: &str = "Relative paths are relative to the .http file."; + pub const PART_KIND: &str = "Kind"; + pub const PART_VALUE: &str = "Value / file"; + pub const PART_CONTENT_TYPE: &str = "Content-Type"; + pub const ADD_FIELD: &str = "Add field"; +} + +/// The Auth tab and the folder auth dialog. +pub mod auth { + pub const TYPE_LABEL: &str = "Type:"; + pub const INHERIT: &str = "Inherit"; + pub const NOT_SET: &str = "Not set"; + pub const BASIC: &str = "Basic"; + pub const BEARER: &str = "Bearer token"; + pub const USERNAME: &str = "Username"; + pub const PASSWORD: &str = "Password"; + pub const BASIC_NOTE: &str = + "Written as `Authorization: Basic user password`; it is base64-encoded when sent, like JetBrains does."; + pub const TOKEN: &str = "Token"; + pub const HEADER_VALUE: &str = "Header value"; + pub const NO_AUTH_SET: &str = "No Authorization header, not even the folder's (`# @no-auth`)."; + pub const CUSTOM: &str = "Custom Authorization header:"; + pub const SECRETS_NOTE: &str = "Auth is just the Authorization header; put secrets in the private env file."; + + pub const NOT_IN_COLLECTION: &str = "Not in a collection, so there is nothing to inherit."; + pub const USES: &str = "Uses"; + pub fn from_folder(folder: &str) -> String { + format!("from {folder}.") + } + pub fn folder_sends_none(folder: &str) -> String { + format!("No auth: {folder} is set to send none.") + } + pub const NO_FOLDER_AUTH: &str = "No auth: no folder above this request has auth set."; + pub const FOLDER_AUTH_BUTTON: &str = "Folder auth…"; + pub const COLLECTION_DEFAULT_BUTTON: &str = "Collection default…"; + pub const COLLECTION_DEFAULT_HOVER: &str = "Auth for every request in the collection that doesn't set its own"; + pub const UNTITLED_NOTE: &str = "Untitled requests use the collection default."; + + pub const COLLECTION_DEFAULT_TITLE: &str = "Collection default auth"; + pub const FOLDER_AUTH_TITLE: &str = "Folder auth"; + pub const ROOT_NOT_SET: &str = "Requests that don't set auth send none."; + pub fn parent_uses(value: &str, folder: &str) -> String { + format!("Uses `{value}` from {folder}.") + } + pub fn parent_none(folder: &str) -> String { + format!("No auth, as set on {folder}.") + } + pub const NO_PARENT_AUTH: &str = "No auth: no parent folder has auth set."; + pub const FOLDER_NONE: &str = "Requests here send no auth unless they set their own."; + pub const FOLDER_NOTE: &str = + "Used by requests in this folder and its subfolders that have no Authorization header of their own. \ + Saved in .reqlite/folder.json (other .http tools ignore it)."; +} + +/// The "Consolidate auth" dialog and its result. +pub mod consolidate { + pub const TITLE: &str = "Consolidate auth"; + pub fn intro(folder: &str) -> String { + format!( + "Let requests in {folder} inherit one shared auth instead of each carrying its own Authorization header." + ) + } + pub const NOTHING: &str = "None of these requests has an Authorization header, and there is no auth to inherit."; + pub const SHARED_AUTH: &str = "Shared auth:"; + pub fn choice(value: &str, n: usize) -> String { + format!("{value} ({})", super::common::requests(n)) + } + pub fn will_save(folder: &str) -> String { + format!("It will be saved as the auth of {folder}.") + } + pub fn already_uses(folder: &str) -> String { + format!("{folder} already uses it.") + } + pub const NO_OWN: &str = "No request here has its own Authorization header."; + pub const REMOVE_FROM: &str = "Remove the Authorization header from:"; + pub const MATCHING: &str = "Matching"; + pub const MATCHING_HOVER: &str = "Only those that send the same thing"; + pub fn would_send(has: &str, would: &str) -> String { + format!("has `{has}`; would send `{would}` instead") + } + pub fn affected(n: usize, target: &str) -> String { + format!("{n} request(s) without a header of their own would start sending `{target}`:") + } + pub fn affected_item(label: &str, now: &str) -> String { + format!("{} {label} (now: {now})", super::icon::BULLET) + } + pub const KEEP_AFFECTED: &str = "Keep what they send today"; + pub const KEEP_AFFECTED_HOVER: &str = "Gives them their current header, or `# @no-auth`"; + pub fn skipped_dirty(labels: &str) -> String { + format!("Skipped, because their tabs have unsaved edits: {labels}") + } + + // The status message after applying; parts are joined with ", ". + pub fn set_folder(target: &str) -> String { + format!("set the folder auth to `{target}`") + } + pub fn dropped(n: usize) -> String { + format!("{n} request(s) now inherit it") + } + pub fn pinned(n: usize) -> String { + format!("{n} request(s) keep their auth explicitly") + } + pub fn skipped(n: usize) -> String { + format!("{n} with unsaved edits skipped") + } + pub const NOTHING_TO_CHANGE: &str = "Auth: nothing to change"; +} + +/// The response panel. +pub mod response { + pub fn sending(secs: f32) -> String { + format!("Sending… {secs:.1} s") + } + pub const EMPTY: &str = "Send the request to see the response here."; + pub fn millis(ms: u128) -> String { + format!("{ms} ms") + } + pub fn millis_f(ms: f32) -> String { + format!("{ms:.1} ms") + } + pub const SPILLED: &str = "(stored in a temp file)"; + pub const SAVE_TO_FILE: &str = "Save to file…"; + pub const COPY_BODY: &str = "Copy body"; + pub const BODY_TAB: &str = "Body"; + pub fn headers_tab(n: usize) -> String { + format!("Headers ({n})") + } + pub const TIMINGS_TAB: &str = "Timings"; + pub fn final_url(url: &str) -> String { + format!("Final URL: {url}") + } + pub const PREPARING: &str = "Preparing the body…"; + pub const NO_BODY: &str = "No body."; + pub const PRETTY: &str = "Pretty"; + pub const RAW: &str = "Raw"; + pub const BINARY: &str = "Binary body, shown as hex. Use “Save to file” to keep it."; + pub const TRUNCATED: &str = "Only the start of this large body is shown."; + pub const FIND_BUTTON: &str = "🔍 Find"; + pub const FIND_HOVER: &str = "Search the body (Ctrl+F)"; + pub const FIND_HINT: &str = "Find"; + pub const NO_MATCHES: &str = "no matches"; + pub const PREV: &str = "Prev"; + pub const NEXT: &str = "Next"; + pub const TOTAL: &str = "Total"; +} + +/// The collection tree. +pub mod sidebar { + pub const COLLECTIONS: &str = "Collections"; + pub const OPEN: &str = "Open…"; + pub const OPEN_HOVER: &str = "Open another collection folder"; + pub const NO_COLLECTION: &str = "No collection open."; + pub const WHAT_IS_A_COLLECTION: &str = "A collection is a folder of .http files."; + pub const OPEN_FOLDER: &str = "Open folder…"; + pub const RECENT: &str = "Recent"; + pub fn collection_hover(root: impl std::fmt::Display) -> String { + format!("{root}\nClick to use its environments for new tabs") + } + pub const NEW_HTTP_FILE: &str = "New .http file…"; + pub const DEFAULT_AUTH: &str = "Default auth…"; + pub const CLOSE_COLLECTION: &str = "Close collection"; + pub const CLOSE_COLLECTION_HOVER: &str = "Close this collection"; + pub const PRIVATE_NOT_IGNORED: &str = + "http-client.private.env.json is not in .gitignore, so secrets could be committed."; + pub const ADD_TO_GITIGNORE: &str = "Add to .gitignore"; + pub fn env_error(e: &str) -> String { + format!("Environments: {e}") + } + pub fn folder_error(e: &str) -> String { + format!("Folder settings: {e}") + } + pub const NO_FILES: &str = "No .http files yet."; + pub const CREATE_ONE: &str = "Create one"; + pub const AUTH_HOVER: &str = "Auth for the requests in here that don't set their own"; + pub const CONSOLIDATE: &str = "Consolidate auth…"; + pub const CONSOLIDATE_HOVER: &str = "Make requests in here inherit one shared auth"; + pub fn folder(name: &str) -> String { + format!("{} {name}", super::icon::FOLDER) + } + pub fn file(name: &str) -> String { + format!("{} {name}", super::icon::FILE) + } + pub fn folder_auth_hover(value: &str) -> String { + format!("Auth: {value}") + } + pub const DUPLICATE: &str = "Duplicate"; + pub const MOVE_TO: &str = "Move to"; + pub const DELETE: &str = "Delete…"; + pub const NO_REQUESTS: &str = "(no requests)"; + pub const RENAME_FILE: &str = "Rename file…"; + pub const RENAME_FILE_TITLE: &str = "Rename file"; + pub const DUPLICATE_FILE: &str = "Duplicate file"; + pub const DELETE_FILE: &str = "Delete file…"; + pub const NO_URL: &str = "(no URL)"; +} + +/// Modal dialogs. +pub mod dialog { + pub const UNSAVED: &str = "Unsaved changes"; + pub fn tab_unsaved(title: &str) -> String { + format!("“{title}” has changes that are not saved.") + } + pub const SAVE_AND_CLOSE: &str = "Save and close"; + pub const DISCARD: &str = "Discard"; + pub fn tabs_unsaved(n: usize) -> String { + format!("{n} tab(s) have changes that are not saved:") + } + pub const DISCARD_AND_CLOSE: &str = "Discard and close"; + pub const KEEP_OPEN: &str = "Keep them open"; + + pub const QUIT_TITLE: &str = "Quit reqlite?"; + pub fn quit_unsaved(n: usize) -> String { + format!("{n} tab(s) have unsaved changes; they will be lost.") + } + pub const QUIT_WITHOUT_SAVING: &str = "Quit without saving"; + + pub const CONFLICT_TITLE: &str = "File changed on disk"; + pub fn conflict(path: impl std::fmt::Display) -> String { + format!("{path} was changed outside reqlite, and this tab has unsaved edits.") + } + pub const RELOAD_HOVER: &str = "Discard my edits"; + pub const KEEP_MINE: &str = "Keep my version"; + pub const KEEP_MINE_HOVER: &str = "Saving will overwrite this request in the new file"; + + pub const DELETE_TITLE: &str = "Delete?"; + pub fn delete_request(label: &str) -> String { + format!("the request “{label}”") + } + pub fn delete_file(path: impl std::fmt::Display) -> String { + format!("the file {path}") + } + pub fn delete_body(what: &str) -> String { + format!("This deletes {what} from disk.") + } + + pub const IMPORT_TITLE: &str = "Import finished"; + pub fn import_wrote(files: usize, root: impl std::fmt::Display) -> String { + format!("Wrote {files} .http file(s) to {root}.") + } + pub fn warnings(n: usize) -> String { + format!("{n} warning(s):") + } + + pub const NEW_ENVIRONMENT: &str = "New environment"; +} + +/// The Settings window. +pub mod settings { + pub const TITLE: &str = "Settings"; + pub const TIMEOUT: &str = "Default timeout"; + pub const SECONDS_SUFFIX: &str = " s"; + pub const TIMEOUT_NOTE: &str = "0 = none; `# @timeout` wins"; + pub const PROXY: &str = "Proxy"; + pub const MANUAL: &str = "Manual"; + pub const PROXY_HINT: &str = "http://user:pass@proxy:3128"; + pub const TLS: &str = "TLS"; + pub const VERIFY_TLS: &str = "Verify certificates"; + pub const SYSTEM_STORE: &str = "System store only"; + pub const ADD_CA: &str = "Add CA file…"; + pub const THEME: &str = "Theme"; + pub const LIGHT: &str = "Light"; + pub const DARK: &str = "Dark"; + pub const FONT_SIZE: &str = "Font size"; + pub fn percent(v: f64) -> String { + format!("{:.0}%", v * 100.0) + } + pub const PARALLEL: &str = "Parallel requests"; + pub const AT_ONCE: &str = "at once"; + pub const HISTORY_SIZE: &str = "History size"; +} + +/// The History window. +pub mod history { + pub const TITLE: &str = "History"; + pub fn count(n: usize) -> String { + format!("{n} request(s)") + } + pub const ERR: &str = "ERR"; + pub fn hover(url: &str, ms: u64, env: Option<&str>) -> String { + format!( + "{url}\n{ms} ms{}", + env.map(|v| format!(", env {v}")).unwrap_or_default() + ) + } + pub const RESTORE_HOVER: &str = "Restore into a new tab"; +} + +/// The Cookies window. +pub mod cookies { + pub const TITLE: &str = "Cookies"; + pub const NOTE: &str = "Cookies are kept in memory per collection; `# @no-cookie-jar` skips them."; + pub const EMPTY: &str = "No cookies yet."; + pub const CLEAR_ALL: &str = "Clear all"; + pub const DOMAIN: &str = "Domain"; + pub const PATH: &str = "Path"; +} + +/// The About window. +pub mod about { + pub const TITLE: &str = "About reqlite"; + pub fn heading(version: &str) -> String { + format!("reqlite {version}") + } + pub const TAGLINE: &str = "A small API client for .http files."; + pub const SHORTCUTS: &str = "Shortcuts"; + pub const KEYS: [(&str, &str); 8] = [ + ("Ctrl+Enter", "Send"), + ("Ctrl+S", "Save"), + ("Ctrl+T", "New tab"), + ("Ctrl+W", "Close tab"), + ("Ctrl+Shift+W", "Close all tabs"), + ("Ctrl+L", "Focus the URL bar"), + ("Ctrl+P", "Quick-open a request"), + ("Ctrl+F", "Find in the response"), + ]; +} + +/// The environment editor window. +pub mod env { + pub fn title(collection: &str, dirty: bool) -> String { + format!( + "Environments: {collection}{}", + if dirty { super::icon::DIRTY } else { "" } + ) + } + pub const SHARED: &str = "$shared (all environments)"; + pub const NEW: &str = "New…"; + pub const PRIVATE: &str = "Private"; + pub const STRUCTURED: &str = "(object; edit the JSON file)"; + pub const PRIVATE_HOVER: &str = "Stored in http-client.private.env.json (keep it out of git)"; + pub const SHOW_HIDE_HOVER: &str = "Show / hide"; + pub const ADD_VARIABLE: &str = "Add variable"; + pub const SAVE_NOTE: &str = "Writes http-client.env.json and http-client.private.env.json."; +} + +/// The quick-open popup. +pub mod quick_open { + pub const TITLE: &str = "Open request"; + pub const HINT: &str = "Type to find a request…"; + pub const NO_MATCHES: &str = "No matching requests"; +} + +/// Variable hover text in editors. +pub mod vars { + pub fn undefined(name: &str) -> String { + format!("{{{{{name}}}}} is not defined in the selected environment") + } + pub fn builtin(name: &str) -> String { + format!("{{{{{name}}}}}: built-in dynamic value") + } + pub const FROM_PRIVATE_ENV: &str = "private env"; + pub const FROM_ENV: &str = "env"; + pub const FROM_FILE: &str = "file variable"; + pub const FROM_BUILTIN: &str = "built-in"; + pub fn resolved(value: &str, result: &str) -> String { + format!("{value} -> {result}") + } + pub fn hover(name: &str, shown: &str, from: &str) -> String { + format!("{name} = {shown} ({from})") + } +} + +/// Sizes. +pub mod units { + pub fn bytes(n: u64) -> String { + format!("{n} B") + } + pub fn kilobytes(kb: f64) -> String { + format!("{kb:.1} KB") + } + pub fn megabytes(mb: f64) -> String { + format!("{mb:.1} MB") + } +} + +/// Native file dialogs. +pub mod pick { + pub const OPEN_COLLECTION: &str = "Open collection folder"; + pub const SAVE_REQUEST: &str = "Save request to .http file"; + pub const HTTP_FILTER: &str = "HTTP request files"; + pub const BODY_FILE: &str = "Request body file"; + pub const CA_FILE: &str = "CA certificate bundle (PEM)"; + pub const PEM_FILTER: &str = "PEM"; + pub const POSTMAN_FILE: &str = "Postman collection (v2.1) to import"; + pub const POSTMAN_FILTER: &str = "Postman collection"; + pub const IMPORT_TARGET: &str = "Folder to write the .http files to"; + pub const SAVE_RESPONSE: &str = "Save response body"; +} + +/// Status bar messages and errors shown in a tab. +pub mod msg { + use std::fmt::Display; + + pub const NO_REQUEST_IN_TEXT: &str = "No request in that text"; + pub const CURL_IMPORTED: &str = "Imported the curl command"; + pub fn curl_import_failed(e: impl Display) -> String { + format!("Could not import curl command: {e}") + } + pub const NO_REQUEST_LINE: &str = "No request line found"; + pub fn not_one_request(n: usize) -> String { + format!("The source must contain exactly one request (found {n})") + } + pub const CANCELLED: &str = "Cancelled"; + pub fn overlaps(root: impl Display, other: impl Display) -> String { + format!("{root} overlaps the open collection {other}; close that one first") + } + pub fn collection_failed(e: impl Display) -> String { + format!("Could not open the collection: {e}") + } + pub fn already_exists(path: impl Display) -> String { + format!("{path} already exists") + } + pub fn pick_empty_folder(path: impl Display) -> String { + format!("{path} already exists; pick an empty folder") + } + pub const NEED_COLLECTION_FOR_ENVS: &str = + "Open a collection folder first; environments live next to the .http files"; + pub const NEED_COLLECTION_FOR_QUICK_OPEN: &str = "Open a collection to quick-open its requests"; + pub const COPIED_CURL: &str = "Copied as curl"; + pub fn curl_failed(e: impl Display) -> String { + format!("Cannot build the curl command: {e}") + } + pub const COPIED_HTTP: &str = "Copied as .http"; + pub fn fix_source(e: impl Display) -> String { + format!("Fix the source first: {e}") + } + pub fn cannot_save(e: impl Display) -> String { + format!("Cannot save: {e}") + } + pub fn not_loaded(path: impl Display) -> String { + format!("{path} is not loaded") + } + pub const NO_LONGER_IN_FILE: &str = "The request is no longer in its file; use Save As"; + pub fn invalid_json(e: impl Display) -> String { + format!("Not valid JSON: {e}") + } + pub fn settings_file(e: impl Display) -> String { + format!("settings.toml: {e}") + } + pub fn added_to_gitignore(file: &str) -> String { + format!("Added {file} to .gitignore") + } + /// An error about a particular file. + pub fn file_error(path: impl Display, e: impl Display) -> String { + format!("{path}: {e}") + } + pub fn postman_failed(e: impl Display) -> String { + format!("Postman import failed: {e}") + } + pub fn saved(path: impl Display) -> String { + format!("Saved {path}") + } + pub fn settings_save_failed(e: impl Display) -> String { + format!("Could not save settings: {e}") + } + pub fn cannot_watch(path: impl Display, e: impl Display) -> String { + format!("Cannot watch {path}: {e}") + } +} + +/// Names the app gives new things (written to files, so users see them). +pub mod names { + pub const REQUEST: &str = "Request"; + pub fn copy_of(base: &str) -> String { + format!("{base} copy") + } + pub fn file_copy(stem: &str, ext: &str) -> String { + format!("{stem} copy.{ext}") + } + pub fn file_copy_n(stem: &str, n: usize, ext: &str) -> String { + format!("{stem} copy {n}.{ext}") + } + pub fn numbered(base: &str, n: usize) -> String { + format!("{base} {n}") + } + pub fn collection(name: &str) -> String { + format!("the collection “{name}”") + } + pub fn folder(path: impl std::fmt::Display) -> String { + format!("the folder {path}") + } +} diff --git a/crates/app/src/ui/mod.rs b/crates/app/src/ui/mod.rs index a231142..842d4fb 100644 --- a/crates/app/src/ui/mod.rs +++ b/crates/app/src/ui/mod.rs @@ -10,6 +10,7 @@ use egui::{Context, Key, KeyboardShortcut, Modifiers, RichText, Ui}; use crate::action::Action; use crate::state::{AppState, QuickOpen}; +use crate::strings as txt; use widgets::VarCtx; pub fn draw(ui: &mut Ui, state: &AppState, acts: &mut Vec) { @@ -32,10 +33,7 @@ pub fn draw(ui: &mut Ui, state: &AppState, acts: &mut Vec) { is_private: &is_private, }; if tab.orphaned { - ui.label( - RichText::new("This request is no longer in its file. Save writes it to a file you pick.") - .color(ui.visuals().warn_fg_color), - ); + ui.label(RichText::new(txt::main::ORPHANED).color(ui.visuals().warn_fg_color)); } request::url_bar(ui, state, tab, &vars, acts); ui.add_space(4.0); @@ -101,16 +99,16 @@ fn shortcuts(ctx: &Context, state: &AppState, acts: &mut Vec) { fn menu_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { egui::MenuBar::new().ui(ui, |ui| { - ui.menu_button("File", |ui| { - if ui.button("New tab Ctrl+T").clicked() { + ui.menu_button(txt::main::FILE, |ui| { + if ui.button(txt::main::NEW_TAB).clicked() { acts.push(Action::NewTab); ui.close(); } - if ui.button("Open collection folder…").clicked() { + if ui.button(txt::common::OPEN_COLLECTION_FOLDER).clicked() { acts.push(Action::PickCollection); ui.close(); } - ui.menu_button("Recent collections", |ui| { + ui.menu_button(txt::main::RECENT_COLLECTIONS, |ui| { for p in &state.settings.recent_collections { if ui.button(p.display().to_string()).clicked() { acts.push(Action::OpenCollection(p.clone())); @@ -118,62 +116,55 @@ fn menu_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { } } if state.settings.recent_collections.is_empty() { - ui.label(RichText::new("None yet").weak()); + ui.label(RichText::new(txt::main::NONE_YET).weak()); } }); ui.separator(); let has_tab = state.active.is_some(); - if ui - .add_enabled(has_tab, egui::Button::new("Save Ctrl+S")) - .clicked() - { + if ui.add_enabled(has_tab, egui::Button::new(txt::main::SAVE)).clicked() { acts.push(Action::Save(state.active.unwrap())); ui.close(); } if ui - .add_enabled(has_tab, egui::Button::new("Close all tabs Ctrl+Shift+W")) + .add_enabled(has_tab, egui::Button::new(txt::main::CLOSE_ALL_TABS)) .clicked() { acts.push(Action::CloseTabs(state.tabs.iter().map(|t| t.id).collect())); ui.close(); } ui.separator(); - if ui.button("Import Postman collection…").clicked() { + if ui.button(txt::main::IMPORT_POSTMAN).clicked() { acts.push(Action::ImportPostman); ui.close(); } - ui.label( - RichText::new("Tip: paste a curl command into the URL bar to import it.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::main::WELCOME_TIP).small().weak()); ui.separator(); - if ui.button("Settings…").clicked() { + if ui.button(txt::main::SETTINGS).clicked() { acts.push(Action::SetWindows(crate::state::Windows { settings: true, ..state.windows })); ui.close(); } - if ui.button("Quit").clicked() { + if ui.button(txt::main::QUIT).clicked() { acts.push(Action::CloseRequested); ui.close(); } }); - ui.menu_button("View", |ui| { + ui.menu_button(txt::main::VIEW, |ui| { let mut w = state.windows; - ui.checkbox(&mut w.history, "History"); - ui.checkbox(&mut w.cookies, "Cookies"); + ui.checkbox(&mut w.history, txt::main::HISTORY); + ui.checkbox(&mut w.cookies, txt::main::COOKIES); if w != state.windows { acts.push(Action::SetWindows(w)); } - if ui.button("Quick open… Ctrl+P").clicked() { + if ui.button(txt::main::QUICK_OPEN).clicked() { acts.push(Action::QuickOpen(Some(QuickOpen::default()))); ui.close(); } }); - ui.menu_button("Help", |ui| { - if ui.button("About and shortcuts").clicked() { + ui.menu_button(txt::main::HELP, |ui| { + if ui.button(txt::main::ABOUT).clicked() { acts.push(Action::SetWindows(crate::state::Windows { about: true, ..state.windows @@ -185,17 +176,24 @@ fn menu_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { // Environment picker on the right. ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { if let Some(c) = state.current_collection() { - if ui.button("Edit…").on_hover_text("Edit environments").clicked() { + if ui + .button(txt::main::EDIT_ENVS) + .on_hover_text(txt::main::EDIT_ENVS_HOVER) + .clicked() + { acts.push(Action::OpenEnvEditor); } let names = c.envs.names(); - let label = c.selected_env.clone().unwrap_or_else(|| "No environment".into()); + let label = c + .selected_env + .clone() + .unwrap_or_else(|| txt::main::NO_ENVIRONMENT.into()); egui::ComboBox::from_id_salt("env-picker") .selected_text(label) .width(150.0) .show_ui(ui, |ui| { if ui - .selectable_label(c.selected_env.is_none(), "No environment") + .selectable_label(c.selected_env.is_none(), txt::main::NO_ENVIRONMENT) .clicked() { acts.push(Action::SelectEnv(None)); @@ -208,10 +206,10 @@ fn menu_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { }); // With several collections, say whose environments these are. if state.collections.len() > 1 { - ui.label(format!("{} environment:", c.name())) - .on_hover_text("The collection of the active tab, or the one last clicked in the sidebar"); + ui.label(txt::main::collection_environment(c.name())) + .on_hover_text(txt::main::ENV_OWNER_HOVER); } else { - ui.label("Environment:"); + ui.label(txt::common::ENVIRONMENT_LABEL); } } }); @@ -229,10 +227,10 @@ fn tab_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { let selected = state.active == Some(t.id); let mut title = t.title(); if t.is_dirty() { - title.push_str(" •"); + title.push_str(txt::icon::DIRTY); } if t.in_flight.is_some() { - title.push_str(" ⏳"); + title.push_str(txt::icon::IN_FLIGHT); } let resp = ui.selectable_label(selected, title); let resp = match &t.origin { @@ -249,31 +247,39 @@ fn tab_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { acts.push(rename_tab_prompt(t)); } resp.context_menu(|ui| { - if ui.button("Rename…").clicked() { + if ui.button(txt::common::RENAME).clicked() { acts.push(rename_tab_prompt(t)); ui.close(); } ui.separator(); - if ui.button("Close").clicked() { + if ui.button(txt::common::CLOSE).clicked() { acts.push(Action::CloseTab(t.id)); ui.close(); } - if ui.button("Close others").clicked() { + if ui.button(txt::tabs::CLOSE_OTHERS).clicked() { let others = state.tabs.iter().map(|o| o.id).filter(|&o| o != t.id).collect(); acts.push(Action::CloseTabs(others)); ui.close(); } - if ui.button("Close all").clicked() { + if ui.button(txt::tabs::CLOSE_ALL).clicked() { acts.push(Action::CloseTabs(state.tabs.iter().map(|o| o.id).collect())); ui.close(); } }); - if ui.small_button("×").on_hover_text("Close (Ctrl+W)").clicked() { + if ui + .small_button(txt::icon::CLOSE) + .on_hover_text(txt::tabs::CLOSE_HOVER) + .clicked() + { acts.push(Action::CloseTab(t.id)); } ui.separator(); } - if ui.button("+").on_hover_text("New tab (Ctrl+T)").clicked() { + if ui + .button(txt::icon::ADD) + .on_hover_text(txt::tabs::NEW_TAB_HOVER) + .clicked() + { acts.push(Action::NewTab); } }); @@ -292,19 +298,19 @@ fn status_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { ui.visuals().text_color() }; ui.colored_label(color, &s.text); - if ui.small_button("×").clicked() { + if ui.small_button(txt::icon::CLOSE).clicked() { acts.push(Action::DismissStatus); } } None => { - ui.label(RichText::new("Ready").weak()); + ui.label(RichText::new(txt::main::READY).weak()); } } ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { let n = state.tabs.iter().filter(|t| t.in_flight.is_some()).count(); if n > 0 { ui.spinner(); - ui.label(format!("{n} in flight")); + ui.label(txt::main::in_flight(n)); } }); }); @@ -313,17 +319,17 @@ fn status_bar(ui: &mut Ui, state: &AppState, acts: &mut Vec) { fn welcome(ui: &mut Ui, acts: &mut Vec) { ui.vertical_centered(|ui| { ui.add_space(60.0); - ui.heading("reqlite"); - ui.label("Send HTTP requests and keep them as .http files."); + ui.heading(txt::common::APP_NAME); + ui.label(txt::main::WELCOME); ui.add_space(12.0); - if ui.button("New request (Ctrl+T)").clicked() { + if ui.button(txt::main::WELCOME_NEW_REQUEST).clicked() { acts.push(Action::NewTab); } - if ui.button("Open a collection folder…").clicked() { + if ui.button(txt::main::WELCOME_OPEN_FOLDER).clicked() { acts.push(Action::PickCollection); } ui.add_space(12.0); - ui.label(RichText::new("Tip: paste a curl command into the URL bar to import it.").weak()); + ui.label(RichText::new(txt::main::WELCOME_TIP).weak()); }); } @@ -331,7 +337,7 @@ fn welcome(ui: &mut Ui, acts: &mut Vec) { pub fn rename_tab_prompt(t: &crate::state::Tab) -> Action { Action::ShowDialog(Some(crate::state::Dialog::Prompt(crate::state::Prompt { kind: crate::state::PromptKind::RenameTab { tab: t.id }, - title: "Rename request".into(), + title: txt::common::RENAME_REQUEST.into(), value: t.request.display_name().unwrap_or("").to_string(), }))) } diff --git a/crates/app/src/ui/request.rs b/crates/app/src/ui/request.rs index 152a770..11c5a68 100644 --- a/crates/app/src/ui/request.rs +++ b/crates/app/src/ui/request.rs @@ -9,6 +9,7 @@ use reqlite_core::{Body, Header, Method, Part, PartBody}; use super::widgets::{code_edit, method_color, var_text_edit, VarCtx}; use crate::action::Action; use crate::state::{AppState, RequestTab, Tab}; +use crate::strings as txt; pub const MULTIPART_BOUNDARY: &str = "WebAppBoundary"; @@ -38,14 +39,7 @@ pub fn url_bar(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &m let buttons_w = 190.0; let mut url = tab.request.url.clone(); let w = (ui.available_width() - buttons_w).max(120.0); - let resp = var_text_edit( - ui, - &mut url, - Some(vars), - "Enter a URL, or paste a curl command", - w, - ("url", id), - ); + let resp = var_text_edit(ui, &mut url, Some(vars), txt::request::URL_HINT, w, ("url", id)); if state.focus_url { resp.request_focus(); acts.push(Action::UrlFocused); @@ -58,40 +52,44 @@ pub fn url_bar(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &m } if tab.in_flight.is_some() { - if ui.button("Cancel").on_hover_text("Stop the request").clicked() { + if ui + .button(txt::common::CANCEL) + .on_hover_text(txt::request::CANCEL_HOVER) + .clicked() + { acts.push(Action::Cancel(id)); } } else if ui - .add(egui::Button::new(RichText::new("Send").strong())) - .on_hover_text("Send (Ctrl+Enter)") + .add(egui::Button::new(RichText::new(txt::request::SEND).strong())) + .on_hover_text(txt::request::SEND_HOVER) .clicked() { acts.push(Action::Send(id)); } - let save_label = if tab.is_dirty() { "Save •" } else { "Save" }; - if ui - .button(save_label) - .on_hover_text("Save to the .http file (Ctrl+S)") - .clicked() - { + let save_label = if tab.is_dirty() { + txt::request::SAVE_DIRTY + } else { + txt::common::SAVE + }; + if ui.button(save_label).on_hover_text(txt::request::SAVE_HOVER).clicked() { acts.push(Action::Save(id)); } - ui.menu_button("…", |ui| { - if ui.button("Copy as curl").clicked() { + ui.menu_button(txt::icon::MORE, |ui| { + if ui.button(txt::request::COPY_AS_CURL).clicked() { acts.push(Action::CopyAsCurl(id)); ui.close(); } - if ui.button("Copy as .http").clicked() { + if ui.button(txt::request::COPY_AS_HTTP).clicked() { acts.push(Action::CopyAsHttp(id)); ui.close(); } - if ui.button("Rename…").clicked() { + if ui.button(txt::common::RENAME).clicked() { acts.push(super::rename_tab_prompt(tab)); ui.close(); } ui.separator(); let mut follow = !tab.request.directives.no_redirect; - if ui.checkbox(&mut follow, "Follow redirects").changed() { + if ui.checkbox(&mut follow, txt::request::FOLLOW_REDIRECTS).changed() { acts.push(Action::SetNoRedirect(id, !follow)); } }); @@ -103,23 +101,23 @@ pub fn editor(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mu ui.horizontal(|ui| { let enabled_headers = tab.request.headers.iter().filter(|h| !h.disabled).count(); let tabs = [ - (RequestTab::Params, format!("Params ({})", tab.params.len())), - (RequestTab::Headers, format!("Headers ({enabled_headers})")), + (RequestTab::Params, txt::request::params_tab(tab.params.len())), + (RequestTab::Headers, txt::request::headers_tab(enabled_headers)), ( RequestTab::Body, if tab.request.body.is_none() { - "Body".into() + txt::request::BODY_TAB.into() } else { - "Body •".into() + txt::request::BODY_TAB_SET.into() }, ), - (RequestTab::Auth, "Auth".into()), + (RequestTab::Auth, txt::request::AUTH_TAB.into()), ( RequestTab::Source, if tab.source_error.is_some() { - "Source ⚠".into() + txt::request::SOURCE_TAB_ERROR.into() } else { - "Source".into() + txt::request::SOURCE_TAB.into() }, ), ]; @@ -155,8 +153,8 @@ fn params(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { .num_columns(3) .striped(true) .show(ui, |ui| { - ui.label(RichText::new("Key").weak()); - ui.label(RichText::new("Value").weak()); + ui.label(RichText::new(txt::request::KEY).weak()); + ui.label(RichText::new(txt::common::VALUE).weak()); ui.label(""); ui.end_row(); for (i, p) in rows.iter_mut().enumerate() { @@ -164,7 +162,7 @@ fn params(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { ui, &mut p.key, Some(vars), - if i == n { "Add parameter" } else { "" }, + if i == n { txt::request::ADD_PARAMETER } else { "" }, w, ("pk", id, i), ) @@ -174,7 +172,12 @@ fn params(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { p.value = Some(v); changed = true; } - if i < n && ui.small_button("×").on_hover_text("Remove").clicked() { + if i < n + && ui + .small_button(txt::icon::CLOSE) + .on_hover_text(txt::common::REMOVE) + .clicked() + { remove = Some(i); } ui.end_row(); @@ -194,11 +197,7 @@ fn params(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { acts.push(Action::ParamsEdited(id, rows)); } ui.add_space(4.0); - ui.label( - RichText::new("Parameters are kept in the URL, exactly as typed.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::request::PARAMS_NOTE).small().weak()); } fn headers(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { @@ -214,8 +213,8 @@ fn headers(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { .striped(true) .show(ui, |ui| { ui.label(""); - ui.label(RichText::new("Name").weak()); - ui.label(RichText::new("Value").weak()); + ui.label(RichText::new(txt::common::NAME).weak()); + ui.label(RichText::new(txt::common::VALUE).weak()); ui.label(""); ui.end_row(); for (i, h) in rows.iter_mut().enumerate() { @@ -223,7 +222,7 @@ fn headers(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { let mut on = !h.disabled; if ui .checkbox(&mut on, "") - .on_hover_text("Disabled headers are kept as `# Name: value` comments") + .on_hover_text(txt::request::DISABLED_HEADER_HOVER) .changed() { h.disabled = !on; @@ -236,14 +235,19 @@ fn headers(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { ui, &mut h.name, Some(vars), - if i == n { "Add header" } else { "" }, + if i == n { txt::request::ADD_HEADER } else { "" }, (w * 0.35).max(100.0), ("hn", id, i), ) .changed(); changed |= var_text_edit(ui, &mut h.value, Some(vars), "", (w * 0.65).max(120.0), ("hv", id, i)).changed(); - if i < n && ui.small_button("×").on_hover_text("Remove").clicked() { + if i < n + && ui + .small_button(txt::icon::CLOSE) + .on_hover_text(txt::common::REMOVE) + .clicked() + { remove = Some(i); } ui.end_row(); @@ -282,10 +286,10 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec }; ui.horizontal(|ui| { for (k, label) in [ - (BodyKind::None, "None"), - (BodyKind::Text, "Text"), - (BodyKind::File, "File"), - (BodyKind::Form, "Multipart form"), + (BodyKind::None, txt::common::NONE), + (BodyKind::Text, txt::common::TEXT), + (BodyKind::File, txt::common::FILE), + (BodyKind::Form, txt::body::MULTIPART_FORM), ] { if ui.radio(kind == k, label).clicked() && kind != k { match k { @@ -326,18 +330,18 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec ui.add_space(4.0); match &req.body { Body::None => { - ui.label(RichText::new("This request has no body.").weak()); + ui.label(RichText::new(txt::body::NO_BODY).weak()); } Body::Text(text) => { let ct = req.header("content-type").unwrap_or("").to_ascii_lowercase(); let is_json = ct.contains("json"); ui.horizontal(|ui| { - ui.label("Content-Type:"); + ui.label(txt::body::CONTENT_TYPE_LABEL); for (label, value) in [ - ("JSON", "application/json"), - ("XML", "application/xml"), - ("Text", "text/plain"), - ("Form", "application/x-www-form-urlencoded"), + (txt::body::JSON, "application/json"), + (txt::body::XML, "application/xml"), + (txt::common::TEXT, "text/plain"), + (txt::body::FORM, "application/x-www-form-urlencoded"), ] { if ui.selectable_label(ct.starts_with(value), label).clicked() { let mut headers = req.headers.clone(); @@ -346,24 +350,23 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec acts.push(Action::HeadersEdited(id, headers)); } } - if is_json && ui.button("Format").on_hover_text("Pretty-print the JSON").clicked() { + if is_json + && ui + .button(txt::body::FORMAT) + .on_hover_text(txt::body::FORMAT_HOVER) + .clicked() + { match serde_json::from_str::(text) { Ok(v) => acts.push(Action::BodyEdited( id, Body::Text(serde_json::to_string_pretty(&v).unwrap_or_else(|_| text.clone())), )), - Err(e) => acts.push(Action::Error(format!("Not valid JSON: {e}"))), + Err(e) => acts.push(Action::Error(txt::msg::invalid_json(e))), } } }); if text.len() > MAX_EDITABLE_BODY { - ui.label( - RichText::new(format!( - "The body is {} KB, too large to edit here. Edit it in the .http file, or move it to a file (`< ./body.json`).", - text.len() / 1024 - )) - .weak(), - ); + ui.label(RichText::new(txt::body::too_large(text.len() / 1024)).weak()); } else { let mut t = text.clone(); if code_edit(ui, &mut t, is_json, Some(vars.resolver), 12, ("body", id)).changed() { @@ -373,7 +376,7 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec } Body::FileRef { path, substitute } => { ui.horizontal(|ui| { - ui.label("File:"); + ui.label(txt::body::FILE_LABEL); let mut p = path.display().to_string(); if ui .add(egui::TextEdit::singleline(&mut p).desired_width(320.0)) @@ -387,15 +390,12 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec }, )); } - if ui.button("Browse…").clicked() { + if ui.button(txt::body::BROWSE).clicked() { acts.push(Action::PickBodyFile(id)); } }); let mut sub = *substitute; - if ui - .checkbox(&mut sub, "Replace {{variables}} in the file (`<@`)") - .changed() - { + if ui.checkbox(&mut sub, txt::body::SUBSTITUTE).changed() { acts.push(Action::BodyEdited( id, Body::FileRef { @@ -404,11 +404,7 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec }, )); } - ui.label( - RichText::new("Relative paths are relative to the .http file.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::body::RELATIVE_PATHS).small().weak()); } Body::Multipart { boundary, parts } => { let mut parts = parts.clone(); @@ -418,7 +414,13 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec .num_columns(5) .striped(true) .show(ui, |ui| { - for h in ["Name", "Kind", "Value / file", "Content-Type", ""] { + for h in [ + txt::common::NAME, + txt::body::PART_KIND, + txt::body::PART_VALUE, + txt::body::PART_CONTENT_TYPE, + "", + ] { ui.label(RichText::new(h).weak()); } ui.end_row(); @@ -432,14 +434,14 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec let is_file = matches!(p.body, PartBody::File(_)); egui::ComboBox::from_id_salt(("pk", id, i)) .width(60.0) - .selected_text(if is_file { "File" } else { "Text" }) + .selected_text(if is_file { txt::common::FILE } else { txt::common::TEXT }) .show_ui(ui, |ui| { - if ui.selectable_label(!is_file, "Text").clicked() && is_file { + if ui.selectable_label(!is_file, txt::common::TEXT).clicked() && is_file { p.body = PartBody::Text(String::new()); p.filename = None; changed = true; } - if ui.selectable_label(is_file, "File").clicked() && !is_file { + if ui.selectable_label(is_file, txt::common::FILE).clicked() && !is_file { p.body = PartBody::File("./file.bin".into()); p.filename = Some("file.bin".into()); changed = true; @@ -480,7 +482,7 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec } changed = true; } - if ui.small_button("×").clicked() { + if ui.small_button(txt::icon::CLOSE).clicked() { remove = Some(i); } ui.end_row(); @@ -490,7 +492,7 @@ fn body(ui: &mut Ui, _state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec parts.remove(i); changed = true; } - if ui.button("Add field").clicked() { + if ui.button(txt::body::ADD_FIELD).clicked() { parts.push(Part { name: format!("field{}", parts.len() + 1), filename: None, @@ -567,7 +569,7 @@ pub fn header_kind(value: &str) -> AuthKind { pub fn auth_kind_row(ui: &mut Ui, current: AuthKind, kinds: &[(AuthKind, &str)]) -> Option { let mut picked = None; ui.horizontal(|ui| { - ui.label("Type:"); + ui.label(txt::auth::TYPE_LABEL); for &(k, label) in kinds { if ui.radio(current == k, label).clicked() && current != k { picked = Some(k); @@ -587,26 +589,22 @@ pub fn auth_value_fields(ui: &mut Ui, value: &str, vars: &VarCtx, salt: &str) -> let (mut u, mut p) = (a, b); let mut changed = false; egui::Grid::new(("basic", salt)).num_columns(2).show(ui, |ui| { - ui.label("Username"); + ui.label(txt::auth::USERNAME); changed |= var_text_edit(ui, &mut u, Some(vars), "", 260.0, ("bu", salt)).changed(); ui.end_row(); - ui.label("Password"); + ui.label(txt::auth::PASSWORD); changed |= var_text_edit(ui, &mut p, Some(vars), "", 260.0, ("bp", salt)).changed(); ui.end_row(); }); if changed { out = Some(format!("Basic {u} {p}")); } - ui.label( - RichText::new("Written as `Authorization: Basic user password`; it is base64-encoded when sent, like JetBrains does.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::auth::BASIC_NOTE).small().weak()); } AuthKind::Bearer => { let mut t = a; ui.horizontal(|ui| { - ui.label("Token"); + ui.label(txt::auth::TOKEN); if var_text_edit(ui, &mut t, Some(vars), "{{token}}", 420.0, ("bt", salt)).changed() { out = Some(format!("Bearer {t}")); } @@ -615,7 +613,7 @@ pub fn auth_value_fields(ui: &mut Ui, value: &str, vars: &VarCtx, salt: &str) -> _ => { let mut v = value.to_string(); ui.horizontal(|ui| { - ui.label("Header value"); + ui.label(txt::auth::HEADER_VALUE); if var_text_edit(ui, &mut v, Some(vars), "", 420.0, ("bo", salt)).changed() { out = Some(v.clone()); } @@ -634,10 +632,10 @@ fn auth(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec< AuthMode::Inherit => AuthKind::Inherit, }; let kinds = [ - (AuthKind::Inherit, "Inherit"), - (AuthKind::None, "None"), - (AuthKind::Basic, "Basic"), - (AuthKind::Bearer, "Bearer token"), + (AuthKind::Inherit, txt::auth::INHERIT), + (AuthKind::None, txt::common::NONE), + (AuthKind::Basic, txt::auth::BASIC), + (AuthKind::Bearer, txt::auth::BEARER), ]; if let Some(k) = auth_kind_row(ui, kind, &kinds) { acts.push(Action::AuthEdited( @@ -653,11 +651,11 @@ fn auth(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec< match &mode { AuthMode::Inherit => inherited(ui, state, tab, acts), AuthMode::NoAuth => { - ui.label(RichText::new("No Authorization header, not even the folder's (`# @no-auth`).").weak()); + ui.label(RichText::new(txt::auth::NO_AUTH_SET).weak()); } AuthMode::Own(v) => { if kind == AuthKind::Other { - ui.label("Custom Authorization header:"); + ui.label(txt::auth::CUSTOM); } if let Some(v) = auth_value_fields(ui, v, vars, &format!("tab{id}")) { acts.push(Action::AuthEdited(id, AuthMode::Own(v))); @@ -665,55 +663,51 @@ fn auth(ui: &mut Ui, state: &AppState, tab: &Tab, vars: &VarCtx, acts: &mut Vec< } } ui.add_space(6.0); - ui.label( - RichText::new("Auth is just the Authorization header; put secrets in the private env file.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::auth::SECRETS_NOTE).small().weak()); } /// What an inheriting request sends, and buttons to change it. fn inherited(ui: &mut Ui, state: &AppState, tab: &Tab, acts: &mut Vec) { let Some(c) = state.collection_for_tab(tab) else { - ui.label(RichText::new("Not in a collection, so there is nothing to inherit.").weak()); + ui.label(RichText::new(txt::auth::NOT_IN_COLLECTION).weak()); return; }; match state.inherited_auth_for(tab) { Some(InheritedAuth { from, value: Some(v) }) => { ui.horizontal_wrapped(|ui| { - ui.label("Uses"); + ui.label(txt::auth::USES); ui.label(RichText::new(&v).monospace()); - ui.label(format!("from {}.", c.folder_label(&from))); + ui.label(txt::auth::from_folder(&c.folder_label(&from))); }); } Some(InheritedAuth { from, value: None }) => { - ui.label(format!("No auth: {} is set to send none.", c.folder_label(&from))); + ui.label(txt::auth::folder_sends_none(&c.folder_label(&from))); } None => { - ui.label(RichText::new("No auth: no folder above this request has auth set.").weak()); + ui.label(RichText::new(txt::auth::NO_FOLDER_AUTH).weak()); } } let dir = state.auth_dir_for(tab); ui.horizontal(|ui| { if let Some(dir) = dir.as_ref().filter(|d| **d != c.root) { - if ui.button("Folder auth…").on_hover_text(c.folder_label(dir)).clicked() { + if ui + .button(txt::auth::FOLDER_AUTH_BUTTON) + .on_hover_text(c.folder_label(dir)) + .clicked() + { acts.push(Action::EditFolderAuth(dir.clone())); } } if ui - .button("Collection default…") - .on_hover_text("Auth for every request in the collection that doesn't set its own") + .button(txt::auth::COLLECTION_DEFAULT_BUTTON) + .on_hover_text(txt::auth::COLLECTION_DEFAULT_HOVER) .clicked() { acts.push(Action::EditFolderAuth(c.root.clone())); } }); if tab.origin.is_none() { - ui.label( - RichText::new("Untitled requests use the collection default.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::auth::UNTITLED_NOTE).small().weak()); } } @@ -726,11 +720,7 @@ fn source(ui: &mut Ui, tab: &Tab, vars: &VarCtx, acts: &mut Vec) { if code_edit(ui, &mut text, false, Some(vars.resolver), 14, ("source", id)).changed() { acts.push(Action::SourceEdited(id, text)); } - ui.label( - RichText::new("The request as it is stored in the .http file. Comments and response handlers are kept; scripts are never run.") - .small() - .weak(), - ); + ui.label(RichText::new(txt::request::SOURCE_NOTE).small().weak()); } #[cfg(test)] diff --git a/crates/app/src/ui/response.rs b/crates/app/src/ui/response.rs index af91052..40963ba 100644 --- a/crates/app/src/ui/response.rs +++ b/crates/app/src/ui/response.rs @@ -5,6 +5,7 @@ use egui::{Align, FontId, Layout, RichText, Ui}; use super::widgets::{build_job, human_size, json_spans, status_color, Palette}; use crate::action::Action; use crate::state::{BodyKind, BodyView, ResponseTab, Tab, TextLines}; +use crate::strings as txt; /// Lines longer than this are cut in the viewer (the full body can be saved /// or copied). @@ -15,8 +16,8 @@ pub fn show(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { if let Some(f) = &tab.in_flight { ui.horizontal(|ui| { ui.spinner(); - ui.label(format!("Sending… {:.1} s", f.started.elapsed().as_secs_f32())); - if ui.button("Cancel").clicked() { + ui.label(txt::response::sending(f.started.elapsed().as_secs_f32())); + if ui.button(txt::common::CANCEL).clicked() { acts.push(Action::Cancel(id)); } }); @@ -29,7 +30,7 @@ pub fn show(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { } let Some(view) = &tab.response else { ui.centered_and_justified(|ui| { - ui.label(RichText::new("Send the request to see the response here.").weak()); + ui.label(RichText::new(txt::response::EMPTY).weak()); }); return; }; @@ -43,20 +44,20 @@ pub fn show(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { .color(status_color(r.status, dark)), ); ui.separator(); - ui.label(format!("{} ms", r.timings.total.as_millis())); + ui.label(txt::response::millis(r.timings.total.as_millis())); ui.separator(); ui.label(human_size(r.size)); ui.separator(); ui.label(RichText::new(&r.http_version).weak()); if r.body.is_spilled() { - ui.label(RichText::new("(stored in a temp file)").weak()); + ui.label(RichText::new(txt::response::SPILLED).weak()); } ui.with_layout(Layout::right_to_left(Align::Center), |ui| { - if ui.button("Save to file…").clicked() { + if ui.button(txt::response::SAVE_TO_FILE).clicked() { acts.push(Action::SaveResponseBody(id)); } if let Some(p) = &view.prepared { - if p.kind != BodyKind::Image && ui.button("Copy body").clicked() { + if p.kind != BodyKind::Image && ui.button(txt::response::COPY_BODY).clicked() { ui.ctx().copy_text(p.text(tab.body_view).text.to_string()); } } @@ -65,9 +66,9 @@ pub fn show(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { ui.horizontal(|ui| { for (t, label) in [ - (ResponseTab::Body, "Body".to_string()), - (ResponseTab::Headers, format!("Headers ({})", r.headers.len())), - (ResponseTab::Timings, "Timings".to_string()), + (ResponseTab::Body, txt::response::BODY_TAB.to_string()), + (ResponseTab::Headers, txt::response::headers_tab(r.headers.len())), + (ResponseTab::Timings, txt::response::TIMINGS_TAB.to_string()), ] { if ui.selectable_label(tab.response_tab == t, label).clicked() { acts.push(Action::SetResponseTab(id, t)); @@ -95,7 +96,7 @@ pub fn show(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { }); if r.effective_url != tab.request.url { ui.add_space(8.0); - ui.label(RichText::new(format!("Final URL: {}", r.effective_url)).weak()); + ui.label(RichText::new(txt::response::final_url(&r.effective_url)).weak()); } }); } @@ -109,13 +110,13 @@ fn body(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { let Some(p) = &view.prepared else { ui.horizontal(|ui| { ui.spinner(); - ui.label("Preparing the body…"); + ui.label(txt::response::PREPARING); }); return; }; match p.kind { BodyKind::Empty => { - ui.label(RichText::new("No body.").weak()); + ui.label(RichText::new(txt::response::NO_BODY).weak()); return; } BodyKind::Image => { @@ -139,27 +140,30 @@ fn body(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { ui.horizontal(|ui| { if p.pretty.is_some() { if ui - .selectable_label(tab.body_view == BodyView::Pretty, "Pretty") + .selectable_label(tab.body_view == BodyView::Pretty, txt::response::PRETTY) .clicked() { acts.push(Action::SetBodyView(id, BodyView::Pretty)); } - if ui.selectable_label(tab.body_view == BodyView::Raw, "Raw").clicked() { + if ui + .selectable_label(tab.body_view == BodyView::Raw, txt::response::RAW) + .clicked() + { acts.push(Action::SetBodyView(id, BodyView::Raw)); } ui.separator(); } if p.kind == BodyKind::Binary { - ui.label(RichText::new("Binary body, shown as hex. Use “Save to file” to keep it.").weak()); + ui.label(RichText::new(txt::response::BINARY).weak()); } if p.truncated { - ui.label(RichText::new("Only the start of this large body is shown.").weak()); + ui.label(RichText::new(txt::response::TRUNCATED).weak()); } if tab.search.open { search_bar(ui, tab, acts); } else if ui - .small_button("🔍 Find") - .on_hover_text("Search the body (Ctrl+F)") + .small_button(txt::response::FIND_BUTTON) + .on_hover_text(txt::response::FIND_HOVER) .clicked() { acts.push(Action::SearchOpen(id, true)); @@ -176,7 +180,7 @@ fn search_bar(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { let mut q = tab.search.query.clone(); let resp = ui.add( egui::TextEdit::singleline(&mut q) - .hint_text("Find") + .hint_text(txt::response::FIND_HINT) .desired_width(180.0) .id_salt(("find", id)), ); @@ -195,15 +199,15 @@ fn search_bar(ui: &mut Ui, tab: &Tab, acts: &mut Vec) { if n > 0 { ui.label(format!("{}/{}", tab.search.current + 1, n)); } else if !tab.search.query.is_empty() { - ui.label(RichText::new("no matches").weak()); + ui.label(RichText::new(txt::response::NO_MATCHES).weak()); } - if ui.small_button("Prev").clicked() { + if ui.small_button(txt::response::PREV).clicked() { acts.push(Action::SearchStep(id, -1)); } - if ui.small_button("Next").clicked() { + if ui.small_button(txt::response::NEXT).clicked() { acts.push(Action::SearchStep(id, 1)); } - if ui.small_button("×").clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) { + if ui.small_button(txt::icon::CLOSE).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) { acts.push(Action::SearchOpen(id, false)); } } @@ -285,7 +289,7 @@ fn timings(ui: &mut Ui, tab: &Tab) { for (label, d) in t.phases() { let secs = d.as_secs_f32(); ui.label(label); - ui.label(RichText::new(format!("{:.1} ms", secs * 1000.0)).monospace()); + ui.label(RichText::new(txt::response::millis_f(secs * 1000.0)).monospace()); let (rect, _) = ui.allocate_exact_size(egui::vec2(bar_w, 12.0), egui::Sense::hover()); let x0 = rect.left() + bar_w * (start / total); let x1 = (x0 + (bar_w * secs / total).max(1.0)).min(rect.right()); @@ -297,8 +301,12 @@ fn timings(ui: &mut Ui, tab: &Tab) { start += secs; ui.end_row(); } - ui.label(RichText::new("Total").strong()); - ui.label(RichText::new(format!("{:.1} ms", total * 1000.0)).monospace().strong()); + ui.label(RichText::new(txt::response::TOTAL).strong()); + ui.label( + RichText::new(txt::response::millis_f(total * 1000.0)) + .monospace() + .strong(), + ); ui.end_row(); }); } diff --git a/crates/app/src/ui/sidebar.rs b/crates/app/src/ui/sidebar.rs index 7170644..a287a50 100644 --- a/crates/app/src/ui/sidebar.rs +++ b/crates/app/src/ui/sidebar.rs @@ -8,14 +8,15 @@ use reqlite_core::collection::Node; use super::widgets::method_color; use crate::action::Action; use crate::state::{AppState, CollectionState, DeleteTarget, Dialog, Prompt, PromptKind}; +use crate::strings as txt; pub fn show(ui: &mut Ui, state: &AppState, acts: &mut Vec) { ui.horizontal(|ui| { - ui.label(RichText::new("Collections").strong()); + ui.label(RichText::new(txt::sidebar::COLLECTIONS).strong()); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { if ui - .small_button("Open…") - .on_hover_text("Open another collection folder") + .small_button(txt::sidebar::OPEN) + .on_hover_text(txt::sidebar::OPEN_HOVER) .clicked() { acts.push(Action::PickCollection); @@ -25,15 +26,15 @@ pub fn show(ui: &mut Ui, state: &AppState, acts: &mut Vec) { if state.collections.is_empty() { ui.add_space(8.0); - ui.label("No collection open."); - ui.label(RichText::new("A collection is a folder of .http files.").weak()); + ui.label(txt::sidebar::NO_COLLECTION); + ui.label(RichText::new(txt::sidebar::WHAT_IS_A_COLLECTION).weak()); ui.add_space(4.0); - if ui.button("Open folder…").clicked() { + if ui.button(txt::sidebar::OPEN_FOLDER).clicked() { acts.push(Action::PickCollection); } if !state.settings.recent_collections.is_empty() { ui.add_space(8.0); - ui.label(RichText::new("Recent").strong()); + ui.label(RichText::new(txt::sidebar::RECENT).strong()); for p in &state.settings.recent_collections { let name = p .file_name() @@ -59,7 +60,7 @@ pub fn show(ui: &mut Ui, state: &AppState, acts: &mut Vec) { // Right-clicking the empty space below the tree. let size = egui::vec2(ui.available_width(), ui.available_height().max(40.0)); ui.allocate_response(size, egui::Sense::click()).context_menu(|ui| { - if ui.button("Open collection folder…").clicked() { + if ui.button(txt::common::OPEN_COLLECTION_FOLDER).clicked() { acts.push(Action::PickCollection); ui.close(); } @@ -78,38 +79,47 @@ fn collection(ui: &mut Ui, state: &AppState, c: &CollectionState, current: bool, } let resp = ui .add(egui::Label::new(name).sense(egui::Sense::click())) - .on_hover_text(format!( - "{}\nClick to use its environments for new tabs", - c.root.display() - )); + .on_hover_text(txt::sidebar::collection_hover(c.root.display())); if resp.clicked() { acts.push(Action::SetActiveCollection(c.root.clone())); } resp.context_menu(|ui| { - if ui.button("New .http file…").clicked() { + if ui.button(txt::sidebar::NEW_HTTP_FILE).clicked() { acts.push(new_file_prompt(&c.root)); ui.close(); } - if ui.button("Reload from disk").clicked() { + if ui.button(txt::common::RELOAD_FROM_DISK).clicked() { acts.push(Action::Rescan(c.root.clone())); ui.close(); } ui.separator(); - auth_menu_items(ui, &c.root, "Default auth…", acts); + auth_menu_items(ui, &c.root, txt::sidebar::DEFAULT_AUTH, acts); ui.separator(); - if ui.button("Close collection").clicked() { + if ui.button(txt::sidebar::CLOSE_COLLECTION).clicked() { acts.push(Action::CloseCollection(c.root.clone())); ui.close(); } }); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { - if ui.small_button("×").on_hover_text("Close this collection").clicked() { + if ui + .small_button(txt::icon::CLOSE) + .on_hover_text(txt::sidebar::CLOSE_COLLECTION_HOVER) + .clicked() + { acts.push(Action::CloseCollection(c.root.clone())); } - if ui.small_button("⟳").on_hover_text("Reload from disk").clicked() { + if ui + .small_button(txt::icon::RELOAD) + .on_hover_text(txt::common::RELOAD_FROM_DISK) + .clicked() + { acts.push(Action::Rescan(c.root.clone())); } - if ui.small_button("+").on_hover_text("New .http file").clicked() { + if ui + .small_button(txt::icon::ADD) + .on_hover_text(txt::common::NEW_HTTP_FILE) + .clicked() + { acts.push(new_file_prompt(&c.root)); } }); @@ -117,32 +127,27 @@ fn collection(ui: &mut Ui, state: &AppState, c: &CollectionState, current: bool, .body(|ui| { if c.private_not_ignored && !c.gitignore_offer_dismissed { egui::Frame::group(ui.style()).show(ui, |ui| { - ui.label( - RichText::new( - "http-client.private.env.json is not in .gitignore, so secrets could be committed.", - ) - .color(ui.visuals().warn_fg_color), - ); + ui.label(RichText::new(txt::sidebar::PRIVATE_NOT_IGNORED).color(ui.visuals().warn_fg_color)); ui.horizontal(|ui| { - if ui.button("Add to .gitignore").clicked() { + if ui.button(txt::sidebar::ADD_TO_GITIGNORE).clicked() { acts.push(Action::AddPrivateFileToGitignore(c.root.clone())); } - if ui.button("Dismiss").clicked() { + if ui.button(txt::common::DISMISS).clicked() { acts.push(Action::DismissGitignoreOffer(c.root.clone())); } }); }); } if let Some(e) = &c.env_error { - ui.colored_label(ui.visuals().error_fg_color, format!("Environments: {e}")); + ui.colored_label(ui.visuals().error_fg_color, txt::sidebar::env_error(e)); } for e in &c.folder_errors { - ui.colored_label(ui.visuals().error_fg_color, format!("Folder settings: {e}")); + ui.colored_label(ui.visuals().error_fg_color, txt::sidebar::folder_error(e)); } if let Node::Folder { children, .. } = &c.tree { if children.is_empty() { - ui.label(RichText::new("No .http files yet.").weak()); - if ui.button("Create one").clicked() { + ui.label(RichText::new(txt::sidebar::NO_FILES).weak()); + if ui.button(txt::sidebar::CREATE_ONE).clicked() { acts.push(new_file_prompt(&c.root)); } } @@ -154,17 +159,13 @@ fn collection(ui: &mut Ui, state: &AppState, c: &CollectionState, current: bool, } fn auth_menu_items(ui: &mut Ui, dir: &Path, edit_label: &str, acts: &mut Vec) { - if ui - .button(edit_label) - .on_hover_text("Auth for the requests in here that don't set their own") - .clicked() - { + if ui.button(edit_label).on_hover_text(txt::sidebar::AUTH_HOVER).clicked() { acts.push(Action::EditFolderAuth(dir.to_path_buf())); ui.close(); } if ui - .button("Consolidate auth…") - .on_hover_text("Make requests in here inherit one shared auth") + .button(txt::sidebar::CONSOLIDATE) + .on_hover_text(txt::sidebar::CONSOLIDATE_HOVER) .clicked() { acts.push(Action::ConsolidateAuth { @@ -178,7 +179,7 @@ fn auth_menu_items(ui: &mut Ui, dir: &Path, edit_label: &str, acts: &mut Vec Action { Action::ShowDialog(Some(Dialog::Prompt(Prompt { kind: PromptKind::NewFile { dir: dir.to_path_buf() }, - title: "New .http file".into(), + title: txt::common::NEW_HTTP_FILE.into(), value: "requests.http".into(), }))) } @@ -186,7 +187,7 @@ fn new_file_prompt(dir: &Path) -> Action { fn node(ui: &mut Ui, state: &AppState, c: &CollectionState, n: &Node, acts: &mut Vec) { match n { Node::Folder { name, path, children } => { - let resp = egui::CollapsingHeader::new(format!("📁 {name}")) + let resp = egui::CollapsingHeader::new(txt::sidebar::folder(name)) .id_salt(path) .default_open(true) .show(ui, |ui| { @@ -196,20 +197,20 @@ fn node(ui: &mut Ui, state: &AppState, c: &CollectionState, n: &Node, acts: &mut }); let mut header = resp.header_response; if let reqlite_core::folder::FolderAuth::Header(v) = c.folder_auth(path) { - header = header.on_hover_text(format!("Auth: {v}")); + header = header.on_hover_text(txt::sidebar::folder_auth_hover(&v)); } header.context_menu(|ui| { - if ui.button("New .http file…").clicked() { + if ui.button(txt::sidebar::NEW_HTTP_FILE).clicked() { acts.push(new_file_prompt(path)); ui.close(); } ui.separator(); - auth_menu_items(ui, path, "Folder auth…", acts); + auth_menu_items(ui, path, txt::auth::FOLDER_AUTH_BUTTON, acts); }); } Node::File { name, path } => { let Some(file) = c.files.get(path) else { return }; - let resp = egui::CollapsingHeader::new(format!("📄 {name}")) + let resp = egui::CollapsingHeader::new(txt::sidebar::file(name)) .id_salt(path) .default_open(true) .show(ui, |ui| { @@ -250,32 +251,32 @@ fn node(ui: &mut Ui, state: &AppState, c: &CollectionState, n: &Node, acts: &mut }); } item.context_menu(|ui| { - if ui.button("Open").clicked() { + if ui.button(txt::common::OPEN).clicked() { acts.push(Action::OpenRequest { file: path.clone(), index: i, }); ui.close(); } - if ui.button("Rename…").clicked() { + if ui.button(txt::common::RENAME).clicked() { acts.push(Action::ShowDialog(Some(Dialog::Prompt(Prompt { kind: PromptKind::RenameRequest { file: path.clone(), index: i, }, - title: "Rename request".into(), + title: txt::common::RENAME_REQUEST.into(), value: r.display_name().unwrap_or("").to_string(), })))); ui.close(); } - if ui.button("Duplicate").clicked() { + if ui.button(txt::sidebar::DUPLICATE).clicked() { acts.push(Action::DuplicateRequest { file: path.clone(), index: i, }); ui.close(); } - ui.menu_button("Move to", |ui| { + ui.menu_button(txt::sidebar::MOVE_TO, |ui| { let many = state.collections.len() > 1; let targets = state .collections @@ -299,7 +300,7 @@ fn node(ui: &mut Ui, state: &AppState, c: &CollectionState, n: &Node, acts: &mut } }); ui.separator(); - if ui.button("Delete…").clicked() { + if ui.button(txt::sidebar::DELETE).clicked() { acts.push(Action::ShowDialog(Some(Dialog::ConfirmDelete(DeleteTarget::Request { file: path.clone(), index: i, @@ -310,28 +311,28 @@ fn node(ui: &mut Ui, state: &AppState, c: &CollectionState, n: &Node, acts: &mut }); } if file.request_count() == 0 { - ui.label(RichText::new("(no requests)").weak()); + ui.label(RichText::new(txt::sidebar::NO_REQUESTS).weak()); } }); resp.header_response.context_menu(|ui| { - if ui.button("New request").clicked() { + if ui.button(txt::common::NEW_REQUEST).clicked() { acts.push(Action::NewRequestIn { file: path.clone() }); ui.close(); } - if ui.button("Rename file…").clicked() { + if ui.button(txt::sidebar::RENAME_FILE).clicked() { acts.push(Action::ShowDialog(Some(Dialog::Prompt(Prompt { kind: PromptKind::RenameFile { path: path.clone() }, - title: "Rename file".into(), + title: txt::sidebar::RENAME_FILE_TITLE.into(), value: name.clone(), })))); ui.close(); } - if ui.button("Duplicate file").clicked() { + if ui.button(txt::sidebar::DUPLICATE_FILE).clicked() { acts.push(Action::DuplicateFile(path.clone())); ui.close(); } ui.separator(); - if ui.button("Delete file…").clicked() { + if ui.button(txt::sidebar::DELETE_FILE).clicked() { acts.push(Action::ShowDialog(Some(Dialog::ConfirmDelete(DeleteTarget::File( path.clone(), ))))); @@ -356,7 +357,7 @@ fn short_url(url: &str) -> String { let u = url.split("://").nth(1).unwrap_or(url); let s: String = u.chars().take(40).collect(); if s.is_empty() { - "(no URL)".into() + txt::sidebar::NO_URL.into() } else { s } diff --git a/crates/app/src/ui/widgets.rs b/crates/app/src/ui/widgets.rs index 11bff4e..9a6e48d 100644 --- a/crates/app/src/ui/widgets.rs +++ b/crates/app/src/ui/widgets.rs @@ -7,6 +7,8 @@ use egui::text::{LayoutJob, TextFormat}; use egui::{Color32, FontId, TextBuffer, Ui}; use reqlite_core::template::{find_vars, Resolver, VarSource}; +use crate::strings as txt; + pub struct Palette { pub text: Color32, pub key: Color32, @@ -199,24 +201,24 @@ impl VarCtx<'_> { /// Text for the hover tooltip of a variable. pub fn describe(&self, name: &str) -> String { match self.resolver.lookup(name) { - None => format!("{{{{{name}}}}} is not defined in the selected environment"), - Some((_, VarSource::Builtin)) => format!("{{{{{name}}}}}: built-in dynamic value"), + None => txt::vars::undefined(name), + Some((_, VarSource::Builtin)) => txt::vars::builtin(name), Some((v, src)) => { let from = match src { - VarSource::PrivateEnv => "private env", - VarSource::PublicEnv => "env", - VarSource::File => "file variable", - VarSource::Builtin => "built-in", + VarSource::PrivateEnv => txt::vars::FROM_PRIVATE_ENV, + VarSource::PublicEnv => txt::vars::FROM_ENV, + VarSource::File => txt::vars::FROM_FILE, + VarSource::Builtin => txt::vars::FROM_BUILTIN, }; let shown = if (self.is_private)(name) { - "••••".to_string() + txt::icon::MASKED_SHORT.to_string() } else { match self.resolver.resolve(&v) { - Ok(r) if r != v => format!("{v} -> {r}"), + Ok(r) if r != v => txt::vars::resolved(&v, &r), _ => v, } }; - format!("{name} = {shown} ({from})") + txt::vars::hover(name, &shown, from) } } } @@ -344,9 +346,9 @@ pub fn status_color(status: u16, dark: bool) -> Color32 { pub fn human_size(n: u64) -> String { match n { - n if n < 1024 => format!("{n} B"), - n if n < 1024 * 1024 => format!("{:.1} KB", n as f64 / 1024.0), - n => format!("{:.1} MB", n as f64 / (1024.0 * 1024.0)), + n if n < 1024 => txt::units::bytes(n), + n if n < 1024 * 1024 => txt::units::kilobytes(n as f64 / 1024.0), + n => txt::units::megabytes(n as f64 / (1024.0 * 1024.0)), } } diff --git a/crates/app/src/ui/windows.rs b/crates/app/src/ui/windows.rs index 843ce60..d5b0b94 100644 --- a/crates/app/src/ui/windows.rs +++ b/crates/app/src/ui/windows.rs @@ -11,6 +11,7 @@ use crate::settings::{ProxyMode, Settings, ThemeChoice}; use crate::state::{ AppState, ConsolidateAuth, DeleteTarget, Dialog, EnvEditor, FolderAuthEdit, Prompt, PromptKind, QuickOpen, }; +use crate::strings as txt; pub fn show(ctx: &Context, state: &AppState, acts: &mut Vec) { if let Some(d) = &state.dialog { @@ -49,66 +50,63 @@ fn dialog(ctx: &Context, state: &AppState, d: &Dialog, acts: &mut Vec) { Dialog::ConfirmCloseTab(id) => { let title = state.tab(*id).map(|t| t.title()).unwrap_or_default(); let has_file = state.tab(*id).is_some_and(|t| t.origin.is_some()); - ui.heading("Unsaved changes"); - ui.label(format!("“{title}” has changes that are not saved.")); + ui.heading(txt::dialog::UNSAVED); + ui.label(txt::dialog::tab_unsaved(&title)); ui.add_space(8.0); ui.horizontal(|ui| { - if has_file && ui.button("Save and close").clicked() { + if has_file && ui.button(txt::dialog::SAVE_AND_CLOSE).clicked() { acts.push(close()); acts.push(Action::Save(*id)); acts.push(Action::CloseTab(*id)); } - if ui.button("Discard").clicked() { + if ui.button(txt::dialog::DISCARD).clicked() { acts.push(Action::DiscardAndCloseTab(*id)); } - if ui.button("Cancel").clicked() { + if ui.button(txt::common::CANCEL).clicked() { acts.push(close()); } }); } Dialog::ConfirmCloseTabs(ids) => { - ui.heading("Unsaved changes"); - ui.label(format!("{} tab(s) have changes that are not saved:", ids.len())); + ui.heading(txt::dialog::UNSAVED); + ui.label(txt::dialog::tabs_unsaved(ids.len())); for id in ids { if let Some(t) = state.tab(*id) { - ui.label(format!("• {}", t.title())); + ui.label(txt::common::bullet(t.title())); } } ui.add_space(8.0); ui.horizontal(|ui| { - if ui.button("Discard and close").clicked() { + if ui.button(txt::dialog::DISCARD_AND_CLOSE).clicked() { acts.push(Action::DiscardAndCloseTabs(ids.clone())); } - if ui.button("Keep them open").clicked() { + if ui.button(txt::dialog::KEEP_OPEN).clicked() { acts.push(close()); } }); } Dialog::ConfirmQuit => { let n = state.tabs.iter().filter(|t| t.is_dirty()).count(); - ui.heading("Quit reqlite?"); - ui.label(format!("{n} tab(s) have unsaved changes; they will be lost.")); + ui.heading(txt::dialog::QUIT_TITLE); + ui.label(txt::dialog::quit_unsaved(n)); ui.add_space(8.0); ui.horizontal(|ui| { - if ui.button("Quit without saving").clicked() { + if ui.button(txt::dialog::QUIT_WITHOUT_SAVING).clicked() { acts.push(Action::ConfirmQuit); } - if ui.button("Cancel").clicked() { + if ui.button(txt::common::CANCEL).clicked() { acts.push(close()); } }); } Dialog::Conflict { tab, path } => { - ui.heading("File changed on disk"); - ui.label(format!( - "{} was changed outside reqlite, and this tab has unsaved edits.", - path.display() - )); + ui.heading(txt::dialog::CONFLICT_TITLE); + ui.label(txt::dialog::conflict(path.display())); ui.add_space(8.0); ui.horizontal(|ui| { if ui - .button("Reload from disk") - .on_hover_text("Discard my edits") + .button(txt::common::RELOAD_FROM_DISK) + .on_hover_text(txt::dialog::RELOAD_HOVER) .clicked() { acts.push(Action::ResolveConflict { @@ -117,8 +115,8 @@ fn dialog(ctx: &Context, state: &AppState, d: &Dialog, acts: &mut Vec) { }); } if ui - .button("Keep my version") - .on_hover_text("Saving will overwrite this request in the new file") + .button(txt::dialog::KEEP_MINE) + .on_hover_text(txt::dialog::KEEP_MINE_HOVER) .clicked() { acts.push(Action::ResolveConflict { @@ -133,15 +131,15 @@ fn dialog(ctx: &Context, state: &AppState, d: &Dialog, acts: &mut Vec) { Dialog::ConsolidateAuth(plan) => consolidate_auth(ui, state, plan, acts), Dialog::ConfirmDelete(target) => { let what = match target { - DeleteTarget::Request { label, .. } => format!("the request “{label}”"), - DeleteTarget::File(p) => format!("the file {}", p.display()), + DeleteTarget::Request { label, .. } => txt::dialog::delete_request(label), + DeleteTarget::File(p) => txt::dialog::delete_file(p.display()), }; - ui.heading("Delete?"); - ui.label(format!("This deletes {what} from disk.")); + ui.heading(txt::dialog::DELETE_TITLE); + ui.label(txt::dialog::delete_body(&what)); ui.add_space(8.0); ui.horizontal(|ui| { if ui - .button(RichText::new("Delete").color(ui.visuals().error_fg_color)) + .button(RichText::new(txt::common::DELETE).color(ui.visuals().error_fg_color)) .clicked() { acts.push(match target { @@ -152,25 +150,25 @@ fn dialog(ctx: &Context, state: &AppState, d: &Dialog, acts: &mut Vec) { DeleteTarget::File(p) => Action::DeleteFile(p.clone()), }); } - if ui.button("Cancel").clicked() { + if ui.button(txt::common::CANCEL).clicked() { acts.push(close()); } }); } Dialog::ImportSummary { root, files, warnings } => { - ui.heading("Import finished"); - ui.label(format!("Wrote {files} .http file(s) to {}.", root.display())); + ui.heading(txt::dialog::IMPORT_TITLE); + ui.label(txt::dialog::import_wrote(*files, root.display())); if !warnings.is_empty() { ui.add_space(6.0); - ui.label(RichText::new(format!("{} warning(s):", warnings.len())).strong()); + ui.label(RichText::new(txt::dialog::warnings(warnings.len())).strong()); egui::ScrollArea::vertical().max_height(240.0).show(ui, |ui| { for w in warnings { - ui.label(format!("• {w}")); + ui.label(txt::common::bullet(w)); } }); } ui.add_space(8.0); - if ui.button("OK").clicked() { + if ui.button(txt::common::OK).clicked() { acts.push(close()); } } @@ -188,9 +186,9 @@ fn folder_auth(ui: &mut egui::Ui, state: &AppState, ed: &FolderAuthEdit, acts: & }; let is_root = ed.dir == c.root; ui.heading(if is_root { - "Collection default auth" + txt::auth::COLLECTION_DEFAULT_TITLE } else { - "Folder auth" + txt::auth::FOLDER_AUTH_TITLE }); ui.label(RichText::new(c.relative(&ed.dir).display().to_string()).weak()); ui.add_space(4.0); @@ -206,10 +204,17 @@ fn folder_auth(ui: &mut egui::Ui, state: &AppState, ed: &FolderAuthEdit, acts: & FolderAuth::Header(v) => header_kind(v), }; let kinds = [ - (AuthKind::Inherit, if is_root { "Not set" } else { "Inherit" }), - (AuthKind::None, "None"), - (AuthKind::Basic, "Basic"), - (AuthKind::Bearer, "Bearer token"), + ( + AuthKind::Inherit, + if is_root { + txt::auth::NOT_SET + } else { + txt::auth::INHERIT + }, + ), + (AuthKind::None, txt::common::NONE), + (AuthKind::Basic, txt::auth::BASIC), + (AuthKind::Bearer, txt::auth::BEARER), ]; if let Some(k) = auth_kind_row(ui, kind, &kinds) { acts.push(set(match k { @@ -221,19 +226,19 @@ fn folder_auth(ui: &mut egui::Ui, state: &AppState, ed: &FolderAuthEdit, acts: & ui.add_space(6.0); match &ed.auth { FolderAuth::Inherit if is_root => { - ui.label(RichText::new("Requests that don't set auth send none.").weak()); + ui.label(RichText::new(txt::auth::ROOT_NOT_SET).weak()); } FolderAuth::Inherit => { let parent = ed.dir.parent().and_then(|p| c.inherited_auth(p)); let text = match parent { - Some(InheritedAuth { from, value: Some(v) }) => format!("Uses `{v}` from {}.", c.folder_label(&from)), - Some(InheritedAuth { from, value: None }) => format!("No auth, as set on {}.", c.folder_label(&from)), - None => "No auth: no parent folder has auth set.".into(), + Some(InheritedAuth { from, value: Some(v) }) => txt::auth::parent_uses(&v, &c.folder_label(&from)), + Some(InheritedAuth { from, value: None }) => txt::auth::parent_none(&c.folder_label(&from)), + None => txt::auth::NO_PARENT_AUTH.into(), }; ui.label(RichText::new(text).weak()); } FolderAuth::None => { - ui.label(RichText::new("Requests here send no auth unless they set their own.").weak()); + ui.label(RichText::new(txt::auth::FOLDER_NONE).weak()); } FolderAuth::Header(v) => { let resolver = c.envs.resolver(c.selected_env.as_deref(), &[]); @@ -249,23 +254,16 @@ fn folder_auth(ui: &mut egui::Ui, state: &AppState, ed: &FolderAuthEdit, acts: & } } ui.add_space(6.0); - ui.label( - RichText::new( - "Used by requests in this folder and its subfolders that have no Authorization header of their own. \ - Saved in .reqlite/folder.json (other .http tools ignore it).", - ) - .small() - .weak(), - ); + ui.label(RichText::new(txt::auth::FOLDER_NOTE).small().weak()); ui.add_space(8.0); ui.horizontal(|ui| { - if ui.button("Save").clicked() { + if ui.button(txt::common::SAVE).clicked() { acts.push(Action::SetFolderAuth { dir: ed.dir.clone(), auth: ed.auth.clone(), }); } - if ui.button("Cancel").clicked() { + if ui.button(txt::common::CANCEL).clicked() { acts.push(Action::ShowDialog(None)); } }); @@ -277,23 +275,20 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, return; }; let set = |plan: ConsolidateAuth| Action::ShowDialog(Some(Dialog::ConsolidateAuth(plan))); - ui.heading("Consolidate auth"); - ui.label(format!( - "Let requests in {} inherit one shared auth instead of each carrying its own Authorization header.", - c.folder_label(&plan.dir) - )); + ui.heading(txt::consolidate::TITLE); + ui.label(txt::consolidate::intro(&c.folder_label(&plan.dir))); ui.add_space(6.0); let Some(target) = &plan.target else { - ui.label("None of these requests has an Authorization header, and there is no auth to inherit."); + ui.label(txt::consolidate::NOTHING); ui.add_space(8.0); - if ui.button("OK").clicked() { + if ui.button(txt::common::OK).clicked() { acts.push(Action::ShowDialog(None)); } return; }; ui.horizontal(|ui| { - ui.label("Shared auth:"); + ui.label(txt::consolidate::SHARED_AUTH); if plan.choices.is_empty() { ui.label(RichText::new(target).monospace()); } else { @@ -301,7 +296,7 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, .selected_text(RichText::new(target).monospace()) .show_ui(ui, |ui| { for (v, n) in &plan.choices { - let label = format!("{v} ({n} request{})", if *n == 1 { "" } else { "s" }); + let label = txt::consolidate::choice(v, *n); if ui.selectable_label(v == target, label).clicked() && v != target { acts.push(Action::ConsolidateAuth { dir: plan.dir.clone(), @@ -313,38 +308,32 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, } }); if plan.set_folder { - ui.label( - RichText::new(format!( - "It will be saved as the auth of {}.", - c.folder_label(&plan.dir) - )) - .weak(), - ); + ui.label(RichText::new(txt::consolidate::will_save(&c.folder_label(&plan.dir))).weak()); } else { - ui.label(RichText::new(format!("{} already uses it.", c.folder_label(&plan.dir))).weak()); + ui.label(RichText::new(txt::consolidate::already_uses(&c.folder_label(&plan.dir))).weak()); } ui.add_space(8.0); if plan.own.is_empty() { - ui.label("No request here has its own Authorization header."); + ui.label(txt::consolidate::NO_OWN); } else { ui.horizontal(|ui| { - ui.label(RichText::new("Remove the Authorization header from:").strong()); + ui.label(RichText::new(txt::consolidate::REMOVE_FROM).strong()); if ui - .small_button("Matching") - .on_hover_text("Only those that send the same thing") + .small_button(txt::consolidate::MATCHING) + .on_hover_text(txt::consolidate::MATCHING_HOVER) .clicked() { let mut p = plan.clone(); p.own.iter_mut().for_each(|o| o.selected = o.same()); acts.push(set(p)); } - if ui.small_button("All").clicked() { + if ui.small_button(txt::common::ALL).clicked() { let mut p = plan.clone(); p.own.iter_mut().for_each(|o| o.selected = true); acts.push(set(p)); } - if ui.small_button("None").clicked() { + if ui.small_button(txt::common::NONE).clicked() { let mut p = plan.clone(); p.own.iter_mut().for_each(|o| o.selected = false); acts.push(set(p)); @@ -363,10 +352,10 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, acts.push(set(p)); } if !o.same() { - let would = o.inherits.as_deref().unwrap_or("no auth"); + let would = o.inherits.as_deref().unwrap_or(txt::common::NO_AUTH); ui.indent(("diff", i), |ui| { ui.label( - RichText::new(format!("has `{}`; would send `{would}` instead", o.value)) + RichText::new(txt::consolidate::would_send(&o.value, would)) .small() .color(ui.visuals().warn_fg_color), ); @@ -378,23 +367,20 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, if plan.set_folder && !plan.affected.is_empty() { ui.add_space(8.0); - ui.label(format!( - "{} request(s) without a header of their own would start sending `{target}`:", - plan.affected.len() - )); + ui.label(txt::consolidate::affected(plan.affected.len(), target)); egui::ScrollArea::vertical() .id_salt("consolidate-affected") .max_height(120.0) .show(ui, |ui| { for (r, before) in &plan.affected { - let now = before.as_deref().unwrap_or("no auth"); - ui.label(format!("• {} (now: {now})", r.label)); + let now = before.as_deref().unwrap_or(txt::common::NO_AUTH); + ui.label(txt::consolidate::affected_item(&r.label, now)); } }); let mut keep = plan.keep_affected; if ui - .checkbox(&mut keep, "Keep what they send today") - .on_hover_text("Gives them their current header, or `# @no-auth`") + .checkbox(&mut keep, txt::consolidate::KEEP_AFFECTED) + .on_hover_text(txt::consolidate::KEEP_AFFECTED_HOVER) .changed() { let mut p = plan.clone(); @@ -406,13 +392,13 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, if !plan.skipped_dirty.is_empty() { ui.add_space(6.0); ui.label( - RichText::new(format!( - "Skipped, because their tabs have unsaved edits: {}", - plan.skipped_dirty + RichText::new(txt::consolidate::skipped_dirty( + &plan + .skipped_dirty .iter() .map(|r| r.label.as_str()) .collect::>() - .join(", ") + .join(", "), )) .weak(), ); @@ -423,10 +409,13 @@ fn consolidate_auth(ui: &mut egui::Ui, state: &AppState, plan: &ConsolidateAuth, || plan.own.iter().any(|o| o.selected) || (plan.keep_affected && plan.set_folder && !plan.affected.is_empty()); ui.horizontal(|ui| { - if ui.add_enabled(anything, egui::Button::new("Apply")).clicked() { + if ui + .add_enabled(anything, egui::Button::new(txt::common::APPLY)) + .clicked() + { acts.push(Action::ApplyConsolidateAuth(plan.clone())); } - if ui.button("Cancel").clicked() { + if ui.button(txt::common::CANCEL).clicked() { acts.push(Action::ShowDialog(None)); } }); @@ -452,7 +441,7 @@ fn prompt(ui: &mut egui::Ui, state: &AppState, p: &Prompt, acts: &mut Vec Action::NewFile { dir: dir.clone(), @@ -487,7 +476,7 @@ fn prompt(ui: &mut egui::Ui, state: &AppState, p: &Prompt, acts: &mut Vec) { let mut n = s.clone(); - egui::Window::new("Settings") + egui::Window::new(txt::settings::TITLE) .open(open) .resizable(false) .show(ctx, |ui| { @@ -503,77 +492,77 @@ fn settings(ctx: &Context, s: &Settings, open: &mut bool, acts: &mut Vec .num_columns(2) .spacing([12.0, 8.0]) .show(ui, |ui| { - ui.label("Default timeout"); + ui.label(txt::settings::TIMEOUT); ui.horizontal(|ui| { ui.add( egui::DragValue::new(&mut n.default_timeout_secs) .range(0..=3600) - .suffix(" s"), + .suffix(txt::settings::SECONDS_SUFFIX), ); - ui.label(RichText::new("0 = none; `# @timeout` wins").weak()); + ui.label(RichText::new(txt::settings::TIMEOUT_NOTE).weak()); }); ui.end_row(); - ui.label("Proxy"); + ui.label(txt::settings::PROXY); ui.vertical(|ui| { ui.horizontal(|ui| { - ui.radio_value(&mut n.proxy_mode, ProxyMode::System, "System"); - ui.radio_value(&mut n.proxy_mode, ProxyMode::None, "None"); - ui.radio_value(&mut n.proxy_mode, ProxyMode::Manual, "Manual"); + ui.radio_value(&mut n.proxy_mode, ProxyMode::System, txt::common::SYSTEM); + ui.radio_value(&mut n.proxy_mode, ProxyMode::None, txt::common::NONE); + ui.radio_value(&mut n.proxy_mode, ProxyMode::Manual, txt::settings::MANUAL); }); if n.proxy_mode == ProxyMode::Manual { ui.add_sized( [260.0, ui.spacing().interact_size.y], - egui::TextEdit::singleline(&mut n.proxy_url).hint_text("http://user:pass@proxy:3128"), + egui::TextEdit::singleline(&mut n.proxy_url).hint_text(txt::settings::PROXY_HINT), ); } }); ui.end_row(); - ui.label("TLS"); + ui.label(txt::settings::TLS); ui.vertical(|ui| { - ui.checkbox(&mut n.verify_tls, "Verify certificates"); + ui.checkbox(&mut n.verify_tls, txt::settings::VERIFY_TLS); ui.horizontal(|ui| { let ca = n .ca_file .as_ref() .map(|p| p.display().to_string()) - .unwrap_or_else(|| "System store only".into()); + .unwrap_or_else(|| txt::settings::SYSTEM_STORE.into()); ui.label(RichText::new(ca).weak()); - if ui.button("Add CA file…").clicked() { + if ui.button(txt::settings::ADD_CA).clicked() { acts.push(Action::PickCaFile); } - if n.ca_file.is_some() && ui.button("Clear").clicked() { + if n.ca_file.is_some() && ui.button(txt::common::CLEAR).clicked() { n.ca_file = None; } }); }); ui.end_row(); - ui.label("Theme"); + ui.label(txt::settings::THEME); ui.horizontal(|ui| { - ui.radio_value(&mut n.theme, ThemeChoice::System, "System"); - ui.radio_value(&mut n.theme, ThemeChoice::Light, "Light"); - ui.radio_value(&mut n.theme, ThemeChoice::Dark, "Dark"); + ui.radio_value(&mut n.theme, ThemeChoice::System, txt::common::SYSTEM); + ui.radio_value(&mut n.theme, ThemeChoice::Light, txt::settings::LIGHT); + ui.radio_value(&mut n.theme, ThemeChoice::Dark, txt::settings::DARK); }); ui.end_row(); - ui.label("Font size"); + ui.label(txt::settings::FONT_SIZE); ui.add( egui::Slider::new(&mut n.zoom, 0.75..=2.0) .step_by(0.05) - .custom_formatter(|v, _| format!("{:.0}%", v * 100.0)), + .custom_formatter(|v, _| txt::settings::percent(v)), ); ui.end_row(); - ui.label("Parallel requests"); + ui.label(txt::settings::PARALLEL); ui.horizontal(|ui| { ui.add(egui::DragValue::new(&mut n.max_concurrent_requests).range(1..=64)); - ui.label(RichText::new("at once").weak()); + ui.label(RichText::new(txt::settings::AT_ONCE).weak()); }); ui.end_row(); - ui.label("History size"); + ui.label(txt::settings::HISTORY_SIZE); ui.add(egui::DragValue::new(&mut n.history_limit).range(10..=10_000)); ui.end_row(); }); @@ -584,13 +573,13 @@ fn settings(ctx: &Context, s: &Settings, open: &mut bool, acts: &mut Vec } fn history(ctx: &Context, state: &AppState, open: &mut bool, acts: &mut Vec) { - egui::Window::new("History") + egui::Window::new(txt::history::TITLE) .open(open) .default_size([620.0, 420.0]) .show(ctx, |ui| { ui.horizontal(|ui| { - ui.label(format!("{} request(s)", state.history.len())); - if ui.button("Clear").clicked() { + ui.label(txt::history::count(state.history.len())); + if ui.button(txt::common::CLEAR).clicked() { acts.push(Action::ClearHistory); } }); @@ -603,9 +592,9 @@ fn history(ctx: &Context, state: &AppState, open: &mut bool, acts: &mut Vec ui.label(RichText::new(s.to_string()).color(status_color(s, dark))), (None, Some(err)) => ui - .label(RichText::new("ERR").color(ui.visuals().error_fg_color)) + .label(RichText::new(txt::history::ERR).color(ui.visuals().error_fg_color)) .on_hover_text(err), - _ => ui.label("—"), + _ => ui.label(txt::icon::NONE), }; ui.label( RichText::new(&e.method) @@ -613,15 +602,11 @@ fn history(ctx: &Context, state: &AppState, open: &mut bool, acts: &mut Vec String { fn cookies(ctx: &Context, state: &AppState, open: &mut bool, acts: &mut Vec) { let key = state.current_collection().map(|c| c.root.clone()); let jar = state.cookie_jars.get(&key); - egui::Window::new("Cookies") + egui::Window::new(txt::cookies::TITLE) .open(open) .default_size([560.0, 300.0]) .show(ctx, |ui| { - ui.label(RichText::new("Cookies are kept in memory per collection; `# @no-cookie-jar` skips them.").weak()); + ui.label(RichText::new(txt::cookies::NOTE).weak()); let cookies = jar.map(|j| j.cookies()).unwrap_or(&[]); if cookies.is_empty() { - ui.label("No cookies yet."); + ui.label(txt::cookies::EMPTY); return; } - if ui.button("Clear all").clicked() { + if ui.button(txt::cookies::CLEAR_ALL).clicked() { acts.push(Action::ClearCookies); } egui::ScrollArea::vertical().show(ui, |ui| { egui::Grid::new("cookies").num_columns(5).striped(true).show(ui, |ui| { - for h in ["Domain", "Path", "Name", "Value", ""] { + for h in [ + txt::cookies::DOMAIN, + txt::cookies::PATH, + txt::common::NAME, + txt::common::VALUE, + "", + ] { ui.label(RichText::new(h).weak()); } ui.end_row(); @@ -668,7 +659,7 @@ fn cookies(ctx: &Context, state: &AppState, open: &mut bool, acts: &mut Vec) { .file_name() .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_default(); - let dirty = if ed.dirty { " •" } else { "" }; - egui::Window::new(format!("Environments: {name}{dirty}")) + egui::Window::new(txt::env::title(&name, ed.dirty)) .id(egui::Id::unique("env-editor")) .open(&mut open) .default_size([640.0, 380.0]) .show(ctx, |ui| { ui.horizontal(|ui| { - ui.label("Environment:"); + ui.label(txt::common::ENVIRONMENT_LABEL); let mut names = e.envs.names(); names.insert(0, SHARED_ENV.to_string()); egui::ComboBox::from_id_salt("env-edit-sel") @@ -731,17 +712,17 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { .show_ui(ui, |ui| { for n in names { let label = if n == SHARED_ENV { - "$shared (all environments)".to_string() + txt::env::SHARED.to_string() } else { n.clone() }; ui.selectable_value(&mut e.selected, n, label); } }); - if ui.button("New…").clicked() { + if ui.button(txt::env::NEW).clicked() { acts.push(Action::ShowDialog(Some(Dialog::Prompt(Prompt { kind: PromptKind::NewEnvironment, - title: "New environment".into(), + title: txt::dialog::NEW_ENVIRONMENT.into(), value: String::new(), })))); } @@ -763,14 +744,14 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { let mut remove = None; egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| { egui::Grid::new("env-vars").num_columns(5).striped(true).show(ui, |ui| { - for h in ["Name", "Value", "Private", "", ""] { + for h in [txt::common::NAME, txt::common::VALUE, txt::env::PRIVATE, "", ""] { ui.label(RichText::new(h).weak()); } ui.end_row(); for (i, (name, value, private, structured)) in new_rows.iter_mut().enumerate() { if *structured { ui.label(name.as_str()); - ui.label(RichText::new("(object; edit the JSON file)").weak()); + ui.label(RichText::new(txt::env::STRUCTURED).weak()); ui.label(""); ui.label(""); ui.label(""); @@ -782,7 +763,7 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { .changed(); let revealed = e.revealed.contains(&(env.clone(), name.clone())); if *private && !revealed { - ui.label(RichText::new("••••••••").monospace()); + ui.label(RichText::new(txt::icon::MASKED).monospace()); } else { changed |= ui .add_sized( @@ -793,12 +774,12 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { } changed |= ui .checkbox(private, "") - .on_hover_text("Stored in http-client.private.env.json (keep it out of git)") + .on_hover_text(txt::env::PRIVATE_HOVER) .changed(); if *private { if ui - .small_button(if revealed { "🙈" } else { "👁" }) - .on_hover_text("Show / hide") + .small_button(if revealed { txt::icon::HIDE } else { txt::icon::SHOW }) + .on_hover_text(txt::env::SHOW_HIDE_HOVER) .clicked() { let k = (env.clone(), name.clone()); @@ -812,14 +793,14 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { } else { ui.label(""); } - if ui.small_button("×").clicked() { + if ui.small_button(txt::icon::CLOSE).clicked() { remove = Some(i); } ui.end_row(); } }); }); - if ui.button("Add variable").clicked() { + if ui.button(txt::env::ADD_VARIABLE).clicked() { let n = (1..) .map(|i| format!("var{i}")) .find(|n| !new_rows.iter().any(|r| &r.0 == n)) @@ -839,10 +820,10 @@ fn env_editor(ctx: &Context, ed: &EnvEditor, acts: &mut Vec) { } ui.separator(); ui.horizontal(|ui| { - if ui.add_enabled(e.dirty, egui::Button::new("Save")).clicked() { + if ui.add_enabled(e.dirty, egui::Button::new(txt::common::SAVE)).clicked() { save = true; } - ui.label(RichText::new("Writes http-client.env.json and http-client.private.env.json.").weak()); + ui.label(RichText::new(txt::env::SAVE_NOTE).weak()); }); }); if e.selected != ed.selected { @@ -888,7 +869,7 @@ fn apply_rows(file: &mut EnvFile, env: &str, rows: &[(String, String, bool, bool fn quick_open(ctx: &Context, state: &AppState, q: &QuickOpen, acts: &mut Vec) { if state.collections.is_empty() { acts.push(Action::QuickOpen(None)); - acts.push(Action::Error("Open a collection to quick-open its requests".into())); + acts.push(Action::Error(txt::msg::NEED_COLLECTION_FOR_QUICK_OPEN.into())); return; } let query = q.query.to_lowercase(); @@ -943,7 +924,7 @@ fn quick_open(ctx: &Context, state: &AppState, q: &QuickOpen, acts: &mut Vec