prodigy 0.4.4

Turn ad-hoc Claude sessions into reproducible development pipelines with parallel AI agents
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

//! Combined application environment
//!
//! Provides a unified environment type that combines all I/O capabilities.

use super::mock::{MockDbEnv, MockFileEnv, MockGitEnv, MockProcessEnv};
use super::real::{RealDbEnv, RealFileEnv, RealGitEnv, RealProcessEnv};
use super::traits::{DbEnv, FileEnv, GitEnv, ProcessEnv};
use std::path::PathBuf;
use std::sync::Arc;

/// Combined application environment
///
/// Provides access to all I/O capabilities (file system, process execution, git, database).
/// Can be constructed with real or mock implementations for testing.
///
/// # Examples
///
/// ```
/// use prodigy::env::AppEnv;
///
/// // Create real environment for production use
/// let env = AppEnv::real();
///
/// // Create mock environment for testing
/// let test_env = AppEnv::mock();
/// ```
#[derive(Clone)]
pub struct AppEnv {
    pub fs: Arc<dyn FileEnv>,
    pub process: Arc<dyn ProcessEnv>,
    pub git: Arc<dyn GitEnv>,
    pub db: Arc<dyn DbEnv>,
}

impl AppEnv {
    /// Create an environment with real implementations
    ///
    /// Use this in production code to interact with the actual file system,
    /// processes, git repositories, and databases.
    pub fn real() -> Self {
        Self::real_with_git_dir(std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")))
    }

    /// Create a real environment with a specific git working directory
    pub fn real_with_git_dir(git_dir: PathBuf) -> Self {
        Self {
            fs: Arc::new(RealFileEnv::new()),
            process: Arc::new(RealProcessEnv::new()),
            git: Arc::new(RealGitEnv::new(git_dir)),
            db: Arc::new(RealDbEnv::new()),
        }
    }

    /// Create an environment with mock implementations
    ///
    /// Use this in tests to avoid actual I/O operations.
    pub fn mock() -> Self {
        Self {
            fs: Arc::new(MockFileEnv::new()),
            process: Arc::new(MockProcessEnv::new()),
            git: Arc::new(MockGitEnv::new()),
            db: Arc::new(MockDbEnv::new()),
        }
    }

    /// Create a custom environment with specific implementations
    pub fn custom(
        fs: Arc<dyn FileEnv>,
        process: Arc<dyn ProcessEnv>,
        git: Arc<dyn GitEnv>,
        db: Arc<dyn DbEnv>,
    ) -> Self {
        Self {
            fs,
            process,
            git,
            db,
        }
    }
}

impl std::fmt::Debug for AppEnv {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AppEnv")
            .field("fs", &"dyn FileEnv")
            .field("process", &"dyn ProcessEnv")
            .field("git", &"dyn GitEnv")
            .field("db", &"dyn DbEnv")
            .finish()
    }
}

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

    #[test]
    fn test_mock_env_creation() {
        let env = AppEnv::mock();
        let mock_fs = env.fs.clone();

        // Verify mock file system works
        let path = Path::new("test.txt");
        assert!(!mock_fs.exists(path));
    }

    #[test]
    fn test_real_env_creation() {
        let env = AppEnv::real();
        // Just verify it constructs without panic
        assert!(env.fs.exists(Path::new(".")));
    }
}