tix/app/

pickers.rs

#[allow(clippy::wildcard_imports)]
use super::*;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FormPickerField {
    Labels,
    Assignee,
    Cycles,
    Milestones,
    Reviewer,
    /// The issue's board column (tix #1508). Single-select, options are the
    /// active board's columns plus the field's current value. No inline create:
    /// a column the board does not configure renders in the Mismatched column, and
    /// inventing one from a form is not something the dropdown should do.
    Status,
    /// The issue's priority (tix #1508). Single-select, options are the built-in
    /// `low`/`medium`/`high` plus every priority the store already uses, plus the
    /// current value. Inline `+` create is kept: a custom priority is a preserved
    /// concept in the model (`Priority::Other`), so a genuinely new one must
    /// remain expressible.
    Priority,
    /// The new-issue templates configured in `[templates.<name>]`
    /// (tui-new-issue-mode). Single-select: choosing one names a record to
    /// pre-fill the form from.
    Template,
    /// The parent issue (WP06 / T026). Single-select, per C-001: one parent,
    /// never a list, so this is `DropdownState::single` below and never `multi`.
    Parent,
    /// The issue's project associations (WP06 T029). **Multi-select**, because the
    /// model and the CLI's `--projects` both hold a list, and the options come from
    /// the project **service** ([`crate::projects::list_projects`]), not from
    /// anything the form constructs. No inline create: a project is a registry
    /// record with an identity, and `tix project create` is where one is made.
    Project,
    /// The issue's epic references (WP06 T031). **Multi-select**, the exact analogue
    /// of `Project` for the epic registry (C-003): the model and the CLI's `--epics`
    /// both hold a list, and the options come from the epic **service**
    /// ([`crate::epics::list_epics`]). No inline create: an epic is a registry record
    /// with an identity, and `tix epic create` is where one is made.
    Epic,
}

#[derive(Debug, Clone)]
pub(in crate::app) struct FormPicker {
    pub(in crate::app) field: FormPickerField,
    pub(in crate::app) state: DropdownState,
}

/// The prefix on a stable-ID template's picker option id (`[issue_templates.<id>]`).
///
/// A stable template ID and a legacy `[templates.<name>]` name live in two
/// config tables that are documented never to share a key space, but a single
/// picker presents both — so each option id is namespaced here and decoded on
/// selection. That keeps "a name in one is never mistaken for an ID in the
/// other" true *inside the picker* as well (registry module doc), and it is why
/// the form stores a bare ID/name rather than this opaque token.
pub(in crate::app) const STABLE_TEMPLATE_PREFIX: &str = "stable:";

/// The prefix on a legacy `[templates.<name>]` picker option id. See
/// [`STABLE_TEMPLATE_PREFIX`].
pub(in crate::app) const LEGACY_TEMPLATE_PREFIX: &str = "legacy:";

impl FormPickerField {
    /// Whether the picker's `+` inline create is offered on this field.
    ///
    /// Every field but Status keeps the keystroke it had: cycles, milestones and
    /// team members become configuration records, labels and priorities are
    /// preserved values, and parent/template simply no-op downstream. A board
    /// column cannot be created from the form (tix #1508) — a status the board
    /// does not configure renders in the Mismatched column, so the dropdown must
    /// not pretend to add one.
    pub(in crate::app) fn allows_inline_create(self) -> bool {
        // A project is a registry record with an identity the service owns, so the
        // form may no more invent one than it may invent a board column: `+` here
        // would be a project `tix project list` never shows.
        !matches!(
            self,
            FormPickerField::Status | FormPickerField::Project | FormPickerField::Epic
        )
    }
}

