feat: keep several logins and switch between them
config.toml now holds a list of [[server]] logins and the active one. The single-login file of earlier versions loads as the only entry. Settings lists the servers first: confirm switches, the queue button pressed twice removes, and Add server opens the login form, which can now be cancelled. Removing the last login returns to the login screen. A switch saves the queue of the server being left, stops the player and restores the other server's saved queue paused. Player events sent before the stop are dropped by an epoch, and cover loads started for the old server by a generation, so nothing of one server shows on the other. Covers are cached on disk per server, keyed like the saved queue. The shoulder triggers wrap around the sections, which puts Settings one press from the first section.
This commit is contained in:
+159
-9
@@ -69,21 +69,104 @@ pub fn state_dir() -> Option<PathBuf> {
|
||||
dirs().map(|d| d.state_dir().unwrap_or(d.data_dir()).to_path_buf())
|
||||
}
|
||||
|
||||
pub fn load() -> Result<Option<Config>> {
|
||||
let Some(path) = config_path() else { return Ok(None) };
|
||||
impl Config {
|
||||
/// Names the server and user, as the sidebar shows them.
|
||||
pub fn label(&self) -> String {
|
||||
let host = self.url.split("://").nth(1).unwrap_or(&self.url);
|
||||
format!("{} on {}", self.username, host.trim_end_matches('/'))
|
||||
}
|
||||
|
||||
fn same_login(&self, other: &Config) -> bool {
|
||||
self.url == other.url && self.username == other.username
|
||||
}
|
||||
}
|
||||
|
||||
/// Every saved login, and which one is browsed.
|
||||
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Logins {
|
||||
/// Index into `servers`.
|
||||
#[serde(default)]
|
||||
pub active: usize,
|
||||
/// `[[server]]` tables in the file.
|
||||
#[serde(rename = "server", default)]
|
||||
pub servers: Vec<Config>,
|
||||
}
|
||||
|
||||
impl Logins {
|
||||
pub fn active(&self) -> Option<&Config> {
|
||||
self.servers.get(self.active)
|
||||
}
|
||||
|
||||
/// Adds a login, or refreshes the saved one for the same server and user,
|
||||
/// and makes it the active one.
|
||||
pub fn add(&mut self, cfg: Config) {
|
||||
match self.servers.iter().position(|s| s.same_login(&cfg)) {
|
||||
Some(i) => {
|
||||
self.servers[i] = cfg;
|
||||
self.active = i;
|
||||
}
|
||||
None => {
|
||||
self.servers.push(cfg);
|
||||
self.active = self.servers.len() - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes a login. The active one stays the same server where it can;
|
||||
/// removing it makes the first remaining login active.
|
||||
pub fn remove(&mut self, i: usize) {
|
||||
if i >= self.servers.len() {
|
||||
return;
|
||||
}
|
||||
self.servers.remove(i);
|
||||
if i < self.active {
|
||||
self.active -= 1;
|
||||
} else if i == self.active {
|
||||
self.active = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The single login of earlier versions, or the list. Tried in that order:
|
||||
/// every field of the list has a default, so it would take an old file as an
|
||||
/// empty list, while the old shape needs `url` and `username` at the top.
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum Stored {
|
||||
One(Config),
|
||||
List(Logins),
|
||||
}
|
||||
|
||||
fn parse_logins(text: &str) -> Result<Logins> {
|
||||
Ok(match toml::from_str::<Stored>(text)? {
|
||||
Stored::List(mut l) => {
|
||||
if l.active >= l.servers.len() {
|
||||
l.active = 0;
|
||||
}
|
||||
l
|
||||
}
|
||||
Stored::One(c) => Logins {
|
||||
active: 0,
|
||||
servers: vec![c],
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
pub fn load() -> Result<Logins> {
|
||||
let Some(path) = config_path() else {
|
||||
return Ok(Logins::default());
|
||||
};
|
||||
match fs::read_to_string(&path) {
|
||||
Ok(text) => Ok(Some(
|
||||
toml::from_str(&text).with_context(|| format!("parsing {}", path.display()))?,
|
||||
)),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
|
||||
Ok(text) => parse_logins(&text).with_context(|| format!("parsing {}", path.display())),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Logins::default()),
|
||||
Err(e) => Err(e).with_context(|| format!("reading {}", path.display())),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save(cfg: &Config) -> Result<()> {
|
||||
pub fn save(logins: &Logins) -> Result<()> {
|
||||
let path = config_path().context("no config directory")?;
|
||||
write_atomic(&path, &toml::to_string(cfg)?)?;
|
||||
log::info!("saved login to {}", path.display());
|
||||
write_atomic(&path, &toml::to_string(logins)?)?;
|
||||
log::info!("saved {} login(s) to {}", logins.servers.len(), path.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -212,6 +295,73 @@ mod tests {
|
||||
assert!(!text.contains("salt") && !text.contains("token"), "{text}");
|
||||
}
|
||||
|
||||
fn login(url: &str, user: &str, auth: Auth) -> Config {
|
||||
Config::from_client(&Client::new(url, user, auth))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_login_file_loads_as_the_only_login() {
|
||||
let old = "url = \"https://h\"\nusername = \"u\"\nsalt = \"s\"\ntoken = \"t\"\n";
|
||||
let l = parse_logins(old).unwrap();
|
||||
assert_eq!(l.servers.len(), 1);
|
||||
assert_eq!(l.active, 0);
|
||||
assert_eq!(l.active().unwrap().username, "u");
|
||||
let old = "url = \"https://h\"\nusername = \"u\"\npassword = \"p\"\n";
|
||||
let l = parse_logins(old).unwrap();
|
||||
assert_eq!(*l.active().unwrap().client().auth(), Auth::Password("p".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_login_list_round_trips_with_both_auth_methods() {
|
||||
let mut l = Logins::default();
|
||||
l.add(login(
|
||||
"https://a",
|
||||
"u",
|
||||
Auth::Token {
|
||||
salt: "s".into(),
|
||||
token: "t".into(),
|
||||
},
|
||||
));
|
||||
l.add(login("https://b", "v", Auth::Password("p".into())));
|
||||
let text = toml::to_string(&l).unwrap();
|
||||
assert!(text.contains("[[server]]"), "{text}");
|
||||
let back = parse_logins(&text).unwrap();
|
||||
assert_eq!(back, l);
|
||||
assert_eq!(back.active, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adding_the_same_login_again_replaces_it() {
|
||||
let mut l = Logins::default();
|
||||
l.add(login("https://a", "u", Auth::Password("old".into())));
|
||||
l.add(login("https://b", "u", Auth::Password("p".into())));
|
||||
l.add(login("https://a", "u", Auth::Password("new".into())));
|
||||
assert_eq!(l.servers.len(), 2);
|
||||
assert_eq!(l.active, 0);
|
||||
assert_eq!(*l.servers[0].client().auth(), Auth::Password("new".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removing_keeps_the_active_server_where_it_can() {
|
||||
let mut l = Logins::default();
|
||||
for host in ["https://a", "https://b", "https://c"] {
|
||||
l.add(login(host, "u", Auth::Password("p".into())));
|
||||
}
|
||||
l.active = 2;
|
||||
l.remove(0);
|
||||
assert_eq!(l.active().unwrap().url, "https://c");
|
||||
l.remove(1);
|
||||
assert_eq!(l.active().unwrap().url, "https://b");
|
||||
l.remove(0);
|
||||
assert!(l.active().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_out_of_range_active_index_falls_back_to_the_first() {
|
||||
let text = "active = 5\n[[server]]\nurl = \"https://a\"\nusername = \"u\"\npassword = \"p\"\n";
|
||||
assert_eq!(parse_logins(text).unwrap().active, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_default_when_fields_are_missing() {
|
||||
let s: Settings = toml::from_str("").unwrap();
|
||||
|
||||
Reference in New Issue
Block a user