622 lines
23 KiB
Rust
622 lines
23 KiB
Rust
use crate::format::{ConfigItem, PathSegment};
|
|
use tui_input::Input;
|
|
use crate::undo::UndoTree;
|
|
|
|
/// Represents the current operating mode of the application.
|
|
///
|
|
/// Modality allows the application to reuse the same keyboard events
|
|
/// for different contextual actions (navigation vs. text entry).
|
|
pub enum Mode {
|
|
/// Standard navigation and command mode.
|
|
Normal,
|
|
/// Active text entry mode for modifying values.
|
|
Insert,
|
|
/// Active text entry mode for modifying keys.
|
|
InsertKey,
|
|
/// Active search mode for filtering keys.
|
|
Search,
|
|
}
|
|
|
|
/// Defines where the cursor starts when entering Insert mode.
|
|
pub enum InsertVariant {
|
|
/// Cursor at the beginning of the text.
|
|
Start,
|
|
/// Cursor at the end of the text.
|
|
End,
|
|
/// Text is cleared before entry.
|
|
Substitute,
|
|
}
|
|
|
|
/// The core application state, holding all configuration variables and UI status.
|
|
///
|
|
/// This struct is the "Single Source of Truth" for the TUI. It manages
|
|
/// selection, filtering, history, and structural mutations.
|
|
pub struct App {
|
|
/// The flattened list of configuration variables being edited.
|
|
pub vars: Vec<ConfigItem>,
|
|
/// Index of the currently selected variable in the list.
|
|
pub selected: usize,
|
|
/// The current interaction mode (Normal, Insert, etc.).
|
|
pub mode: Mode,
|
|
/// Whether the main application loop should continue running.
|
|
pub running: bool,
|
|
/// An optional message to display in the status bar.
|
|
pub status_message: Option<String>,
|
|
/// The active text input buffer for the selected variable.
|
|
pub input: Input,
|
|
/// The current search query for filtering keys.
|
|
pub search_query: String,
|
|
/// Undo history structured as a tree.
|
|
pub undo_tree: UndoTree,
|
|
}
|
|
|
|
impl App {
|
|
/// Initializes a new application instance with the provided variables.
|
|
///
|
|
/// It automatically initializes the undo tree with the starting state.
|
|
pub fn new(vars: Vec<ConfigItem>) -> Self {
|
|
let initial_input = vars.first().and_then(|v| v.value.clone()).unwrap_or_default();
|
|
let undo_tree = UndoTree::new(vars.clone(), 0);
|
|
Self {
|
|
vars,
|
|
selected: 0,
|
|
mode: Mode::Normal,
|
|
running: true,
|
|
status_message: None,
|
|
input: Input::new(initial_input),
|
|
search_query: String::new(),
|
|
undo_tree,
|
|
}
|
|
}
|
|
|
|
/// Returns the indices of variables that match the search query (case-insensitive).
|
|
pub fn matching_indices(&self) -> Vec<usize> {
|
|
if self.search_query.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
let query = self.search_query.to_lowercase();
|
|
self.vars
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, v)| v.key.to_lowercase().contains(&query))
|
|
.map(|(i, _)| i)
|
|
.collect()
|
|
}
|
|
|
|
/// Moves the selection to the next variable in the list, wrapping around if necessary.
|
|
pub fn next(&mut self) {
|
|
if !self.vars.is_empty() {
|
|
self.selected = (self.selected + 1) % self.vars.len();
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Moves the selection to the previous variable in the list, wrapping around if necessary.
|
|
pub fn previous(&mut self) {
|
|
if !self.vars.is_empty() {
|
|
if self.selected == 0 {
|
|
self.selected = self.vars.len() - 1;
|
|
} else {
|
|
self.selected -= 1;
|
|
}
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Jumps the selection to the top of the list.
|
|
pub fn jump_top(&mut self) {
|
|
if !self.vars.is_empty() {
|
|
self.selected = 0;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Jumps the selection to the bottom of the list.
|
|
pub fn jump_bottom(&mut self) {
|
|
if !self.vars.is_empty() {
|
|
self.selected = self.vars.len() - 1;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Jumps to the next variable that matches the search query.
|
|
pub fn jump_next_match(&mut self) {
|
|
let indices = self.matching_indices();
|
|
if indices.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let next_match = indices
|
|
.iter()
|
|
.find(|&&i| i > self.selected)
|
|
.or_else(|| indices.first());
|
|
|
|
if let Some(&index) = next_match {
|
|
self.selected = index;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Jumps to the previous variable that matches the search query.
|
|
pub fn jump_previous_match(&mut self) {
|
|
let indices = self.matching_indices();
|
|
if indices.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let prev_match = indices
|
|
.iter()
|
|
.rev()
|
|
.find(|&&i| i < self.selected)
|
|
.or_else(|| indices.last());
|
|
|
|
if let Some(&index) = prev_match {
|
|
self.selected = index;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Updates the input buffer to reflect the current state of the selected item.
|
|
///
|
|
/// If in `InsertKey` mode, the buffer is synced with the item's `key`.
|
|
/// Otherwise, it is synced with the item's `value`.
|
|
pub fn sync_input_with_selected(&mut self) {
|
|
if let Some(var) = self.vars.get(self.selected) {
|
|
let val = match self.mode {
|
|
Mode::InsertKey => var.key.clone(),
|
|
_ => var.value.clone().unwrap_or_default(),
|
|
};
|
|
self.input = Input::new(val);
|
|
}
|
|
}
|
|
|
|
/// Commits the current text in the input buffer back to the selected variable.
|
|
///
|
|
/// Returns true if commit was successful, false if there was an error
|
|
/// (e.g., a key name collision or empty key).
|
|
pub fn commit_input(&mut self) -> bool {
|
|
match self.mode {
|
|
Mode::Insert => {
|
|
if let Some(var) = self.vars.get_mut(self.selected)
|
|
&& !var.is_group {
|
|
var.value = Some(self.input.value().to_string());
|
|
var.status = crate::format::ItemStatus::Modified;
|
|
}
|
|
true
|
|
}
|
|
Mode::InsertKey => {
|
|
let new_key = self.input.value().trim().to_string();
|
|
if new_key.is_empty() {
|
|
self.status_message = Some("Key cannot be empty".to_string());
|
|
return false;
|
|
}
|
|
|
|
let selected_var = self.vars[self.selected].clone();
|
|
if selected_var.key == new_key {
|
|
return true;
|
|
}
|
|
|
|
// Collision check: ensure siblings don't already have this key.
|
|
let parent_path = if selected_var.path.len() > 1 {
|
|
&selected_var.path[..selected_var.path.len() - 1]
|
|
} else {
|
|
&[]
|
|
};
|
|
|
|
let exists = self.vars.iter().enumerate().any(|(i, v)| {
|
|
i != self.selected
|
|
&& v.path.len() == selected_var.path.len()
|
|
&& v.path.starts_with(parent_path)
|
|
&& v.key == new_key
|
|
});
|
|
|
|
if exists {
|
|
self.status_message = Some(format!("Key already exists: {}", new_key));
|
|
return false;
|
|
}
|
|
|
|
// Update selected item's key and its full internal path.
|
|
let old_path = selected_var.path.clone();
|
|
let mut new_path = parent_path.to_vec();
|
|
new_path.push(PathSegment::Key(new_key.clone()));
|
|
|
|
{
|
|
let var = self.vars.get_mut(self.selected).unwrap();
|
|
var.key = new_key;
|
|
var.path = new_path.clone();
|
|
var.status = crate::format::ItemStatus::Modified;
|
|
}
|
|
|
|
// Recursively update paths of all children if the renamed item is a group.
|
|
if selected_var.is_group {
|
|
for var in self.vars.iter_mut() {
|
|
if var.path.starts_with(&old_path) && var.path.len() > old_path.len() {
|
|
let mut p = new_path.clone();
|
|
p.extend(var.path[old_path.len()..].iter().cloned());
|
|
var.path = p;
|
|
var.status = crate::format::ItemStatus::Modified;
|
|
}
|
|
}
|
|
}
|
|
true
|
|
}
|
|
_ => true,
|
|
}
|
|
}
|
|
|
|
/// Transitions the application into `InsertKey` mode to modify item names.
|
|
///
|
|
/// Renaming is blocked for array indices (e.g., `[0]`) as they are
|
|
/// managed automatically by the application logic.
|
|
pub fn enter_insert_key(&mut self) {
|
|
if !self.vars.is_empty() {
|
|
if let Some(var) = self.vars.get(self.selected)
|
|
&& matches!(var.path.last(), Some(PathSegment::Index(_))) {
|
|
self.status_message = Some("Cannot rename array indices".to_string());
|
|
return;
|
|
}
|
|
self.mode = Mode::InsertKey;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Transitions the application into `Insert` mode to modify variable values.
|
|
///
|
|
/// If the selected item is a group, it automatically routes to
|
|
/// `enter_insert_key` instead.
|
|
pub fn enter_insert(&mut self, variant: InsertVariant) {
|
|
if let Some(var) = self.vars.get(self.selected) {
|
|
if var.is_group {
|
|
self.enter_insert_key();
|
|
} else {
|
|
if !matches!(variant, InsertVariant::Substitute) {
|
|
self.sync_input_with_selected();
|
|
}
|
|
self.mode = Mode::Insert;
|
|
match variant {
|
|
InsertVariant::Start => {
|
|
use tui_input::InputRequest;
|
|
self.input.handle(InputRequest::GoToStart);
|
|
}
|
|
InsertVariant::End => {
|
|
use tui_input::InputRequest;
|
|
self.input.handle(InputRequest::GoToEnd);
|
|
}
|
|
InsertVariant::Substitute => {
|
|
self.input = Input::new(String::new());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Commits the current input and transitions back to `Normal` mode.
|
|
pub fn enter_normal(&mut self) {
|
|
if self.commit_input() {
|
|
self.save_undo_state();
|
|
self.mode = Mode::Normal;
|
|
}
|
|
}
|
|
|
|
/// Aborts the current input and reverts to `Normal` mode without saving changes.
|
|
pub fn cancel_insert(&mut self) {
|
|
self.mode = Mode::Normal;
|
|
self.sync_input_with_selected();
|
|
self.status_message = None;
|
|
}
|
|
|
|
/// Deletes the currently selected item and all its nested children.
|
|
///
|
|
/// If the deleted item is part of an array, subsequent indices are
|
|
/// automatically shifted and renamed to maintain a continuous sequence.
|
|
pub fn delete_selected(&mut self) {
|
|
if self.vars.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let selected_path = self.vars[self.selected].path.clone();
|
|
let is_group = self.vars[self.selected].is_group;
|
|
|
|
// 1. Identify all items to remove (the item itself + all children)
|
|
let mut to_remove = Vec::new();
|
|
to_remove.push(self.selected);
|
|
|
|
if is_group {
|
|
for (i, var) in self.vars.iter().enumerate() {
|
|
if i == self.selected {
|
|
continue;
|
|
}
|
|
if var.path.starts_with(&selected_path) {
|
|
to_remove.push(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Perform removal (reverse order to preserve indices)
|
|
to_remove.sort_unstable_by(|a, b| b.cmp(a));
|
|
for i in to_remove {
|
|
self.vars.remove(i);
|
|
}
|
|
|
|
// 3. Re-index subsequent array items if applicable
|
|
if let Some(PathSegment::Index(removed_idx)) = selected_path.last() {
|
|
let base_path = &selected_path[..selected_path.len() - 1];
|
|
|
|
for var in self.vars.iter_mut() {
|
|
if var.path.starts_with(base_path) && var.path.len() >= selected_path.len() {
|
|
if let PathSegment::Index(i) = var.path[selected_path.len() - 1]
|
|
&& i > *removed_idx {
|
|
let new_idx = i - 1;
|
|
var.path[selected_path.len() - 1] = PathSegment::Index(new_idx);
|
|
|
|
if var.path.len() == selected_path.len() {
|
|
var.key = format!("[{}]", new_idx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4. Adjust selection
|
|
if self.selected >= self.vars.len() && !self.vars.is_empty() {
|
|
self.selected = self.vars.len() - 1;
|
|
}
|
|
self.sync_input_with_selected();
|
|
self.save_undo_state();
|
|
}
|
|
|
|
/// Adds a new item relative to the selected item.
|
|
///
|
|
/// - `after`: If true, adds below the selection; otherwise adds above.
|
|
/// - `is_group`: If true, creates a new structural node (object/array).
|
|
/// - `as_child`: If true, adds inside the selected group.
|
|
///
|
|
/// The method automatically detects if the parent is an array and
|
|
/// formats the new key accordingly (e.g., `[1]`).
|
|
pub fn add_item(&mut self, after: bool, is_group: bool, as_child: bool) {
|
|
if self.vars.is_empty() {
|
|
let new_key = if is_group { "NEW_GROUP".to_string() } else { "NEW_VAR".to_string() };
|
|
self.vars.push(ConfigItem {
|
|
key: new_key.clone(),
|
|
path: vec![PathSegment::Key(new_key)],
|
|
value: if is_group { None } else { Some("".to_string()) },
|
|
template_value: None,
|
|
default_value: None,
|
|
depth: 0,
|
|
is_group,
|
|
status: crate::format::ItemStatus::Modified,
|
|
value_type: if is_group { crate::format::ValueType::Null } else { crate::format::ValueType::String },
|
|
});
|
|
self.selected = 0;
|
|
self.sync_input_with_selected();
|
|
self.save_undo_state();
|
|
if is_group {
|
|
self.enter_insert_key();
|
|
} else {
|
|
self.enter_insert(InsertVariant::Start);
|
|
}
|
|
return;
|
|
}
|
|
|
|
let selected_item = self.vars[self.selected].clone();
|
|
|
|
// 1. Determine new item properties (path, key, depth, position)
|
|
let mut new_path;
|
|
let new_depth;
|
|
let insert_pos;
|
|
let mut is_array_item = false;
|
|
|
|
if !as_child && let Some(PathSegment::Index(idx)) = selected_item.path.last() {
|
|
// ARRAY ITEM LOGIC (Adding sibling to an existing index)
|
|
is_array_item = true;
|
|
let base_path = selected_item.path[..selected_item.path.len() - 1].to_vec();
|
|
let new_idx = if after { idx + 1 } else { *idx };
|
|
insert_pos = if after { self.selected + 1 } else { self.selected };
|
|
|
|
// Shift subsequent indices
|
|
for var in self.vars.iter_mut() {
|
|
if var.path.starts_with(&base_path) && var.path.len() > base_path.len()
|
|
&& let PathSegment::Index(i) = var.path[base_path.len()]
|
|
&& i >= new_idx {
|
|
var.path[base_path.len()] = PathSegment::Index(i + 1);
|
|
if var.path.len() == base_path.len() + 1 {
|
|
var.key = format!("[{}]", i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
new_path = base_path;
|
|
new_path.push(PathSegment::Index(new_idx));
|
|
new_depth = selected_item.depth;
|
|
} else if as_child && selected_item.is_group {
|
|
// ADD AS CHILD OF GROUP
|
|
insert_pos = self.selected + 1;
|
|
new_path = selected_item.path.clone();
|
|
new_depth = selected_item.depth + 1;
|
|
|
|
if self.is_array_group(&selected_item.path) {
|
|
is_array_item = true;
|
|
let new_idx = 0; // Prepend to array
|
|
new_path.push(PathSegment::Index(new_idx));
|
|
|
|
// Shift existing children
|
|
for var in self.vars.iter_mut() {
|
|
if var.path.starts_with(&selected_item.path) && var.path.len() > selected_item.path.len()
|
|
&& let PathSegment::Index(i) = var.path[selected_item.path.len()] {
|
|
var.path[selected_item.path.len()] = PathSegment::Index(i + 1);
|
|
if var.path.len() == selected_item.path.len() + 1 {
|
|
var.key = format!("[{}]", i + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// ADD AS SIBLING
|
|
let parent_path = if selected_item.path.len() > 1 {
|
|
selected_item.path[..selected_item.path.len() - 1].to_vec()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
|
|
insert_pos = if after {
|
|
let mut p = self.selected + 1;
|
|
while p < self.vars.len() && self.vars[p].path.starts_with(&selected_item.path) {
|
|
p += 1;
|
|
}
|
|
p
|
|
} else {
|
|
self.selected
|
|
};
|
|
|
|
new_path = parent_path;
|
|
new_depth = selected_item.depth;
|
|
|
|
if !new_path.is_empty() && self.is_array_group(&new_path) {
|
|
is_array_item = true;
|
|
if let Some(PathSegment::Index(idx)) = selected_item.path.last() {
|
|
let new_idx = if after { idx + 1 } else { *idx };
|
|
new_path.push(PathSegment::Index(new_idx));
|
|
} else {
|
|
new_path.push(PathSegment::Index(0));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Generate a unique key for non-array items
|
|
let final_key = if is_array_item {
|
|
if let Some(PathSegment::Index(idx)) = new_path.last() {
|
|
format!("[{}]", idx)
|
|
} else {
|
|
"NEW_VAR".to_string()
|
|
}
|
|
} else {
|
|
let mut count = 1;
|
|
let mut candidate = if is_group { "NEW_GROUP".to_string() } else { "NEW_VAR".to_string() };
|
|
let parent_path_slice = new_path.as_slice();
|
|
|
|
while self.vars.iter().any(|v| {
|
|
v.path.starts_with(parent_path_slice)
|
|
&& v.path.len() == parent_path_slice.len() + 1
|
|
&& v.key == candidate
|
|
}) {
|
|
candidate = if is_group { format!("NEW_GROUP_{}", count) } else { format!("NEW_VAR_{}", count) };
|
|
count += 1;
|
|
}
|
|
new_path.push(PathSegment::Key(candidate.clone()));
|
|
candidate
|
|
};
|
|
|
|
// 3. Insert new item
|
|
let new_item = ConfigItem {
|
|
key: final_key,
|
|
path: new_path,
|
|
value: if is_group { None } else { Some("".to_string()) },
|
|
template_value: None,
|
|
default_value: None,
|
|
depth: new_depth,
|
|
is_group,
|
|
status: crate::format::ItemStatus::Modified,
|
|
value_type: if is_group { crate::format::ValueType::Null } else { crate::format::ValueType::String },
|
|
};
|
|
|
|
self.vars.insert(insert_pos, new_item);
|
|
self.selected = insert_pos;
|
|
self.save_undo_state();
|
|
|
|
if is_array_item {
|
|
self.sync_input_with_selected();
|
|
self.enter_insert(InsertVariant::Start);
|
|
} else {
|
|
self.enter_insert_key();
|
|
}
|
|
self.status_message = None;
|
|
}
|
|
|
|
/// Toggles the group status of the currently selected item.
|
|
///
|
|
/// Changing a group to a variable clears its children (visually)
|
|
/// and resets its value. Changing a variable to a group removes its value.
|
|
pub fn toggle_group_selected(&mut self) {
|
|
if let Some(var) = self.vars.get_mut(self.selected) {
|
|
if matches!(var.path.last(), Some(PathSegment::Index(_))) {
|
|
self.status_message = Some("Cannot toggle array items".to_string());
|
|
return;
|
|
}
|
|
|
|
var.is_group = !var.is_group;
|
|
if var.is_group {
|
|
var.value = None;
|
|
var.value_type = crate::format::ValueType::Null;
|
|
} else {
|
|
var.value = Some("".to_string());
|
|
var.value_type = crate::format::ValueType::String;
|
|
}
|
|
var.status = crate::format::ItemStatus::Modified;
|
|
self.sync_input_with_selected();
|
|
}
|
|
}
|
|
|
|
/// Returns true if the selected item is a structural node (group/object).
|
|
pub fn selected_is_group(&self) -> bool {
|
|
self.vars.get(self.selected).map(|v| v.is_group).unwrap_or(false)
|
|
}
|
|
|
|
/// Returns true if the provided path identifies a node that contains array elements.
|
|
pub fn is_array_group(&self, group_path: &[PathSegment]) -> bool {
|
|
self.vars.iter().any(|v|
|
|
v.path.starts_with(group_path)
|
|
&& v.path.len() == group_path.len() + 1
|
|
&& matches!(v.path.last(), Some(PathSegment::Index(_)))
|
|
)
|
|
}
|
|
|
|
/// Returns true if the selected item is an indexed array element.
|
|
pub fn selected_is_array(&self) -> bool {
|
|
self.vars.get(self.selected)
|
|
.map(|v| !v.is_group && matches!(v.path.last(), Some(PathSegment::Index(_))))
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
/// Returns true if the selected item exists in the template but not the active config.
|
|
pub fn selected_is_missing(&self) -> bool {
|
|
self.vars.get(self.selected)
|
|
.map(|v| v.status == crate::format::ItemStatus::MissingFromActive)
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
/// Saves a snapshot of the current state to the undo history tree.
|
|
pub fn save_undo_state(&mut self) {
|
|
self.undo_tree.push(self.vars.clone(), self.selected);
|
|
}
|
|
|
|
/// Reverts the application state to the previous history point.
|
|
pub fn undo(&mut self) {
|
|
if let Some(action) = self.undo_tree.undo() {
|
|
self.vars = action.state.clone();
|
|
self.selected = action.selected;
|
|
if self.selected >= self.vars.len() && !self.vars.is_empty() {
|
|
self.selected = self.vars.len() - 1;
|
|
}
|
|
self.sync_input_with_selected();
|
|
self.status_message = Some("Undo applied".to_string());
|
|
} else {
|
|
self.status_message = Some("Nothing to undo".to_string());
|
|
}
|
|
}
|
|
|
|
/// Advances the application state to the next history point in the active branch.
|
|
pub fn redo(&mut self) {
|
|
if let Some(action) = self.undo_tree.redo() {
|
|
self.vars = action.state.clone();
|
|
self.selected = action.selected;
|
|
if self.selected >= self.vars.len() && !self.vars.is_empty() {
|
|
self.selected = self.vars.len() - 1;
|
|
}
|
|
self.sync_input_with_selected();
|
|
self.status_message = Some("Redo applied".to_string());
|
|
} else {
|
|
self.status_message = Some("Nothing to redo".to_string());
|
|
}
|
|
}
|
|
}
|