settingspec 0.1.1__tar.gz → 0.2.0__tar.gz

{settingspec-0.1.1 → settingspec-0.2.0}/Cargo.lock

@@ -564,7 +564,7 @@ dependencies = [
 
 [[package]]
 name = "settingspec"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "assert_cmd",

{settingspec-0.1.1 → settingspec-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "settingspec"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 description = "One file for all environments, all languages, all submodules."
 readme = "README.md"

{settingspec-0.1.1 → settingspec-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: settingspec
-Version: 0.1.1
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{settingspec-0.1.1 → settingspec-0.2.0}/src/cli.rs

@@ -23,6 +23,8 @@ pub struct Cli {
 
 #[derive(Subcommand, Debug)]
 pub enum Commands {
+    /// Initializes settingspec.toml in current directory
+    Init,
     /// Generates all configured export files and/or writes formatted output to stdout
     Export,
     /// Validates configuration syntax, profile completeness, and environment variables
@@ -34,19 +36,71 @@ pub enum Commands {
     },
 }
 
+pub const INIT_CONFIG: &str = r#"[spec]
+profile.options = ["local", "prod"]
+profile.default = "local"  # Switch via $SETTINGSPEC_PROFILE
+
+[settings]
+key.local.val = "local"
+key.prod.env = "KEY"  # Load from $KEY when active profile is "prod"
+"#;
+
+pub fn init_config() -> Result<()> {
+    let config_path = Path::new("settingspec.toml");
+    if config_path.exists() {
+        return Ok(());
+    }
+    std::fs::write(config_path, INIT_CONFIG)?;
+    Ok(())
+}
+
 pub struct ExecutionContext {
     pub doc: SettingSpecDocument,
     pub active_profile: Option<String>,
     pub resolved_settings: Vec<ResolvedSetting>,
     pub sourced_env: HashMap<String, String>,
+    pub project_root: PathBuf,
+}
+
+pub fn find_project_root(start_dir: &Path) -> Option<PathBuf> {
+    let mut current = if start_dir.is_relative() {
+        match std::env::current_dir() {
+            Ok(cwd) => cwd.join(start_dir),
+            Err(_) => start_dir.to_path_buf(),
+        }
+    } else {
+        start_dir.to_path_buf()
+    };
+    if let Ok(canon) = current.canonicalize() {
+        current = canon;
+    } else {
+        current = normalize_path(&current);
+    }
+    loop {
+        let config = current.join("settingspec.toml");
+        if config.is_file() {
+            return Some(current);
+        }
+        if !current.pop() {
+            break;
+        }
+    }
+    None
 }
 
 pub fn load_and_resolve() -> Result<ExecutionContext> {
-    let config_path = Path::new("settingspec.toml");
-    if !config_path.exists() {
-        return Err(SettingSpecError::ConfigNotFound);
+    let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let project_root = find_project_root(&current_dir).ok_or(SettingSpecError::ConfigNotFound)?;
+
+    if let Ok(current_canon) = current_dir.canonicalize() {
+        if project_root != current_canon {
+            std::env::set_current_dir(&project_root)?;
+        }
+    } else if project_root != current_dir {
+        std::env::set_current_dir(&project_root)?;
     }
 
+    let config_path = Path::new("settingspec.toml");
     let content = std::fs::read_to_string(config_path)?;
     let doc = parse_config_str(&content)?;
 
@@ -64,6 +118,7 @@ pub fn load_and_resolve() -> Result<ExecutionContext> {
         active_profile,
         resolved_settings,
         sourced_env,
+        project_root,
     })
 }
 
@@ -71,6 +126,7 @@ pub fn run_cli() -> Result<()> {
     let cli = Cli::parse();
 
     match cli.command {
+        Commands::Init => init_config(),
         Commands::Check => {
             // Check only validates config syntax, profiles, env vars without creating files
             load_and_resolve()?;
@@ -224,7 +280,7 @@ fn execute_run(ctx: &ExecutionContext, command_args: &[String]) -> Result<()> {
     Ok(())
 }
 
-pub fn write_export_file(path: &Path, content: &str, mode: u32) -> Result<()> {
+pub fn write_export_file(path: &Path, content: &str, _mode: u32) -> Result<()> {
     if let Some(parent) = path.parent()
         && !parent.as_os_str().is_empty()
     {
@@ -236,7 +292,7 @@ pub fn write_export_file(path: &Path, content: &str, mode: u32) -> Result<()> {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
-        let perms = std::fs::Permissions::from_mode(mode);
+        let perms = std::fs::Permissions::from_mode(_mode);
         let _ = std::fs::set_permissions(path, perms);
     }
 
@@ -296,12 +352,12 @@ fn is_entry_in_gitignore(existing_content: &str, entry: &str) -> bool {
         }
         // In git, a pattern without '/' matches anywhere in the repository:
         // E.g. if .gitignore has "settings.toml", it matches "subdir/settings.toml".
-        if !trimmed.starts_with('/') && !norm_line.contains('/') {
-            if let Some((_, file_name)) = norm_entry.rsplit_once('/') {
-                if file_name == norm_line {
-                    return true;
-                }
-            }
+        if !trimmed.starts_with('/')
+            && !norm_line.contains('/')
+            && let Some((_, file_name)) = norm_entry.rsplit_once('/')
+            && file_name == norm_line
+        {
+            return true;
         }
     }
     false
@@ -312,8 +368,8 @@ pub fn auto_append_gitignore(ctx: &ExecutionContext) -> Result<()> {
         return Ok(());
     }
 
-    let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    let git_root = match find_git_root(&current_dir) {
+    let current_dir = &ctx.project_root;
+    let git_root = match find_git_root(current_dir) {
         Some(root) => root,
         None => return Ok(()),
     };

{settingspec-0.1.1 → settingspec-0.2.0}/src/model.rs

@@ -155,14 +155,16 @@ where
     D: Deserializer<'de>,
 {
     let val = i64::deserialize(deserializer)?;
-    let mode_u32 = if val == 0x600 || val == 0o600 {
-        0o600
-    } else if (0..=0o777).contains(&val) {
-        val as u32
-    } else {
-        0o600
-    };
-    Ok(mode_u32)
+    if (0..=0o777).contains(&val) {
+        return Ok(val as u32);
+    }
+    let hex = format!("{:x}", val);
+    if let Ok(octal) = u32::from_str_radix(&hex, 8)
+        && (0..=0o7777).contains(&octal)
+    {
+        return Ok(octal);
+    }
+    Ok(0o600)
 }
 
 /// A field that accepts either a boolean toggle or a string value in TOML.