runtime-checker 1.0.0

package/src/data.rs

@@ -0,0 +1,266 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::OnceLock,
+};
+
+use anyhow::{Context, Result};
+use serde::Deserialize;
+
+use crate::{cli::RuntimeKind, version::RuntimeVersion};
+
+static NODE_SPEC: &str = include_str!("../data/node.ron");
+static DENO_SPEC: &str = include_str!("../data/mdn/deno.ron");
+static BUN_SPEC: &str = include_str!("../data/mdn/bun.ron");
+static SAFARI_SPEC: &str = include_str!("../data/mdn/safari.ron");
+static CHROME_SPEC: &str = include_str!("../data/mdn/chrome.ron");
+static FIREFOX_SPEC: &str = include_str!("../data/mdn/firefox.ron");
+static NODE_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+static DENO_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+static BUN_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+static SAFARI_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+static CHROME_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+static FIREFOX_RUNTIME: OnceLock<RuntimeDb> = OnceLock::new();
+
+#[derive(Debug, Deserialize)]
+struct RuntimeSpec {
+    schema: u32,
+    runtime: String,
+    features: Vec<FeatureSpec>,
+}
+
+#[derive(Debug, Deserialize)]
+struct FeatureSpec {
+    name: String,
+    version: RuntimeVersion,
+    detect: Vec<DetectRule>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub enum DetectRule {
+    Global(String),
+    MemberChain(String),
+    Property(String),
+}
+
+#[derive(Debug)]
+pub struct RuntimeDb {
+    name: String,
+    features: Vec<Feature>,
+    globals: HashMap<String, usize>,
+    member_chains: HashMap<String, usize>,
+    properties: HashMap<String, usize>,
+    fast_patterns: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Feature {
+    pub id: usize,
+    pub name: String,
+    pub version: RuntimeVersion,
+}
+
+impl RuntimeDb {
+    fn from_spec(spec: RuntimeSpec) -> Result<Self> {
+        anyhow::ensure!(
+            spec.schema == 1,
+            "unsupported {} schema {}",
+            spec.runtime,
+            spec.schema
+        );
+
+        let mut db = Self {
+            name: spec.runtime,
+            features: Vec::with_capacity(spec.features.len()),
+            globals: HashMap::new(),
+            member_chains: HashMap::new(),
+            properties: HashMap::new(),
+            fast_patterns: Vec::new(),
+        };
+
+        let mut patterns = HashSet::new();
+        for feature in spec.features {
+            let index = db.features.len();
+            db.features.push(Feature {
+                id: index,
+                name: feature.name,
+                version: feature.version,
+            });
+
+            for rule in feature.detect {
+                match rule {
+                    DetectRule::Global(name) => {
+                        db.insert_highest_global(name.clone(), index);
+                        patterns.insert(name);
+                    }
+                    DetectRule::MemberChain(name) => {
+                        db.insert_highest_member_chain(name.clone(), index);
+                        patterns.insert(name);
+                    }
+                    DetectRule::Property(name) => {
+                        db.insert_highest_property(name.clone(), index);
+                        patterns.insert(name);
+                    }
+                }
+            }
+        }
+
+        db.fast_patterns = patterns.into_iter().collect();
+        db.fast_patterns
+            .sort_by_key(|pattern| std::cmp::Reverse(pattern.len()));
+        Ok(db)
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn fast_patterns(&self) -> &[String] {
+        &self.fast_patterns
+    }
+
+    pub fn feature_for_pattern(&self, pattern: &str) -> Option<&Feature> {
+        self.globals
+            .get(pattern)
+            .or_else(|| self.member_chains.get(pattern))
+            .or_else(|| self.properties.get(pattern))
+            .and_then(|index| self.features.get(*index))
+    }
+
+    pub fn is_global_or_member_pattern(&self, pattern: &str) -> bool {
+        self.globals.contains_key(pattern) || self.member_chains.contains_key(pattern)
+    }
+
+    pub fn is_property_pattern(&self, pattern: &str) -> bool {
+        self.properties.contains_key(pattern)
+    }
+
+    pub fn match_global(&self, name: &str) -> Option<&Feature> {
+        self.globals
+            .get(name)
+            .and_then(|index| self.features.get(*index))
+    }
+
+    pub fn match_member_chain(&self, name: &str) -> Option<&Feature> {
+        self.member_chains
+            .get(name)
+            .and_then(|index| self.features.get(*index))
+    }
+
+    pub fn match_property(&self, name: &str) -> Option<&Feature> {
+        self.properties
+            .get(name)
+            .and_then(|index| self.features.get(*index))
+    }
+
+    fn insert_highest_global(&mut self, name: String, index: usize) {
+        insert_highest(&self.features, &mut self.globals, name, index);
+    }
+
+    fn insert_highest_member_chain(&mut self, name: String, index: usize) {
+        insert_highest(&self.features, &mut self.member_chains, name, index);
+    }
+
+    fn insert_highest_property(&mut self, name: String, index: usize) {
+        insert_highest(&self.features, &mut self.properties, name, index);
+    }
+}
+
+fn insert_highest(
+    features: &[Feature],
+    map: &mut HashMap<String, usize>,
+    key: String,
+    candidate: usize,
+) {
+    match map.get(&key).copied() {
+        Some(existing) if features[existing].version >= features[candidate].version => {}
+        _ => {
+            map.insert(key, candidate);
+        }
+    }
+}
+
+#[cfg(test)]
+pub fn node_runtime() -> Result<&'static RuntimeDb> {
+    runtime(RuntimeKind::Node)
+}
+
+pub fn runtime(kind: RuntimeKind) -> Result<&'static RuntimeDb> {
+    match kind {
+        RuntimeKind::All => anyhow::bail!("all is not a concrete runtime database"),
+        RuntimeKind::Node => load_runtime(&NODE_RUNTIME, NODE_SPEC, "data/node.ron"),
+        RuntimeKind::Deno => load_runtime(&DENO_RUNTIME, DENO_SPEC, "data/mdn/deno.ron"),
+        RuntimeKind::Bun => load_runtime(&BUN_RUNTIME, BUN_SPEC, "data/mdn/bun.ron"),
+        RuntimeKind::Safari => load_runtime(&SAFARI_RUNTIME, SAFARI_SPEC, "data/mdn/safari.ron"),
+        RuntimeKind::Chrome => load_runtime(&CHROME_RUNTIME, CHROME_SPEC, "data/mdn/chrome.ron"),
+        RuntimeKind::Firefox => {
+            load_runtime(&FIREFOX_RUNTIME, FIREFOX_SPEC, "data/mdn/firefox.ron")
+        }
+    }
+}
+
+fn load_runtime(
+    lock: &'static OnceLock<RuntimeDb>,
+    source: &'static str,
+    source_name: &str,
+) -> Result<&'static RuntimeDb> {
+    if let Some(runtime) = lock.get() {
+        return Ok(runtime);
+    }
+
+    let spec = ron::from_str::<RuntimeSpec>(source)
+        .with_context(|| format!("failed to parse {source_name}"))?;
+    let runtime = RuntimeDb::from_spec(spec)?;
+    Ok(lock.get_or_init(|| runtime))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::cli::RuntimeKind;
+
+    use super::{node_runtime, runtime};
+
+    #[test]
+    fn loads_node_ron_database() {
+        let db = node_runtime().unwrap();
+        assert_eq!(db.name(), "node");
+        assert_eq!(
+            db.match_global("Temporal").unwrap().version.to_string(),
+            "26.0.0"
+        );
+        assert_eq!(
+            db.match_property("toSorted").unwrap().version.to_string(),
+            "20.0.0"
+        );
+    }
+
+    #[test]
+    fn loads_mdn_runtime_databases() {
+        let deno = runtime(RuntimeKind::Deno).unwrap();
+        let bun = runtime(RuntimeKind::Bun).unwrap();
+        let safari = runtime(RuntimeKind::Safari).unwrap();
+        let chrome = runtime(RuntimeKind::Chrome).unwrap();
+        let firefox = runtime(RuntimeKind::Firefox).unwrap();
+
+        assert_eq!(deno.name(), "deno");
+        assert_eq!(bun.name(), "bun");
+        assert_eq!(safari.name(), "safari");
+        assert_eq!(chrome.name(), "chrome");
+        assert_eq!(firefox.name(), "firefox");
+        assert_eq!(
+            deno.match_global("Temporal").unwrap().version.to_string(),
+            "2.7.0"
+        );
+        assert_eq!(
+            bun.match_global("fetch").unwrap().version.to_string(),
+            "1.0.0"
+        );
+        assert_eq!(
+            chrome
+                .match_property("toSorted")
+                .unwrap()
+                .version
+                .to_string(),
+            "110.0.0"
+        );
+    }
+}

