//! `Action`s (what happened) and the pure `update` function that applies them //! to [`AppState`] and returns [`Effect`]s (what to do outside: I/O, dialogs). use std::collections::BTreeMap; use std::path::{Path, PathBuf}; use std::time::{Instant, SystemTime, UNIX_EPOCH}; use reqlite_core::collection::{self, Collection}; use reqlite_core::env::{self, Environments}; use reqlite_core::export::curl::to_curl; use reqlite_core::folder::{ self, auth_mode, same_auth, with_inherited_auth, AuthHeader, AuthMode, FolderAuth, FolderSettings, }; use reqlite_core::http::{HttpError, Response}; use reqlite_core::httpfile::{render_request, HttpFile}; use reqlite_core::import::curl::{from_curl, looks_like_curl}; use reqlite_core::params::{parse_params, with_params, Param}; use reqlite_core::resolve::resolve_request; use reqlite_core::{Body, CancelToken, Header, Method, Request}; 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 { // Tabs. NewTab, CloseTab(TabId), /// Close even with unsaved changes. DiscardAndCloseTab(TabId), /// Close several tabs; asks once about the ones with unsaved changes. CloseTabs(Vec), DiscardAndCloseTabs(Vec), /// Rename the tab's request: in its file right away if the tab has no /// other unsaved edits, else as an edit that Save writes. RenameTab { tab: TabId, title: String, }, SelectTab(TabId), OpenRequest { file: PathBuf, index: usize, }, NewTabFromHttp(String), // Editing a tab. SetMethod(TabId, Method), UrlEdited(TabId, String), ParamsEdited(TabId, Vec), HeadersEdited(TabId, Vec
), BodyEdited(TabId, Body), /// Sets the request's own Authorization header, `# @no-auth`, or /// neither (it inherits its folder's auth). AuthEdited(TabId, AuthMode), SourceEdited(TabId, String), SetRequestTab(TabId, RequestTab), SetResponseTab(TabId, ResponseTab), SetBodyView(TabId, BodyView), SetNoRedirect(TabId, bool), PickBodyFile(TabId), BodyFilePicked(TabId, PathBuf), // Sending. Send(TabId), Cancel(TabId), ResponseReceived { tab: TabId, seq: u64, result: Result, }, BodyPrepared { tab: TabId, seq: u64, body: PreparedBody, }, SaveResponseBody(TabId), // Response search. SearchOpen(TabId, bool), SearchQuery(TabId, String), SearchStep(TabId, i32), ScrolledTo(TabId), // Collections. PickCollection, OpenCollection(PathBuf), CloseCollection(PathBuf), /// Makes a collection the current one (environment picker, untitled tabs). SetActiveCollection(PathBuf), CollectionLoaded(Result), /// The environments, and whether the private file exists without being git-ignored. EnvironmentsLoaded { root: PathBuf, result: Result<(Environments, bool), String>, }, FileChangedOnDisk { path: PathBuf, text: Option, }, Rescan(PathBuf), Save(TabId), /// `existing` is the current content of `path`, if it exists. SaveAs { tab: TabId, path: PathBuf, existing: Option, }, ResolveConflict { tab: TabId, keep_mine: bool, }, NewFile { dir: PathBuf, name: String, }, NewRequestIn { file: PathBuf, }, RenameRequest { file: PathBuf, index: usize, title: String, }, DuplicateRequest { file: PathBuf, index: usize, }, DeleteRequest { file: PathBuf, index: usize, }, MoveRequest { from: PathBuf, index: usize, to: PathBuf, }, RenameFile { path: PathBuf, new_name: String, }, DeleteFile(PathBuf), DuplicateFile(PathBuf), // Folder auth. /// Opens the folder auth editor for a folder (or the collection root). EditFolderAuth(PathBuf), SetFolderAuth { dir: PathBuf, auth: FolderAuth, }, /// Opens (or re-plans) the "Consolidate auth" dialog for a folder; /// `target` picks the auth to inherit when the folder has none. ConsolidateAuth { dir: PathBuf, target: Option, }, ApplyConsolidateAuth(ConsolidateAuth), // Environments. SelectEnv(Option), OpenEnvEditor, EnvEditorChanged(EnvEditor), EnvEditorSave, EnvEditorClose, AddPrivateFileToGitignore(PathBuf), DismissGitignoreOffer(PathBuf), // Import / export. CopyAsCurl(TabId), CopyAsHttp(TabId), ImportPostman, PostmanImported { root: PathBuf, files: usize, warnings: Vec, }, // History, cookies, settings. HistoryLoaded(Vec), RestoreHistory(usize), ClearHistory, ClearCookies, DeleteCookie(usize), SettingsLoaded(Settings), SettingsChanged(Settings), PickCaFile, CaFilePicked(PathBuf), // Shell. ShowDialog(Option), SetWindows(Windows), QuickOpen(Option), FocusUrl, UrlFocused, CloseRequested, ConfirmQuit, Error(String), Info(String), DismissStatus, } /// Applies an action. The only place that changes [`AppState`]. pub fn update(state: &mut AppState, action: Action) -> Vec { let mut fx = Vec::new(); match action { // ---------------------------------------------------------- tabs Action::NewTab => { new_tab(state, Request::default(), None, String::new()); state.focus_url = true; } Action::CloseTab(id) => { if state.tab(id).is_some_and(Tab::is_dirty) { state.dialog = Some(Dialog::ConfirmCloseTab(id)); } else { close_tab(state, id); } } Action::DiscardAndCloseTab(id) => { state.dialog = None; close_tab(state, id); } Action::CloseTabs(ids) => { let mut dirty = Vec::new(); for id in ids { if state.tab(id).is_some_and(Tab::is_dirty) { dirty.push(id); } else { close_tab(state, id); } } if !dirty.is_empty() { state.dialog = Some(Dialog::ConfirmCloseTabs(dirty)); } } Action::DiscardAndCloseTabs(ids) => { state.dialog = None; for id in ids { close_tab(state, id); } } Action::RenameTab { tab, title } => { state.dialog = None; let Some(t) = state.tab(tab) else { return fx }; let in_file = t .origin .as_ref() .filter(|_| !t.is_dirty()) .and_then(|o| Some((o.file.clone(), file_of(state, &o.file)?.find(&o.key)?))); if let Some((file, index)) = in_file { return update(state, Action::RenameRequest { file, index, title }); } let title = title.trim().to_string(); edit(state, tab, |r| { r.title = (!title.is_empty()).then_some(title); if r.name.is_some() { r.name = r.title.as_deref().map(slug_name); } }); } Action::SelectTab(id) => { if let Some(t) = state.tab(id) { let root = t .origin .as_ref() .and_then(|o| state.collection_of(&o.file)) .map(|c| c.root.clone()); state.active = Some(id); if root.is_some() { state.active_collection = root; } } } Action::OpenRequest { file, index } => open_request(state, &file, index), Action::NewTabFromHttp(text) => { let f = HttpFile::parse(text.clone()); match f.request(0) { Some(r) => { let mut r = r.clone(); r.source = Default::default(); let src = f.request_source(0).unwrap_or("").to_string(); new_tab(state, r, None, src); } None => state.set_error(txt::msg::NO_REQUEST_IN_TEXT), } } // ---------------------------------------------------- editing Action::SetMethod(id, m) => edit(state, id, |r| r.method = m), Action::UrlEdited(id, url) => { if looks_like_curl(&url) { match from_curl(&url) { Ok(mut req) => { if let Some(t) = state.tab(id) { req.title = t.request.title.clone(); req.name = t.request.name.clone(); } edit(state, id, |r| *r = req); state.set_info(txt::msg::CURL_IMPORTED); } Err(e) => { state.set_error(txt::msg::curl_import_failed(e)); edit(state, id, |r| r.url = url); } } } else { edit(state, id, |r| r.url = url); } } Action::ParamsEdited(id, params) => { if let Some(t) = state.tab_mut(id) { let url = with_params(&t.request.url, ¶ms); t.request.url = url; // Keep the rows as the user has them (including a half-typed // empty row) rather than re-deriving from the URL. t.params = params; after_form_edit(t); } } Action::HeadersEdited(id, headers) => edit(state, id, |r| r.headers = headers), Action::BodyEdited(id, body) => edit(state, id, |r| r.body = body), Action::AuthEdited(id, mode) => edit(state, id, |r| folder::set_auth_mode(r, &mode)), Action::SetNoRedirect(id, on) => edit(state, id, |r| r.directives.no_redirect = on), Action::PickBodyFile(id) => fx.push(Effect::PickBodyFile(id)), Action::BodyFilePicked(id, path) => { let Some(t) = state.tab(id) else { return fx }; // Store it relative to the .http file when possible, like `< ./x`. let base = state.base_dir_for(t); let path = match path.strip_prefix(&base) { Ok(rel) => Path::new(".").join(rel), Err(_) => path, }; let substitute = matches!(t.request.body, Body::FileRef { substitute: true, .. }); edit(state, id, |r| r.body = Body::FileRef { path, substitute }); } Action::SourceEdited(id, text) => { if let Some(t) = state.tab_mut(id) { let f = HttpFile::parse(text.clone()); t.source = text; t.source_authoritative = true; match f.request_count() { 1 => { let mut r = f.request(0).unwrap().clone(); r.source = t.request.source; t.params = parse_params(&r.url); t.request = r; t.source_error = None; } 0 => t.source_error = Some(txt::msg::NO_REQUEST_LINE.into()), n => t.source_error = Some(txt::msg::not_one_request(n)), } } } Action::SetRequestTab(id, rt) => { if let Some(t) = state.tab_mut(id) { t.request_tab = rt; } } Action::SetResponseTab(id, rt) => { if let Some(t) = state.tab_mut(id) { t.response_tab = rt; } } Action::SetBodyView(id, v) => { if let Some(t) = state.tab_mut(id) { t.body_view = v; recompute_search(t); } } // ---------------------------------------------------- sending Action::Send(id) => send(state, id, &mut fx), Action::Cancel(id) => { if let Some(t) = state.tab_mut(id) { if let Some(f) = t.in_flight.take() { f.cancel.cancel(); t.error = Some(txt::msg::CANCELLED.into()); } } } Action::ResponseReceived { tab, seq, result } => receive(state, tab, seq, result, &mut fx), Action::BodyPrepared { tab, seq, body } => { if let Some(t) = state.tab_mut(tab) { if t.seq == seq { if let Some(r) = &mut t.response { r.prepared = Some(body); } recompute_search(t); } } } Action::SaveResponseBody(id) => { if let Some(r) = state.tab(id).and_then(|t| t.response.as_ref()) { fx.push(Effect::SaveResponseBody { body: r.response.body.clone(), suggested_name: suggested_file_name(&r.response), }); } } // ---------------------------------------------------- search Action::SearchOpen(id, open) => { if let Some(t) = state.tab_mut(id) { t.search.open = open; if open { t.response_tab = ResponseTab::Body; } } } Action::SearchQuery(id, q) => { if let Some(t) = state.tab_mut(id) { t.search.query = q; t.search.current = 0; recompute_search(t); t.search.scroll_to = t.search.matches.first().map(|m| m.0); } } Action::SearchStep(id, delta) => { if let Some(t) = state.tab_mut(id) { let n = t.search.matches.len(); if n > 0 { t.search.current = (t.search.current as i64 + delta as i64).rem_euclid(n as i64) as usize; t.search.scroll_to = Some(t.search.matches[t.search.current].0); } } } Action::ScrolledTo(id) => { if let Some(t) = state.tab_mut(id) { t.search.scroll_to = None; } } // ---------------------------------------------------- collections Action::PickCollection => fx.push(Effect::PickCollectionFolder), Action::OpenCollection(root) => { if state.collection(&root).is_some() { state.active_collection = Some(root); return fx; } if let Some(other) = state .collections .iter() .find(|c| root.starts_with(&c.root) || c.root.starts_with(&root)) { state.set_error(txt::msg::overlaps(root.display(), other.root.display())); return fx; } state.settings.add_recent(root.clone()); if !state.settings.open_collections.contains(&root) { state.settings.open_collections.push(root.clone()); } fx.push(Effect::SaveSettings(state.settings.clone())); fx.push(Effect::LoadCollection(root)); } Action::CloseCollection(root) => { let Some(pos) = state.collections.iter().position(|c| c.root == root) else { return fx; }; state.collections.remove(pos); fx.push(Effect::Unwatch(root.clone())); state.settings.open_collections.retain(|r| r != &root); fx.push(Effect::SaveSettings(state.settings.clone())); state.cookie_jars.remove(&Some(root.clone())); if state.env_editor.as_ref().is_some_and(|e| e.root == root) { state.env_editor = None; } if state.active_collection.as_ref() == Some(&root) { state.active_collection = state.collections.first().map(|c| c.root.clone()); } // Clean tabs from it close; tabs with edits stay, detached from their file. let ids: Vec<(TabId, bool)> = state .tabs .iter() .filter(|t| t.origin.as_ref().is_some_and(|o| o.file.starts_with(&root))) .map(|t| (t.id, t.is_dirty())) .collect(); for (id, dirty) in ids { if dirty { if let Some(t) = state.tab_mut(id) { t.origin = None; t.orphaned = true; } } else { close_tab(state, id); } } } Action::SetActiveCollection(root) => { if state.collection(&root).is_some() { state.active_collection = Some(root); } } 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) { match result { Ok((envs, private_not_ignored)) => { c.envs = envs; c.env_error = None; c.private_not_ignored = private_not_ignored; if c.selected_env.as_ref().is_some_and(|sel| !c.envs.names().contains(sel)) { c.selected_env = None; } } Err(e) => c.env_error = Some(e), } } } Action::FileChangedOnDisk { path, text } => file_changed(state, path, text, &mut fx), Action::Rescan(root) => { if state.collection(&root).is_some() { fx.push(Effect::LoadCollection(root)); } } Action::Save(id) => save(state, id, &mut fx), Action::SaveAs { tab, path, existing } => save_as(state, tab, path, existing, &mut fx), Action::ResolveConflict { tab, keep_mine } => { state.dialog = None; if !keep_mine { if let Some(t) = state.tab(tab) { if let Some(o) = t.origin.clone() { reload_tab_from_file(state, tab, &o.file); } } } } Action::NewFile { dir, name } => { state.dialog = None; let name = name.trim(); if name.is_empty() { return fx; } let name = if collection::is_http_file(Path::new(name)) { name.to_string() } else { format!("{name}.http") }; let path = dir.join(name); if state.collection_of(&path).is_some_and(|c| c.files.contains_key(&path)) { state.set_error(txt::msg::already_exists(path.display())); return fx; } let req = Request { title: Some(txt::common::NEW_REQUEST.into()), ..Request::default() }; let text = render_request(&req, "\n"); fx.push(file_ops(state, vec![FileOp::Write(path.clone(), text.clone())], true)); insert_file(state, &path, text); open_request(state, &path, 0); } Action::NewRequestIn { file } => { let Some(f) = file_of(state, &file) else { return fx }; let n = f.request_count(); let req = Request { title: Some(unique_title(f, txt::common::NEW_REQUEST)), ..Request::default() }; let text = f.insert_request(None, &req); fx.push(file_ops(state, vec![FileOp::Write(file.clone(), text.clone())], false)); insert_file(state, &file, text); open_request(state, &file, n); state.focus_url = true; } Action::RenameRequest { file, index, title } => { state.dialog = None; let Some(f) = file_of(state, &file) else { return fx }; let Some(old) = f.request(index).cloned() else { return fx; }; let mut req = old.clone(); let title = title.trim().to_string(); req.title = (!title.is_empty()).then_some(title); // A rename should rename: drop an @name that would shadow the title. if req.name.is_some() { req.name = req.title.as_deref().map(slug_name); } let Some(text) = f.replace_request(index, &req) else { return fx; }; fx.push(file_ops(state, vec![FileOp::Write(file.clone(), text.clone())], false)); insert_file(state, &file, text); // Keep open tabs pointing at the renamed request. let new_key = file_of(state, &file).and_then(|f| f.key_of(index)); for t in state.tabs.iter_mut() { if let Some(o) = &mut t.origin { if o.file == file && o.key.index == index { if let Some(k) = &new_key { o.key = k.clone(); } t.request.title = req.title.clone(); t.request.name = req.name.clone(); t.saved.title = req.title.clone(); t.saved.name = req.name.clone(); refresh_source(t); } } } } Action::DuplicateRequest { file, index } => { let Some(f) = file_of(state, &file) else { return fx }; 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(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, &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); } let block = if copy.text().starts_with("###") { copy.text().to_string() } else { format!("###\n{}", copy.text()) }; let text = f.insert_request_text(Some(index), &block); fx.push(file_ops(state, vec![FileOp::Write(file.clone(), text.clone())], false)); shift_origins(state, &file, index + 1, 1); insert_file(state, &file, text); open_request(state, &file, index + 1); } Action::DeleteRequest { file, index } => { state.dialog = None; let Some(f) = file_of(state, &file) else { return fx }; let Some(text) = f.remove_request(index) else { return fx }; fx.push(file_ops(state, vec![FileOp::Write(file.clone(), text.clone())], false)); orphan_tabs(state, &file, Some(index)); shift_origins(state, &file, index + 1, -1); insert_file(state, &file, text); } Action::MoveRequest { from, index, to } => { if from == to { return fx; } let (Some(src_file), Some(dst_file)) = (file_of(state, &from), file_of(state, &to)) else { return fx; }; let Some(block) = src_file.request_source(index) else { return fx; }; let mut block = block.to_string(); if !block.starts_with("###") { block = format!("###\n{block}"); } let new_index = dst_file.request_count(); let Some(src_text) = src_file.remove_request(index) else { return fx; }; let dst_text = dst_file.insert_request_text(None, &block); fx.push(file_ops( state, vec![ FileOp::Write(to.clone(), dst_text.clone()), FileOp::Write(from.clone(), src_text.clone()), ], false, )); // Tabs follow the request to its new file. for t in state.tabs.iter_mut() { if let Some(o) = &mut t.origin { if o.file == from && o.key.index == index { o.file = to.clone(); o.key.index = new_index; } } } shift_origins(state, &from, index + 1, -1); insert_file(state, &to, dst_text); insert_file(state, &from, src_text); } Action::RenameFile { path, new_name } => { state.dialog = None; let new_name = new_name.trim(); if new_name.is_empty() { return fx; } let new_name = if collection::is_http_file(Path::new(new_name)) { new_name.to_string() } else { format!("{new_name}.http") }; let Some(dir) = path.parent() else { return fx }; let to = dir.join(new_name); if to == path { return fx; } fx.push(file_ops(state, vec![FileOp::Rename(path.clone(), to.clone())], true)); for t in state.tabs.iter_mut() { if let Some(o) = &mut t.origin { if o.file == path { o.file = to.clone(); } } } if let Some(c) = state.collection_of_mut(&path) { if let Some(f) = c.files.remove(&path) { c.files.insert(to, f); } } } Action::DuplicateFile(path) => { let Some(f) = file_of(state, &path) else { return fx }; let text = f.text().to_string(); let stem = path .file_stem() .map(|s| s.to_string_lossy().into_owned()) .unwrap_or_default(); let ext = path .extension() .map(|e| e.to_string_lossy().into_owned()) .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(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)); insert_file(state, ©, text); } Action::DeleteFile(path) => { state.dialog = None; fx.push(file_ops(state, vec![FileOp::Delete(path.clone())], true)); orphan_tabs(state, &path, None); if let Some(c) = state.collection_of_mut(&path) { c.files.remove(&path); } } // ---------------------------------------------------- folder auth Action::EditFolderAuth(dir) => { if let Some(c) = state.collection_of(&dir) { state.dialog = Some(Dialog::FolderAuth(FolderAuthEdit { auth: c.folder_auth(&dir), dir, })); } } Action::SetFolderAuth { dir, auth } => { state.dialog = None; let Some(c) = state.collection_of_mut(&dir) else { return fx; }; let mut settings = c.folders.get(&dir).cloned().unwrap_or_default(); settings.auth = auth; let path = folder::settings_path(&dir); let op = if settings.is_empty() { c.folders.remove(&dir).map(|_| FileOp::Delete(path)) } else { let json = settings.to_json(); c.folders.insert(dir, settings); Some(FileOp::Write(path, json)) }; if let Some(op) = op { fx.push(Effect::FileOps { ops: vec![op], rescan: None, }); } } Action::ConsolidateAuth { dir, target } => { state.dialog = plan_consolidation(state, &dir, target).map(Dialog::ConsolidateAuth); } Action::ApplyConsolidateAuth(plan) => apply_consolidation(state, plan, &mut fx), // ---------------------------------------------------- environments Action::SelectEnv(e) => { let Some(root) = state.current_collection().map(|c| c.root.clone()) else { return fx; }; if let Some(c) = state.collection_mut(&root) { c.selected_env = e; } state.active_collection = Some(root); } Action::OpenEnvEditor => { if let Some(c) = state.current_collection() { let selected = c .selected_env .clone() .or_else(|| c.envs.names().first().cloned()) .unwrap_or_else(|| "dev".into()); state.env_editor = Some(EnvEditor { root: c.root.clone(), envs: c.envs.clone(), selected, revealed: Vec::new(), dirty: false, }); } else { state.set_error(txt::msg::NEED_COLLECTION_FOR_ENVS); } } Action::EnvEditorChanged(e) => state.env_editor = Some(e), Action::EnvEditorClose => state.env_editor = None, Action::EnvEditorSave => { let Some(ed) = &mut state.env_editor else { return fx }; let Some(c) = state.collections.iter_mut().find(|c| c.root == ed.root) else { return fx; }; let mut ops = Vec::new(); if ed.envs.public != c.envs.public { ops.push(FileOp::Write(c.root.join(env::PUBLIC_FILE), ed.envs.public.to_json())); } if ed.envs.private != c.envs.private { ops.push(FileOp::Write(c.root.join(env::PRIVATE_FILE), ed.envs.private.to_json())); } c.envs = ed.envs.clone(); ed.dirty = false; if !ops.is_empty() { fx.push(Effect::FileOps { ops, rescan: None }); // Re-check whether the private file is git-ignored. fx.push(Effect::LoadEnvironments(c.root.clone())); } } Action::AddPrivateFileToGitignore(root) => { if let Some(c) = state.collection_mut(&root) { fx.push(Effect::AppendGitignore(root)); c.private_not_ignored = false; } } Action::DismissGitignoreOffer(root) => { if let Some(c) = state.collection_mut(&root) { c.gitignore_offer_dismissed = true; } } // ---------------------------------------------------- import/export Action::CopyAsCurl(id) => { let Some(t) = state.tab(id) else { return fx }; let resolver = state.resolver_for(t); match resolve_request( &with_inherited_auth(&t.request, state.inherited_auth_for(t).as_ref()), &resolver, &state.base_dir_for(t), &state.settings.request_options(), ) { Ok(r) => { fx.push(Effect::CopyToClipboard(to_curl(&r))); state.set_info(txt::msg::COPIED_CURL); } Err(e) => state.set_error(txt::msg::curl_failed(e)), } } Action::CopyAsHttp(id) => { let Some(t) = state.tab(id) else { return fx }; let text = if t.source.trim().is_empty() { render_request(&t.request, "\n") } else { t.source.clone() }; fx.push(Effect::CopyToClipboard(text)); state.set_info(txt::msg::COPIED_HTTP); } Action::ImportPostman => fx.push(Effect::PickPostmanImport), Action::PostmanImported { root, files, warnings } => { state.dialog = Some(Dialog::ImportSummary { root: root.clone(), files, warnings, }); return update(state, Action::OpenCollection(root)); } // ---------------------------------------------------- history etc. Action::HistoryLoaded(h) => state.history = h, Action::RestoreHistory(i) => { if let Some(e) = state.history.get(i) { let text = e.http.clone(); let env = e.env.clone(); let root = state.current_collection().map(|c| c.root.clone()); if let (Some(env), Some(root)) = (env, root) { if let Some(c) = state.collection_mut(&root) { if c.envs.names().contains(&env) { c.selected_env = Some(env); } } } return update(state, Action::NewTabFromHttp(text)); } } Action::ClearHistory => { state.history.clear(); fx.push(Effect::RewriteHistory(Vec::new())); } Action::ClearCookies => { let key = state.current_collection().map(|c| c.root.clone()); state.cookie_jars.entry(key).or_default().clear(); } Action::DeleteCookie(i) => { let key = state.current_collection().map(|c| c.root.clone()); state.cookie_jars.entry(key).or_default().remove(i); } Action::SettingsLoaded(s) => { fx.push(Effect::SetConcurrency(s.max_concurrent_requests)); state.settings = s; } Action::SettingsChanged(s) => { if s.max_concurrent_requests != state.settings.max_concurrent_requests { fx.push(Effect::SetConcurrency(s.max_concurrent_requests)); } state.settings = s; fx.push(Effect::SaveSettings(state.settings.clone())); } Action::PickCaFile => fx.push(Effect::PickCaFile), Action::CaFilePicked(p) => { state.settings.ca_file = Some(p); fx.push(Effect::SaveSettings(state.settings.clone())); } // ---------------------------------------------------- shell Action::ShowDialog(d) => state.dialog = d, Action::SetWindows(w) => state.windows = w, Action::QuickOpen(q) => state.quick_open = q, Action::FocusUrl => state.focus_url = true, Action::UrlFocused => state.focus_url = false, Action::CloseRequested => { if state.any_dirty() && !state.quit_confirmed { state.dialog = Some(Dialog::ConfirmQuit); } else { state.quit_confirmed = true; fx.push(Effect::Quit); } } Action::ConfirmQuit => { state.dialog = None; state.quit_confirmed = true; fx.push(Effect::Quit); } Action::Error(e) => state.set_error(e), Action::Info(i) => state.set_info(i), Action::DismissStatus => state.status = None, } fx } // ------------------------------------------------------------------ helpers fn new_tab(state: &mut AppState, req: Request, origin: Option, source: String) -> TabId { let id = state.alloc_tab_id(); let source = if source.is_empty() && !req.url.is_empty() { render_request(&req, "\n") } else { source }; state.tabs.push(Tab::new(id, req, origin, source)); state.active = Some(id); id } fn close_tab(state: &mut AppState, id: TabId) { let Some(pos) = state.tabs.iter().position(|t| t.id == id) else { return; }; let tab = state.tabs.remove(pos); if let Some(f) = tab.in_flight { f.cancel.cancel(); } if state.active == Some(id) { state.active = state .tabs .get(pos) .or_else(|| state.tabs.get(pos.wrapping_sub(1))) .map(|t| t.id); } } fn file_of<'a>(state: &'a AppState, path: &Path) -> Option<&'a HttpFile> { state.collection_of(path)?.files.get(path) } fn insert_file(state: &mut AppState, path: &Path, text: String) { if let Some(c) = state.collection_of_mut(path) { c.files.insert(path.to_path_buf(), HttpFile::parse(text)); } } /// File operations, followed by a rescan of the collection of the first /// operation's file when `rescan` is set. fn file_ops(state: &AppState, ops: Vec, rescan: bool) -> Effect { let first = ops.first().map(|op| match op { FileOp::Write(p, _) | FileOp::Delete(p) | FileOp::Rename(p, _) => p.clone(), }); Effect::FileOps { rescan: first .filter(|_| rescan) .and_then(|p| state.collection_of(&p)) .map(|c| c.root.clone()), ops, } } fn open_request(state: &mut AppState, file: &Path, index: usize) { // Focus an existing tab for the same request. if let Some(t) = state.tabs.iter().find(|t| { t.origin .as_ref() .is_some_and(|o| o.file == file && o.key.index == index) }) { state.active = Some(t.id); return; } let Some(f) = file_of(state, file) else { return }; let (Some(req), Some(key), Some(src)) = (f.request(index), f.key_of(index), f.request_source(index)) else { return; }; let (req, src) = (req.clone(), src.to_string()); state.active_collection = state.collection_of(file).map(|c| c.root.clone()); new_tab( state, req, Some(Origin { file: file.to_path_buf(), key, }), src, ); } /// Applies a form edit to a tab's request. fn edit(state: &mut AppState, id: TabId, f: impl FnOnce(&mut Request)) { if let Some(t) = state.tab_mut(id) { f(&mut t.request); t.params = parse_params(&t.request.url); after_form_edit(t); } } fn after_form_edit(t: &mut Tab) { t.source_authoritative = false; t.source_error = None; refresh_source(t); } /// Regenerates the Source text from the form, keeping comments and other /// unmodelled parts of the saved text. fn refresh_source(t: &mut Tab) { let base = HttpFile::parse(t.saved_source.clone()); t.source = if base.request_count() == 1 { base.replace_request(0, &t.request) .unwrap_or_else(|| render_request(&t.request, "\n")) } else { render_request(&t.request, "\n") }; } fn send(state: &mut AppState, id: TabId, fx: &mut Vec) { let Some(t) = state.tab(id) else { return }; if t.in_flight.is_some() { return; } if let Some(e) = &t.source_error { let e = e.clone(); if let Some(t) = state.tab_mut(id) { t.error = Some(txt::msg::fix_source(e)); } return; } let resolver = state.resolver_for(t); let base_dir = state.base_dir_for(t); let inherited = state.inherited_auth_for(t); let req = with_inherited_auth(&t.request, inherited.as_ref()); let resolved = resolve_request(&req, &resolver, &base_dir, &state.settings.request_options()); let mut resolved = match resolved { Ok(r) => r, Err(e) => { if let Some(t) = state.tab_mut(id) { t.error = Some(e.to_string()); t.response = None; } return; } }; let collection = state.collection_for_tab(t); let jar_key = (!t.request.directives.no_cookie_jar).then(|| collection.map(|c| c.root.clone())); let env = collection.and_then(|c| c.selected_env.clone()); if let Some(key) = &jar_key { let has_cookie = resolved.headers.iter().any(|(n, _)| n.eq_ignore_ascii_case("cookie")); if let Some(c) = state .cookie_jars .get(key) .and_then(|j| j.header_for(&resolved.url, SystemTime::now())) { if !has_cookie { resolved.headers.push(("Cookie".into(), c)); } } } let history = HistoryEntry { at: SystemTime::now() .duration_since(UNIX_EPOCH) .map(|d| d.as_secs()) .unwrap_or(0), method: resolved.method.clone(), url: resolved.url.clone(), status: None, duration_ms: 0, env, http: if t.source.trim().is_empty() { render_request(&t.request, "\n") } else { t.source.clone() }, error: None, }; let no_log = t.request.directives.no_log; let cancel = CancelToken::new(); let t = state.tab_mut(id).unwrap(); t.seq += 1; t.error = None; t.search.matches.clear(); t.in_flight = Some(InFlight { cancel: cancel.clone(), started: Instant::now(), seq: t.seq, history: HistoryEntry { // `@no-log` keeps the request out of history. http: if no_log { String::new() } else { history.http }, ..history }, cookie_jar: jar_key, url: resolved.url.clone(), }); fx.push(Effect::SendRequest { tab: id, seq: t.seq, request: resolved, cancel, }); } fn receive(state: &mut AppState, id: TabId, seq: u64, result: Result, fx: &mut Vec) { let Some(t) = state.tab_mut(id) else { return }; if t.seq != seq { return; // a newer request replaced this one } let Some(flight) = t.in_flight.take() else { return; // cancelled }; let mut entry = flight.history; entry.duration_ms = flight.started.elapsed().as_millis() as u64; match result { Ok(resp) => { entry.status = Some(resp.status); entry.duration_ms = resp.timings.total.as_millis() as u64; fx.push(Effect::PrepareBody { tab: id, seq, body: resp.body.clone(), content_type: resp.content_type().to_string(), }); let set_cookies: Vec = resp.headers_named("set-cookie").map(str::to_string).collect(); t.response = Some(ResponseView { response: resp, received_at: SystemTime::now(), prepared: None, }); t.error = None; if let Some(key) = flight.cookie_jar { state.cookie_jars.entry(key).or_default().store( &flight.url, set_cookies.iter().map(String::as_str), SystemTime::now(), ); } } Err(HttpError::Cancelled) => return, Err(e) => { entry.error = Some(e.to_string()); t.error = Some(e.to_string()); t.response = None; } } if !entry.http.is_empty() { state.history.push(entry.clone()); let limit = state.settings.history_limit.max(1); if state.history.len() > limit { let excess = state.history.len() - limit; state.history.drain(..excess); } fx.push(Effect::AppendHistory(entry)); } } fn suggested_file_name(r: &Response) -> String { let last = r .effective_url .split(['?', '#']) .next() .unwrap_or("") .rsplit('/') .next() .unwrap_or("") .to_string(); let ext = match r.content_type().split(';').next().unwrap_or("").trim() { "application/json" => "json", "text/html" => "html", "text/plain" => "txt", "application/xml" | "text/xml" => "xml", "image/png" => "png", "image/jpeg" => "jpg", "application/pdf" => "pdf", _ => "bin", }; if !last.is_empty() && last.contains('.') { last } else if !last.is_empty() { format!("{last}.{ext}") } else { format!("response.{ext}") } } /// Recomputes search matches over the visible body text. fn recompute_search(t: &mut Tab) { t.search.matches.clear(); let q = t.search.query.to_lowercase(); if q.is_empty() { return; } let Some(prepared) = t.response.as_ref().and_then(|r| r.prepared.as_ref()) else { return; }; let lines = prepared.text(t.body_view); const MAX: usize = 10_000; for i in 0..lines.line_count() { let line = lines.line(i); let lower = line.to_lowercase(); // Byte offsets only line up when lowercasing kept the length. if lower.len() != line.len() { continue; } let mut from = 0; while let Some(pos) = lower[from..].find(&q) { let start = from + pos; t.search.matches.push((i, start..start + q.len())); from = start + q.len().max(1); if t.search.matches.len() >= MAX { return; } } } if t.search.current >= t.search.matches.len() { t.search.current = 0; } } fn collection_loaded(state: &mut AppState, c: Collection, fx: &mut Vec) { let root = c.root.clone(); match state.collection_mut(&root) { Some(existing) => { // A rescan: keep environments and choices, take the new tree. existing.tree = c.tree; existing.files = c.files; existing.folders = c.folders; existing.folder_errors = c.folder_errors; let ids: Vec<(TabId, PathBuf)> = state .tabs .iter() .filter_map(|t| t.origin.as_ref().map(|o| (t.id, o.file.clone()))) .filter(|(_, f)| f.starts_with(&root)) .collect(); for (id, file) in ids { if file_of(state, &file).is_none() { if let Some(t) = state.tab_mut(id) { t.orphaned = true; } } } } None => { state.collections.push(CollectionState { root: c.root, tree: c.tree, files: c.files, folders: c.folders, folder_errors: c.folder_errors, envs: Environments::default(), selected_env: None, env_error: None, private_not_ignored: false, gitignore_offer_dismissed: false, }); state.active_collection = Some(root.clone()); fx.push(Effect::Watch(root.clone())); } } fx.push(Effect::LoadEnvironments(root)); } fn file_changed(state: &mut AppState, path: PathBuf, text: Option, fx: &mut Vec) { let Some(c) = state.collection_of_mut(&path) else { return; }; let root = c.root.clone(); if let Some(dir) = folder::settings_dir(&path) { let dir = dir.to_path_buf(); c.folder_errors.clear(); match text.map(|t| FolderSettings::parse(&t, &path)) { None => { c.folders.remove(&dir); } Some(Ok(s)) => { c.folders.insert(dir, s); } Some(Err(e)) => c.folder_errors.push(e.to_string()), } return; } let name = path.file_name().and_then(|n| n.to_str()).unwrap_or(""); if name == env::PUBLIC_FILE || name == env::PRIVATE_FILE { // Only the env files at the collection root count. if path.parent() == Some(root.as_path()) { fx.push(Effect::LoadEnvironments(root)); } return; } if !collection::is_http_file(&path) { return; } match text { None => { if c.files.remove(&path).is_some() { orphan_tabs(state, &path, None); fx.push(Effect::LoadCollection(root)); } } Some(text) => { if c.files.get(&path).is_some_and(|f| f.text() == text) { return; // our own write, or no real change } let is_new = !c.files.contains_key(&path); c.files.insert(path.clone(), HttpFile::parse(text)); if is_new { fx.push(Effect::LoadCollection(root)); } let ids: Vec = state .tabs .iter() .filter(|t| t.origin.as_ref().is_some_and(|o| o.file == path)) .map(|t| t.id) .collect(); for id in ids { let dirty = state.tab(id).is_some_and(Tab::is_dirty); if dirty { state.dialog = Some(Dialog::Conflict { tab: id, path: path.clone(), }); } else { reload_tab_from_file(state, id, &path); } } } } } /// Replaces a tab's request with the version in its file. fn reload_tab_from_file(state: &mut AppState, id: TabId, path: &Path) { let Some(key) = state.tab(id).and_then(|t| t.origin.as_ref()).map(|o| o.key.clone()) else { return; }; let found = file_of(state, path).and_then(|f| { let i = f.find(&key)?; Some((f.request(i)?.clone(), f.request_source(i)?.to_string(), f.key_of(i)?)) }); let Some(t) = state.tab_mut(id) else { return }; match found { Some((req, src, key)) => { t.params = parse_params(&req.url); t.request = req.clone(); t.saved = req; t.source = src.clone(); t.saved_source = src; t.source_authoritative = false; t.source_error = None; t.orphaned = false; if let Some(o) = &mut t.origin { o.key = key; } } None => t.orphaned = true, } } /// Marks tabs whose request no longer exists in its file. fn orphan_tabs(state: &mut AppState, file: &Path, index: Option) { for t in state.tabs.iter_mut() { if let Some(o) = &t.origin { if o.file == file && index.is_none_or(|i| o.key.index == i) { t.origin = None; t.orphaned = true; } } } } /// Shifts the index of tabs pointing at requests `from..` in `file`. fn shift_origins(state: &mut AppState, file: &Path, from: usize, delta: i64) { for t in state.tabs.iter_mut() { if let Some(o) = &mut t.origin { if o.file == file && o.key.index >= from { o.key.index = (o.key.index as i64 + delta).max(0) as usize; } } } } fn unique_title(f: &HttpFile, base: &str) -> String { let taken = |t: &str| f.requests().any(|r| r.display_name() == Some(t)); if !taken(base) { return base.to_string(); } (2..) .map(|n| txt::names::numbered(base, n)) .find(|t| !taken(t)) .unwrap() } fn slug_name(title: &str) -> String { reqlite_core::import::postman::slug(title) } /// Works out what "Consolidate auth" on `dir` would do: which requests can /// drop their own auth header and inherit `dir`'s auth instead. /// When `dir` has no auth of its own, `pick` (or what it already inherits, /// or the most used header) becomes its auth. pub fn plan_consolidation(state: &AppState, dir: &Path, pick: Option) -> Option { let c = state.collection_of(dir)?; let requests: Vec<_> = c.all_requests().filter(|(p, _, _)| p.starts_with(dir)).collect(); let mut choices: Vec<(AuthHeader, usize)> = Vec::new(); for (_, _, r) in &requests { if let AuthMode::Own(v) = auth_mode(r) { match choices.iter_mut().find(|(c, _)| same_auth(c, &v)) { Some(c) => c.1 += 1, None => choices.push((v, 1)), } } } choices.sort_by_key(|c| std::cmp::Reverse(c.1)); let current = c.inherited_auth(dir).and_then(|i| i.value); let (target, set_folder) = match c.folder_auth(dir) { FolderAuth::Header(h) => { choices.clear(); (Some(h), false) } _ => { let target = pick .or_else(|| current.clone()) .or_else(|| choices.first().map(|c| c.0.clone())); let same_as_now = matches!((¤t, &target), (Some(a), Some(b)) if same_auth(a, b)); (target.clone(), target.is_some() && !same_as_now) } }; // Folder settings as they will be after applying. let mut new_settings = c.folders.get(dir).cloned().unwrap_or_default(); if let Some(t) = &target { new_settings.auth = FolderAuth::Header(t.clone()); } let after = |d: &Path| { folder::inherited_auth(&c.root, d, |x| { if set_folder && x == dir { Some(&new_settings) } else { c.folders.get(x) } }) .and_then(|i| i.value) }; let dirty = |file: &Path, index: usize| { state.tabs.iter().any(|t| { t.is_dirty() && t.origin .as_ref() .is_some_and(|o| o.file == file && o.key.index == index) }) }; let mut plan = ConsolidateAuth { dir: dir.to_path_buf(), target, set_folder, choices, own: Vec::new(), affected: Vec::new(), keep_affected: true, skipped_dirty: Vec::new(), }; for (file, index, r) in requests { let fdir = file.parent().unwrap_or(dir); let request = RequestRef { file: file.clone(), index, label: format!( "{} › {}", c.relative(file).display(), r.display_name().unwrap_or(r.url.as_str()) ), }; let item = match auth_mode(r) { AuthMode::Own(value) => { let mut own = OwnAuth { request, value, inherits: after(fdir), selected: false, }; own.selected = own.same(); Some(Ok(own)) } AuthMode::Inherit => { let before = c.inherited_auth(fdir).and_then(|i| i.value); let changes = match (&before, &after(fdir)) { (Some(a), Some(b)) => !same_auth(a, b), (a, b) => a.is_some() != b.is_some(), }; changes.then_some(Err((request, before))) } AuthMode::NoAuth => None, }; match item { Some(Ok(own)) if dirty(file, index) => plan.skipped_dirty.push(own.request), Some(Err((request, _))) if dirty(file, index) => plan.skipped_dirty.push(request), Some(Ok(own)) => plan.own.push(own), Some(Err(affected)) => plan.affected.push(affected), None => {} } } Some(plan) } /// What consolidating does to one request. enum AuthFix { /// Drop its own header so it inherits. Inherit, /// Pin the auth it sends today (a header, or `# @no-auth` for `None`). Keep(Option), } fn apply_consolidation(state: &mut AppState, plan: ConsolidateAuth, fx: &mut Vec) { state.dialog = None; let mut edits: BTreeMap> = BTreeMap::new(); for o in plan.own.iter().filter(|o| o.selected) { edits .entry(o.request.file.clone()) .or_default() .push((o.request.index, AuthFix::Inherit)); } if plan.keep_affected && plan.set_folder { for (r, before) in &plan.affected { edits .entry(r.file.clone()) .or_default() .push((r.index, AuthFix::Keep(before.clone()))); } } let mut ops = Vec::new(); let (mut dropped, mut pinned) = (0, 0); for (path, list) in edits { let Some(mut f) = file_of(state, &path).cloned() else { continue; }; for (index, edit) in list { let Some(mut r) = f.request(index).cloned() else { continue; }; // The file may have changed since the plan was made. match (&edit, auth_mode(&r)) { (AuthFix::Inherit, AuthMode::Own(_)) => { folder::set_auth_mode(&mut r, &AuthMode::Inherit); dropped += 1; } (AuthFix::Keep(before), AuthMode::Inherit) => { let mode = match before { Some(h) => AuthMode::Own(h.clone()), None => AuthMode::NoAuth, }; folder::set_auth_mode(&mut r, &mode); pinned += 1; } _ => continue, } if let Some(text) = f.replace_request(index, &r) { f = HttpFile::parse(text); } } if file_of(state, &path).is_some_and(|old| old.text() != f.text()) { ops.push(FileOp::Write(path.clone(), f.text().to_string())); insert_file(state, &path, f.text().to_string()); let clean: Vec = state .tabs .iter() .filter(|t| !t.is_dirty() && t.origin.as_ref().is_some_and(|o| o.file == path)) .map(|t| t.id) .collect(); for id in clean { reload_tab_from_file(state, id, &path); } } } let mut msg = Vec::new(); if plan.set_folder { if let (Some(target), Some(c)) = (&plan.target, state.collection_of_mut(&plan.dir)) { let mut settings = c.folders.get(&plan.dir).cloned().unwrap_or_default(); 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(txt::consolidate::set_folder(&target.to_string())); } } if dropped > 0 { msg.push(txt::consolidate::dropped(dropped)); } if pinned > 0 { msg.push(txt::consolidate::pinned(pinned)); } if !plan.skipped_dirty.is_empty() { 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(txt::consolidate::NOTHING_TO_CHANGE); } else { let mut text = msg.join(", "); text[..1].make_ascii_uppercase(); state.set_info(text); } } 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(txt::msg::cannot_save(e)); return; } let Some(origin) = t.origin.clone() else { fx.push(Effect::PickSaveTarget(id)); return; }; let Some(f) = file_of(state, &origin.file) else { state.set_error(txt::msg::not_loaded(origin.file.display())); return; }; let Some(index) = f.find(&origin.key) else { state.set_error(txt::msg::NO_LONGER_IN_FILE); return; }; let new_text = if t.source_authoritative { f.replace_request_text(index, &t.source) } else { f.replace_request(index, &t.request) }; let Some(new_text) = new_text else { return }; let changed = new_text != f.text(); if changed { fx.push(Effect::FileOps { ops: vec![FileOp::Write(origin.file.clone(), new_text.clone())], rescan: None, }); insert_file(state, &origin.file, new_text); } // The file may now say slightly different things (e.g. a new title). let fresh = file_of(state, &origin.file).and_then(|f| { Some(( f.request(index)?.clone(), f.request_source(index)?.to_string(), f.key_of(index)?, )) }); let t = state.tab_mut(id).unwrap(); if let Some((req, src, key)) = fresh { t.saved = req.clone(); t.request = req; t.saved_source = src.clone(); t.source = src; t.source_authoritative = false; t.params = parse_params(&t.request.url); if let Some(o) = &mut t.origin { o.key = key; } } t.orphaned = false; } fn save_as(state: &mut AppState, id: TabId, path: PathBuf, existing: Option, fx: &mut Vec) { let Some(t) = state.tab(id) else { return }; let block = if t.source_authoritative && !t.source.trim().is_empty() { t.source.clone() } else { render_request(&t.request, "\n") }; let existing = file_of(state, &path).map(|f| f.text().to_string()).or(existing); let file = HttpFile::parse(existing.unwrap_or_default()); let index = file.request_count(); let block = if index > 0 && !block.starts_with("###") { format!("###\n{block}") } else { block }; let text = file.insert_request_text(None, &block); fx.push(Effect::FileOps { ops: vec![FileOp::Write(path.clone(), text.clone())], rescan: state.collection_of(&path).map(|c| c.root.clone()), }); let parsed = HttpFile::parse(text); let fresh = (|| { Some(( parsed.request(index)?.clone(), parsed.request_source(index)?.to_string(), parsed.key_of(index)?, )) })(); if let Some(c) = state.collection_of_mut(&path) { c.files.insert(path.clone(), parsed); } let t = state.tab_mut(id).unwrap(); if let Some((req, src, key)) = fresh { t.request = req.clone(); t.saved = req; t.source = src.clone(); t.saved_source = src; t.source_authoritative = false; t.origin = Some(Origin { file: path, key }); t.orphaned = false; } } #[cfg(test)] mod tests;