@tishlang/tish 1.0.7 → 1.0.10

package/crates/tish_eval/src/value_convert.rs

@@ -0,0 +1,85 @@
+//! Conversion between tish_eval::Value and tish_core::Value for opaque method calls.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use tish_core::Value as CoreValue;
+
+use crate::value::Value;
+
+/// Convert interpreter Value to core Value. Fails for interpreter-only variants.
+pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
+    match v {
+        Value::Number(n) => Ok(CoreValue::Number(*n)),
+        Value::String(s) => Ok(CoreValue::String(Arc::clone(s))),
+        Value::Bool(b) => Ok(CoreValue::Bool(*b)),
+        Value::Null => Ok(CoreValue::Null),
+        Value::Array(arr) => {
+            let mut out = Vec::new();
+            for item in arr.borrow().iter() {
+                out.push(eval_to_core(item)?);
+            }
+            Ok(CoreValue::Array(Rc::new(RefCell::new(out))))
+        }
+        Value::Object(map) => {
+            let mut out = HashMap::new();
+            for (k, v) in map.borrow().iter() {
+                out.insert(Arc::clone(k), eval_to_core(v)?);
+            }
+            Ok(CoreValue::Object(Rc::new(RefCell::new(out))))
+        }
+        Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
+        _ => Err(format!(
+            "Cannot pass {:?} to native function (unsupported type)",
+            std::mem::discriminant(v)
+        )),
+    }
+}
+
+/// Convert core Value to interpreter Value.
+pub fn core_to_eval(v: CoreValue) -> Value {
+    match v {
+        CoreValue::Number(n) => Value::Number(n),
+        CoreValue::String(s) => Value::String(s),
+        CoreValue::Bool(b) => Value::Bool(b),
+        CoreValue::Null => Value::Null,
+        CoreValue::Array(arr) => {
+            let mut out = Vec::new();
+            for item in arr.borrow().iter() {
+                out.push(core_to_eval(item.clone()));
+            }
+            Value::Array(Rc::new(RefCell::new(out)))
+        }
+        CoreValue::Object(map) => {
+            let mut out = HashMap::new();
+            for (k, v) in map.borrow().iter() {
+                out.insert(Arc::clone(k), core_to_eval(v.clone()));
+            }
+            Value::Object(Rc::new(RefCell::new(out)))
+        }
+        CoreValue::Opaque(o) => Value::Opaque(o),
+        #[cfg(feature = "http")]
+        CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
+        #[cfg(not(feature = "http"))]
+        CoreValue::Promise(_) => Value::Null,
+        #[cfg(any(feature = "http", feature = "ws"))]
+        CoreValue::Function(f) => Value::CoreFn(Rc::clone(&f)),
+        #[cfg(not(any(feature = "http", feature = "ws")))]
+        CoreValue::Function(_) => Value::Null,
+        // tish_core gets regex from http or regex features; handle RegExp when it exists
+        #[cfg(any(feature = "http", feature = "regex"))]
+        CoreValue::RegExp(re) => {
+            #[cfg(feature = "regex")]
+            {
+                Value::RegExp(re)
+            }
+            #[cfg(not(feature = "regex"))]
+            {
+                let _ = re;
+                Value::Null
+            }
+        }
+    }
+}

package/crates/tish_fmt/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "tish_fmt"
+version = "0.1.0"
+edition = "2021"
+description = "Opinionated formatter for Tish source (parse → pretty-print)"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[[bin]]
+name = "tish-fmt"
+path = "src/bin/tish-fmt.rs"
+
+[dependencies]
+clap = { version = "4.6.0", features = ["derive"] }
+tish_ast = { path = "../tish_ast" }
+tish_parser = { path = "../tish_parser" }

package/crates/tish_fmt/src/bin/tish-fmt.rs

@@ -0,0 +1,41 @@
+//! Standalone formatter — not part of the `tish` compiler CLI.
+
+use std::fs;
+
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(name = "tish-fmt")]
+#[command(about = "Format Tish source (pretty-print via AST)")]
+struct Cli {
+    #[arg(required = true)]
+    file: String,
+    #[arg(long)]
+    check: bool,
+}
+
+fn main() {
+    let cli = Cli::parse();
+    if let Err(e) = run(&cli.file, cli.check) {
+        eprintln!("{}", e);
+        std::process::exit(1);
+    }
+}
+
+fn run(path: &str, check: bool) -> Result<(), String> {
+    let source = fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
+    let formatted = tish_fmt::format_source(&source)?;
+    if check {
+        if formatted != source {
+            return Err(format!(
+                "Format check failed: {} needs formatting (run `tish-fmt {}`)",
+                path, path
+            ));
+        }
+        println!("{}: OK", path);
+        return Ok(());
+    }
+    fs::write(path, formatted).map_err(|e| format!("Cannot write {}: {}", path, e))?;
+    println!("Formatted: {}", path);
+    Ok(())
+}