impl App {
    pub(in crate::app) fn handle_form_picker_key(&mut self, key: KeyEvent) -> Result<Action> {
        if matches!(key.code, KeyCode::Esc | KeyCode::F(2)) {
            self.form_picker = None;
            return Ok(Action::None);
        }
        // The Status dropdown refuses inline create (tix #1508): a board column the
        // form invents is not a column the board has, and it would render in the
        // Mismatched column rather than somewhere real. Swallow the create keys
        // before `DropdownState::handle_key` turns them into an InlineCreate prompt.
        if let Some(picker) = self.form_picker.as_ref()
            && !picker.field.allows_inline_create()
            && picker.state.mode != PickerMode::InlineCreate
            && matches!(key.code, KeyCode::Char('+') | KeyCode::Insert)
        {
            return Ok(Action::None);
        }
        let event = match self.form_picker.as_mut() {
            Some(picker) => picker.state.handle_key(key.code),
            None => return Ok(Action::None),
        };
        match event {
            PickerEvent::None => {}
            PickerEvent::Cancelled => {
                self.form_picker = None;
            }
            PickerEvent::Selected(ids) => {
                self.apply_picker_selection(ids);
            }
            PickerEvent::Created(value) => {
                self.apply_picker_created(value)?;
            }
        }
        Ok(Action::None)
    }

    pub(in crate::app) fn open_form_picker(&mut self) {
        let Some(form) = self.form.as_ref() else {
            return;
        };
        let field = match form.focus {
            form::FormFocus::Status => FormPickerField::Status,
            form::FormFocus::Priority => FormPickerField::Priority,
            form::FormFocus::Labels => FormPickerField::Labels,
            form::FormFocus::Assignee => FormPickerField::Assignee,
            form::FormFocus::Cycles => FormPickerField::Cycles,
            form::FormFocus::Milestones => FormPickerField::Milestones,
            form::FormFocus::Reviewer => FormPickerField::Reviewer,
            form::FormFocus::Parent => FormPickerField::Parent,
            form::FormFocus::Projects => FormPickerField::Project,
            form::FormFocus::Epics => FormPickerField::Epic,
            form::FormFocus::Template => FormPickerField::Template,
            _ => return,
        };
        // The template picker has its own opener (`open_template_picker`), which
        // seeds the `(none)` option and refuses when nothing is configured; F2 on
        // the row routes there rather than duplicating the fallback here.
        if field == FormPickerField::Template {
            self.open_template_picker();
            return;
        }
        let options = self.picker_options(field);
        let mut state = match field {
            FormPickerField::Labels
            | FormPickerField::Cycles
            | FormPickerField::Milestones
            | FormPickerField::Project
            | FormPickerField::Epic => DropdownState::multi(options),
            FormPickerField::Assignee
            | FormPickerField::Reviewer
            | FormPickerField::Parent
            | FormPickerField::Status
            | FormPickerField::Priority
            | FormPickerField::Template => DropdownState::single(options),
        };
        self.seed_picker_selection(field, &mut state);
        self.form_picker = Some(FormPicker { field, state });
    }

