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: assert that BashParser handles the input without panicking.
/// Accepts both successful parses and parse errors (documentation tests
/// only verify the parser doesn't crash, not that the input is valid).

#[test]
fn test_REDIR_002_stderr_redirection() {
    // DOCUMENTATION: stderr redirection (2>) is SUPPORTED (POSIX)
    //
    // File descriptor redirection syntax:
    // 0< - stdin (same as <)
    // 1> - stdout (same as >)
    // 2> - stderr
    //
    // Redirect stderr to file:
    // $ cmd 2> errors.txt
    // $ cmd > output.txt 2> errors.txt
    // $ cmd > output.txt 2>&1  # stderr to stdout

    let stderr_redir = r#"
# Redirect stderr only
ls nonexistent 2> errors.txt

# Redirect stdout and stderr separately
cmd > output.txt 2> errors.txt

# Redirect stderr to stdout
cmd > combined.txt 2>&1
"#;

    let result = BashParser::new(stderr_redir);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "stderr redirection (2>) is POSIX-compliant"
            );
        }
        Err(_) => {
            // Parse error acceptable - 2> may not be fully implemented yet
        }
    }
}

#[test]
fn test_REDIR_002_combined_io_redirection() {
    // DOCUMENTATION: Combined input/output redirection (POSIX)
    //
    // Commands can have both input and output redirection:
    // $ sort < unsorted.txt > sorted.txt
    // $ grep "pattern" < input.txt > matches.txt
    // $ wc -l < data.txt > count.txt
    //
    // Order doesn't matter in POSIX:
    // $ cmd > out.txt < in.txt  # Same as < in.txt > out.txt

    let combined_redir = r#"
# Input and output
sort < unsorted.txt > sorted.txt
grep "pattern" < input.txt > matches.txt

# Order doesn't matter
wc -l < data.txt > count.txt
wc -l > count.txt < data.txt
"#;

    let result = BashParser::new(combined_redir);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "Combined I/O redirection is POSIX-compliant"
            );
        }
        Err(_) => {
            // Parse error acceptable
        }
    }
}

#[test]
fn test_REDIR_002_rust_file_mapping() {
    // DOCUMENTATION: Rust std::fs mapping for output redirection
    //
    // Bash > maps to Rust:
    // use std::fs::File;
    // use std::io::Write;
    //
    // // Overwrite (>)
    // let mut file = File::create("output.txt")?;
    // writeln!(file, "content")?;
    //
    // // Append (>>)
    // use std::fs::OpenOptions;
    // let mut file = OpenOptions::new()
    //     .create(true)
    //     .append(true)
    //     .open("output.txt")?;
    // writeln!(file, "more")?;
    //
    // // Command with output redirection
    // let output = Command::new("ls")
    //     .output()?;
    // File::create("listing.txt")?
    //     .write_all(&output.stdout)?;

    // This test documents the mapping strategy above
    // Test passes if the documentation compiles correctly
}

#[test]
fn test_REDIR_002_common_use_cases() {
    // DOCUMENTATION: Common output redirection patterns (POSIX)
    //
    // 1. Save command output:
    //    $ ls -la > listing.txt
    //    $ ps aux > processes.txt
    //
    // 2. Log file appending:
    //    $ echo "$(date): Started" >> app.log
    //    $ cmd >> app.log 2>&1
    //
    // 3. Discard output:
    //    $ cmd > /dev/null 2>&1
    //
    // 4. Create empty file:
    //    $ > empty.txt
    //    $ : > empty.txt  # More portable
    //
    // 5. Capture errors:
    //    $ cmd 2> errors.txt
    //    $ cmd 2>&1 | tee combined.log
    //
    // 6. Split stdout/stderr:
    //    $ cmd > output.txt 2> errors.txt

    let common_patterns = r#"
# Save output
ls -la > listing.txt

# Append to log
echo "Started" >> app.log

# Discard output
cmd > /dev/null 2>&1

# Create empty file
: > empty.txt

# Capture errors
cmd 2> errors.txt

# Split output
cmd > output.txt 2> errors.txt
"#;

    let result = BashParser::new(common_patterns);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "Common output redirection patterns documented"
            );
        }
        Err(_) => {
            // Parse error acceptable
        }
    }
}

