@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_core/src/json.rs

@@ -0,0 +1,327 @@
+//! JSON parsing and stringification for Tish values.
+
+use crate::Value;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+/// Parse JSON string into a Value.
+pub fn json_parse(json: &str) -> Result<Value, String> {
+    let json = json.trim();
+    if json.is_empty() {
+        return Err("SyntaxError: Unexpected end of JSON input".to_string());
+    }
+    let (value, rest) = parse_value(json)?;
+    if !rest.trim().is_empty() {
+        return Err("SyntaxError: Unexpected token at end of JSON".to_string());
+    }
+    Ok(value)
+}
+
+/// Stringify a Value to JSON.
+pub fn json_stringify(value: &Value) -> String {
+    match value {
+        Value::Null => "null".to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Number(n) => {
+            if n.is_nan() || n.is_infinite() {
+                "null".to_string()
+            } else {
+                n.to_string()
+            }
+        }
+        Value::String(s) => format!("\"{}\"", escape_json_string(s)),
+        Value::Array(arr) => {
+            let borrowed = arr.borrow();
+            let mut result = String::with_capacity(borrowed.len() * 8 + 2);
+            result.push('[');
+            let mut first = true;
+            for item in borrowed.iter() {
+                if !first {
+                    result.push(',');
+                }
+                first = false;
+                result.push_str(&json_stringify(item));
+            }
+            result.push(']');
+            result
+        }
+        Value::Object(obj) => {
+            let borrowed = obj.borrow();
+            let mut keys: Vec<_> = borrowed.keys().collect();
+            keys.sort();
+            let mut result = String::with_capacity(borrowed.len() * 16 + 2);
+            result.push('{');
+            let mut first = true;
+            for key in keys {
+                if !first {
+                    result.push(',');
+                }
+                first = false;
+                result.push('"');
+                result.push_str(&escape_json_string(key));
+                result.push_str("\":");
+                result.push_str(&json_stringify(borrowed.get(key).unwrap()));
+            }
+            result.push('}');
+            result
+        }
+        Value::Function(_) => "null".to_string(),
+        Value::Promise(_) => "null".to_string(),
+        Value::Opaque(_) => "null".to_string(),
+        #[cfg(feature = "regex")]
+        Value::RegExp(_) => "null".to_string(),
+    }
+}
+
+fn escape_json_string(s: &str) -> String {
+    let mut result = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '"' => result.push_str("\\\""),
+            '\\' => result.push_str("\\\\"),
+            '\n' => result.push_str("\\n"),
+            '\r' => result.push_str("\\r"),
+            '\t' => result.push_str("\\t"),
+            c if c.is_control() => result.push_str(&format!("\\u{:04x}", c as u32)),
+            c => result.push(c),
+        }
+    }
+    result
+}
+
+fn parse_value(input: &str) -> Result<(Value, &str), String> {
+    let input = input.trim_start();
+    if input.is_empty() {
+        return Err("Unexpected end of JSON input".to_string());
+    }
+
+    match input.chars().next().unwrap() {
+        'n' => parse_null(input),
+        't' | 'f' => parse_bool(input),
+        '"' => parse_string(input),
+        '[' => parse_array(input),
+        '{' => parse_object(input),
+        c if c == '-' || c.is_ascii_digit() => parse_number(input),
+        c => Err(format!("Unexpected character '{}' in JSON", c)),
+    }
+}
+
+fn parse_null(input: &str) -> Result<(Value, &str), String> {
+    if let Some(rest) = input.strip_prefix("null") {
+        Ok((Value::Null, rest))
+    } else {
+        Err("Expected 'null'".to_string())
+    }
+}
+
+fn parse_bool(input: &str) -> Result<(Value, &str), String> {
+    if let Some(rest) = input.strip_prefix("true") {
+        Ok((Value::Bool(true), rest))
+    } else if let Some(rest) = input.strip_prefix("false") {
+        Ok((Value::Bool(false), rest))
+    } else {
+        Err("Expected 'true' or 'false'".to_string())
+    }
+}
+
+fn parse_string(input: &str) -> Result<(Value, &str), String> {
+    let input = &input[1..]; // skip opening quote
+    let mut result = String::new();
+    let mut chars = input.chars().peekable();
+    let mut byte_count = 0;
+
+    loop {
+        match chars.next() {
+            None => return Err("Unterminated string".to_string()),
+            Some('"') => {
+                byte_count += 1;
+                break;
+            }
+            Some('\\') => {
+                byte_count += 1;
+                match chars.next() {
+                    Some('n') => {
+                        result.push('\n');
+                        byte_count += 1;
+                    }
+                    Some('r') => {
+                        result.push('\r');
+                        byte_count += 1;
+                    }
+                    Some('t') => {
+                        result.push('\t');
+                        byte_count += 1;
+                    }
+                    Some('\\') => {
+                        result.push('\\');
+                        byte_count += 1;
+                    }
+                    Some('"') => {
+                        result.push('"');
+                        byte_count += 1;
+                    }
+                    Some('/') => {
+                        result.push('/');
+                        byte_count += 1;
+                    }
+                    Some('u') => {
+                        byte_count += 1;
+                        let mut hex = String::new();
+                        for _ in 0..4 {
+                            if let Some(c) = chars.next() {
+                                hex.push(c);
+                                byte_count += c.len_utf8();
+                            }
+                        }
+                        if let Ok(n) = u32::from_str_radix(&hex, 16) {
+                            if let Some(c) = char::from_u32(n) {
+                                result.push(c);
+                            }
+                        }
+                    }
+                    Some(c) => {
+                        result.push(c);
+                        byte_count += c.len_utf8();
+                    }
+                    None => return Err("Unterminated escape sequence".to_string()),
+                }
+            }
+            Some(c) => {
+                result.push(c);
+                byte_count += c.len_utf8();
+            }
+        }
+    }
+
+    Ok((Value::String(result.into()), &input[byte_count..]))
+}
+
+fn parse_number(input: &str) -> Result<(Value, &str), String> {
+    let mut end = 0;
+    let chars: Vec<char> = input.chars().collect();
+
+    if chars.get(end) == Some(&'-') {
+        end += 1;
+    }
+
+    while end < chars.len() && chars[end].is_ascii_digit() {
+        end += 1;
+    }
+
+    if chars.get(end) == Some(&'.') {
+        end += 1;
+        while end < chars.len() && chars[end].is_ascii_digit() {
+            end += 1;
+        }
+    }
+
+    if chars.get(end) == Some(&'e') || chars.get(end) == Some(&'E') {
+        end += 1;
+        if chars.get(end) == Some(&'+') || chars.get(end) == Some(&'-') {
+            end += 1;
+        }
+        while end < chars.len() && chars[end].is_ascii_digit() {
+            end += 1;
+        }
+    }
+
+    let num_str: String = chars[..end].iter().collect();
+    let byte_len: usize = chars[..end].iter().map(|c| c.len_utf8()).sum();
+    
+    num_str
+        .parse::<f64>()
+        .map(|n| (Value::Number(n), &input[byte_len..]))
+        .map_err(|_| format!("Invalid number: {}", num_str))
+}
+
+fn parse_array(input: &str) -> Result<(Value, &str), String> {
+    let mut input = &input[1..]; // skip '['
+    let mut items = Vec::new();
+
+    input = input.trim_start();
+    if let Some(rest) = input.strip_prefix(']') {
+        return Ok((Value::Array(Rc::new(RefCell::new(items))), rest));
+    }
+
+    loop {
+        let (value, rest) = parse_value(input)?;
+        items.push(value);
+        input = rest.trim_start();
+
+        match input.chars().next() {
+            Some(',') => input = &input[1..],
+            Some(']') => return Ok((Value::Array(Rc::new(RefCell::new(items))), &input[1..])),
+            _ => return Err("Expected ',' or ']' in array".to_string()),
+        }
+    }
+}
+
+fn parse_object(input: &str) -> Result<(Value, &str), String> {
+    let mut input = &input[1..]; // skip '{'
+    let mut map = HashMap::new();
+
+    input = input.trim_start();
+    if let Some(rest) = input.strip_prefix('}') {
+        return Ok((Value::Object(Rc::new(RefCell::new(map))), rest));
+    }
+
+    loop {
+        input = input.trim_start();
+        if !input.starts_with('"') {
+            return Err("Expected string key in object".to_string());
+        }
+
+        let (key_val, rest) = parse_string(input)?;
+        let key: Arc<str> = match key_val {
+            Value::String(s) => s,
+            _ => unreachable!(),
+        };
+
+        input = rest.trim_start();
+        if !input.starts_with(':') {
+            return Err("Expected ':' after key in object".to_string());
+        }
+        input = &input[1..];
+
+        let (value, rest) = parse_value(input)?;
+        map.insert(key, value);
+        input = rest.trim_start();
+
+        match input.chars().next() {
+            Some(',') => input = &input[1..],
+            Some('}') => return Ok((Value::Object(Rc::new(RefCell::new(map))), &input[1..])),
+            _ => return Err("Expected ',' or '}' in object".to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_primitives() {
+        assert!(matches!(json_parse("null").unwrap(), Value::Null));
+        assert!(matches!(json_parse("true").unwrap(), Value::Bool(true)));
+        assert!(matches!(json_parse("false").unwrap(), Value::Bool(false)));
+        assert!(matches!(json_parse("42").unwrap(), Value::Number(n) if n == 42.0));
+        assert!(matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello"));
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        let original = "{\"name\":\"test\",\"count\":42}";
+        let value = json_parse(original).unwrap();
+        let stringified = json_stringify(&value);
+        let reparsed = json_parse(&stringified).unwrap();
+        
+        match (&value, &reparsed) {
+            (Value::Object(a), Value::Object(b)) => {
+                assert_eq!(a.borrow().len(), b.borrow().len());
+            }
+            _ => panic!("Expected objects"),
+        }
+    }
+}

package/crates/tish_core/src/lib.rs

@@ -0,0 +1,15 @@
+//! Tish Core - Shared types and utilities for the Tish language.
+//!
+//! This crate provides the unified Value type and utilities used by both
+//! the interpreter (tish_eval) and compiled runtime (tish_runtime).
+
+mod console_style;
+mod json;
+mod macros;
+mod uri;
+mod value;
+
+pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
+pub use value::*;
+pub use json::{json_parse, json_stringify};
+pub use uri::{percent_decode, percent_encode};

package/crates/tish_core/src/macros.rs

@@ -0,0 +1,37 @@
+//! Macros for building Tish native modules.
+
+/// Build a Tish module object from method name => function pairs.
+///
+/// Each function must have signature `fn(&[Value]) -> Value` (or equivalent closure).
+/// Pass either a `fn` pointer or a closure; the macro wraps them in `Rc::new`.
+///
+/// # Example
+///
+/// ```ignore
+/// use tish_core::{tish_module, Value};
+///
+/// pub fn my_object() -> Value {
+///     tish_module! {
+///         "run" => |args: &[Value]| {
+///             // ...
+///             Value::Null
+///         },
+///         "read_csv" => my_read_csv_fn,
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! tish_module {
+    ($($name:expr => $fn:expr),* $(,)?) => {{
+        use std::cell::RefCell;
+        use std::collections::HashMap;
+        use std::rc::Rc;
+        use std::sync::Arc;
+        use $crate::Value;
+        let mut map = HashMap::new();
+        $(
+            map.insert(Arc::from($name), Value::Function(Rc::new($fn)));
+        )*
+        Value::Object(Rc::new(RefCell::new(map)))
+    }};
+}

package/crates/tish_core/src/uri.rs

@@ -0,0 +1,115 @@
+//! URI encoding/decoding utilities.
+
+/// Percent-decode a string (for decodeURI).
+/// Does NOT decode reserved URI characters: ; / ? : @ & = + $ , #
+/// These are characters that encodeURI does not encode, so decodeURI won't decode them.
+pub fn percent_decode(input: &str) -> Result<String, String> {
+    // Reserved characters that decodeURI should NOT decode (because encodeURI doesn't encode them)
+    const RESERVED_ENCODED: &[&str] = &[
+        "%3B", "%3b", // ;
+        "%2F", "%2f", // /
+        "%3F", "%3f", // ?
+        "%3A", "%3a", // :
+        "%40",        // @
+        "%26",        // &
+        "%3D", "%3d", // =
+        "%2B", "%2b", // +
+        "%24",        // $
+        "%2C", "%2c", // ,
+        "%23",        // #
+    ];
+
+    let mut result = String::with_capacity(input.len());
+    let mut chars = input.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        if c == '%' {
+            // Peek at the next two characters to check if this is a reserved sequence
+            let mut hex = String::new();
+            let mut peek_chars = Vec::new();
+            for _ in 0..2 {
+                match chars.next() {
+                    Some(h) if h.is_ascii_hexdigit() => {
+                        hex.push(h);
+                        peek_chars.push(h);
+                    }
+                    Some(h) => {
+                        // Not a valid hex sequence, push as-is
+                        result.push('%');
+                        for pc in peek_chars {
+                            result.push(pc);
+                        }
+                        result.push(h);
+                        hex.clear();
+                        break;
+                    }
+                    None => return Err("URIError: malformed URI sequence".to_string()),
+                }
+            }
+            
+            if hex.len() == 2 {
+                let encoded = format!("%{}", hex);
+                // Check if this is a reserved character that should NOT be decoded
+                if RESERVED_ENCODED.iter().any(|r| r.eq_ignore_ascii_case(&encoded)) {
+                    result.push_str(&encoded);
+                } else if let Ok(byte) = u8::from_str_radix(&hex, 16) {
+                    result.push(byte as char);
+                }
+            }
+        } else {
+            result.push(c);
+        }
+    }
+
+    Ok(result)
+}
+
+/// Percent-encode a string (for encodeURI).
+/// Preserves: A-Z a-z 0-9 - _ . ! ~ * ' ( ) ; / ? : @ & = + $ , #
+pub fn percent_encode(input: &str) -> String {
+    const UNRESERVED: &[char] = &[
+        '-', '_', '.', '!', '~', '*', '\'', '(', ')', ';', '/', '?', ':', '@', '&', '=', '+', '$',
+        ',', '#',
+    ];
+
+    let mut result = String::with_capacity(input.len());
+    for c in input.chars() {
+        if c.is_ascii_alphanumeric() || UNRESERVED.contains(&c) {
+            result.push(c);
+        } else {
+            for byte in c.to_string().as_bytes() {
+                result.push_str(&format!("%{:02X}", byte));
+            }
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn percent_encode_component(input: &str) -> String {
+        const UNRESERVED: &[char] = &['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
+        let mut result = String::new();
+        for c in input.chars() {
+            if c.is_ascii_alphanumeric() || UNRESERVED.contains(&c) {
+                result.push(c);
+            } else {
+                for byte in c.to_string().as_bytes() {
+                    result.push_str(&format!("%{:02X}", byte));
+                }
+            }
+        }
+        result
+    }
+
+    #[test]
+    fn test_encode_decode_roundtrip() {
+        let original = "hello world";
+        let encoded = percent_encode_component(original);
+        assert_eq!(encoded, "hello%20world");
+        let decoded = percent_decode(&encoded).unwrap();
+        assert_eq!(decoded, original);
+    }
+}