tzemanovic/inflorescence - Change E7HE2UFTIOINUJQBRVCIG5GMANK6XWOYFX2ZHA73QJ6RW627G55QC

handle multiple or no pijul identity

Created by tzemanovic on March 6, 2026

E7HE2UFTIOINUJQBRVCIG5GMANK6XWOYFX2ZHA73QJ6RW627G55QC

Dependencies

In channels

main

Change contents

Replacement in libflorescence/src/identity.rs at line 8 [3.28]

B:BD[3.100] → [3.100:249]

pub fn load() -> Id {
    let all = Id::load_all().unwrap();
    // TODO: handle identity creation if none found
    all.into_iter().next().unwrap()

[3.100]

[3.249]

pub fn load() -> anyhow::Result<Vec<Id>> {
    Id::load_all()

Insertion in inflorescence_view/src/view.rs at line 13 [6.12409]
[16.266]
[6.12583]
```
use libflorescence::identity::Id;
```
Insertion in inflorescence_view/src/view.rs at line 45 [6.12409]
[21.13266]
[10.404]
```
    SelectIdentity(usize),
```

Replacement in inflorescence_view/src/view.rs at line 229 [6.12409]

B:BD[15.2045] → [20.20382:20426]

∅:D[20.20426] → [9.4062:4156]

B:BD[9.4062] → [9.4062:4156]

        ManagingRepoSubState::SelectingId {
            user_ids: _,
            user_selection_ix: _,
            user_selection_nav: _,

[15.2045]

[9.4156]

        ManagingRepoSubState::SelectingIdentity {
            ids,
            selection_ix,
            selection_nav,
            confirmed_selection_ix,

Replacement in inflorescence_view/src/view.rs at line 235 [6.12409]

B:BD[9.4177] → [9.4177:4199]

        } => todo!(),

[9.4177]

[20.20427]

        } => {
            let main = el(container(view_selecting_identity(
                ids,
                confirmed_selection_ix.unwrap_or_else(|| *selection_ix),
                selection_nav,
            ))
            .width(Length::Fill)
            .height(Length::Fill));
            add_actions_and_report(
                None,
                main,
                window_size,
                allowed_actions,
                report,
            )
        }

Insertion in inflorescence_view/src/view.rs at line 260 [6.12409]

[10.664]

[7.124]

        ManagingRepoSubState::NoIdFound { repo: _ } => {
            let main = el(container(text("No Pijul identity found. Create a new one in with Pijul CLI and then reload it here."))
                .width(Length::Fill)
                .height(Length::Fill));
            add_actions_and_report(
                None,
                main,
                window_size,
                allowed_actions,
                report,
            )
        }

Insertion in inflorescence_view/src/view.rs at line 280 [6.12409]

[8.3730]

[7.255]

}
fn view_selecting_identity<'a>(
    ids: &'a [Id],
    selection_ix: usize,
    selection_nav: &'a nav_scrollable::State,
) -> Element<'a, Msg, Theme> {
    el(column([
        el(text("Select identity:")),
        el(nav_scrollable(
            selection_nav,
            ids.iter().enumerate().map(|(ix, id)| {
                el(button(text(id.name.to_string()))
                    .on_press(Msg::SelectIdentity(ix))
                    .class(if ix == selection_ix {
                        theme::Button::Selected
                    } else {
                        theme::Button::Normal
                    }))
            }),
        )),
    ]))

Replacement in inflorescence_view/src/view/test.rs at line 50 [26.4223]
∅:D[20.21578] → [18.106:132]
B:BD[18.106] → [18.106:132]
```
        user_ids: vec![],
```
[20.21578]
[18.132]
```
        user_ids: None,
```

Replacement in inflorescence_model/src/model.rs at line 99 [12.3550]

B:BD[12.4561] → [12.4561:4588]

        user_ids: Vec<Id>,

[12.4561]

