solarboat 0.8.9

A CLI tool for intelligent Terraform operations management with automatic dependency detection
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

use crate::config::{ConfigLoader, ConfigResolver};
use anyhow::Result;
use std::path::PathBuf;

/// Application settings that can be loaded from configuration files
pub struct Settings {
    /// The resolved configuration for the application
    pub config_resolver: ConfigResolver,
}

impl Settings {
    /// Load settings from configuration file
    pub fn load<P: AsRef<std::path::Path>>(config_path: P) -> Result<Self> {
        let config_path = config_path.as_ref().to_path_buf();
        
        // Check if the path is a file or directory
        if config_path.is_file() {
            // Load from specific file
            let config_dir = config_path.parent().unwrap_or(&PathBuf::from(".")).to_path_buf();
            let loader = ConfigLoader::new(&config_dir);
            let config = loader.load_from_path(&config_path)?;
            
            // Validate configuration
            loader.validate_config(&config)?;
            
            // Create resolver
            let config_resolver = ConfigResolver::new(Some(config), config_dir);
            Ok(Self { config_resolver })
        } else {
            // Load from directory (auto-discover)
            let loader = ConfigLoader::new(&config_path);
            let config = loader.load()?;
            
            // Validate configuration if loaded
            if let Some(ref config_data) = config {
                loader.validate_config(config_data)?;
            }
            
            // Create resolver
            let config_resolver = ConfigResolver::new(config, config_path);
            Ok(Self { config_resolver })
        }
    }
    
    /// Load settings from current working directory
    pub fn load_from_current_dir() -> Result<Self> {
        let loader = ConfigLoader::from_current_dir()?;
        let config_dir = loader.search_dir.clone();
        
        // Load configuration file
        let config = loader.load()?;
        
        // Validate configuration if loaded
        if let Some(ref config_data) = config {
            loader.validate_config(config_data)?;
        }
        
        // Create resolver
        let config_resolver = ConfigResolver::new(config, config_dir);
        
        Ok(Self { config_resolver })
    }
    
    /// Get the configuration resolver
    pub fn resolver(&self) -> &ConfigResolver {
        &self.config_resolver
    }
}