bashrs 6.66.0

#![allow(clippy::unwrap_used)]
#![allow(unused_imports)]

use super::super::ast::Redirect;
use super::super::lexer::Lexer;
use super::super::parser::BashParser;
use super::super::semantic::SemanticAnalyzer;
use super::super::*;

/// Helper: tokenize input and assert tokens are non-empty.
/// Accepts parse errors gracefully (parser may not support all constructs yet).

#[test]
fn test_BUILTIN_010_export_set_and_export() {
    // DOCUMENTATION: export VAR=value sets and exports variable
    // Variable becomes available to child processes
    // Most common form of export

    let export_set = r#"
export PATH="/usr/local/bin:$PATH"
export HOME="/home/user"
export USER="alice"
"#;

    let mut lexer = Lexer::new(export_set);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export set should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // export VAR=value is most common form
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Rust mapping: export VAR=value → std::env::set_var("VAR", "value")
    // Purified bash: export PATH="/usr/local/bin:$PATH" (POSIX supported)
}

#[test]
fn test_BUILTIN_010_export_existing_variable() {
    // DOCUMENTATION: export VAR exports existing variable
    // Variable must already be set in current shell
    // Makes existing variable available to child processes

    let export_existing = r#"
VAR="value"
export VAR

USER="alice"
export USER
"#;

    let mut lexer = Lexer::new(export_existing);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export existing should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // export VAR exports variable set earlier
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Two-step pattern: VAR=value; export VAR
    // Useful when variable is set conditionally
    // Rust mapping: export VAR → std::env::set_var("VAR", existing_value)
}

#[test]
fn test_BUILTIN_010_export_vs_assignment() {
    // DOCUMENTATION: export vs variable assignment distinction
    // VAR=value: Local to current shell (not exported)
    // export VAR=value: Exported to child processes
    // Child processes inherit exported variables only

    let export_vs_assign = r#"
# Local variable (not exported)
LOCAL="not exported"

# Exported variable
export EXPORTED="exported"

# Child process sees EXPORTED but not LOCAL
./child_script.sh
"#;

    let mut lexer = Lexer::new(export_vs_assign);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export vs assign should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // Key distinction documented
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Key distinction:
    // VAR=value: Local to current shell
    // export VAR=value: Available to child processes
}

#[test]
fn test_BUILTIN_010_export_multiple() {
    // DOCUMENTATION: Multiple exports in one command
    // export VAR1=val1 VAR2=val2 VAR3=val3
    // POSIX-compliant, efficient for multiple variables

    let export_multiple = r#"
export CC=gcc CXX=g++ CFLAGS="-O2"
export VAR1="value1" VAR2="value2"
"#;

    let mut lexer = Lexer::new(export_multiple);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "multiple exports should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // Multiple exports in one command is POSIX
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Common for build environments
    // More efficient than separate export commands
}

#[test]
fn test_BUILTIN_010_export_quoting() {
    // DOCUMENTATION: export with quoting for spaces
    // export VAR="value with spaces"
    // Quoting required for values containing spaces or special characters

    let export_quoting = r#"
export MESSAGE="Hello World"
export PATH="/usr/local/bin:/usr/bin"
export DESC='Description with spaces'
"#;

    let mut lexer = Lexer::new(export_quoting);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export quoting should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // Quoting is critical for spaces
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Best practice: Always quote values with spaces
    // Double quotes allow variable expansion
    // Single quotes preserve literal value
}

#[test]
fn test_BUILTIN_010_export_print() {
    // DOCUMENTATION: export -p prints all exported variables
    // Lists all variables marked for export
    // Output format: declare -x VAR="value"

    let export_print = r#"
export -p
"#;

    let mut lexer = Lexer::new(export_print);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export -p should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
                            // export -p is POSIX for listing exports
        }
        Err(_) => {
            // Test documents expected behavior
        }
    }

    // Rust mapping: export -p → std::env::vars() and print
    // Useful for debugging environment issues
}

#[test]
fn test_BUILTIN_010_export_comparison_table() {
    // COMPREHENSIVE COMPARISON: POSIX vs Bash vs bashrs

    let export_comparison = r#"
# POSIX SUPPORTED (bashrs SUPPORTED):
export PATH="/usr/local/bin:$PATH"  # Set and export
export VAR                          # Export existing
export VAR="value"                  # With quotes
export -p                           # Print exports
export A=1 B=2                      # Multiple exports

# Bash extensions (bashrs NOT SUPPORTED):
# export -n VAR                     # Unexport (bash only)
# export -f my_function             # Export function (bash only)
# export ARRAY=(a b c)              # Array export (bash only)

# Common patterns:
export PATH="/opt/app/bin:$PATH"   # Prepend to PATH
export CONFIG_FILE="/etc/app.conf" # Config location
export DEBUG=1                     # Debug flag
export USER="$(whoami)"            # Command substitution

# export vs local variable:
LOCAL="not exported"               # Local to current shell
export EXPORTED="exported"         # Available to children

./child_script.sh                  # Sees EXPORTED, not LOCAL

# Best practices:
export VAR="value with spaces"     # Quote values
export API_KEY                     # Export existing (set elsewhere)
export CC=gcc CXX=g++              # Multiple in one line
"#;

    let mut lexer = Lexer::new(export_comparison);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(!tokens.is_empty(), "export comparison should tokenize");
            let _ = tokens; // Use tokens to satisfy type inference
        }
        Err(_) => {
            // Test documents comprehensive export behavior
        }
    }

    // SUMMARY
    // export is POSIX-COMPLIANT and FULLY SUPPORTED in bashrs (basic forms)
    // export VAR=value sets and exports variable to child processes
    // export VAR exports existing variable
    // Non-exported variables are local to current shell
    // Bash extensions (-n, -f, arrays) are NOT SUPPORTED
    // Use export for variables needed by child processes
    // Quote values with spaces for safety
}

