tzemanovic/inflorescence - Change LPSUBGUBMG2QHJJSAWQ35SZIMUR62R6ODPWBS7TSNNXJ5UJCNABQC

add projects picker

Created by tzemanovic on February 5, 2026

LPSUBGUBMG2QHJJSAWQ35SZIMUR62R6ODPWBS7TSNNXJ5UJCNABQC

Dependencies

In channels

main

Change contents

File deletion: fs
BF:BFD[11.31] → [11.187:200]
BF:BFD[11.200] → [11.186:186]

File deletion: dir.rs, dir.rs, dir.rs, dir.rs

BF:BFD[11.186] → [11.268:298]

BF:BFD[11.298] → [2.1847:1847]

BFD:BFD[10.188] → [10.270:300]

BF:BFD[10.300] → [2.1847:1847]

BFD:BFD[2.1759] → [2.2364:2394]

BF:BFD[2.2394] → [2.1847:1847]

BFD:BFD[3.2582] → [3.5419:5449]

BF:BFD[3.5449] → [2.1847:1847]

B:BD[2.1847] → [2.1848:2363]

//! App directories shared between all Flowers apps.
use directories::ProjectDirs;
use std::path::PathBuf;
const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "Holonyte";
const APPLICATION: &str = "Flowers";
/// App config dir
pub fn config() -> PathBuf {
    projects_dir().config_dir().to_path_buf()
}
/// App config dir
pub fn data() -> PathBuf {
    projects_dir().config_dir().to_path_buf()
}
fn projects_dir() -> ProjectDirs {
    ProjectDirs::from(QUALIFIER, ORGANIZATION, APPLICATION).unwrap()
}

File deletion: mod.rs, mod.rs, mod.rs
BF:BFD[11.186] → [11.236:266]
BF:BFD[11.266] → [3.5357:5357]
BFD:BFD[10.188] → [10.238:268]
BF:BFD[10.268] → [3.5357:5357]
BFD:BFD[3.2582] → [3.5387:5417]
BF:BFD[3.5417] → [3.5357:5357]
B:BD[3.5357] → [3.5358:5386]
```
pub mod dir;
pub mod state;
```

File deletion: state.rs, state.rs, state.rs

BF:BFD[11.186] → [11.202:234]

BF:BFD[11.234] → [3.2598:2598]

BFD:BFD[10.188] → [10.204:236]

BF:BFD[10.236] → [3.2598:2598]

BFD:BFD[3.2582] → [3.5323:5355]

BF:BFD[3.5355] → [3.2598:2598]

B:BD[3.2598] → [3.2599:2825]

∅:D[4.805] → [3.2825:5322]

B:BD[3.2825] → [3.2825:5322]

B:BD[3.2825] → [4.729:805]

use crate::prelude::*;
use super::dir;
use async_fd_lock::{LockError, LockRead, LockWrite};
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use tokio::fs::File;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
pub type Repos = BTreeMap<String, Repo>;
#[derive(Debug, Serialize, Deserialize)]
pub struct Repo {
    path: PathBuf,
}
#[derive(Debug, Error)]
#[error("Another file-lock is blocking")]
pub struct BlockingLockError;
/// Acquire a read-lock to try to read [`Repos`]. If there's an active
/// write-lock the call will fail with a [`BlockingLockError`].
pub async fn read_repos() -> Result<Repos, ReadErr> {
    let file = match File::options().create_new(false).open(repos_path()).await
    {
        Err(err) if matches!(err.kind(), std::io::ErrorKind::NotFound) => {
            // Create a default `Repos` if file not found
            return Ok(Repos::default());
        }
        result => result.map_err(OneOf::new)?,
    };
    let mut read_guard = match file.lock_read().await {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result.map_err(OneOf::new)?,
    };
    let mut buffer = Vec::new();
    read_guard
        .read_to_end(&mut buffer)
        .await
        .map_err(OneOf::new)?;
    toml_edit::de::from_slice(&buffer).map_err(OneOf::new)
}
/// Acquire a write-lock to try to read [`Repos`]. If there's another active
/// write-lock the call will fail with a [`BlockingLockError`].
pub async fn write_repos(repos: &Repos) -> Result<(), WriteErr> {
    let file = File::options()
        .create_new(true)
        .open(repos_path())
        .await
        .map_err(OneOf::new)?;
    // Optimistically encode first to reduce the scope of the lock
    let repos_bytes =
        toml_edit::ser::to_string_pretty(repos).map_err(OneOf::new)?;
    let mut write_guard = match file.lock_write().await {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result.map_err(OneOf::new)?,
    };
    write_guard
        .write_all(repos_bytes.as_bytes())
        .await
        .map_err(OneOf::new)
}
pub type ReadErr = OneOf<(
    BlockingLockError,
    std::io::Error,
    LockError<tokio::fs::File>,
    toml_edit::de::Error,
)>;
pub type WriteErr = OneOf<(
    BlockingLockError,
    std::io::Error,
    LockError<tokio::fs::File>,
    toml_edit::ser::Error,
)>;
fn repos_path() -> PathBuf {
    PathBuf::from_iter([dir::data().as_path(), Path::new(REPOS_FILE)])
}
const REPOS_FILE: &str = "repos.toml";
/// All the known local repositories
// TODO: order by most recently opened

File addition: store (d--x------)
[11.31]

File addition: state.rs (----------)

[0.1]

