nord-usb 0.6.0

Talk to a Nord keyboard over USB from Rust, on the desktop and in the browser
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

//! Finding and reading replay scripts. Nothing here knows how a tree is laid out — a
//! script joins by having the extension, wherever it sits.
//!
//! ⚠️ A rustc-visible support module, not a test target — each test target that
//! includes it compiles its own copy.
#![allow(dead_code)]

use nord_usb::transport::Script;
use std::fs;
use std::path::{Path, PathBuf};

/// The committed scripts, which every checkout has.
pub fn fixtures() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/scripts")
}

/// The private corpus checkout: `NORD_CORPUS_ROOT`.
pub fn corpus() -> PathBuf {
    std::env::var_os("NORD_CORPUS_ROOT")
        .map(PathBuf::from)
        .expect("set NORD_CORPUS_ROOT to a nord-corpus checkout for --features corpus")
}

/// Every `*.script` under `root`, in a stable order.
pub fn walk(root: &Path) -> Vec<PathBuf> {
    let mut found = Vec::new();
    let mut stack = vec![root.to_path_buf()];
    while let Some(dir) = stack.pop() {
        for entry in fs::read_dir(&dir).unwrap_or_else(|e| panic!("{}: {e}", dir.display())) {
            let path = entry.unwrap().path();
            if path.is_dir() {
                if path.file_name().is_some_and(|n| n != ".git") {
                    stack.push(path);
                }
            } else if path.extension().is_some_and(|e| e == "script") {
                found.push(path);
            }
        }
    }
    found.sort();
    found
}

/// One script, read and parsed.
pub fn read(path: &Path) -> Script {
    let text =
        fs::read_to_string(path).unwrap_or_else(|e| panic!("reading {}: {e}", path.display()));
    Script::parse(&text).unwrap_or_else(|e| panic!("{}: {e}", path.display()))
}

/// One committed script, by its path under `tests/scripts`.
pub fn fixture(rel: &str) -> Script {
    read(&fixtures().join(rel))
}

/// The path under its root, `/`-joined on every platform so the documented filters and
/// the trial kinds read the same everywhere.
pub fn rel(root: &Path, path: &Path) -> String {
    path.strip_prefix(root)
        .unwrap_or(path)
        .components()
        .map(|c| c.as_os_str().to_string_lossy())
        .collect::<Vec<_>>()
        .join("/")
}