[12.4588]

        user_ids: Option<Vec<Id>>,
        repo: Option<repo::State>,
    },
    SelectingIdentity {
        ids: Vec<Id>,
        selection_ix: usize,
        selection_nav: nav_scrollable::State,
        // This will be set if confirmed before a repo is loaded
        confirmed_selection_ix: Option<usize>,

Replacement in inflorescence_model/src/model.rs at line 110 [12.3550]

B:BD[12.4630] → [12.4630:4760]

    SelectingId {
        user_ids: Vec<Id>,
        user_selection_ix: usize,
        user_selection_nav: nav_scrollable::State,

[12.4630]

[12.4760]

    NoIdFound {

Insertion in inflorescence_model/src/action.rs at line 58 [10.3501]
[19.532010]
[10.4320]
```
    ReloadIdentity,
```
Insertion in inflorescence_model/src/action.rs at line 121 [10.3501]
[19.532079]
[10.5127]
```
        (ReloadIdentity, ReloadIdentity) => true,
```
Insertion in inflorescence_model/src/action.rs at line 143 [10.3501]
[19.532119]
[10.5587]
```
        (ReloadIdentity, _) => false,
```

Replacement in inflorescence_model/src/action.rs at line 460 [10.3501]

B:BD[20.3593292] → [20.3593292:3593360]

        model::ManagingRepoSubState::SelectingId { .. } => todo!(),

[20.3593292]

[20.3593360]

        model::ManagingRepoSubState::SelectingIdentity { .. } => {
            vec![confirm("confirm"), down(), up()]
        }

Insertion in inflorescence_model/src/action.rs at line 466 [10.3501]

[20.3593474]

        model::ManagingRepoSubState::NoIdFound { .. } => vec![Binding {
            keys_str: "r",
            keys: ModKeys::One(ModKey {
                key: Key::Character("r".into()),
                mods: Mods::NONE,
            }),
            label: "Reload identity",
            msg: Some(FilteredMsg::ReloadIdentity),
        }],

Replacement in inflorescence/src/test.rs at line 58 [27.2521]

B:BD[20.3594608] → [20.3594608:3594686]

            && matches!(msg, Msg::ManagingRepo(ManagingRepoMsg::LoadedId(_)))

[20.3594608]

[20.3594686]

            && matches!(
                msg,
                Msg::ManagingRepo(ManagingRepoMsg::LoadedIdentities(_))
            )

Replacement in inflorescence/src/main.rs at line 112 [28.2763]
∅:D[20.3609729] → [14.2018:2041]
B:BD[14.2018] → [14.2018:2041]
```
    LoadedId(Box<Id>),
```
[20.3609729]
[14.2061]
```
    LoadedIdentities(anyhow::Result<Vec<Id>>),
```
Replacement in inflorescence/src/main.rs at line 221 [28.2763]
B:BD[2.1997] → [3.531:639]
B:BD[3.639] → [20.3611492:3611540]
∅:D[4.4572] → [3.669:677]
∅:D[6.25685] → [3.669:677]
∅:D[20.3611540] → [3.669:677]
B:BD[3.669] → [3.669:677]
```
    let load_id_task = Task::future(async {
        let id = spawn_blocking(identity::load).await.unwrap();
        ManagingRepoMsg::LoadedId(Box::new(id))
    });
```
[2.1997]
[5.2126]
```
    let load_ids_task = load_identities_task();
```
Replacement in inflorescence/src/main.rs at line 227 [28.2763]
B:BD[20.3611583] → [20.3611583:3611628]
```
        load_id_task.map(Msg::ManagingRepo),
```
[20.3611583]
[20.3611628]
```
        load_ids_task.map(Msg::ManagingRepo),
```
Replacement in inflorescence/src/main.rs at line 243 [28.2763]
∅:D[20.3611788] → [10.23669:23703]
B:BD[10.23669] → [10.23669:23703]
```
            user_ids: Vec::new(),
```
[20.3611788]
[10.23703]
```
            user_ids: None,
```

Replacement in inflorescence/src/main.rs at line 469 [28.2763]

B:BD[23.4852] → [23.4852:4920]

            | action::FilteredMsg::EnterSubMenu(_) => Task::none(),

[23.4852]

[23.4920]

            | action::FilteredMsg::EnterSubMenu(_)
            | action::FilteredMsg::ReloadIdentity => Task::none(),

Replacement in inflorescence/src/main.rs at line 489 [28.2763]

B:BD[21.21457] → [21.21457:21507]

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

[21.21457]

[21.21507]

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

Replacement in inflorescence/src/main.rs at line 573 [28.2763]

∅:D[21.21660] → [20.3613691:3613846]

B:BD[20.3613691] → [20.3613691:3613846]

∅:D[10.23975] → [9.80169:80301]

∅:D[20.3613846] → [9.80169:80301]

B:BD[9.80169] → [9.80169:80301]

        ManagingRepoMsg::LoadedId(id) => {
            match &mut model.sub {
                model::ManagingRepoSubState::Loading { user_ids, repo } => {
                    // TODO switch to `SelectingId` if more than one id found
                    if let Some(repo) = repo.take() {

[21.21660]

[20.3613847]

        ManagingRepoMsg::LoadedIdentities(ids) => {
            match ids {
                Ok(mut user_ids) => {
                    let get_repo = |sub: &mut model::ManagingRepoSubState| {
                        match sub {
                            model::ManagingRepoSubState::Loading {
                                repo,
                                ..
                            } => repo.take(),
                            model::ManagingRepoSubState::SelectingIdentity {
                                repo,
                                ..
                            } => repo.take(),
                            model::ManagingRepoSubState::NoIdFound { repo } => {
                                repo.take()
                            }
                            model::ManagingRepoSubState::Ready(_) => {
                                unreachable!()
                            }
                        }
                    };
                    if user_ids.is_empty() {
                        let repo = get_repo(&mut model.sub);

Replacement in inflorescence/src/main.rs at line 597 [28.2763]

B:BD[20.3613883] → [20.3613883:3614005]

                            model::ManagingRepoSubState::Ready(ReadyState {
                                user_id: *id,

[20.3613883]

[20.3614005]

                            model::ManagingRepoSubState::NoIdFound { repo }
                    } else if user_ids.len() == 1 {
                        let user_id = user_ids.pop().unwrap();
                        match &mut model.sub {
                            model::ManagingRepoSubState::Loading {
                                user_ids,

Replacement in inflorescence/src/main.rs at line 604 [28.2763]

B:BD[20.3614043] → [20.3614043:3614459]

                                selection: default(),
                                navigation: default(),
                                record_changes: default(),
                                forking_channel_name: default(),
                                logs: default(),
                                to_record: default(),
                                jobs: default(),
                            })

[20.3614043]

[9.80732]

                            } => {
                                if let Some(repo) = repo.take() {
                                    model.sub =
                                        model::ManagingRepoSubState::Ready(
                                            ReadyState {
                                                user_id,
                                                repo,
                                                selection: default(),
                                                navigation: default(),
                                                record_changes: default(),
                                                forking_channel_name: default(),
                                                logs: default(),
                                                to_record: default(),
                                                jobs: default(),
                                            },
                                        )
                                } else {
                                    *user_ids = Some(vec![user_id]);
                                }
                            }
                            model::ManagingRepoSubState::SelectingIdentity {
                                ..
                            } => {
                                unreachable!()
                            }
                            model::ManagingRepoSubState::Ready(..) => {
                                unreachable!()
                            }
                            model::ManagingRepoSubState::NoIdFound {
                                repo,
                            } => {
                                if let Some(repo) = repo.take() {
                                    model.sub =
                                        model::ManagingRepoSubState::Ready(
                                            ReadyState {
                                                user_id,
                                                repo,
                                                selection: default(),
                                                navigation: default(),
                                                record_changes: default(),
                                                forking_channel_name: default(),
                                                logs: default(),
                                                to_record: default(),
                                                jobs: default(),
                                            },
                                        )
                                } else {
                                    model.sub = model::ManagingRepoSubState::SelectingIdentity {
                                        ids: user_ids,
                                        selection_ix: default(),
                                        selection_nav: default(),
                                        confirmed_selection_ix: default(),
                                        repo: default(),
                                    };
                                }
                            }
                        }

Replacement in inflorescence/src/main.rs at line 662 [28.2763]

B:BD[9.80761] → [9.80761:80805]

                        user_ids.push(*id);

[9.80761]

[9.80805]

                        let repo = get_repo(&mut model.sub);
                        model.sub =
                            model::ManagingRepoSubState::SelectingIdentity {
                                ids: user_ids,
                                selection_ix: default(),
                                selection_nav: default(),
                                confirmed_selection_ix: default(),
                                repo,
                            }

Replacement in inflorescence/src/main.rs at line 673 [28.2763]

B:BD[9.80845] → [20.3614460:3614564]

B:BD[20.3614564] → [20.3614564:3614582]

B:BD[20.3614582] → [20.3614582:3614642]

∅:D[10.24172] → [9.80952:80987]

∅:D[20.3614642] → [9.80952:80987]

B:BD[9.80952] → [9.80952:80987]

                model::ManagingRepoSubState::SelectingId { .. } => {
                    unreachable!()
                }
                model::ManagingRepoSubState::Ready(..) => {
                    unreachable!()

[9.80845]

[9.80987]

                Err(err) => {
                    let msg =
                        format!("Failed to load Pijul identity with {err:#?}");
                    report::show_err(report, msg);

Replacement in inflorescence/src/main.rs at line 993 [28.2763]

B:BD[22.19039] → [22.19039:19107]

            | action::FilteredMsg::EnterSubMenu(_) => Task::none(),

[22.19039]

[22.19107]

            | action::FilteredMsg::EnterSubMenu(_)
            | action::FilteredMsg::ReloadIdentity => Task::none(),

Replacement in inflorescence/src/main.rs at line 1009 [28.2763]

B:BD[21.23235] → [21.23235:23288]

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

[21.23235]

[20.3616655]

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

Insertion in inflorescence/src/main.rs at line 1095 [28.2763]

[16.17224]

[21.23289]

        view::Msg::SelectIdentity(ix) => {
            if let model::ManagingRepoSubState::SelectingIdentity {
                ids,
                repo,
                confirmed_selection_ix,
                ..
            } = &mut model.sub
            {
                if let Some(repo) = repo.take() {
                    let user_id = ids.get(ix).unwrap().clone();
                    model.sub =
                        model::ManagingRepoSubState::Ready(ReadyState {
                            user_id,
                            repo,
                            selection: default(),
                            navigation: default(),
                            record_changes: default(),
                            forking_channel_name: default(),
                            logs: default(),
                            to_record: default(),
                            jobs: default(),
                        });
                } else {
                    *confirmed_selection_ix = Some(ix);
                }
            }
            Task::none()
        }

Insertion in inflorescence/src/main.rs at line 1197 [28.2763]

[24.7983]

                } else if let model::ManagingRepoSubState::SelectingIdentity {
                    ids,
                    selection_ix,
                    selection_nav: _,
                    confirmed_selection_ix,
                    repo,
                } = &mut model.sub
                {
                    if let Some(repo) = repo.take() {
                        let user_id = ids.get(*selection_ix).unwrap().clone();
                        model.sub =
                            model::ManagingRepoSubState::Ready(ReadyState {
                                user_id,
                                repo,
                                selection: default(),
                                navigation: default(),
                                record_changes: default(),
                                forking_channel_name: default(),
                                logs: default(),
                                to_record: default(),
                                jobs: default(),
                            });
                    } else {
                        *confirmed_selection_ix = Some(*selection_ix);
                    }
                    Task::none()

Insertion in inflorescence/src/main.rs at line 1278 [28.2763]

[24.8094]

[11.60508]

            } else if let model::ManagingRepoSubState::SelectingIdentity {
                ids,
                selection_ix,
                selection_nav: _,
                confirmed_selection_ix,
                repo: _,
            } = &mut model.sub
            {
                match msg {
                    selection::Msg::PressDir(dir) => match dir {
                        inflorescence_model::selection::Dir::Down => {
                            *confirmed_selection_ix = None;
                            if *selection_ix == ids.len().saturating_sub(1) {
                                *selection_ix = 0;
                            } else {
                                *selection_ix += 1;
                            }
                        }
                        inflorescence_model::selection::Dir::Up => {
                            *confirmed_selection_ix = None;
                            if *selection_ix == 0 {
                                *selection_ix = ids.len().saturating_sub(1);
                            } else {
                                *selection_ix -= 1;
                            }
                        }
                        inflorescence_model::selection::Dir::Right
                        | inflorescence_model::selection::Dir::Left => {}
                    },
                    selection::Msg::AltPressDir(_) => {}
                }
                Task::none()

Insertion in inflorescence/src/main.rs at line 1437 [28.2763]

[16.18195]

[11.60824]


        action::FilteredMsg::ReloadIdentity => {
            load_identities_task().map(Msg::ManagingRepo)
        }

Insertion in inflorescence/src/main.rs at line 1554 [28.2763]

[11.64717]

[25.3489]

}
fn load_identities_task() -> Task<ManagingRepoMsg> {
    Task::future(async {
        let ids = spawn_blocking(identity::load).await.unwrap();
        ManagingRepoMsg::LoadedIdentities(ids)
    })

Replacement in inflorescence/src/main.rs at line 2155 [28.2763]

B:BD[20.3623971] → [20.3623971:3624020]

∅:D[13.14403] → [9.90921:90976]

∅:D[20.3624020] → [9.90921:90976]

B:BD[9.90921] → [9.90921:90976]

B:BD[9.90976] → [20.3624021:3624085]

∅:D[10.26488] → [9.91022:91174]

∅:D[20.3624085] → [9.91022:91174]

B:BD[9.91022] → [9.91022:91174]

B:BD[9.91174] → [13.14404:14451]

∅:D[13.14451] → [9.91217:91307]

B:BD[9.91217] → [9.91217:91307]

B:BD[9.91307] → [16.18196:18238]

B:BD[16.18238] → [17.9125:9162]

∅:D[17.9162] → [9.91307:91347]

∅:D[16.18238] → [9.91307:91347]

B:BD[9.91307] → [9.91307:91347]

B:BD[9.91347] → [20.3624086:3624145]

∅:D[10.26536] → [9.91388:91584]

∅:D[20.3624145] → [9.91388:91584]

B:BD[9.91388] → [9.91388:91584]

            model.sub = if user_ids.len() == 1 {
                let user_id = user_ids.pop().unwrap();
                model::ManagingRepoSubState::Ready(ReadyState {
                    user_id,
                    repo: repo_state,
                    selection: default(),
                    navigation: default(),
                    record_changes: default(),
                    forking_channel_name: default(),
                    logs: default(),
                    to_record: default(),
                    jobs: default(),
                })
            } else {
                model::ManagingRepoSubState::SelectingId {
                    user_ids: mem::take(user_ids),
                    user_selection_ix: default(),
                    user_selection_nav: default(),
                    repo: Some(repo_state),

[20.3623971]

[9.91584]

            if let Some(user_ids) = user_ids {
                model.sub = if user_ids.len() == 1 {
                    let user_id = user_ids.pop().unwrap();
                    model::ManagingRepoSubState::Ready(ReadyState {
                        user_id,
                        repo: repo_state,
                        selection: default(),
                        navigation: default(),
                        record_changes: default(),
                        forking_channel_name: default(),
                        logs: default(),
                        to_record: default(),
                        jobs: default(),
                    })
                } else {
                    model::ManagingRepoSubState::SelectingIdentity {
                        ids: mem::take(user_ids),
                        selection_ix: default(),
                        selection_nav: default(),
                        confirmed_selection_ix: default(),
                        repo: Some(repo_state),
                    }

Replacement in inflorescence/src/main.rs at line 2180 [28.2763]

B:BD[20.3624156] → [20.3624156:3624223]

        model::ManagingRepoSubState::SelectingId { repo, .. } => {

[20.3624156]

[20.3624223]

        model::ManagingRepoSubState::SelectingIdentity { repo, .. } => {

Insertion in inflorescence/src/main.rs at line 2184 [28.2763]

[20.3624313]

[9.91733]

        model::ManagingRepoSubState::NoIdFound { repo } => {
            *repo = Some(repo_state)
        }

Replacement in inflorescence/src/main.rs at line 2269 [28.2763]

B:BD[10.26831] → [20.3624772:3624839]

        model::ManagingRepoSubState::SelectingId { repo, .. } => {

[10.26831]

[20.3624839]

        model::ManagingRepoSubState::SelectingIdentity { repo, .. } => {

Insertion in inflorescence/src/main.rs at line 2295 [28.2763]

[9.92659]

        }
        model::ManagingRepoSubState::NoIdFound { repo } => {
            *repo = Some(repo_state)