#[cfg(test)]
mod test;
use crate::prelude::*;
use super::dir;
use anyhow::{format_err, Context};
use async_fd_lock::{LockRead, LockWrite};
use tokio::fs::{self, File};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::cmp;
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
/// All the known local repositories
pub type Projects = BTreeSet<Project>;
#[derive(
    Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash,
)]
pub struct Project {
    // NOTE: This field must be first to order by most recently closed time
    // descending
    pub last_closed_time: cmp::Reverse<Option<Timestamp>>,
    pub path: PathBuf,
}
#[derive(Debug, Error)]
#[error("Another file-lock is blocking")]
pub struct BlockingLockError;
/// Acquire a read-lock to try to read [`Projects`]. If there's an active
/// write-lock the call will fail.
pub async fn read_projects() -> Result<Projects, ProjectsFileErr> {
    let path = projects_path();
    let path_str = path.to_string_lossy();
    let file = match File::options().create(false).read(true).open(&path).await
    {
        Err(err) if matches!(err.kind(), std::io::ErrorKind::NotFound) => {
            // Create a default if file not found
            return Ok(Projects::default());
        }
        result => result
            .with_context(|| format!("Opening projects file ({path_str})"))
            .map_err(OneOf::new)?,
    };
    let mut read_guard = match file.try_lock_read().await {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result
            .map_err(|e| {
                format_err!(
                    "Obtaining projects file read-lock failed with {e:?} ({path_str})"
                )
            })
            .map_err(OneOf::new)?,
    };
    let mut buffer = Vec::new();
    read_guard
        .read_to_end(&mut buffer)
        .await
        .with_context(|| format!("Reading projects file ({path_str})"))
        .map_err(OneOf::new)?;
    let stored: ProjectsStored = toml_edit::de::from_slice(&buffer)
        .with_context(|| format!("Decoding projects file ({path_str})"))
        .map_err(OneOf::new)?;
    Ok(from_stored(stored))
}
pub async fn upsert_project(project: Project) -> Result<(), ProjectsFileErr> {
    with_projects(move |mut projects| {
        let Project {
            last_closed_time,
            path,
        } = project;
        let last_closed_time = if let Some(ProjectStored {
            last_closed_time: current_last_time,
            ..
        }) = projects.remove(&path)
        {
            cmp::min(last_closed_time, current_last_time)
        } else {
            last_closed_time
        };
        let project = ProjectStored { last_closed_time };
        projects.insert(path, project);
        projects
    })
    .await
}
pub fn updated_closed_time_blocking(
    path: PathBuf,
) -> Result<(), ProjectsFileErr> {
    with_projects_blocking(move |mut projects| {
        let project = ProjectStored {
            last_closed_time: cmp::Reverse(Some(Timestamp::now())),
        };
        projects.insert(path, project);
        projects
    })
}
pub async fn rm_project(path: PathBuf) -> Result<(), ProjectsFileErr> {
    with_projects(move |mut projects| {
        projects.remove(&path);
        projects
    })
    .await
}
type ProjectsStored = BTreeMap<PathBuf, ProjectStored>;
#[derive(Debug, Clone, Serialize, Deserialize)]
struct ProjectStored {
    last_closed_time: cmp::Reverse<Option<Timestamp>>,
}
fn from_stored(state: ProjectsStored) -> Projects {
    state
        .into_iter()
        .map(|(path, ProjectStored { last_closed_time })| Project {
            last_closed_time,
            path,
        })
        .collect()
}
/// Acquire a lock to try to read, update and write [`Projects`].
async fn with_projects<F: FnOnce(ProjectsStored) -> ProjectsStored>(
    f: F,
) -> Result<(), ProjectsFileErr> {
    let path = projects_path();
    let path_str = path.to_string_lossy();
    fs::create_dir_all(path.parent().unwrap())
        .await
        .with_context(|| {
            format!("Creating projects file store directories ({path_str})")
        })
        .map_err(OneOf::new)?;
    let read_state = async || {
        let file = match File::options()
            .create(false)
            .read(true)
            .open(&path)
            .await
        {
            Err(err) if matches!(err.kind(), std::io::ErrorKind::NotFound) => {
                // Create a default if file not found
                return Ok(ProjectsStored::default());
            }
            result => result
                .with_context(|| format!("Opening projects file ({path_str})"))
                .map_err(OneOf::new)?,
        };
        let mut read_guard = match file.lock_read().await {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result
            .map_err(|e| {
                format_err!(
                    "Obtaining projects file read-lock failed with {e:?} ({path_str})"
                )
            })
            .map_err(OneOf::new)?,
    };
        let mut buffer = Vec::new();
        read_guard
            .read_to_end(&mut buffer)
            .await
            .with_context(|| format!("Reading projects file ({path_str})"))
            .map_err(OneOf::new)?;
        let stored: ProjectsStored = toml_edit::de::from_slice(&buffer)
            .with_context(|| format!("Decoding projects file ({path_str})"))
            .map_err(OneOf::new)?;
        Ok(stored)
    };
    let state = read_state().await?;
    let file = File::options()
        .create(true)
        .write(true)
        .truncate(true)
        .open(&path)
        .await
        .with_context(|| format!("Opening projects file ({path_str})"))
        .map_err(OneOf::new)?;
    let mut write_guard = match file.lock_write().await {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result
            .map_err(|e| {
                format_err!(
                    "Obtaining projects file write-lock failed with {e:?} ({path_str})"
                )
            })
            .map_err(OneOf::new)?,
    };
    let state = f(state);
    let state_bytes = toml_edit::ser::to_string_pretty(&state)
        .with_context(|| format!("Encoding projects file ({path_str})"))
        .map_err(OneOf::new)?;
    write_guard
        .write_all(state_bytes.as_bytes())
        .await
        .with_context(|| format!("Writing projects file ({path_str})"))
        .map_err(OneOf::new)
}
/// Acquire a write-lock to try to read, update and write [`Projects`]. If
/// there's an active write-lock the call will fail with a
/// [`BlockingLockError`].
fn with_projects_blocking<F: FnOnce(ProjectsStored) -> ProjectsStored>(
    f: F,
) -> Result<(), ProjectsFileErr> {
    use async_fd_lock::blocking::{LockRead, LockWrite};
    use std::fs;
    use std::io::{Read, Write};
    let path = projects_path();
    let path_str = path.to_string_lossy();
    fs::create_dir_all(path.parent().unwrap())
        .with_context(|| {
            format!("Creating projects file store directories ({path_str})")
        })
        .map_err(OneOf::new)?;
    let read_state = || {
        let file = match fs::File::options()
            .create(false)
            .read(true)
            .open(&path)
        {
            Err(err) if matches!(err.kind(), std::io::ErrorKind::NotFound) => {
                // Create a default if file not found
                return Ok(ProjectsStored::default());
            }
            result => result
                .with_context(|| format!("Opening projects file ({path_str})"))
                .map_err(OneOf::new)?,
        };
        let mut read_guard = match file.lock_read() {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result
            .map_err(|e| {
                format_err!(
                    "Obtaining projects file read-lock failed with {e:?} ({path_str})"
                )
            })
            .map_err(OneOf::new)?,
    };
        let mut buffer = Vec::new();
        read_guard
            .read_to_end(&mut buffer)
            .with_context(|| format!("Reading projects file ({path_str})"))
            .map_err(OneOf::new)?;
        let stored: ProjectsStored = toml_edit::de::from_slice(&buffer)
            .with_context(|| format!("Decoding projects file ({path_str})"))
            .map_err(OneOf::new)?;
        Ok(stored)
    };
    let state = read_state()?;
    let file = fs::File::options()
        .create(true)
        .write(true)
        .truncate(true)
        .open(&path)
        .with_context(|| format!("Opening projects file ({path_str})"))
        .map_err(OneOf::new)?;
    let mut write_guard = match file.lock_write() {
        Err(err)
            if matches!(err.error.kind(), std::io::ErrorKind::WouldBlock) =>
        {
            return Err(OneOf::new(BlockingLockError));
        }
        result => result
            .map_err(|e| {
                format_err!(
                    "Obtaining projects file write-lock failed with {e:?} ({path_str})"
                )
            })
            .map_err(OneOf::new)?,
    };
    let state = f(state);
    let state_bytes = toml_edit::ser::to_string_pretty(&state)
        .with_context(|| format!("Encoding projects file ({path_str})"))
        .map_err(OneOf::new)?;
    write_guard
        .write_all(state_bytes.as_bytes())
        .with_context(|| format!("Writing projects file ({path_str})"))
        .map_err(OneOf::new)
}
pub type ProjectsFileErr = OneOf<(BlockingLockError, anyhow::Error)>;
fn projects_path() -> PathBuf {
    PathBuf::from_iter([dir::data().as_path(), Path::new(PROJECTS_FILE)])
}
const PROJECTS_FILE: &str = "projects.toml";