    #[allow(clippy::too_many_lines)]
    pub(in crate::app) fn picker_options(&self, field: FormPickerField) -> Vec<PickerItem> {
        match field {
            FormPickerField::Cycles => {
                let root = self.project_root();
                let planner = Planner::from_config(self.store.config.clone(), root);
                planner
                    .cycle_names()
                    .into_iter()
                    .map(|name| PickerItem {
                        id: name.clone(),
                        label: name,
                    })
                    .collect()
            }
            FormPickerField::Milestones => {
                let root = self.project_root();
                let planner = Planner::from_config(self.store.config.clone(), root);
                planner
                    .milestone_names()
                    .unwrap_or_default()
                    .into_iter()
                    .map(|name| PickerItem {
                        id: name.clone(),
                        label: name,
                    })
                    .collect()
            }
            FormPickerField::Labels => {
                let mut out = std::collections::BTreeSet::new();
                for issue in self.store.list().unwrap_or_default() {
                    for label in issue.labels {
                        if !label.trim().is_empty() {
                            out.insert(label);
                        }
                    }
                }
                out.into_iter()
                    .map(|label| PickerItem {
                        id: label.clone(),
                        label,
                    })
                    .collect()
            }
            // The board's columns, in board order, plus the field's current value
            // when the board no longer configures it. A status the board has
            // dropped must not become unselectable from a form that still holds
            // it (tix #1508) — the same "keep the current value" rule the assignee
            // and reviewer pickers follow.
            FormPickerField::Status => {
                let columns = self.active_board_config().columns.clone();
                let mut options = crate::ui::triage::status_options(&columns);
                if let Some(form) = self.form.as_ref() {
                    let current = form.status.trim();
                    if !current.is_empty() && !columns.iter().any(|c| c == current) {
                        options.push(PickerItem {
                            id: current.to_string(),
                            label: current.to_string(),
                        });
                    }
                }
                options
            }
            // The built-in set first, then every priority the store already uses,
            // then the field's current value — the same "defaults plus what the
            // project actually uses" rule Labels follows. A custom priority is a
            // preserved model value (`Priority::Other`), so it must be listed once
            // an issue carries it rather than being re-typed from memory.
            FormPickerField::Priority => {
                const BUILT_INS: [&str; 3] = ["low", "medium", "high"];
                let mut out: Vec<String> = BUILT_INS.iter().map(|p| (*p).to_string()).collect();
                for issue in self.store.list().unwrap_or_default() {
                    let priority = issue.priority.to_string();
                    if !priority.trim().is_empty() && !out.contains(&priority) {
                        out.push(priority);
                    }
                }
                if let Some(form) = self.form.as_ref() {
                    let current = form.priority.trim().to_string();
                    if !current.is_empty() && !out.contains(&current) {
                        out.push(current);
                    }
                }
                out.into_iter()
                    .map(|priority| PickerItem {
                        id: priority.clone(),
                        label: priority,
                    })
                    .collect()
            }
            FormPickerField::Parent => {
                // Every issue in the store is a candidate parent.
                //
                // T026's note asks for the issue itself to be excluded from the
                // list, as "the first line of defense against a self-parent". The
                // form is **create-only** — `Mode::Form` has one entry point and it
                // always builds a fresh `FormState` — so there is no issue-under-edit
                // to exclude: the child does not exist yet and cannot be among its
                // own ancestors. The list is therefore unfiltered here, and the
                // defense is `hierarchy::validate_new_parent`, which runs at submit.
                // (Tracked as tix #1384: once an edit form exists, this arm must
                // exclude the edited issue, and `set_parent` becomes the write.)
                self.store
                    .list()
                    .unwrap_or_default()
                    .into_iter()
                    .map(|issue| PickerItem {
                        id: issue.number.to_string(),
                        label: format!("#{} {}", issue.number, issue.title),
                    })
                    .collect()
            }
            // Unreachable in practice: `open_form_picker` routes the Template row
            // to `open_template_picker`, which owns the `(none)` option. Kept
            // exhaustive and honest — the options *are* the configured templates.
            FormPickerField::Template => self.template_picker_options(),
            // The **service's** project list, in declaration order. The option id is
            // the resolved project id (what the model stores and what the filter
            // matches), and the label is the shared `name (id)` display form, so the
            // picker and `tix project list` cannot spell a project two ways. Nothing
            // here constructs or validates a project: a reference the registry does
            // not hold never appears, and a stored reference that no longer resolves
            // is kept visible by the current-value rule below
            // (`seed_picker_selection` seeds it, and `DropdownState` lists a seeded
            // value even when no option carries it).
            FormPickerField::Project => {
                let mut options: Vec<PickerItem> = self
                    .live_projects()
                    .into_iter()
                    .map(|project| PickerItem {
                        id: project.id.to_string(),
                        label: crate::projects::project_display(&project.id, &project.name),
                    })
                    .collect();
                if let Some(form) = self.form.as_ref() {
                    for current in form.projects.split(',').map(str::trim) {
                        if !current.is_empty() && !options.iter().any(|o| o.id == current) {
                            options.push(PickerItem {
                                id: current.to_string(),
                                label: format!("{current} (missing project)"),
                            });
                        }
                    }
                }
                options
            }
            // The **service's** epic list, in declaration order — the exact analogue
            // of the Project arm above. The option id is the resolved epic id (what
            // the model stores and what the filter matches), and the label is the
            // shared `name (id)` display form, so the picker and `tix epic list`
            // cannot spell an epic two ways. Nothing here constructs or validates an
            // epic: a reference the registry does not hold never appears, and a stored
            // reference that no longer resolves is kept visible by the current-value
            // rule below.
            //
            // No "exclude the issue itself" filter, and the reason is the Parent
            // picker's: the form is **create-only** (`Mode::Form` always builds a
            // fresh `FormState`), so there is no issue-under-edit to exclude, and an
            // issue→epic reference cannot close a cycle in the epic **parent**
            // hierarchy anyway — the two are different graphs (contracts/epic-
            // service.md §3). A reference the service rejects (an unknown id, or a
            // cycle a future edit form introduces) is refused at submit through the
            // service's own diagnostic, which is the rule this row must not restate.
            FormPickerField::Epic => {
                let mut options: Vec<PickerItem> = self
                    .live_epics()
                    .into_iter()
                    .map(|epic| PickerItem {
                        id: epic.id.to_string(),
                        label: crate::epics::epic_display(&epic.id, &epic.name),
                    })
                    .collect();
                if let Some(form) = self.form.as_ref() {
                    for current in form.epics.split(',').map(str::trim) {
                        if !current.is_empty() && !options.iter().any(|o| o.id == current) {
                            options.push(PickerItem {
                                id: current.to_string(),
                                label: format!("{current} (missing epic)"),
                            });
                        }
                    }
                }
                options
            }
            FormPickerField::Assignee | FormPickerField::Reviewer => {
                let mut out = std::collections::BTreeSet::new();
                for team in self.store.config.teams.values() {
                    for member in &team.members {
                        if !member.trim().is_empty() {
                            out.insert(member.trim().to_string());
                        }
                    }
                }
                if let Some(id) = git_identity() {
                    out.insert(id.to_string());
                }
                if let Some(form) = self.form.as_ref() {
                    let current = match field {
                        FormPickerField::Assignee => form.assignee.trim(),
                        FormPickerField::Reviewer => form.reviewer.trim(),
                        _ => "",
                    };
                    if !current.is_empty() {
                        out.insert(current.to_string());
                    }
                }
                out.into_iter()
                    .map(|member| PickerItem {
                        id: member.clone(),
                        label: member,
                    })
                    .collect()
            }
        }
    }