#[test]
fn test_REDIR_002_bash_vs_posix_output_redir() {
    // DOCUMENTATION: Bash vs POSIX output redirection comparison
    //
    // | Feature                  | POSIX sh | Bash | bashrs |
    // |--------------------------|----------|------|--------|
    // | > (overwrite)            | ✅       | ✅   | ✅     |
    // | >> (append)              | ✅       | ✅   | ✅     |
    // | 2> (stderr)              | ✅       | ✅   | ✅     |
    // | 2>&1 (merge)             | ✅       | ✅   | ✅     |
    // | &> file (Bash shortcut)  | ❌       | ✅   | ❌     |
    // | >& file (csh-style)      | ❌       | ✅   | ❌     |
    // | >| (force overwrite)     | ❌       | ✅   | ❌     |
    // | >(cmd) process subst     | ❌       | ✅   | ❌     |
    //
    // POSIX-compliant output redirection:
    // - > overwrites file
    // - >> appends to file
    // - fd> redirects file descriptor (0-9)
    // - 2>&1 duplicates fd 2 to fd 1
    //
    // Bash extensions NOT SUPPORTED:
    // - &> file (shortcut for > file 2>&1)
    // - >& file (csh-style, same as &>)
    // - >| file (force overwrite, ignore noclobber)
    // - >(cmd) process substitution
    //
    // bashrs strategy:
    // - Generate > and >> for POSIX compliance
    // - Convert &> to > file 2>&1 during purification
    // - Always quote filenames for safety
    // - Use standard file descriptors (0, 1, 2)

    let bash_extensions = r#"
# POSIX (SUPPORTED)
echo "data" > file.txt
echo "more" >> file.txt
cmd 2> errors.txt
cmd > output.txt 2>&1

# Bash extensions (NOT SUPPORTED)
cmd &> combined.txt
cmd >& combined.txt
cmd >| noclobber.txt
cmd > >(logger)
"#;

    let result = BashParser::new(bash_extensions);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "Bash extensions NOT SUPPORTED, POSIX redirections SUPPORTED"
            );
        }
        Err(_) => {
            // Parse error expected for Bash extensions
        }
    }

    // Summary:
    // POSIX output redirection: Fully supported (>, >>, 2>, 2>&1)
    // Bash extensions: NOT SUPPORTED (&>, >&, >|, >(cmd))
    // bashrs: Generate POSIX-compliant redirections only
}

// ============================================================================
// REDIR-003: Combined Redirection (&>) (Bash 4.0+, NOT SUPPORTED)
// ============================================================================

#[test]
fn test_REDIR_003_combined_redirection_not_supported() {
    // DOCUMENTATION: Combined redirection (&>) is NOT SUPPORTED (Bash extension)
    //
    // &> is Bash shorthand for redirecting both stdout and stderr to the same file:
    // $ cmd &> output.txt
    //
    // This is equivalent to POSIX:
    // $ cmd > output.txt 2>&1
    //
    // Bash 4.0+ feature, not POSIX sh.

    let combined_redir = r#"
cmd &> output.txt
ls &> listing.txt
"#;

    let result = BashParser::new(combined_redir);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "&> is Bash extension, NOT SUPPORTED"
            );
        }
        Err(_) => {
            // Parse error acceptable - Bash extension
        }
    }
}

#[test]
fn test_REDIR_003_csh_style_redirection_not_supported() {
    // DOCUMENTATION: csh-style >& redirection is NOT SUPPORTED (Bash extension)
    //
    // >& is csh-style syntax (also supported by Bash):
    // $ cmd >& output.txt
    //
    // Same as &> (Bash 4.0+), equivalent to POSIX:
    // $ cmd > output.txt 2>&1
    //
    // Not POSIX sh, Bash extension only.

    let csh_redir = r#"
cmd >& output.txt
ls >& listing.txt
"#;

    let result = BashParser::new(csh_redir);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                ">& is Bash/csh extension, NOT SUPPORTED"
            );
        }
        Err(_) => {
            // Parse error acceptable - Bash extension
        }
    }
}

#[test]
fn test_REDIR_003_append_combined_not_supported() {
    // DOCUMENTATION: Append combined redirection (&>>) is NOT SUPPORTED
    //
    // &>> appends both stdout and stderr to file:
    // $ cmd &>> log.txt
    //
    // Equivalent to POSIX:
    // $ cmd >> log.txt 2>&1
    //
    // Bash extension, not POSIX.

    let append_combined = r#"
cmd &>> log.txt
echo "error" &>> errors.log
"#;

    let result = BashParser::new(append_combined);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "&>> is Bash extension, NOT SUPPORTED"
            );
        }
        Err(_) => {
            // Parse error acceptable - Bash extension
        }
    }
}

#[test]
fn test_REDIR_003_posix_equivalent() {
    // DOCUMENTATION: POSIX equivalent for &> redirection (SUPPORTED)
    //
    // Instead of Bash &>, use POSIX > file 2>&1:
    //
    // Bash (NOT SUPPORTED):
    // $ cmd &> output.txt
    //
    // POSIX (SUPPORTED):
    // $ cmd > output.txt 2>&1
    //
    // Order matters in POSIX:
    // - > output.txt 2>&1 (CORRECT: stdout to file, then stderr to stdout)
    // - 2>&1 > output.txt (WRONG: stderr to original stdout, then stdout to file)
    //
    // Always put > before 2>&1.

    let posix_equivalent = r#"
# POSIX-compliant combined redirection
cmd > output.txt 2>&1
ls > listing.txt 2>&1
cat data.txt > result.txt 2>&1
"#;

    let result = BashParser::new(posix_equivalent);
    match result {
        Ok(mut parser) => {
            let parse_result = parser.parse();
            assert!(
                parse_result.is_ok() || parse_result.is_err(),
                "POSIX > file 2>&1 is SUPPORTED"
            );
        }
        Err(_) => {
            // Parse error acceptable - may not be fully implemented
        }
    }
}

#[test]

include!("part3_s3_redir_003.rs");