src/buf.rs
src/sqlfuncs.rs
src/futures.rs
src/iox.rs
src/tokiox.rs
src/tokiox/tcpconn.rs
src/serde_parsers.rs
examples/fut_if_some.rs
examples/deser.rs

[package]
name = "orphanage"
version = "0.0.4"
edition = "2021"
license = "0BSD"
# https://crates.io/category_slugs
categories = [ "network-programming" ]
keywords = [ "sqlite", "fs", "path" ]
repository = "https://repos.qrnch.tech/pub/orphanage"
description = "Random collection of stuff that is still searching for a home."

tokio = ["dep:tokio", "dep:async-trait", "dep:killswitch"]
rusqlite = ["dep:rusqlite", "dep:sha2"]
serde = ["dep:serde", "dep:parse-size"]

[dependencies]
async-trait = { version = "0.1.82", optional = true }
killswitch = { version = "0.4.2", optional = true }
parse-size = { version = "1.1.0", optional = true }
rand = { version = "0.8.5" }
rusqlite = { version = "0.32.1", optional = true, features = ["functions"] }
serde = { version = "1.0.210", optional = true, features = ["derive"] }
sha2 = { version = "0.10.7", optional = true }
shellexpand = { version = "3.1.0" }
tokio = { version = "1.40.0", optional = true, features = [
  "macros", "net", "time"
] }

[dev-dependencies]
killswitch = { version = "0.4.2" }
tokio = { version = "1.40.0", features = ["full"] }
tokio-test = { version = "0.4.3" }
toml = { version = "0.8.18" }

[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"]

[lints.clippy]
all = { level = "deny", priority = -1 }
pedantic = { level = "warn", priority = -1 }
nursery = { level = "warn", priority = -1 }
cargo = { level = "warn", priority = -1 }

multiple_crate_versions = "allow"

#[cfg(feature = "serde")]
mod inner {
  use serde::Deserialize;

  use orphanage::serde_parsers::ExpandedPath;

  #[derive(Debug, Deserialize)]
  #[allow(dead_code)]
  struct Config {
    #[serde(rename = "expanded-path")]
    epth: ExpandedPath,

    #[serde(default, rename = "optional-expanded-path")]
    optepth: Option<ExpandedPath>
  }

  #[cfg(feature = "serde")]
  pub fn main() {
    match toml::from_str::<Config>(
      r#"
expanded-path = "~/tmp"
"#
    ) {
      Ok(config) => {
        println!("{config:?}");
      }
      Err(e) => {
        println!("{e}");
      }
    }

    match toml::from_str::<Config>(
      r#"
optional-expanded-path = "$NonExistent"
"#
    ) {
      Ok(config) => {
        println!("{config:?}");
      }
      Err(e) => {
        println!("{e}");
      }
    }
  }
}


#[cfg(feature = "serde")]
fn main() {
  inner::main();
}

#[cfg(not(feature = "serde"))]
fn main() {
  println!("Example requires `serde` feature");
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

use std::time::Duration;

use orphanage::futures::if_some;

use tokio::{task, time::sleep};

use killswitch::KillSwitch;

#[tokio::main(flavor = "multi_thread")]
async fn main() {
  let ks = KillSwitch::new();

  let ks2 = ks.clone();
  task::spawn(async move {
    sleep(Duration::from_secs(1)).await;
    ks2.trigger();
  });

  println!("Should sleep for 1 second, and is then killed");
  maybe_kill_sleep(Some(&ks)).await;

  println!("Should sleep for 4 seconds, and then expires");
  maybe_kill_sleep(None).await;
}


#[allow(clippy::redundant_pub_crate)]
async fn maybe_kill_sleep(ks: Option<&KillSwitch>) {
  let mut kwfut = ks.map(KillSwitch::wait);
  tokio::select! {
    _ = if_some(&mut kwfut) => {
      println!("Killed");
    }
    () = sleep(Duration::from_secs(4)) => {
      println!("Expired");
    }
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

//!   /// Support optional `binsize = 65536` and `binsize = "64KB"`
//!   binsize_opt: Option<BinSize>,
//!
//!   /// Support `decsize = 20000` and `decsize = "20KB"`
//!   decsize: DecSize,
//!
//!   /// Support optional `decsize = 20000` and `decsize = "20KB"`
//!   decsize_opt: Option<DecSize>,
//!
//!   /// Support optional `~/tmp`
//!   epth: Option<ExpandedPath>
//! }
//! ```

use std::path::{Path, PathBuf};

use serde::{de::Deserializer, Deserialize};

#[derive(Debug, Default, PartialEq, Eq)]
pub struct Count(pub u64);

impl Count {

  where
    D: Deserializer<'de>
  {
    decsize(deserializer)
  }
}


#[derive(Debug, Default, PartialEq, Eq)]
pub struct ExpandedPath(pub PathBuf);

impl ExpandedPath {
  #[must_use]
  pub fn get(&self) -> &Path {
    &self.0
  }
}


#[allow(clippy::missing_errors_doc)]
pub fn expand_path<'de, D>(deserializer: D) -> Result<ExpandedPath, D::Error>
where
  D: Deserializer<'de>
{
  let s = String::deserialize(deserializer)?;
  match shellexpand::full(&s) {
    Ok(value) => Ok(ExpandedPath(PathBuf::from(value.into_owned()))),
    Err(e) => {
      let msg = format!("Unable to expand path; {e}");
      Err(serde::de::Error::custom(msg))
    }
  }
}

impl<'de> Deserialize<'de> for ExpandedPath {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: Deserializer<'de>
  {
    expand_path(deserializer)
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

# Change Log

## [Unreleased]

[Details](/vdiff?from=orphanage-0.0.3&to=trunk)

### Added

Add a `ExpandedPath` deserializer.

### Changed

### Removed

---