    pub(in crate::app) fn seed_picker_selection(
        &self,
        field: FormPickerField,
        picker: &mut DropdownState,
    ) {
        let Some(form) = self.form.as_ref() else {
            return;
        };
        let values: Vec<String> = match field {
            FormPickerField::Labels => form
                .labels
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .collect(),
            FormPickerField::Cycles => form
                .cycles
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .collect(),
            FormPickerField::Milestones => form
                .milestones
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .collect(),
            // WP06 T029 step 2: the pre-selected set is the issue's current
            // associations, in the same comma-joined shape the submit path parses.
            FormPickerField::Project => form
                .projects
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .collect(),
            // WP06 T031 step 2: the exact analogue for epic references — the
            // pre-selected set is the issue's current references, so an edit cannot
            // silently drop the ones the user did not touch.
            FormPickerField::Epic => form
                .epics
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .collect(),
            FormPickerField::Assignee => form
                .assignee
                .trim()
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .take(1)
                .collect(),
            FormPickerField::Reviewer => form
                .reviewer
                .trim()
                .split(',')
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .map(str::to_string)
                .take(1)
                .collect(),
            // Status and Priority are single values, held whole (a status can
            // contain spaces, so splitting on commas would be wrong), and an
            // empty field simply starts the dropdown with nothing selected.
            FormPickerField::Status => (!form.status.trim().is_empty())
                .then(|| form.status.trim().to_string())
                .into_iter()
                .collect(),
            FormPickerField::Priority => (!form.priority.trim().is_empty())
                .then(|| form.priority.trim().to_string())
                .into_iter()
                .collect(),
            // Already a resolved number, so no comma-splitting: there is exactly
            // one parent, and splitting it would corrupt a value that is legal.
            FormPickerField::Parent => (!form.parent.trim().is_empty())
                .then(|| form.parent.trim().to_string())
                .into_iter()
                .collect(),
            // Empty is `(none)`, which matches the option's empty id, so the
            // picker opens on the current selection rather than at the top. A
            // stable-ID selection is namespaced like its option; a legacy one
            // likewise. See [`STABLE_TEMPLATE_PREFIX`].
            FormPickerField::Template => {
                match (form.template_scope.as_deref(), form.template.trim()) {
                    (Some(_), id) if !id.is_empty() => {
                        vec![format!("{STABLE_TEMPLATE_PREFIX}{id}")]
                    }
                    (None, name) if !name.is_empty() => {
                        vec![format!("{LEGACY_TEMPLATE_PREFIX}{name}")]
                    }
                    _ => Vec::new(),
                }
            }
        };
        match &mut picker.selection {
            SelectionModel::Single(current) => {
                *current = values.first().cloned();
            }
            SelectionModel::Multi(current) => {
                current.clear();
                current.extend(values);
            }
        }
    }

