allow file arguments to be - to use stdin/out (#9)

Author: bend-n

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "godot-package-manager"
-version = "0.3.1"
+version = "0.4.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/config_file.rs

@@ -1,8 +1,6 @@
 use crate::package::Package;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::fs::write;
-use std::path::PathBuf;
 
 #[derive(Debug, Default)]
 /// The config file: parsed from godot.package, usually.
@@ -21,13 +19,12 @@ struct PackageLock {
 impl ConfigFile {
     /// Creates a new [ConfigFile] from the given path.
     /// Panics if the file doesn't exist, or the file cant be parsed as toml, hjson or yaml.
-    pub fn new(path: PathBuf) -> Self {
+    pub fn new(contents: &String) -> Self {
         #[derive(Debug, Deserialize, Default)]
         #[serde(default)]
         struct W {
             packages: HashMap<String, String>,
         }
-        let contents = &std::fs::read_to_string(path).expect("The config file should exist");
         #[rustfmt::skip]
         let cfg: W = if let Ok(w) = deser_hjson::from_str(contents) { w }
                      else if let Ok(w) = serde_yaml::from_str(contents) { w }
@@ -45,22 +42,18 @@ impl ConfigFile {
 
     /// Creates a lockfile for this config file.
     /// note: Lockfiles are currently unused.
-    pub fn lock(&mut self, path: PathBuf) {
-        write(
-            path,
-            serde_json::to_string(
-                &self
-                    .collect()
-                    .into_iter()
-                    .filter_map(|p| {
-                        p.is_installed()
-                            .then_some((p.name.clone(), PackageLock::new(p)))
-                    })
-                    .collect::<HashMap<String, PackageLock>>(),
-            )
-            .unwrap(),
+    pub fn lock(&mut self) -> String {
+        serde_json::to_string(
+            &self
+                .collect()
+                .into_iter()
+                .filter_map(|p| {
+                    p.is_installed()
+                        .then_some((p.name.clone(), PackageLock::new(p)))
+                })
+                .collect::<HashMap<String, PackageLock>>(),
         )
-        .expect("Writing lock file should work");
+        .unwrap()
     }
 
     /// Iterates over all the packages (and their deps) in this config file.

src/main.rs

@@ -6,8 +6,8 @@ use crate::package::Package;
 use clap::Parser;
 use config_file::ConfigFile;
 use std::env::current_dir;
-use std::fs::{create_dir, read_dir, remove_dir};
-use std::io::Result;
+use std::fs::{create_dir, read_dir, remove_dir, write};
+use std::io::{stdin, Read, Result};
 use std::panic;
 use std::path::{Path, PathBuf};
 
@@ -24,15 +24,15 @@ struct Args {
         default_value = "godot.package",
         global = true
     )]
-    /// Specify the location of the package configuration file (https://github.com/godot-package-manager#godotpackage).
+    /// Specify the location of the package configuration file (https://github.com/godot-package-manager#godotpackage). If -, read from stdin.
     config_file: PathBuf,
     #[arg(
         short = 'l',
         long = "lock-file",
         default_value = "godot.lock",
         global = true
     )]
-    /// Specify the location of the lock file
+    /// Specify the location of the lock file. If -, print to stdout.
     lock_file: PathBuf,
 }
 
@@ -68,14 +68,30 @@ fn main() {
         else { println!("unknown"); };
     }));
     let args = Args::parse();
-    let mut cfg_file = ConfigFile::new(args.config_file);
+    let mut contents = String::from("");
+    if args.config_file == Path::new("-") {
+        let bytes = stdin()
+            .read_to_string(&mut contents)
+            .expect("Stdin read should be ok");
+        if bytes == 0 {
+            panic!("Stdin should not be empty");
+        };
+    } else {
+        contents =
+            std::fs::read_to_string(args.config_file).expect("Reading config file should be ok");
+    };
+    let mut cfg_file = ConfigFile::new(&contents);
     match args.action {
         Actions::Update => update(&mut cfg_file),
         Actions::Purge => purge(&mut cfg_file),
         Actions::Tree => tree(&cfg_file),
     }
-    cfg_file.lock(args.lock_file);
-    println!("Finished");
+    let lockfile = cfg_file.lock();
+    if args.lock_file == Path::new("-") {
+        println!("{lockfile}");
+    } else {
+        write(args.lock_file, lockfile).expect("Writing lock file should be ok");
+    }
 }
 
 fn update(cfg: &mut ConfigFile) {