package/src/engines.rs

@@ -0,0 +1,154 @@
+use std::{fs, path::PathBuf};
+
+use anyhow::{Context, Result};
+use node_semver::{Range, Version};
+use serde_json::Value;
+
+use crate::version::RuntimeVersion;
+
+#[derive(Debug, Clone)]
+pub struct EnginesReport {
+    pub package_json: PathBuf,
+    pub declared: Option<String>,
+    pub required: RuntimeVersion,
+    pub fixed: bool,
+    pub severity: EnginesSeverity,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EnginesSeverity {
+    Info,
+    Warning,
+}
+
+pub fn check_engines(
+    root: &std::path::Path,
+    required: RuntimeVersion,
+    fix: bool,
+) -> Result<Option<EnginesReport>> {
+    let package_json = root.join("package.json");
+    if !package_json.exists() {
+        return Ok(None);
+    }
+
+    let text = fs::read_to_string(&package_json)
+        .with_context(|| format!("failed to read {}", package_json.display()))?;
+    let mut json: Value = serde_json::from_str(&text)
+        .with_context(|| format!("failed to parse {}", package_json.display()))?;
+    let declared = json
+        .get("engines")
+        .and_then(|engines| engines.get("node"))
+        .and_then(Value::as_str)
+        .map(str::to_owned);
+
+    let compatible = declared
+        .as_deref()
+        .is_some_and(|range| range_allows_required(range, required));
+    let severity = declared
+        .as_deref()
+        .map(|range| engines_severity(range, required))
+        .unwrap_or(EnginesSeverity::Warning);
+    let needs_fix = !required.is_zero() && !compatible;
+
+    let mut fixed = false;
+    if fix && needs_fix {
+        set_engines_node(&mut json, &format!(">={required}"))?;
+        fs::write(
+            &package_json,
+            format!("{}\n", serde_json::to_string_pretty(&json)?),
+        )
+        .with_context(|| format!("failed to write {}", package_json.display()))?;
+        fixed = true;
+    }
+
+    if needs_fix || fixed {
+        Ok(Some(EnginesReport {
+            package_json,
+            declared,
+            required,
+            fixed,
+            severity,
+        }))
+    } else {
+        Ok(None)
+    }
+}
+
+fn range_allows_required(range: &str, required: RuntimeVersion) -> bool {
+    let Ok(range) = Range::parse(range) else {
+        return false;
+    };
+    let Ok(version) = Version::parse(required.to_string()) else {
+        return false;
+    };
+    range.satisfies(&version)
+}
+
+fn set_engines_node(json: &mut Value, value: &str) -> Result<()> {
+    let root = json
+        .as_object_mut()
+        .ok_or_else(|| anyhow::anyhow!("package.json root must be an object"))?;
+    let engines = root
+        .entry("engines")
+        .or_insert_with(|| Value::Object(Default::default()));
+    let engines = engines
+        .as_object_mut()
+        .ok_or_else(|| anyhow::anyhow!("package.json engines must be an object"))?;
+    engines.insert("node".to_owned(), Value::String(value.to_owned()));
+    Ok(())
+}
+
+fn engines_severity(range: &str, required: RuntimeVersion) -> EnginesSeverity {
+    if declared_lower_bound(range).is_some_and(|declared| declared > required) {
+        EnginesSeverity::Info
+    } else {
+        EnginesSeverity::Warning
+    }
+}
+
+fn declared_lower_bound(range: &str) -> Option<RuntimeVersion> {
+    let start = range.find(|ch: char| ch.is_ascii_digit())?;
+    let version = range[start..]
+        .chars()
+        .take_while(|ch| ch.is_ascii_digit() || *ch == '.')
+        .collect::<String>();
+    version.parse().ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{EnginesSeverity, engines_severity, range_allows_required};
+    use crate::version::RuntimeVersion;
+
+    #[test]
+    fn checks_npm_style_ranges() {
+        let required = RuntimeVersion {
+            major: 24,
+            minor: 0,
+            patch: 0,
+        };
+        assert!(range_allows_required(">=22", required));
+        assert!(!range_allows_required("^22.0.0", required));
+    }
+
+    #[test]
+    fn classifies_stricter_ranges_as_info() {
+        let required = RuntimeVersion {
+            major: 24,
+            minor: 0,
+            patch: 0,
+        };
+        assert_eq!(
+            engines_severity("^24.13.1", required),
+            EnginesSeverity::Info
+        );
+        assert_eq!(
+            engines_severity(">=24.13.1", required),
+            EnginesSeverity::Info
+        );
+        assert_eq!(
+            engines_severity("^23.0.0", required),
+            EnginesSeverity::Warning
+        );
+    }
+}

package/src/help.rs

@@ -0,0 +1,192 @@
+use terminal_size::{Width, terminal_size};
+
+const LABEL_COLUMN_WIDTH: usize = 28;
+
+type Rgb = (u8, u8, u8);
+
+const EMERALD_500: Rgb = (16, 185, 129);
+const SKY_500: Rgb = (14, 165, 233);
+const NEUTRAL_500: Rgb = (115, 115, 115);
+const NEUTRAL_600: Rgb = (82, 82, 82);
+const NEUTRAL_700: Rgb = (64, 64, 64);
+const WHITE: Rgb = (255, 255, 255);
+
+pub fn print_help() {
+    print!("{}", create_help_body());
+}
+
+fn create_help_body() -> String {
+    let body = [
+        create_header(),
+        create_section("Usage", &[usage_row()]),
+        create_section("Arguments", &[argument_row()]),
+        create_section(
+            "Options",
+            &[
+                option_row(
+                    &["--fast"],
+                    "use FFF text scanning; faster but less precise",
+                ),
+                option_row(
+                    &["--runtime <runtime>"],
+                    "target all, node, deno, bun, safari, chrome, or firefox",
+                ),
+                option_row(&["--summary"], "print only the summary panel"),
+                option_row(
+                    &["--inspect <feature>"],
+                    "print every detection for one feature",
+                ),
+                option_row(&["--fix"], "update package.json engines.node when useful"),
+                option_row(&["-h", "--help"], "display help for command"),
+            ],
+        ),
+    ]
+    .into_iter()
+    .filter(|section| !section.is_empty())
+    .collect::<Vec<_>>()
+    .join("\n\n");
+
+    format!("{body}\n")
+}
+
+fn create_header() -> String {
+    let wordmark = gradient("runtime-checker", EMERALD_500, SKY_500);
+    let version = badge(env!("CARGO_PKG_VERSION"));
+    create_streak(&format!("{wordmark} {version}"))
+}
+
+fn usage_row() -> String {
+    format!(
+        "  {} {}",
+        gradient("runtime-checker", EMERALD_500, SKY_500),
+        fg_rgb("<dir> [options]", WHITE)
+    )
+}
+
+fn argument_row() -> String {
+    let label = gradient("<dir>", EMERALD_500, SKY_500);
+    format!(
+        "  {}{}",
+        pad_ansi(&label, LABEL_COLUMN_WIDTH),
+        fg_rgb("directory to scan", WHITE)
+    )
+}
+
+fn option_row(flags: &[&str], description: &str) -> String {
+    let flags = format_aliases(flags);
+    format!(
+        "  {}{}",
+        pad_ansi(&flags, LABEL_COLUMN_WIDTH),
+        fg_rgb(description, WHITE)
+    )
+}
+
+fn create_section(title: &str, rows: &[String]) -> String {
+    if rows.is_empty() {
+        return String::new();
+    }
+
+    let heading = format!("{} {}", fg_rgb(title, WHITE), fg_rgb("»", NEUTRAL_700));
+    let mut section = heading;
+    for row in trim_empty_edges(rows) {
+        section.push('\n');
+        section.push_str(row);
+    }
+    section
+}
+
+fn format_aliases(aliases: &[&str]) -> String {
+    let separator = fg_rgb(", ", NEUTRAL_500);
+    aliases
+        .iter()
+        .map(|alias| gradient(alias, EMERALD_500, SKY_500))
+        .collect::<Vec<_>>()
+        .join(&separator)
+}
+
+fn trim_empty_edges(rows: &[String]) -> &[String] {
+    let Some(start) = rows.iter().position(|row| !row.is_empty()) else {
+        return &[];
+    };
+    let end = rows
+        .iter()
+        .rposition(|row| !row.is_empty())
+        .unwrap_or(start);
+    &rows[start..=end]
+}
+
+fn create_streak(content: &str) -> String {
+    let columns = terminal_width().saturating_sub(1).max(1);
+    let content_width = visible_width(content);
+    let right_width = columns.saturating_sub(content_width + 3).max(1);
+    format!(
+        "{} {} {}",
+        fg_rgb("─", NEUTRAL_700),
+        content,
+        fg_rgb("─".repeat(right_width), NEUTRAL_700)
+    )
+}
+
+fn terminal_width() -> usize {
+    terminal_size()
+        .map(|(Width(width), _)| width as usize)
+        .unwrap_or(80)
+        .max(40)
+}
+
+fn badge(label: &str) -> String {
+    format!(
+        "\x1b[48;2;{};{};{}m\x1b[38;2;{};{};{}m {label} \x1b[0m",
+        NEUTRAL_600.0, NEUTRAL_600.1, NEUTRAL_600.2, WHITE.0, WHITE.1, WHITE.2
+    )
+}
+
+fn fg_rgb(text: impl AsRef<str>, color: Rgb) -> String {
+    let text = text.as_ref();
+    format!(
+        "\x1b[38;2;{};{};{}m{text}\x1b[0m",
+        color.0, color.1, color.2
+    )
+}
+
+fn gradient(text: &str, from: Rgb, to: Rgb) -> String {
+    let chars = text.chars().collect::<Vec<_>>();
+    let denominator = chars.len().saturating_sub(1).max(1) as f32;
+    chars
+        .iter()
+        .enumerate()
+        .map(|(index, ch)| {
+            let amount = index as f32 / denominator;
+            let red = interpolate(from.0, to.0, amount);
+            let green = interpolate(from.1, to.1, amount);
+            let blue = interpolate(from.2, to.2, amount);
+            format!("\x1b[38;2;{red};{green};{blue}m{ch}\x1b[0m")
+        })
+        .collect()
+}
+
+fn interpolate(from: u8, to: u8, amount: f32) -> u8 {
+    (from as f32 + (to as f32 - from as f32) * amount).round() as u8
+}
+
+fn pad_ansi(value: &str, width: usize) -> String {
+    let padding = width.saturating_sub(visible_width(value));
+    format!("{value}{}", " ".repeat(padding))
+}
+
+fn visible_width(value: &str) -> usize {
+    let mut width = 0;
+    let mut chars = value.chars();
+    while let Some(ch) = chars.next() {
+        if ch == '\x1b' {
+            for next in chars.by_ref() {
+                if next.is_ascii_alphabetic() {
+                    break;
+                }
+            }
+        } else {
+            width += 1;
+        }
+    }
+    width
+}