    pub(in crate::app) fn apply_picker_selection(&mut self, values: Vec<String>) {
        let Some(field) = self.form_picker.as_ref().map(|p| p.field) else {
            return;
        };
        // Templates are single-select *and* choosing one ends the interaction: the
        // picker closes and the form is pre-filled. The multi-select fields below
        // stay open on purpose, so several labels/cycles can be picked in one go.
        if field == FormPickerField::Template {
            let id = values.first().cloned().unwrap_or_default();
            self.form_picker = None;
            self.apply_template_choice(&id);
            return;
        }
        let Some(form) = self.form.as_mut() else {
            return;
        };
        match field {
            FormPickerField::Labels => form.labels = values.join(","),
            FormPickerField::Assignee => {
                form.assignee = values.first().cloned().unwrap_or_default()
            }
            FormPickerField::Cycles => form.cycles = values.join(","),
            FormPickerField::Milestones => form.milestones = values.join(","),
            // WP06 T029: the multi-selection is the association set, written back in
            // the same comma-joined shape every other list field uses. The picker is
            // the only way this row changes, and the ids came from the service, so
            // the form has constructed nothing.
            FormPickerField::Project => form.projects = values.join(","),
            // WP06 T031: the multi-selection is the reference set, written back in
            // the same comma-joined shape every other list field uses. The picker is
            // the only way this row changes, and the ids came from the service, so
            // the form has constructed nothing.
            FormPickerField::Epic => form.epics = values.join(","),
            // Single-select: a Status/Priority dropdown writes the one chosen
            // value, and no selection clears the row, which is the same "empty
            // means unset" the CLI accepts.
            FormPickerField::Status => form.status = values.first().cloned().unwrap_or_default(),
            FormPickerField::Priority => {
                form.priority = values.first().cloned().unwrap_or_default()
            }
            FormPickerField::Reviewer => {
                form.reviewer = values.first().cloned().unwrap_or_default()
            }
            // Single-select: at most one value, and no selection clears the field,
            // which is the same "empty means none" the CLI's `--parent ""` means.
            FormPickerField::Parent => form.parent = values.first().cloned().unwrap_or_default(),
            // Handled before the `form` borrow above: choosing a template closes
            // the picker and re-fills the form through `apply_template_choice`.
            FormPickerField::Template => {}
        }
        // A picker replaces the value wholesale, so the insertion point belongs
        // after it rather than wherever it sat in the text it replaced.
        form.cursor_to_end();
    }

