phprs 0.1.7

A PHP interpreter with build/package manager written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Stream Facade - Enhanced stream operations
//!
//! Provides builder pattern and higher-level stream operations

use crate::php::streams::{FileStream, StreamError, StreamMode, StreamResult};

/// Builder for creating streams with fluent API
pub struct StreamBuilder {
    path: Option<String>,
    mode: StreamMode,
    buffered: bool,
}

impl StreamBuilder {
    /// Create a new stream builder
    pub fn new() -> Self {
        Self {
            path: None,
            mode: StreamMode::Read,
            buffered: false,
        }
    }

    /// Set the path for the stream
    pub fn path(mut self, path: &str) -> Self {
        self.path = Some(path.to_string());
        self
    }

    /// Set the mode for the stream
    pub fn mode(mut self, mode: StreamMode) -> Self {
        self.mode = mode;
        self
    }

    /// Enable buffering
    pub fn buffered(mut self, buffered: bool) -> Self {
        self.buffered = buffered;
        self
    }

    /// Build the stream
    pub fn build(self) -> StreamResult<FileStream> {
        let path = self.path.ok_or_else(|| StreamError::InvalidOperation)?;
        FileStream::open(&path, self.mode)
    }

    /// Open read-only
    pub fn read(path: &str) -> StreamResult<FileStream> {
        Self::new().path(path).mode(StreamMode::Read).build()
    }

    /// Open write-only (truncate)
    pub fn write(path: &str) -> StreamResult<FileStream> {
        Self::new().path(path).mode(StreamMode::Write).build()
    }

    /// Open append
    pub fn append(path: &str) -> StreamResult<FileStream> {
        Self::new().path(path).mode(StreamMode::Append).build()
    }

    /// Open read-write
    pub fn read_write(path: &str) -> StreamResult<FileStream> {
        Self::new().path(path).mode(StreamMode::ReadWrite).build()
    }
}

impl Default for StreamBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Helper for reading entire files
pub fn read_file_contents(path: &str) -> StreamResult<String> {
    let mut stream = StreamBuilder::read(path)?;
    let mut contents = String::new();
    use std::io::Read;
    stream.read_to_string(&mut contents)
        .map_err(|e| StreamError::IoError(e.to_string()))?;
    Ok(contents)
}

/// Helper for writing entire files
pub fn write_file_contents(path: &str, contents: &str) -> StreamResult<()> {
    let mut stream = StreamBuilder::write(path)?;
    use std::io::Write;
    stream.write_all(contents.as_bytes())
        .map_err(|e| StreamError::IoError(e.to_string()))?;
    stream.flush()
        .map_err(|e| StreamError::IoError(e.to_string()))?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;

    #[test]
    fn test_stream_builder_read() {
        // Create a test file
        let test_path = "/tmp/test_stream_read.txt";
        let test_content = "Hello, World!";
        fs::write(test_path, test_content).unwrap();

        let result = StreamBuilder::read(test_path);
        assert!(result.is_ok());

        // Cleanup
        let _ = fs::remove_file(test_path);
    }

    #[test]
    fn test_stream_builder_write() {
        let test_path = "/tmp/test_stream_write.txt";

        let result = StreamBuilder::write(test_path);
        assert!(result.is_ok());

        // Cleanup
        let _ = fs::remove_file(test_path);
    }

    #[test]
    fn test_read_write_helpers() {
        let test_path = "/tmp/test_stream_helpers.txt";
        let test_content = "Test content for helpers";

        // Write
        let write_result = write_file_contents(test_path, test_content);
        assert!(write_result.is_ok());

        // Read
        let read_result = read_file_contents(test_path);
        assert!(read_result.is_ok());
        assert_eq!(read_result.unwrap(), test_content);

        // Cleanup
        let _ = fs::remove_file(test_path);
    }
}