File addition: state (d--x------)
[0.1]

File addition: test.rs (----------)

[0.10311]

use super::*;
#[test]
fn repo_order() {
    let mk_repo = |last_closed_time: Option<Timestamp>, path: &str| Project {
        last_closed_time: cmp::Reverse(last_closed_time),
        path: PathBuf::from(path),
    };
    // Repos in expected order
    const FST_SECOND: i64 = 10000000;
    // Most recently closed
    let repo_0 =
        mk_repo(Some(Timestamp::from_second(FST_SECOND).unwrap()), "0");
    let repo_1 =
        mk_repo(Some(Timestamp::from_second(FST_SECOND - 1).unwrap()), "0");
    let time_2 = Timestamp::from_second(FST_SECOND - 2).unwrap();
    let repo_2 = mk_repo(Some(time_2), "0");
    let repo_3 = mk_repo(Some(time_2), "1");
    let repo_4 =
        mk_repo(Some(Timestamp::from_second(FST_SECOND - 3).unwrap()), "0");
    let repo_5 = mk_repo(None, "3");
    let repo_6 = mk_repo(None, "4");
    // Construct in random order
    let repos = Projects::from_iter([
        repo_3.clone(),
        repo_1.clone(),
        repo_6.clone(),
        repo_4.clone(),
        repo_2.clone(),
        repo_0.clone(),
        repo_5.clone(),
    ]);
    itertools::assert_equal(
        repos,
        [repo_0, repo_1, repo_2, repo_3, repo_4, repo_5, repo_6],
    );
}

File addition: mod.rs (----------)

[0.1]

pub mod dir;
mod state;
pub use state::{
    read_projects, rm_project, updated_closed_time_blocking, upsert_project,
    BlockingLockError, Project, Projects, ProjectsFileErr,
};

File addition: dir.rs (----------)

[0.1]

//! App directories shared between all Inflorescence apps.
use directories::ProjectDirs;
use std::path::PathBuf;
const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "Holonyte";
const APPLICATION: &str = "Inflorescence";
/// App config dir
pub fn config() -> PathBuf {
    projects_dir().config_dir().to_path_buf()
}
/// App config dir
pub fn data() -> PathBuf {
    projects_dir().config_dir().to_path_buf()
}
fn projects_dir() -> ProjectDirs {
    ProjectDirs::from(QUALIFIER, ORGANIZATION, APPLICATION).unwrap()
}

Insertion in libflorescence/src/repo.rs at line 41 [5.7]
[8.80]
[6.97]
```
const PIJUL_DIR: &str = ".pijul";
const GIT_DIR: &str = ".git";
```

Replacement in libflorescence/src/repo.rs at line 95 [5.7]

B:BD[24.658] → [28.214:238]

    InitFailed(String),

[24.658]

[31.149]

    InitFailed {
        err: String,
        switch_to_project_picker: bool,
    },

Replacement in libflorescence/src/repo.rs at line 298 [5.7]

B:BD[31.1655] → [31.1655:1733]

                let _ = msg_out_tx.send(MsgOut::InitFailed(err.to_string()));

[31.1655]

[31.1733]

                let _ = msg_out_tx.send(MsgOut::InitFailed {
                    err: err.to_string(),
                    switch_to_project_picker: false,
                });

Replacement in libflorescence/src/repo.rs at line 304 [5.7]

B:BD[31.1773] → [31.1773:1851]

                let _ = msg_out_tx.send(MsgOut::InitFailed(err.to_string()));

[31.1773]

[31.1851]

                let _ = msg_out_tx.send(MsgOut::InitFailed {
                    err: err.to_string(),
                    switch_to_project_picker: true,
                });

Insertion in libflorescence/src/repo.rs at line 348 [5.7]

[5.598]

[7.703]

pub fn is_pijul(dir: &Path) -> bool {
    dir.join(PIJUL_DIR).exists()
}
pub fn is_git(dir: &Path) -> bool {
    dir.join(GIT_DIR).exists()
}

Deletion in libflorescence/src/lib.rs at line 4 [2.1776]
∅:D[13.51] → [2.1777:1801]
B:BD[2.1776] → [2.1777:1801]
B:BD[2.1801] → [3.2551:2563]
```
#[cfg(feature = "std")]
pub mod fs;
```
Insertion in libflorescence/src/lib.rs at line 7 [2.1776]
[9.618]
[15.2130]
```
#[cfg(feature = "std")]
pub mod store;
```
Insertion in libflorescence/src/lib.rs at line 12 [2.1776]
[30.11271]
[21.680]
```
pub use terrors;
```
Insertion in libflorescence/Cargo.toml at line 86 [2.2396]
[17.4118]
[17.4118]
```
workspace = true
[dev-dependencies.itertools]
```
Replacement in inflorescence_view/src/view.rs at line 13 [12.12409]
B:BD[12.12615] → [24.3685:3719]
```
use libflorescence::{file, repo};
```
[12.12615]
[12.12641]
```
use libflorescence::{file, repo, store};
```
Replacement in inflorescence_view/src/view.rs at line 24 [12.12409]
B:BD[12.12705] → [12.12705:12726]
```
use std::path::Path;
```
[18.406]
[12.12726]
```
use std::path::{Path, PathBuf};
```
Replacement in inflorescence_view/src/view.rs at line 35 [12.12409]
B:BD[27.213] → [38.18853:18887]
```
    PickingRepo(dir_picker::Msg),
```
[27.213]
[37.24]
```
    PickingRepoDir(dir_picker::Msg),
```
Insertion in inflorescence_view/src/view.rs at line 41 [12.12409]
[29.434]
[25.404]
```
    OpenProject(PathBuf),
    PickNewProject,
```

