Starting examples rewriting

Cargo.toml

@@ -33,4 +33,5 @@ members = [
 
     # Internal
     "benchmarks",
+    "examples",
 ]

examples/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "examples"
+version = "0.0.0"
+authors = ["svartalf <self@svartalf.info>"]
+edition = "2018"
+publish = false
+
+[dev-dependencies]
+heim = { path = "../heim", features = ["full", "runtime-tokio"] }
+tokio = { version = "~0.2", features = ["full", "macros"] }
+futures-timer = "~3.0"
+
+[[example]]
+name = "disk_usage"
+path = "disk_usage.rs"
+
+[[example]]
+name = "free"
+path = "free.rs"
+
+[[example]]
+name = "uname"
+path = "uname.rs"
+
+[[example]]
+name = "top"
+path = "top.rs"

heim-disk/examples/disk_usage.rs → examples/disk_usage.rs

@@ -1,23 +1,23 @@
-//! Command similar to `df -BM`
+//! Unix `du -h` command implementation.
 
 use std::ffi::OsStr;
 
-use heim_common::prelude::*;
-use heim_common::units::information;
-use heim_disk as disk;
+use heim::units::information;
+use tokio::stream::StreamExt;
 
-#[heim_derive::main]
-async fn main() -> Result<()> {
+#[tokio::main]
+async fn main() -> heim::Result<()> {
     println!(
         "{:<17} {:<10} {:<10} {:<10} {:<10} Mount",
         "Device", "Total, Mb", "Used, Mb", "Free, Mb", "Type"
     );
 
-    let partitions = disk::partitions_physical();
-    pin_utils::pin_mut!(partitions);
+    let partitions = heim::disk::partitions_physical();
+    tokio::pin!(partitions);
+
     while let Some(part) = partitions.next().await {
         let part = part?;
-        let usage = disk::usage(part.mount_point().to_path_buf()).await?;
+        let usage = heim::disk::usage(part.mount_point().to_path_buf()).await?;
 
         println!(
             "{:<17} {:<10} {:<10} {:<10} {:<10} {}",

heim-memory/examples/free.rs → examples/free.rs

@@ -1,8 +1,8 @@
-use heim_common::prelude::*;
-use heim_common::units::information;
-use heim_memory as memory;
+//! Naive clone of the `free` utility
 
-#[heim_derive::main]
+use heim::{memory, units::information, Result};
+
+#[tokio::main]
 async fn main() -> Result<()> {
     let memory = memory::memory().await?;
     let swap = memory::swap().await?;

heim-process/examples/top.rs → examples/top.rs

@@ -1,9 +1,11 @@
 use std::time::{Duration, Instant};
 use std::usize;
 
-use heim_common::prelude::{StreamExt, TryStreamExt};
-use heim_common::units::{ratio, Ratio};
-use heim_process::{self as process, Process, ProcessResult};
+use futures::stream::{StreamExt, TryStreamExt};
+use heim::{
+    process::{self, Process, ProcessResult},
+    units::{ratio, Ratio},
+};
 
 async fn usage(process: Process) -> ProcessResult<(process::Process, Ratio)> {
     let usage_1 = process.cpu_usage().await?;
@@ -13,7 +15,7 @@ async fn usage(process: Process) -> ProcessResult<(process::Process, Ratio)> {
     Ok((process, usage_2 - usage_1))
 }
 
-#[heim_derive::main]
+#[tokio::main]
 async fn main() -> ProcessResult<()> {
     let start = Instant::now();
 

examples/uname.rs

@@ -0,0 +1,19 @@
+//! `uname -a` implementation
+
+use heim::{host, Result};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let platform = host::platform().await?;
+
+    println!(
+        "{} {} {} {} {}",
+        platform.system(),
+        platform.release(),
+        platform.hostname(),
+        platform.version(),
+        platform.architecture().as_str(),
+    );
+
+    Ok(())
+}