    pub(in crate::app) fn apply_picker_created(&mut self, value: String) -> Result<()> {
        let value = value.trim().to_string();
        if value.is_empty() {
            return Ok(());
        }
        let Some(field) = self.form_picker.as_ref().map(|p| p.field) else {
            return Ok(());
        };
        match field {
            FormPickerField::Cycles => {
                let root = self.project_root();
                let mut planner = Planner::from_config(self.store.config.clone(), root.clone());
                match planner.add_cycle(Some(value.clone())) {
                    Ok(_) => {
                        self.reload_config_from(root.as_path())?;
                    }
                    Err(e) => {
                        self.status_msg = Some(e.to_string());
                        return Ok(());
                    }
                }
            }
            FormPickerField::Milestones => {
                let root = self.project_root();
                let planner = Planner::from_config(self.store.config.clone(), root.clone());
                match planner.create_milestone_file(&value, None, None) {
                    Ok(_) => {
                        self.reload_config_from(root.as_path())?;
                    }
                    Err(e) => {
                        self.status_msg = Some(e.to_string());
                        return Ok(());
                    }
                }
            }
            FormPickerField::Assignee | FormPickerField::Reviewer => {
                let root = self.project_root();
                let mut planner = Planner::from_config(self.store.config.clone(), root.clone());
                let team = self
                    .store
                    .config
                    .planning
                    .default_team
                    .clone()
                    .unwrap_or_else(|| "default".to_string());
                match planner.add_team_member(&team, &value) {
                    Ok(()) => {
                        self.reload_config_from(root.as_path())?;
                    }
                    Err(e) => {
                        self.status_msg = Some(e.to_string());
                        return Ok(());
                    }
                }
            }
            // `+` is inline-create: it makes a *new* cycle, milestone, or team
            // member, and appends it to the list. A parent is not something you
            // make from inside another issue's form — it is an issue that already
            // exists — so the keystroke does nothing here, exactly as it does for
            // Labels. Creating an empty issue to stand in for a parent would be
            // worse than nothing: it would write a file the user never asked for.
            // Templates are configuration, not form values: `+` cannot invent one
            // any more than it can invent a parent. It is edited in `tix.toml`.
            // A priority has no configuration record to write either — the custom
            // value *is* the form value, and it is applied through the selection
            // below like any picked option. Status never reaches here: its dropdown
            // refuses `+`, because a column the board does not configure would
            // render in the Mismatched column rather than becoming a choice.
            FormPickerField::Labels
            | FormPickerField::Parent
            | FormPickerField::Template
            | FormPickerField::Status
            | FormPickerField::Priority
            | FormPickerField::Project
            | FormPickerField::Epic => {}
        }

        let next_options = self.picker_options(field);
        if let Some(picker) = self.form_picker.as_mut() {
            picker.state.options = next_options;
            picker.state.filter.clear();
            picker.state.cursor = 0;
            picker.state.mode = PickerMode::Idle;
            picker.state.create_buffer.clear();
            match &mut picker.state.selection {
                SelectionModel::Single(current) => *current = Some(value.clone()),
                SelectionModel::Multi(current) => {
                    current.insert(value.clone());
                }
            }
            let values = match &picker.state.selection {
                SelectionModel::Single(current) => current.iter().cloned().collect(),
                SelectionModel::Multi(current) => current.iter().cloned().collect(),
            };
            self.apply_picker_selection(values);
        }
        Ok(())
    }

    /// The picker options for the Template row: the stable-ID registry
    /// (`[issue_templates.<id>]`) first, then the legacy `[templates.<name>]`
    /// pre-fill names.
    ///
    /// Each option's id is namespaced ([`STABLE_TEMPLATE_PREFIX`] /
    /// [`LEGACY_TEMPLATE_PREFIX`]) so the two config key spaces stay distinct
    /// inside one picker. A stable label shows the template's **display name and
    /// explicit scope** — registry metadata presented for selection, never
    /// interpreted (WP05/T023, T026). The stable ID is what a selection records,
    /// never the display name (C-002).
    pub(in crate::app) fn template_picker_options(&self) -> Vec<PickerItem> {
        let mut options: Vec<PickerItem> = self
            .store
            .config
            .issue_templates
            .iter()
            .map(|(id, template)| PickerItem {
                id: format!("{STABLE_TEMPLATE_PREFIX}{id}"),
                label: format!(
                    "{} — {} [{}]",
                    id,
                    template.display_name(id),
                    template.scope
                ),
            })
            .collect();
        options.extend(self.store.config.templates.keys().map(|name| PickerItem {
            id: format!("{LEGACY_TEMPLATE_PREFIX}{name}"),
            label: name.clone(),
        }));
        options
    }
}