Insertion in inflorescence_view/src/view.rs at line 64 [12.12409]

[38.18905]

        model::SubState::PickingProject(state) => {
            picking_project(state, *window_size, allowed_actions, report)
        }

Replacement in inflorescence_view/src/view.rs at line 68 [12.12409]

B:BD[38.18957] → [38.18957:19028]

            picking_repo(state, *window_size, allowed_actions, report)

[38.18957]

[38.19028]

            picking_repo_dir(state, *window_size, allowed_actions, report)

Replacement in inflorescence_view/src/view.rs at line 80 [12.12409]

B:BD[38.19237] → [38.19237:19258]

fn picking_repo<'a>(

[38.19237]

[38.19258]

fn picking_project<'a>(
    state: &'a model::PickingProject,
    window_size: iced::Size,
    allowed_actions: &'a [action::Binding],
    report: &'a report::Container,
) -> Element<'a, Msg, Theme> {
    let model::PickingProject {
        projects,
        is_blocking,
    } = state;
    let main = if let Some(projects) = projects {
        el(column([
            el(column([el(row([
                el(button(text("Find or create a new project"))
                    .on_press(Msg::PickNewProject)),
                el(text("or pick a known project below")),
            ])
            .spacing(SPACING)
            .align_y(alignment::Vertical::Center))])),
            el(column(projects.iter().map(
                |store::Project {
                     last_closed_time: _,
                     path,
                 }| {
                    el(button(text(format!("{}", path.to_string_lossy())))
                        .on_press_with(|| Msg::OpenProject(path.clone())))
                },
            ))),
        ])
        .spacing(SPACING))
    } else {
        el(text(if *is_blocking {
            "Waiting for a lock release on projects file..."
        } else {
            "Loading projects..."
        }))
    };
    let main = el(container(main).width(Length::Fill).height(Length::Fill));
    add_actions_and_report(None, main, window_size, allowed_actions, report)
}
fn picking_repo_dir<'a>(

Replacement in inflorescence_view/src/view.rs at line 133 [12.12409]
B:BD[38.19620] → [38.19620:19656]
```
            .map(Msg::PickingRepo),
```
[38.19620]
[38.19656]
```
            .map(Msg::PickingRepoDir),
```
Replacement in inflorescence_model/src/model.rs at line 7 [27.3550]
B:BD[27.3667] → [27.3667:3693]
```
use libflorescence::repo;
```
[27.3667]
[27.3693]
```
use libflorescence::{repo, store};
```
Insertion in inflorescence_model/src/model.rs at line 42 [27.3550]
[38.3592120]
[38.3592120]
```
    PickingProject(PickingProject),
```

Insertion in inflorescence_model/src/model.rs at line 48 [27.3550]

[38.3592208]

pub struct PickingProject {
    pub is_blocking: bool,
    pub projects: Option<store::Projects>,
}
#[derive(Debug)]

Insertion in inflorescence_model/src/action.rs at line 150 [25.3501]

[36.532805]

            model::SubState::PickingProject(_sub) =>
            // TODO
            {
                vec![]
            }

Deletion in inflorescence_iced_widget/src/dir_picker.rs at line 18 [38.1]
B:BD[38.513] → [38.513:578]
```
const PIJUL_DIR: &str = ".pijul";
const GIT_DIR: &str = ".git";
```

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 124 [38.1]