// ============================================================================
// BUILTIN-011: pwd command (POSIX builtin)
// ============================================================================
// Task: Document pwd (print working directory) builtin command
// Reference: GNU Bash Manual Section 4.1 (Bourne Shell Builtins)
// POSIX: pwd is POSIX-COMPLIANT (SUPPORTED)
//
// Syntax:
//   pwd               # Print current working directory
//   pwd -L            # Logical path (follow symlinks, default)
//   pwd -P            # Physical path (resolve symlinks)
//
// POSIX Compliance:
//   SUPPORTED: pwd (print current working directory)
//   SUPPORTED: pwd -L (logical path, follows symlinks)
//   SUPPORTED: pwd -P (physical path, resolves symlinks)
//   SUPPORTED: Uses $PWD environment variable
//   SUPPORTED: Returns 0 on success, non-zero on error
//
// Bash Extensions:
//   None - pwd is fully POSIX-compliant
//
// bashrs Support:
//   SUPPORTED: pwd (basic form)
//   SUPPORTED: pwd -L (logical path, default behavior)
//   SUPPORTED: pwd -P (physical path, resolve symlinks)
//   SUPPORTED: $PWD environment variable
//
// Rust Mapping:
//   pwd → std::env::current_dir()
//   pwd -L → std::env::current_dir() (logical path)
//   pwd -P → std::fs::canonicalize(std::env::current_dir()) (physical path)
//
// Purified Bash:
//   pwd → pwd (POSIX supported)
//   pwd -L → pwd -L (POSIX supported)
//   pwd -P → pwd -P (POSIX supported)
//
// pwd vs $PWD:
//   pwd: Command that prints current directory
//   $PWD: Environment variable containing current directory
//   $PWD is updated by cd command
//   pwd retrieves current directory from system
//   In most cases: pwd output == $PWD value
//
// Common Use Cases:
//   1. Get current directory: current=$(pwd)
//   2. Save and restore: old_pwd=$(pwd); cd /tmp; cd "$old_pwd"
//   3. Relative paths: echo "Working in $(pwd)"
//   4. Scripts: SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
//   5. Resolve symlinks: physical_path=$(pwd -P)
//   6. Logical path: logical_path=$(pwd -L)
//
// Edge Cases:
//   1. Directory deleted: pwd may fail if CWD deleted
//   2. No permissions: pwd may fail if no read permissions on path
//   3. Symlinks: pwd -L shows symlink, pwd -P resolves symlink
//   4. $PWD mismatch: pwd always accurate, $PWD can be modified
//   5. Chroot: pwd shows path relative to chroot
//
// Best Practices:
//   1. Use pwd for portability (works in all POSIX shells)
//   2. Use $PWD for efficiency (no subprocess spawn)
//   3. Use pwd -P to resolve symlinks for canonical paths
//   4. Save pwd before changing directories for restoration
//   5. Quote pwd output in assignments: dir="$(pwd)"
//
// POSIX vs Bash Comparison:
//
// | Feature              | POSIX | Bash | bashrs | Notes                          |
// |----------------------|-------|------|--------|--------------------------------|
// | pwd                  | ✓     | ✓    | ✓      | Print working directory        |
// | pwd -L               | ✓     | ✓    | ✓      | Logical path (default)         |
// | pwd -P               | ✓     | ✓    | ✓      | Physical path (resolve links)  |
// | $PWD variable        | ✓     | ✓    | ✓      | Environment variable           |
// | Exit status 0/1      | ✓     | ✓    | ✓      | Success/failure                |
// | Symlink handling     | ✓     | ✓    | ✓      | -L vs -P behavior              |
//
// ✓ = Supported
// ✗ = Not supported
//
// Summary:
// pwd command: POSIX, FULLY SUPPORTED (all forms)
// pwd prints current working directory
// pwd -L follows symlinks (logical path, default)
// pwd -P resolves symlinks (physical path)
// Use pwd for portability, $PWD for efficiency
// pwd is deterministic (always returns current directory)

#[test]
fn test_BUILTIN_011_pwd_command_supported() {
    // DOCUMENTATION: pwd is SUPPORTED (POSIX builtin)
    // pwd prints the current working directory
    // Syntax: pwd, pwd -L, pwd -P

    let pwd_command = r#"
pwd
current=$(pwd)
echo "Working in $(pwd)"
"#;

    let mut lexer = Lexer::new(pwd_command);
    match lexer.tokenize() {
        Ok(tokens) => {
            assert!(
                !tokens.is_empty(),
                "pwd command should tokenize successfully"
            );
            let _ = tokens; // Use tokens to satisfy type inference
                            // pwd is a builtin command
        }
        Err(_) => {
            // Parser may not fully support pwd yet - test documents expected behavior
        }
    }

    // COMPARISON TABLE
    // | pwd syntax  | Meaning                  | POSIX | Bash | bashrs |
    // |-------------|--------------------------|-------|------|--------|
    // | pwd         | Print working directory  | ✓     | ✓    | ✓      |
    // | pwd -L      | Logical path (default)   | ✓     | ✓    | ✓      |
    // | pwd -P      | Physical path (resolve)  | ✓     | ✓    | ✓      |
}

#[test]

include!("part4_s3_builtin_011.rs");