speechmarkdown-rust 0.1.18__tar.gz → 0.2.0__tar.gz

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "speechmarkdown-rust"
-version = "0.1.18"
+version = "0.2.0"
 edition = "2021"
 authors = ["SpeechMarkdown Contributors"]
 description = "High-performance SpeechMarkdown parser with multi-language bindings"

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speechmarkdown-rust
-Version: 0.1.18
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/Package.swift

@@ -10,12 +10,18 @@ let package = Package(
     targets: [
         .binaryTarget(
             name: "SpeechMarkdownRust",
-            url: "https://github.com/AACTools/speechmarkdown-rust/releases/download/v0.1.15/SpeechMarkdownRust.xcframework.zip",
-            checksum: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+            url: "https://github.com/AACTools/speechmarkdown-rust/releases/download/v0.1.18/SpeechMarkdownRust.xcframework.zip",
+            checksum: "d1de069f1bd7e75747e38be64a43cba3a1445982ed450e60bb24563524c6571e"
         ),
         .target(
-            name: "SpeechMarkdown",
+            name: "CSpeechMarkdown",
             dependencies: ["SpeechMarkdownRust"],
+            path: "bindings/swift/Sources/CSpeechMarkdown",
+            publicHeadersPath: "include"
+        ),
+        .target(
+            name: "SpeechMarkdown",
+            dependencies: ["CSpeechMarkdown"],
             path: "bindings/swift/Sources/SpeechMarkdown"
         ),
     ]

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/bindings/dotnet/SpeechMarkdown.nuspec

@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>SpeechMarkdown</id>
-    <version>0.1.18</version>
+    <version>0.2.0</version>
     <title>SpeechMarkdown</title>
     <authors>SpeechMarkdown Contributors</authors>
     <description>SpeechMarkdown parser - convert SpeechMarkdown syntax to SSML for Alexa, Google Assistant, Azure, and more.</description>

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/bindings/python/Cargo.lock

@@ -43,9 +43,9 @@ checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "memchr"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
 
 [[package]]
 name = "memoffset"
@@ -209,7 +209,7 @@ dependencies = [
 
 [[package]]
 name = "speechmarkdown-python"
-version = "0.1.18"
+version = "0.2.0"
 dependencies = [
  "pyo3",
  "serde_json",
@@ -218,7 +218,7 @@ dependencies = [
 
 [[package]]
 name = "speechmarkdown-rust"
-version = "0.1.18"
+version = "0.2.0"
 dependencies = [
  "quick-xml",
  "serde",

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/bindings/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "speechmarkdown-python"
-version = "0.1.18"
+version = "0.2.0"
 edition = "2021"
 readme = "README.md"
 

speechmarkdown_rust-0.2.0/bindings/swift/Sources/CSpeechMarkdown/module.modulemap

@@ -0,0 +1,5 @@
+module CSpeechMarkdown {
+    header "shim.h"
+    link "speechmarkdown_rust"
+    export *
+}

{speechmarkdown_rust-0.1.18 → speechmarkdown_rust-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "speechmarkdown-rust"
-version = "0.1.18"
+version = "0.2.0"
 description = "SpeechMarkdown parser - convert SpeechMarkdown to SSML"
 readme = "README.md"
 

speechmarkdown_rust-0.1.18/.gitmodules

@@ -1,4 +0,0 @@
-[submodule "tests/test-data"]
-	path = tests/test-data
-	url = https://github.com/willwade/speechmarkdown-test-files.git
-	branch = feat/expand-test-fixtures

speechmarkdown_rust-0.1.18/tests/break_specific_test.rs

@@ -1,27 +0,0 @@
-use speechmarkdown_rust::{SpeechMarkdownParser, Platform};
-use std::fs;
-
-#[test]
-fn test_break_strength_from_file() {
-    let input = fs::read_to_string("tests/test-data/test-data/break-strength/break-strength.smd")
-        .expect("Failed to read test file");
-
-    // Normalize like the integration test does
-    let input = input.replace("\r\n", "\n").replace('\r', "\n").trim_end_matches('\n').to_string();
-
-    println!("Input: {:?}", input);
-
-    let expected = fs::read_to_string("tests/test-data/test-data/break-strength/break-strength.alexa.ssml")
-        .expect("Failed to read expected file");
-
-    println!("Expected: {:?}", expected);
-
-    match SpeechMarkdownParser::to_ssml(&input, Platform::AmazonAlexa) {
-        Ok(actual) => {
-            println!("Actual: {:?}", actual);
-            let normalized_expected = expected.replace("\r\n", "\n").replace('\r', "\n");
-            assert_eq!(actual.trim(), normalized_expected.trim());
-        },
-        Err(e) => panic!("SSML Error: {:?}", e),
-    }
-}

speechmarkdown_rust-0.1.18/tests/debug_failures.rs

@@ -1,129 +0,0 @@
-use speechmarkdown_rust::{Platform, SpeechMarkdownParser};
-use std::collections::HashMap;
-
-fn debug_test(name: &str) -> (bool, HashMap<String, bool>) {
-    let test_dir = std::path::Path::new("tests/test-data/test-data").join(name);
-    let smd_file = test_dir.join(format!("{}.smd", name));
-    if !smd_file.exists() {
-        return (false, HashMap::new());
-    }
-    let input = std::fs::read_to_string(&smd_file)
-        .unwrap()
-        .replace("\r\n", "\n")
-        .replace('\r', "\n")
-        .trim_end_matches('\n')
-        .to_string();
-
-    let mut results = HashMap::new();
-
-    let check = |platform: Platform, ext: &str| -> bool {
-        let file = test_dir.join(format!("{}.{}", name, ext));
-        if !file.exists() {
-            return true;
-        }
-        let expected = std::fs::read_to_string(&file)
-            .unwrap()
-            .replace("\r\n", "\n")
-            .replace('\r', "\n");
-        match SpeechMarkdownParser::to_ssml(&input, platform) {
-            Ok(actual) => actual.trim() == expected.trim(),
-            Err(_) => false,
-        }
-    };
-
-    results.insert("alexa".into(), check(Platform::AmazonAlexa, "alexa.ssml"));
-    results.insert(
-        "google".into(),
-        check(Platform::GoogleAssistant, "google.ssml"),
-    );
-    results.insert(
-        "azure".into(),
-        check(Platform::MicrosoftAzure, "azure.ssml"),
-    );
-
-    let txt_file = test_dir.join(format!("{}.txt", name));
-    let txt_pass = if txt_file.exists() {
-        let expected = std::fs::read_to_string(&txt_file)
-            .unwrap()
-            .replace("\r\n", "\n")
-            .replace('\r', "\n");
-        match SpeechMarkdownParser::to_text(&input) {
-            Ok(actual) => actual.trim() == expected.trim(),
-            Err(_) => false,
-        }
-    } else {
-        true
-    };
-    results.insert("txt".into(), txt_pass);
-
-    let all_pass = results.values().all(|v| *v);
-    (all_pass, results)
-}
-
-#[test]
-fn debug_all_remaining() {
-    let test_data_dir = std::path::Path::new("tests/test-data/test-data");
-    let mut dirs: Vec<String> = Vec::new();
-    for entry in std::fs::read_dir(test_data_dir).unwrap() {
-        let entry = entry.unwrap();
-        if entry.file_type().unwrap().is_dir() {
-            dirs.push(entry.file_name().to_string_lossy().to_string());
-        }
-    }
-    dirs.sort();
-
-    let failures: Vec<String> = dirs
-        .iter()
-        .filter(|name| !debug_test(name).0)
-        .cloned()
-        .collect();
-
-    println!("Failing tests by platform:");
-    println!(
-        "{:<55} {:>6} {:>6} {:>6} {:>4}",
-        "Test", "alexa", "google", "azure", "txt"
-    );
-    for name in &failures {
-        let (_, results) = debug_test(name);
-        let a = if results.get("alexa").is_none_or(|v| *v) {
-            "PASS"
-        } else {
-            "FAIL"
-        };
-        let g = if results.get("google").is_none_or(|v| *v) {
-            "PASS"
-        } else {
-            "FAIL"
-        };
-        let z = if results.get("azure").is_none_or(|v| *v) {
-            "PASS"
-        } else {
-            "FAIL"
-        };
-        let t = if results.get("txt").is_none_or(|v| *v) {
-            "PASS"
-        } else {
-            "FAIL"
-        };
-        println!("{:<55} {:>6} {:>6} {:>6} {:>4}", name, a, g, z, t);
-    }
-    println!("\nTotal failures: {}", failures.len());
-
-    // Debug specific test
-    println!("\n\n=== DEBUG: sections-standard ===");
-    let test_dir = std::path::Path::new("tests/test-data/test-data/sections-standard");
-    let input = std::fs::read_to_string(test_dir.join("sections-standard.smd"))
-        .unwrap()
-        .replace("\r\n", "\n")
-        .replace('\r', "\n")
-        .trim_end_matches('\n')
-        .to_string();
-    let expected = std::fs::read_to_string(test_dir.join("sections-standard.alexa.ssml"))
-        .unwrap()
-        .replace("\r\n", "\n")
-        .replace('\r', "\n");
-    let actual = SpeechMarkdownParser::to_ssml(&input, Platform::AmazonAlexa).unwrap();
-    println!("Input: {:?}", input);
-    println!("Actual:   {:?}", actual.trim());
-    println!("Expected: {:?}", expected.trim());
-}

speechmarkdown_rust-0.1.18/tests/diagnostic_test.rs

@@ -1,92 +0,0 @@
-use speechmarkdown_rust::{Platform, SpeechMarkdownParser};
-use std::fs;
-use std::path::Path;
-
-fn normalize(text: &str) -> String {
-    text.replace("\r\n", "\n").replace('\r', "\n")
-}
-
-fn debug_test(name: &str) {
-    let test_dir = Path::new("tests/test-data/test-data").join(name);
-    let smd_file = test_dir.join(format!("{}.smd", name));
-    if !smd_file.exists() {
-        println!("=== {} === SMD file not found", name);
-        return;
-    }
-    let input = fs::read_to_string(&smd_file)
-        .unwrap()
-        .replace("\r\n", "\n")
-        .replace('\r', "\n")
-        .trim_end_matches('\n')
-        .to_string();
-
-    println!("=== {} ===", name);
-    println!("Input: {:?}", input);
-
-    for (platform, ext) in [
-        (Platform::AmazonAlexa, "alexa.ssml"),
-        (Platform::GoogleAssistant, "google.ssml"),
-        (Platform::MicrosoftAzure, "azure.ssml"),
-    ] {
-        let file = test_dir.join(format!("{}.{}", name, ext));
-        if !file.exists() {
-            continue;
-        }
-        let expected = normalize(&fs::read_to_string(&file).unwrap());
-        match SpeechMarkdownParser::to_ssml(&input, platform) {
-            Ok(actual) => {
-                if actual.trim() != expected.trim() {
-                    println!("[{}] MISMATCH:", ext);
-                    println!("  Actual:   {:?}", actual.trim());
-                    println!("  Expected: {:?}", expected.trim());
-                } else {
-                    println!("[{}] PASS", ext);
-                }
-            }
-            Err(e) => println!("[{}] ERROR: {:?}", ext, e),
-        }
-    }
-
-    let txt_file = test_dir.join(format!("{}.txt", name));
-    if txt_file.exists() {
-        let expected = normalize(&fs::read_to_string(&txt_file).unwrap());
-        match SpeechMarkdownParser::to_text(&input) {
-            Ok(actual) => {
-                if actual.trim() != expected.trim() {
-                    println!("[txt] MISMATCH:");
-                    println!("  Actual:   {:?}", actual.trim());
-                    println!("  Expected: {:?}", expected.trim());
-                } else {
-                    println!("[txt] PASS");
-                }
-            }
-            Err(e) => println!("[txt] ERROR: {:?}", e),
-        }
-    }
-    println!();
-}
-
-#[test]
-fn diagnose_failures() {
-    let tests = [
-        "azure-section-angry",
-        "azure-section-friendly",
-        "bare-ipa",
-        "ipa-short",
-        "combo-emphasis-prosody",
-        "combo-voice-prosody",
-        "combo-ipa-emphasis",
-        "disappointed-standard invalid intensity",
-        "excited-standard invalid intensity",
-        "disappointed-section normal to disappointed intensities to normal",
-        "excited-section normal to excited intensities to normal",
-        "prosody-multiple-modifiers rate + pitch",
-        "prosody-multiple-modifiers rate + volume",
-        "multiple-modifiers-same-text",
-        "voice-azure-displayname",
-        "sections-standard voice section on same line",
-    ];
-    for t in &tests {
-        debug_test(t);
-    }
-}

speechmarkdown_rust-0.1.18/tests/integration_test.rs

@@ -1,199 +0,0 @@
-use speechmarkdown_rust::{Platform, SpeechMarkdownParser};
-use std::fs;
-use std::path::Path;
-
-fn normalize_line_endings(text: &str) -> String {
-    // Normalize all line endings to \n for comparison
-    text.replace("\r\n", "\n").replace('\r', "\n")
-}
-
-#[test]
-fn test_all_test_cases() {
-    let test_data_dir = Path::new("tests/test-data/test-data");
-
-    // Get all test directories
-    let entries = fs::read_dir(test_data_dir).expect("Failed to read test-data directory");
-
-    let mut passed = 0;
-    let mut failed = 0;
-    let mut failed_tests = Vec::new();
-
-    for entry in entries {
-        let entry = entry.expect("Failed to read directory entry");
-        let test_dir = entry.path();
-
-        if !test_dir.is_dir() {
-            continue;
-        }
-
-        let test_name = test_dir
-            .file_name()
-            .and_then(|n| n.to_str())
-            .unwrap_or("unknown");
-
-        // Read the .smd input file
-        let smd_file = test_dir.join(format!("{}.smd", test_name));
-        if !smd_file.exists() {
-            continue;
-        }
-
-        let input = fs::read_to_string(&smd_file)
-            .unwrap_or_else(|_| panic!("Failed to read test file: {:?}", smd_file));
-
-        // Normalize line endings in the input before parsing
-        let input = normalize_line_endings(&input)
-            .trim_end_matches('\n')
-            .to_string();
-
-        // Test parsing
-        let parse_result = SpeechMarkdownParser::parse(&input);
-
-        let test_passed = match parse_result {
-            Ok(_ast) => {
-                let mut all_checks_passed = true;
-
-                // Test text output
-                if let Ok(expected_text) =
-                    fs::read_to_string(test_dir.join(format!("{}.txt", test_name)))
-                {
-                    let text_result = SpeechMarkdownParser::to_text(&input);
-                    if text_result.is_err() {
-                        all_checks_passed = false;
-                    } else if let Ok(actual_text) = text_result {
-                        if actual_text.trim() != normalize_line_endings(expected_text.trim()) {
-                            all_checks_passed = false;
-                        }
-                    }
-                }
-
-                // Test SSML output for Amazon Alexa
-                let alexa_file = test_dir.join(format!("{}.alexa.ssml", test_name));
-                if alexa_file.exists() {
-                    let expected_ssml = fs::read_to_string(&alexa_file).unwrap_or_else(|_| {
-                        panic!("Failed to read Alexa SSML file: {:?}", alexa_file)
-                    });
-
-                    let ssml_result = SpeechMarkdownParser::to_ssml(&input, Platform::AmazonAlexa);
-                    if ssml_result.is_err() {
-                        all_checks_passed = false;
-                    } else if let Ok(actual_ssml) = ssml_result {
-                        if actual_ssml.trim() != normalize_line_endings(expected_ssml.trim()) {
-                            all_checks_passed = false;
-                        }
-                    }
-                }
-
-                // Test SSML output for Google Assistant
-                let google_file = test_dir.join(format!("{}.google.ssml", test_name));
-                if google_file.exists() {
-                    let expected_ssml = fs::read_to_string(&google_file).unwrap_or_else(|_| {
-                        panic!("Failed to read Google SSML file: {:?}", google_file)
-                    });
-
-                    let ssml_result =
-                        SpeechMarkdownParser::to_ssml(&input, Platform::GoogleAssistant);
-                    if ssml_result.is_err() {
-                        all_checks_passed = false;
-                    } else if let Ok(actual_ssml) = ssml_result {
-                        if actual_ssml.trim() != normalize_line_endings(expected_ssml.trim()) {
-                            all_checks_passed = false;
-                        }
-                    }
-                }
-
-                all_checks_passed
-            }
-            Err(_e) => false,
-        };
-
-        if test_passed {
-            passed += 1;
-        } else {
-            failed += 1;
-            failed_tests.push(test_name.to_string());
-        }
-    }
-
-    println!("=== Test Summary ===");
-    println!("Total tests: {}", passed + failed);
-    println!("Passed: {}", passed);
-    println!("Failed: {}", failed);
-    println!(
-        "Pass rate: {:.1}%",
-        (passed as f64 / (passed + failed) as f64) * 100.0
-    );
-
-    if failed > 0 {
-        println!("\n=== All Failed Tests ===");
-        for test in &failed_tests {
-            println!("  - {}", test);
-        }
-    }
-
-    // Only panic if we have significant failures (>50% fail rate)
-    if failed > 0 && (failed as f64 / (passed + failed) as f64) > 0.5 {
-        panic!(
-            "Too many test failures: {}/{} failed",
-            failed,
-            passed + failed
-        );
-    }
-}
-
-// Individual test cases for easier debugging
-#[test]
-fn test_break_short() {
-    run_single_test("break-short");
-}
-
-#[test]
-fn test_emphasis_short_strong() {
-    run_single_test("emphasis-short-strong");
-}
-
-#[test]
-fn test_address_standard() {
-    run_single_test("address-standard");
-}
-
-fn run_single_test(test_name: &str) {
-    let test_dir = Path::new("tests/test-data/test-data").join(test_name);
-    let smd_file = test_dir.join(format!("{}.smd", test_name));
-
-    let input = fs::read_to_string(&smd_file)
-        .unwrap_or_else(|_| panic!("Failed to read test file: {:?}", smd_file))
-        .trim_end_matches(['\r', '\n'])
-        .to_string();
-
-    let _ast = SpeechMarkdownParser::parse(&input).expect("Parse failed");
-
-    // Test text output if it exists
-    let text_file = test_dir.join(format!("{}.txt", test_name));
-    if text_file.exists() {
-        let expected_text = fs::read_to_string(&text_file)
-            .unwrap_or_else(|_| panic!("Failed to read text file: {:?}", text_file));
-
-        let actual_text = SpeechMarkdownParser::to_text(&input).expect("Text formatting failed");
-
-        assert_eq!(
-            actual_text.trim(),
-            normalize_line_endings(expected_text.trim()),
-        );
-    }
-
-    // Test SSML output if it exists
-    let alexa_file = test_dir.join(format!("{}.alexa.ssml", test_name));
-    if alexa_file.exists() {
-        let expected_ssml = fs::read_to_string(&alexa_file)
-            .unwrap_or_else(|_| panic!("Failed to read Alexa SSML file: {:?}", alexa_file));
-
-        let actual_ssml = SpeechMarkdownParser::to_ssml(&input, Platform::AmazonAlexa)
-            .expect("SSML formatting failed");
-
-        assert_eq!(
-            actual_ssml.trim(),
-            normalize_line_endings(expected_ssml.trim()),
-            "Alexa SSML output mismatch"
-        );
-    }
-}

speechmarkdown_rust-0.1.18/tests/remaining_test.rs

@@ -1,102 +0,0 @@
-use speechmarkdown_rust::Platform;
-use speechmarkdown_rust::SpeechMarkdownParser;
-
-fn check(name: &str, platform_str: &str, platform: Platform) {
-    let test_dir = format!("tests/test-data/test-data/{}", name);
-    let smd_path = format!("{}/{}.smd", test_dir, name);
-    let expected_path = format!("{}/{}.{}.ssml", test_dir, name, platform_str);
-
-    let input =
-        std::fs::read_to_string(&smd_path).unwrap_or_else(|_| panic!("no smd: {}", smd_path));
-    let expected = std::fs::read_to_string(&expected_path)
-        .unwrap_or_else(|_| panic!("no expected: {}", expected_path));
-
-    let actual = SpeechMarkdownParser::to_ssml(input.trim(), platform).unwrap();
-
-    if actual.trim() == expected.trim() {
-        println!("{} [{}] PASS", name, platform_str);
-    } else {
-        println!("{} [{}] FAIL", name, platform_str);
-        println!("  Input:    {:?}", input.trim());
-        println!("  Expected: {:?}", expected.trim());
-        println!("  Actual:   {:?}", actual.trim());
-    }
-}
-
-#[test]
-fn diagnose_remaining() {
-    let cases = vec![
-        // ipa-standard (Google only)
-        ("ipa-standard", "google", Platform::GoogleAssistant),
-        (
-            "ipa-standard-alphabet-uk",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        (
-            "ipa-standard-alphabet-us",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        // whisper (Google + Azure)
-        ("whisper-standard", "google", Platform::GoogleAssistant),
-        ("whisper-standard", "azure", Platform::MicrosoftAzure),
-        // combo-whisper-emphasis (Google + Azure)
-        (
-            "combo-whisper-emphasis",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        ("combo-whisper-emphasis", "azure", Platform::MicrosoftAzure),
-        // prosody multiple modifiers (all)
-        (
-            "prosody-multiple-modifiers vol + pitch + rate defaults",
-            "alexa",
-            Platform::AmazonAlexa,
-        ),
-        (
-            "prosody-multiple-modifiers vol + pitch + rate defaults",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        (
-            "prosody-multiple-modifiers vol + pitch + rate defaults",
-            "azure",
-            Platform::MicrosoftAzure,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch",
-            "alexa",
-            Platform::AmazonAlexa,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch",
-            "azure",
-            Platform::MicrosoftAzure,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch + rate",
-            "alexa",
-            Platform::AmazonAlexa,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch + rate",
-            "google",
-            Platform::GoogleAssistant,
-        ),
-        (
-            "prosody-multiple-modifiers volume + pitch + rate",
-            "azure",
-            Platform::MicrosoftAzure,
-        ),
-    ];
-
-    for (name, platform_str, platform) in cases {
-        check(name, platform_str, platform);
-    }
-}