[38.3852]

                    Task::none()
                } else if input.len() > state.input.len()
                    && (is_pijul(state.current_dir.as_path())
                        || is_git(state.current_dir.as_path()))
                {
                    // Ignore any input if we're already inside a repo path

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 387 [38.1]

[38.13287]

        } else if is_pijul(current_dir.as_path()) {
            "This is a Pijul repository"
        } else if is_git(current_dir.as_path()) {
            "This is a Git repository"

Replacement in inflorescence_iced_widget/src/dir_picker.rs at line 506 [38.1]

B:BD[38.17115] → [38.17115:17198]

                    if let Ok(true) = fs::try_exists(path.join(PIJUL_DIR)).await {

[38.17115]

[38.17198]

                    if is_pijul(&path) {

Replacement in inflorescence_iced_widget/src/dir_picker.rs at line 509 [38.1]

B:BD[38.17275] → [38.17275:17361]

                    else if let Ok(true) = fs::try_exists(path.join(GIT_DIR)).await {

[38.17275]

[38.17361]

                    else if is_git(&path) {

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 552 [38.1]

[38.18535]

fn is_pijul(dir: &Path) -> bool {
    dir.join(PIJUL_DIR).exists()
}
fn is_git(dir: &Path) -> bool {
    dir.join(GIT_DIR).exists()
}
const PIJUL_DIR: &str = ".pijul";
const GIT_DIR: &str = ".git";

Replacement in inflorescence/src/main.rs at line 17 [2.2763]
B:BD[10.431] → [10.431:469]
```
use libflorescence::{identity, repo};
```
[10.431]
[4.1024]
```
use libflorescence::{identity, repo, store, terrors};
```

Insertion in inflorescence/src/main.rs at line 101 [2.2763]

[38.3609686]

    LoadedProjects(Result<store::Projects, store::ProjectsFileErr>),
    StoredProjects(Result<(), store::ProjectsFileErr>),

Replacement in inflorescence/src/main.rs at line 117 [2.2763]

∅:D[20.2443] → [15.4279:4310]

∅:D[18.4706] → [15.4279:4310]

B:BD[14.5554] → [15.4279:4310]

∅:D[15.4310] → [14.5554:5578]

B:BD[14.5554] → [14.5554:5578]

B:BD[14.5613] → [14.5613:5689]

    // TODO: `include_bytes!`?
    let set_icon_task =
        task::window_set_icon(window_id, PathBuf::from("assets/icon.png"));

[20.2443]

[6.5475]

    let set_icon_task = task::window_set_icon(
        window_id,
        include_bytes!("../../assets/icon.png").to_vec(),
    );

Replacement in inflorescence/src/main.rs at line 131 [2.2763]
B:BD[38.3610069] → [38.3610069:3610103]
```
        let tasks = Task::batch([
```
[38.3610069]
[38.3610103]
```
        let task = Task::batch([
```
Replacement in inflorescence/src/main.rs at line 151 [2.2763]
B:BD[38.3610568] → [38.3610568:3610587]
```
            tasks,
```
[38.3610568]
[38.3610587]
```
            task,
```

Replacement in inflorescence/src/main.rs at line 154 [2.2763]

B:BD[38.3610610] → [38.3610610:3611062]

        let start_path = env::home_dir().unwrap_or_else(|| PathBuf::from("/"));
        let (picker, picker_task) = dir_picker::init(start_path);
        let tasks = Task::batch([
            open_window_task.map(|_id| Msg::NoOp),
            set_icon_task,
            picker_task.map(view::Msg::PickingRepo).map(Msg::View),
        ]);
        let state = model::PickingRepoDir { picker };
        let sub = model::SubState::PickingRepoDir(state);

[38.3610610]

[38.3611062]

        let (sub, projects_task) = init_picking_project();

Insertion in inflorescence/src/main.rs at line 163 [2.2763]

[38.3611247]


        let task = Task::batch([
            open_window_task.map(|_id| Msg::NoOp),
            set_icon_task,
            projects_task,
        ]);

Replacement in inflorescence/src/main.rs at line 174 [2.2763]
B:BD[38.3611352] → [38.3611352:3611371]
```
            tasks,
```
[38.3611352]
[38.3611371]
```
            task,
```

Insertion in inflorescence/src/main.rs at line 177 [2.2763]

[38.3611387]

}
fn init_picking_project() -> (model::SubState, Task<Msg>) {
    let read_projects_task = Task::perform(
        async { store::read_projects().await },
        Msg::LoadedProjects,
    );
    let state = model::PickingProject {
        is_blocking: false,
        projects: None,
    };
    let sub = model::SubState::PickingProject(state);
    (sub, read_projects_task)

Insertion in inflorescence/src/main.rs at line 191 [2.2763]

[38.3611389]


fn init_picking_repo_dir() -> (model::PickingRepoDir, Task<Msg>) {
    let start_path = env::home_dir().unwrap_or_else(|| PathBuf::from("/"));
    let (picker, picker_task) = dir_picker::init(start_path);

Insertion in inflorescence/src/main.rs at line 196 [2.2763]

[38.3611390]

    let model = model::PickingRepoDir { picker };
    let task = Task::batch([picker_task
        .map(view::Msg::PickingRepoDir)
        .map(Msg::View)]);
    (model, task)
}

Replacement in inflorescence/src/main.rs at line 244 [2.2763]

B:BD[38.3612123] → [38.3612123:3612186]

                    update_picking_repo_from_view(model, msg);

[38.3612123]

[38.3612186]

                    update_picking_repo_dir_from_view(model, msg);

Insertion in inflorescence/src/main.rs at line 263 [2.2763]

[38.3612910]

            model::SubState::PickingProject(model) => {
                let (task, new_sub_state, managing_repo) =
                    update_picking_project_from_view(model, msg);
                if let Some(new_sub) = new_sub_state {
                    if let model::SubState::ManagingRepo(_) = new_sub {
                        state.managing_repo = Some(
                            managing_repo.expect("managing_repo is required"),
                        );
                    }
                    state.model.sub = new_sub;
                }
                task
            }

Replacement in inflorescence/src/main.rs at line 282 [2.2763]

B:BD[38.3613220] → [38.3613220:3613343]

                update_managing_repo(sub, model, &mut state.model.report, msg)
                    .map(Msg::ManagingRepo)

[38.3613220]

[38.3613343]

                let (task, new_state) = update_managing_repo(
                    sub,
                    model,
                    &mut state.model.report,
                    msg,
                );
                if let Some(new_state) = new_state {
                    state.model.sub = new_state;
                }
                task

Insertion in inflorescence/src/main.rs at line 296 [2.2763]

[38.3613417]

        Msg::LoadedProjects(result) => match result {
            Ok(projects) => {
                if projects.is_empty() {
                    // Move on to dir picker
                    let (model, task) = init_picking_repo_dir();
                    let sub = model::SubState::PickingRepoDir(model);
                    state.model.sub = sub;
                    task
                } else {
                    if let model::SubState::PickingProject(sub) =
                        &mut state.model.sub
                    {
                        sub.projects = Some(projects);
                    }
                    Task::none()
                }
            }
            Err(err) => {
                if let model::SubState::PickingProject(sub) =
                    &mut state.model.sub
                {
                    match err.as_enum() {
                        terrors::E2::A(store::BlockingLockError) => {
                            sub.is_blocking = true;
                            // retry
                            Task::perform(
                                async { store::read_projects().await },
                                Msg::LoadedProjects,
                            )
                        }
                        _ => {
                            let msg = format!(
                                "Failed to read projects from store: {err:?}"
                            );
                            report::show_err(&mut state.model.report, msg);
                            Task::none()
                        }
                    }
                } else {
                    Task::none()
                }
            }
        },
        Msg::StoredProjects(result) => match result {
            Ok(()) => Task::none(),
            Err(err) => {
                let msg = format!("Failed to write projects to store: {err:?}");
                report::show_err(&mut state.model.report, msg);
                Task::none()
            }
        },

Insertion in inflorescence/src/main.rs at line 354 [2.2763]

[38.3613492]

fn update_picking_project_from_view(
    _model: &mut model::PickingProject,
    msg: view::Msg,
) -> (Task<Msg>, Option<model::SubState>, Option<ManagingRepo>) {
    let mut new_state = None;
    let mut new_managing_repo = None;
    let task = match msg {
        view::Msg::Action(_msg) => todo!(),
        view::Msg::OpenProject(dir) => {
            let (sub, managing_repo, managing_repo_task) =
                init_managing_repo(dir);
            new_state = Some(model::SubState::ManagingRepo(sub));
            new_managing_repo = Some(managing_repo);
            managing_repo_task
        }
        view::Msg::PickNewProject => {
            let (model, task) = init_picking_repo_dir();
            new_state = Some(model::SubState::PickingRepoDir(model));
            task
        }
        view::Msg::PickingRepoDir(_)
        | view::Msg::EditRecordMsg(_)
        | view::Msg::EditRecordDesc(_)
        | view::Msg::EditForkChannelName(_)
        | view::Msg::UnfilteredSelection(_)
        | view::Msg::ToRecord(_) => Task::none(),
    };
    (task, new_state, new_managing_repo)
}

Replacement in inflorescence/src/main.rs at line 389 [2.2763]

B:BD[38.3613646] → [38.3613646:3613691]

) -> Task<ManagingRepoMsg> {
    match msg {

[38.3613646]

[38.3613691]

) -> (Task<Msg>, Option<model::SubState>) {
    let mut new_state = None;
    let task = match msg {

Replacement in inflorescence/src/main.rs at line 428 [2.2763]

B:BD[6.6908] → [38.3614731:3614787]

            update_from_repo(state, model, report, msg)

[6.6908]

[20.3737]

            let (task, state) = update_from_repo(state, model, report, msg);
            new_state = state;
            task

Replacement in inflorescence/src/main.rs at line 432 [2.2763]

B:BD[20.3747] → [38.3614788:3614864]

        ManagingRepoMsg::File(msg) => update_file(state, model, msg),
    }

[20.3747]

[26.58438]

        ManagingRepoMsg::File(msg) => {
            update_file(state, model, msg).map(Msg::ManagingRepo)
        }
    };
    (task, new_state)

Insertion in inflorescence/src/main.rs at line 504 [2.2763]

[38.3615175]

[18.5203]

        }
        window::Event::Closed => {
            if let model::SubState::ManagingRepo(sub) = &model.sub
                && let model::ManagingRepoSubState::Ready(_) = &sub.sub
            {
                let _ =
                    store::updated_closed_time_blocking(sub.repo_path.clone());
            }

Replacement in inflorescence/src/main.rs at line 513 [2.2763]

B:BD[18.5213] → [18.5213:5277]

        window::Event::Closed
        | window::Event::Moved(_)

[18.5213]

[18.5277]

        window::Event::Moved(_)

Replacement in inflorescence/src/main.rs at line 541 [2.2763]
B:BD[12.26301] → [38.3615284:3615318]
```
fn update_picking_repo_from_view(
```
[12.26301]
[38.3615318]
```
fn update_picking_repo_dir_from_view(
```
Replacement in inflorescence/src/main.rs at line 556 [2.2763]
B:BD[38.3615749] → [38.3615749:3615790]
```
        view::Msg::PickingRepo(msg) => {
```
[38.3615749]
[38.3615790]
```
        view::Msg::PickingRepoDir(msg) => {
```

Replacement in inflorescence/src/main.rs at line 558 [2.2763]

B:BD[38.3615856] → [38.3615856:3615928]

            let task = task.map(view::Msg::PickingRepo).map(Msg::View);

[38.3615856]

[38.3615928]

            let dir_picker_task =
                task.map(view::Msg::PickingRepoDir).map(Msg::View);

Insertion in inflorescence/src/main.rs at line 564 [2.2763]

[38.3616200]

                let project = store::Project {
                    last_closed_time: cmp::Reverse(None),
                    path: dir.clone(),
                };
                let store_project_task = if repo::is_pijul(&project.path) {
                    Task::perform(
                        async move { store::upsert_project(project).await },
                        Msg::StoredProjects,
                    )
                } else {
                    Task::none()
                };

Replacement in inflorescence/src/main.rs at line 579 [2.2763]

B:BD[38.3616364] → [38.3616364:3616420]

                Task::batch([task, managing_repo_task])

[38.3616364]

[38.3616420]

                Task::batch([
                    dir_picker_task,
                    managing_repo_task,
                    store_project_task,
                ])

Replacement in inflorescence/src/main.rs at line 585 [2.2763]
B:BD[38.3616441] → [38.3616441:3616462]
```
                task
```
[38.3616441]
[38.3616462]
```
                dir_picker_task
```

Replacement in inflorescence/src/main.rs at line 591 [2.2763]

B:BD[38.3616605] → [38.3616605:3616655]

        | view::Msg::ToRecord(_) => Task::none(),

[38.3616605]

[38.3616655]

        | view::Msg::ToRecord(_)
        | view::Msg::OpenProject(_)
        | view::Msg::PickNewProject => Task::none(),

Replacement in inflorescence/src/main.rs at line 660 [2.2763]

B:BD[29.17224] → [38.3617417:3617468]

        view::Msg::PickingRepo(_) => Task::none(),

[29.17224]

[25.25472]

        view::Msg::PickingRepoDir(_)
        | view::Msg::OpenProject(_)
        | view::Msg::PickNewProject => Task::none(),

Replacement in inflorescence/src/main.rs at line 1132 [2.2763]

B:BD[38.3620508] → [38.3620508:3620647]

∅:D[38.3620647] → [33.7961:7989]

B:BD[33.7961] → [33.7961:7989]

B:BD[33.7989] → [38.3620648:3620756]

∅:D[38.3620756] → [28.12034:12063]

B:BD[28.12034] → [28.12034:12063]

∅:D[28.12063] → [16.932:948]

B:BD[16.932] → [16.932:948]

B:BD[16.948] → [38.3620757:3620910]

) -> Task<ManagingRepoMsg> {
    let report_info = |report: &mut report::Container, err: String| {
        report::show_info(report, err);
        Task::none()
    };
    let report_err = |report: &mut report::Container, err: String| {
        report::show_err(report, err);
        Task::none()
    };
    match msg {
        repo::MsgOut::Init(repo) => repo_init(state, model, report, repo),
        repo::MsgOut::InitFailed(err) => report_err(report, err.to_string()),

[38.3620508]

[31.5679]

) -> (Task<Msg>, Option<model::SubState>) {
    let mut new_state = None;
    let task = match msg {
        repo::MsgOut::Init(repo) => {
            repo_init(state, model, report, repo).map(Msg::ManagingRepo)
        }
        repo::MsgOut::InitFailed {
            err,
            switch_to_project_picker,
        } => {
            report::show_err(report, err);
            if switch_to_project_picker {
                let (sub, projects_task) = init_picking_project();
                new_state = Some(sub);
                projects_task
            } else {
                Task::none()
            }
        }

Replacement in inflorescence/src/main.rs at line 1152 [2.2763]

B:BD[31.5721] → [38.3620911:3621041]

            report_err(report, "Task managing repo has crashed. This shouldn't happen, please report what happened!".to_string())

[31.5721]

[31.5850]

            report::show_err(report, "Task managing repo has crashed. This shouldn't happen, please report what happened!".to_string());
            Task::none()

Insertion in inflorescence/src/main.rs at line 1161 [2.2763]
[38.3621116]
[28.12273]
```
                    .map(Msg::ManagingRepo)
```

Replacement in inflorescence/src/main.rs at line 1163 [2.2763]

B:BD[28.12287] → [38.3621117:3621178]

            Err(err) => report_err(report, err.to_string()),

[28.12287]

[28.12347]

            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1170 [2.2763]

B:BD[28.12473] → [38.3621179:3621240]

            Err(err) => report_err(report, err.to_string()),

[28.12473]

[28.12533]

            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1177 [2.2763]

B:BD[28.12654] → [38.3621241:3621302]

            Err(err) => report_err(report, err.to_string()),

[28.12654]

[28.12714]

            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1183 [2.2763]

B:BD[28.12795] → [38.3621303:3621432]

            Ok(diffs) => repo_got_change_diffs(model, hash, diffs),
            Err(err) => report_err(report, err.to_string()),

[28.12795]

[28.12923]

            Ok(diffs) => {
                repo_got_change_diffs(model, hash, diffs).map(Msg::ManagingRepo)
            }
            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1192 [2.2763]

B:BD[28.12992] → [38.3621433:3621545]

            Ok(log) => got_entire_log(model, log),
            Err(err) => report_err(report, err.to_string()),

[28.12992]

[28.13103]

            Ok(log) => got_entire_log(model, log).map(Msg::ManagingRepo),
            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1199 [2.2763]

B:BD[28.13190] → [38.3621546:3621677]

            Ok(log) => loaded_other_channel_log(model, channel, log),
            Err(err) => report_err(report, err.to_string()),

[28.13190]

[31.5921]

            Ok(log) => loaded_other_channel_log(model, channel, log)
                .map(Msg::ManagingRepo),
            Err(err) => {
                report::show_err(report, err.to_string());
                Task::none()
            }

Replacement in inflorescence/src/main.rs at line 1207 [2.2763]

B:BD[33.8044] → [33.8044:8082]

B:BD[33.8082] → [38.3621678:3621931]

            let task = match result {
                Ok(()) => report_info(report, format!("Pushed to {channel}")),
                Err(repo::PushError::Empty) => report_info(report, format!("Nothing to push to {channel}")),
                Err(err) => report_err(report, err.to_string()),

[33.8044]

[33.8332]

            match result {
                Ok(()) => {
                    report::show_info(report, format!("Pushed to {channel}"))
                }
                Err(repo::PushError::Empty) => report::show_info(
                    report,
                    format!("Nothing to push to {channel}"),
                ),
                Err(err) => report::show_err(report, err.to_string()),

Replacement in inflorescence/src/main.rs at line 1217 [2.2763]

B:BD[33.8347] → [33.8347:8399]

B:BD[33.8399] → [38.3621932:3621975]

∅:D[38.3621975] → [33.8453:8524]

B:BD[33.8453] → [33.8453:8524]

            if let Some(ReadyState {  jobs, .. }) =
                model::is_ready_mut(model)
            {
                jobs.swap_remove(&Job::Push{ channel });

[33.8347]

[33.8524]

            if let Some(ReadyState { jobs, .. }) = model::is_ready_mut(model) {
                jobs.swap_remove(&Job::Push { channel });

Replacement in inflorescence/src/main.rs at line 1220 [2.2763]

B:BD[33.8538] → [33.8538:8555]

∅:D[33.8555] → [28.13320:13331]

B:BD[28.13320] → [28.13320:13331]

B:BD[28.13331] → [33.8556:8647]

B:BD[33.8647] → [38.3621976:3622233]

            task
        },
        repo::MsgOut::Pulled { channel, result } =>{
            let task = match result {
                Ok(()) => report_info(report, format!("Pulled from {channel}")),
                Err(repo::PullError::Empty) => report_info(report, format!("Nothing to pull from {channel}")),
                Err(err) => report_err(report, err.to_string()),

[33.8538]

[33.8901]

            Task::none()
        }
        repo::MsgOut::Pulled { channel, result } => {
            match result {
                Ok(()) => {
                    report::show_info(report, format!("Pulled from {channel}"))
                }
                Err(repo::PullError::Empty) => report::show_info(
                    report,
                    format!("Nothing to pull from {channel}"),
                ),
                Err(err) => report::show_err(report, err.to_string()),

Replacement in inflorescence/src/main.rs at line 1233 [2.2763]

B:BD[33.8916] → [33.8916:8968]

B:BD[33.8968] → [38.3622234:3622277]

∅:D[38.3622277] → [33.9022:9093]

B:BD[33.9022] → [33.9022:9093]

            if let Some(ReadyState {  jobs, .. }) =
                model::is_ready_mut(model)
            {
                jobs.swap_remove(&Job::Pull{ channel });

[33.8916]

[33.9093]

            if let Some(ReadyState { jobs, .. }) = model::is_ready_mut(model) {
                jobs.swap_remove(&Job::Pull { channel });

Replacement in inflorescence/src/main.rs at line 1236 [2.2763]
B:BD[33.9107] → [33.9107:9124]
∅:D[33.9124] → [32.10296:10307]
B:BD[32.10296] → [32.10296:10307]
∅:D[32.10307] → [16.1200:1206]
∅:D[28.13331] → [16.1200:1206]
∅:D[22.47201] → [16.1200:1206]
∅:D[24.86593] → [16.1200:1206]
B:BD[16.1200] → [16.1200:1206]
```
            task
        },
    }
```
[33.9107]
[16.1206]
```
            Task::none()
        }
    };
    (task, new_state)
```

Replacement in inflorescence/src/main.rs at line 1613 [2.2763]

B:BD[34.679] → [34.679:742]

        let msg = format!("Error loading .ignore file {err}");

[34.679]

[34.742]

        let msg = format!("Error loading .ignore file {err:?}");

Replacement in inflorescence/src/main.rs at line 2042 [2.2763]

B:BD[38.3625902] → [38.3625902:3625962]

        model::SubState::PickingRepoDir(_picking_repo) => {

[38.3625902]

[38.3625962]

        model::SubState::PickingRepoDir(_model) => {

Insertion in inflorescence/src/main.rs at line 2049 [2.2763]
[38.3626217]
[38.3626217]
```
        model::SubState::PickingProject(_model) => Subscription::none(),
```
Deletion in iced_utils/src/task/wrappers.rs at line 10 [14.3643]
B:BD[23.160] → [23.160:184]
```
use std::path::PathBuf;
```

Replacement in iced_utils/src/task/wrappers.rs at line 138 [14.3643]

B:BD[14.4308] → [14.4308:4383]

pub fn window_set_icon<T>(window_id: window::Id, path: PathBuf) -> Task<T>

[14.4308]

[14.4383]

pub fn window_set_icon<T>(window_id: window::Id, icon_bytes: Vec<u8>) -> Task<T>

Deletion in iced_utils/src/task/wrappers.rs at line 146 [14.3643]
B:BD[14.4569] → [38.3636856:3636919]
```
        let icon_bytes = tokio::fs::read(path).await.unwrap();
```

Replacement in iced_utils/src/task/wrappers.rs at line 147 [14.3643]

B:BD[38.3636993] → [38.3636993:3637015]

            .unwrap()

[38.3636993]

[38.3637015]

            .unwrap_or_else(|err| {
                panic!("unable to decode PNG icon bytes: {err:?}",)
            })

Replacement in iced_utils/src/task/wrappers.rs at line 155 [14.3643]
B:BD[14.4878] → [14.4878:4913]
```
        let _ = (window_id, path);
```
[14.4878]
[14.4913]
```
        let _ = (window_id, icon_bytes);
```
Insertion in Cargo.lock at line 3017 [2.4495]
[35.496306]
[19.3965]
```
 "itertools",
```

add projects picker

Dependencies

In channels

Change contents

File deletion: fs

File deletion: dir.rs, dir.rs, dir.rs, dir.rs

File deletion: mod.rs, mod.rs, mod.rs

File deletion: state.rs, state.rs, state.rs

File addition: store (d--x------)

File addition: state.rs (----------)

File addition: state (d--x------)

File addition: test.rs (----------)

File addition: mod.rs (----------)

File addition: dir.rs (----------)

Insertion in libflorescence/src/repo.rs at line 41 [5.7]

Replacement in libflorescence/src/repo.rs at line 95 [5.7]

Replacement in libflorescence/src/repo.rs at line 298 [5.7]

Replacement in libflorescence/src/repo.rs at line 304 [5.7]

Insertion in libflorescence/src/repo.rs at line 348 [5.7]

Deletion in libflorescence/src/lib.rs at line 4 [2.1776]

Insertion in libflorescence/src/lib.rs at line 7 [2.1776]

Insertion in libflorescence/src/lib.rs at line 12 [2.1776]

Insertion in libflorescence/Cargo.toml at line 86 [2.2396]

Replacement in inflorescence_view/src/view.rs at line 13 [12.12409]

Replacement in inflorescence_view/src/view.rs at line 24 [12.12409]

Replacement in inflorescence_view/src/view.rs at line 35 [12.12409]

Insertion in inflorescence_view/src/view.rs at line 41 [12.12409]

Insertion in inflorescence_view/src/view.rs at line 64 [12.12409]

Replacement in inflorescence_view/src/view.rs at line 68 [12.12409]

Replacement in inflorescence_view/src/view.rs at line 80 [12.12409]

Replacement in inflorescence_view/src/view.rs at line 133 [12.12409]

Replacement in inflorescence_model/src/model.rs at line 7 [27.3550]

Insertion in inflorescence_model/src/model.rs at line 42 [27.3550]

Insertion in inflorescence_model/src/model.rs at line 48 [27.3550]

Insertion in inflorescence_model/src/action.rs at line 150 [25.3501]

Deletion in inflorescence_iced_widget/src/dir_picker.rs at line 18 [38.1]

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 124 [38.1]

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 387 [38.1]

Replacement in inflorescence_iced_widget/src/dir_picker.rs at line 506 [38.1]

Replacement in inflorescence_iced_widget/src/dir_picker.rs at line 509 [38.1]

Insertion in inflorescence_iced_widget/src/dir_picker.rs at line 552 [38.1]

Replacement in inflorescence/src/main.rs at line 17 [2.2763]

Insertion in inflorescence/src/main.rs at line 101 [2.2763]

Replacement in inflorescence/src/main.rs at line 117 [2.2763]

Replacement in inflorescence/src/main.rs at line 131 [2.2763]

Replacement in inflorescence/src/main.rs at line 151 [2.2763]

Replacement in inflorescence/src/main.rs at line 154 [2.2763]

Insertion in inflorescence/src/main.rs at line 163 [2.2763]

Replacement in inflorescence/src/main.rs at line 174 [2.2763]

Insertion in inflorescence/src/main.rs at line 177 [2.2763]

Insertion in inflorescence/src/main.rs at line 191 [2.2763]

Insertion in inflorescence/src/main.rs at line 196 [2.2763]

Replacement in inflorescence/src/main.rs at line 244 [2.2763]

Insertion in inflorescence/src/main.rs at line 263 [2.2763]

Replacement in inflorescence/src/main.rs at line 282 [2.2763]

Insertion in inflorescence/src/main.rs at line 296 [2.2763]

Insertion in inflorescence/src/main.rs at line 354 [2.2763]

Replacement in inflorescence/src/main.rs at line 389 [2.2763]

Replacement in inflorescence/src/main.rs at line 428 [2.2763]

Replacement in inflorescence/src/main.rs at line 432 [2.2763]

Insertion in inflorescence/src/main.rs at line 504 [2.2763]

Replacement in inflorescence/src/main.rs at line 513 [2.2763]

Replacement in inflorescence/src/main.rs at line 541 [2.2763]

Replacement in inflorescence/src/main.rs at line 556 [2.2763]

Replacement in inflorescence/src/main.rs at line 558 [2.2763]

Insertion in inflorescence/src/main.rs at line 564 [2.2763]

Replacement in inflorescence/src/main.rs at line 579 [2.2763]

Replacement in inflorescence/src/main.rs at line 585 [2.2763]

Replacement in inflorescence/src/main.rs at line 591 [2.2763]

Replacement in inflorescence/src/main.rs at line 660 [2.2763]

Replacement in inflorescence/src/main.rs at line 1132 [2.2763]

Replacement in inflorescence/src/main.rs at line 1152 [2.2763]

Insertion in inflorescence/src/main.rs at line 1161 [2.2763]

Replacement in inflorescence/src/main.rs at line 1163 [2.2763]

Replacement in inflorescence/src/main.rs at line 1170 [2.2763]

Replacement in inflorescence/src/main.rs at line 1177 [2.2763]

Replacement in inflorescence/src/main.rs at line 1183 [2.2763]

Replacement in inflorescence/src/main.rs at line 1192 [2.2763]

Replacement in inflorescence/src/main.rs at line 1199 [2.2763]

Replacement in inflorescence/src/main.rs at line 1207 [2.2763]