refactor: extract script + function call stacks to their own modules (reubeno#709)

Author: reubeno

brush-core/src/functions.rs

@@ -1,6 +1,11 @@
-//! Structures for managing function registrations.
+//! Structures for managing function registrations and calls.
 
-use std::{collections::HashMap, sync::Arc};
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::Arc,
+};
+
+use brush_parser::ast;
 
 /// An environment for defined, named functions.
 #[derive(Clone, Default)]
@@ -97,3 +102,76 @@ impl Registration {
         self.exported
     }
 }
+
+/// Represents an active shell function call.
+#[derive(Clone, Debug)]
+pub struct FunctionCall {
+    /// The name of the function invoked.
+    pub function_name: String,
+    /// The definition of the invoked function.
+    pub function_definition: Arc<brush_parser::ast::FunctionDefinition>,
+}
+
+/// Encapsulates a function call stack.
+#[derive(Clone, Debug, Default)]
+pub struct CallStack {
+    frames: VecDeque<FunctionCall>,
+}
+
+impl std::fmt::Display for CallStack {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.is_empty() {
+            return Ok(());
+        }
+
+        writeln!(f, "Function call stack (most recent first):")?;
+
+        for (index, frame) in self.iter().enumerate() {
+            writeln!(f, "  #{}| {}", index, frame.function_name)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl CallStack {
+    /// Creates a new empty function call stack.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Removes the top from from the stack. If the stack is empty, does nothing and
+    /// returns `None`; otherwise, returns the removed call frame.
+    pub fn pop(&mut self) -> Option<FunctionCall> {
+        self.frames.pop_front()
+    }
+
+    /// Pushes a new frame onto the stack.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - The name of the function being called.
+    /// * `function_def` - The definition of the function being called.
+    pub fn push(&mut self, name: impl Into<String>, function_def: &Arc<ast::FunctionDefinition>) {
+        self.frames.push_front(FunctionCall {
+            function_name: name.into(),
+            function_definition: function_def.clone(),
+        });
+    }
+
+    /// Returns the current depth of the function call stack.
+    pub fn depth(&self) -> usize {
+        self.frames.len()
+    }
+
+    /// Returns whether or not the function call stack is empty.
+    pub fn is_empty(&self) -> bool {
+        self.frames.is_empty()
+    }
+
+    /// Returns an iterator over the function call frames, starting from the most
+    /// recent.
+    pub fn iter(&self) -> impl Iterator<Item = &FunctionCall> {
+        self.frames.iter()
+    }
+}

brush-core/src/lib.rs

@@ -27,6 +27,7 @@ pub mod patterns;
 pub mod processes;
 mod prompt;
 mod regex;
+pub mod scripts;
 mod shell;
 pub mod sys;
 mod terminal;
@@ -40,8 +41,6 @@ mod wellknownvars;
 pub use commands::{CommandArg, ExecutionContext};
 pub use error::Error;
 pub use interp::{ExecutionParameters, ExecutionResult, ProcessGroupPolicy};
-pub use shell::{
-    CreateOptions, FunctionCall, ScriptCallType, Shell, ShellBuilder, ShellBuilderState,
-};
+pub use shell::{CreateOptions, Shell, ShellBuilder, ShellBuilderState};
 pub use terminal::TerminalControl;
 pub use variables::{ShellValue, ShellVariable};

brush-core/src/scripts.rs

@@ -0,0 +1,246 @@
+//! Call stack representations.
+
+use std::collections::VecDeque;
+
+/// Represents an executing script.
+#[derive(Clone, Debug)]
+pub enum CallType {
+    /// The script was sourced.
+    Sourced,
+    /// The script was executed.
+    Executed,
+}
+
+impl std::fmt::Display for CallType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Sourced => write!(f, "sourced"),
+            Self::Executed => write!(f, "executed"),
+        }
+    }
+}
+
+/// Represents a single frame in a script call stack.
+#[derive(Clone, Debug)]
+pub struct CallFrame {
+    /// The type of script call that resulted in this frame.
+    pub call_type: CallType,
+    /// The source of the script (e.g., file path).
+    pub source: String,
+}
+
+/// Encapsulates a script call stack.
+#[derive(Clone, Debug, Default)]
+pub struct CallStack {
+    frames: VecDeque<CallFrame>,
+}
+
+impl std::fmt::Display for CallStack {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.is_empty() {
+            return Ok(());
+        }
+
+        writeln!(f, "Script call stack (most recent first):")?;
+
+        for (index, frame) in self.iter().enumerate() {
+            writeln!(f, "  #{}| {} ({})", index, frame.source, frame.call_type)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl CallStack {
+    /// Creates a new empty script call stack.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Removes the top from from the stack. If the stack is empty, does nothing and
+    /// returns `None`; otherwise, returns the removed call frame.
+    pub fn pop(&mut self) -> Option<CallFrame> {
+        self.frames.pop_front()
+    }
+
+    /// Pushes a new frame onto the stack.
+    ///
+    /// # Arguments
+    ///
+    /// * `call_type` - The type of script call (sourced or executed).
+    /// * `source` - The source of the script (e.g., file path).
+    pub fn push(&mut self, call_type: CallType, source: impl Into<String>) {
+        self.frames.push_front(CallFrame {
+            call_type,
+            source: source.into(),
+        });
+    }
+
+    /// Returns whether or not the current script stack frame is a sourced script.
+    pub fn in_sourced_script(&self) -> bool {
+        self.frames
+            .front()
+            .is_some_and(|frame| matches!(frame.call_type, CallType::Sourced))
+    }
+
+    /// Returns the current depth of the script call stack.
+    pub fn depth(&self) -> usize {
+        self.frames.len()
+    }
+
+    /// Returns whether or not the script call stack is empty.
+    pub fn is_empty(&self) -> bool {
+        self.frames.is_empty()
+    }
+
+    /// Returns an iterator over the script call frames, starting from the most
+    /// recent.
+    pub fn iter(&self) -> impl Iterator<Item = &CallFrame> {
+        self.frames.iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_call_type_display() {
+        assert_eq!(CallType::Sourced.to_string(), "sourced");
+        assert_eq!(CallType::Executed.to_string(), "executed");
+    }
+
+    #[test]
+    fn test_call_stack_new() {
+        let stack = CallStack::new();
+        assert!(stack.is_empty());
+        assert_eq!(stack.depth(), 0);
+    }
+
+    #[test]
+    fn test_call_stack_default() {
+        let stack = CallStack::default();
+        assert!(stack.is_empty());
+        assert_eq!(stack.depth(), 0);
+    }
+
+    #[test]
+    fn test_call_stack_push_pop() {
+        let mut stack = CallStack::new();
+
+        stack.push(CallType::Sourced, "script1.sh");
+        assert!(!stack.is_empty());
+        assert_eq!(stack.depth(), 1);
+
+        stack.push(CallType::Executed, "script2.sh");
+        assert_eq!(stack.depth(), 2);
+
+        let frame = stack.pop().unwrap();
+        assert_eq!(frame.source, "script2.sh");
+        assert!(matches!(frame.call_type, CallType::Executed));
+        assert_eq!(stack.depth(), 1);
+
+        let frame = stack.pop().unwrap();
+        assert_eq!(frame.source, "script1.sh");
+        assert!(matches!(frame.call_type, CallType::Sourced));
+        assert_eq!(stack.depth(), 0);
+        assert!(stack.is_empty());
+    }
+
+    #[test]
+    fn test_call_stack_pop_empty() {
+        let mut stack = CallStack::new();
+        assert!(stack.pop().is_none());
+    }
+
+    #[test]
+    fn test_in_sourced_script() {
+        let mut stack = CallStack::new();
+        assert!(!stack.in_sourced_script());
+
+        stack.push(CallType::Executed, "script1.sh");
+        assert!(!stack.in_sourced_script());
+
+        stack.push(CallType::Sourced, "script2.sh");
+        assert!(stack.in_sourced_script());
+
+        stack.pop();
+        assert!(!stack.in_sourced_script());
+    }
+
+    #[test]
+    fn test_call_stack_iter() {
+        let mut stack = CallStack::new();
+        stack.push(CallType::Sourced, "script1.sh");
+        stack.push(CallType::Executed, "script2.sh");
+        stack.push(CallType::Sourced, "script3.sh");
+
+        let frames: Vec<_> = stack.iter().collect();
+        assert_eq!(frames.len(), 3);
+        assert_eq!(frames[0].source, "script3.sh");
+        assert_eq!(frames[1].source, "script2.sh");
+        assert_eq!(frames[2].source, "script1.sh");
+    }
+
+    #[test]
+    fn test_call_stack_display_empty() {
+        let stack = CallStack::new();
+        assert_eq!(stack.to_string(), "");
+    }
+
+    #[test]
+    fn test_call_stack_display_with_frames() {
+        let mut stack = CallStack::new();
+        stack.push(CallType::Sourced, "script1.sh");
+        stack.push(CallType::Executed, "script2.sh");
+
+        let output = stack.to_string();
+        assert!(output.contains("Script call stack (most recent first):"));
+        assert!(output.contains("#0| script2.sh (executed)"));
+        assert!(output.contains("#1| script1.sh (sourced)"));
+    }
+
+    #[test]
+    fn test_call_frame_clone() {
+        let frame1 = CallFrame {
+            call_type: CallType::Sourced,
+            source: "test.sh".to_string(),
+        };
+        let frame2 = frame1.clone();
+
+        assert_eq!(frame1.source, frame2.source);
+        assert!(matches!(frame1.call_type, CallType::Sourced));
+        assert!(matches!(frame2.call_type, CallType::Sourced));
+    }
+
+    #[test]
+    fn test_call_stack_clone() {
+        let mut stack1 = CallStack::new();
+        stack1.push(CallType::Sourced, "script1.sh");
+        stack1.push(CallType::Executed, "script2.sh");
+
+        let stack2 = stack1.clone();
+        assert_eq!(stack1.depth(), stack2.depth());
+
+        let frames1: Vec<_> = stack1.iter().map(|f| &f.source).collect();
+        let frames2: Vec<_> = stack2.iter().map(|f| &f.source).collect();
+        assert_eq!(frames1, frames2);
+    }
+
+    #[test]
+    fn test_push_with_string_types() {
+        let mut stack = CallStack::new();
+
+        // Test with &str
+        stack.push(CallType::Sourced, "script1.sh");
+
+        // Test with String
+        stack.push(CallType::Executed, String::from("script2.sh"));
+
+        // Test with owned string reference
+        let owned = "script3.sh".to_string();
+        stack.push(CallType::Sourced, &owned);
+
+        assert_eq!(stack.depth(), 3);
+    }
+}