more concice benches, add json example

Cargo.toml

@@ -35,14 +35,15 @@ clap = { version = "4.4", optional = true, features = ["derive"] }
 serde = { version = "1", features = ["derive"], optional = true }
 typetag = { version = "0.2", optional = true }
 
-# deserializing ron file format
+# format deserialization
 ron = { version = "0.8", optional = true }
 
 # clone stored Replacement trait objects
 dyn-clone = "1.0"
 
 [dev-dependencies]
 ron = { version = "0.8" }
+serde_json = { version = "1.0" }
 criterion = { version = "0.4", features = ["html_reports"] }
 
 [features]

benches/accents.rs

@@ -1,11 +1,10 @@
-use criterion::criterion_main;
-use criterion::{criterion_group, Criterion};
+use criterion::{criterion_group, criterion_main, Criterion};
 use sayit::Accent;
 use std::fs;
 
 pub fn read_accent(filename: &str) -> Accent {
  let content = fs::read_to_string(filename).expect("reading accent definition");
- ron::from_str::<Accent>(&content).expect("parsing accent")
+ ron::from_str::<Accent>(&content).expect(&format!("parsing accent {filename}"))
 }
 
 pub fn read_sample_file() -> String {
@@ -24,7 +23,6 @@ fn accents(c: &mut Criterion) {
  let lines = read_sample_file_lines();
 
  let mut g = c.benchmark_group("accents");
- g.sample_size(2000);
 
  for name in [
  "original", "literal", "any", "weights", "upper", "lower", "concat",

benches/any.ron

@@ -1,27 +1,77 @@
 (
  patterns: [
+ // highly nested
  ("a", {"Any": [
- {"Original": ()},
- {"Literal": "B"},
- {"Literal": "Flat"},
- ]}),
- ("VeryLongNonExistent12344343243244234", {"Any": [{"Original": ()}]}),
- ("you", {"Any": [
  {"Any": [
  {"Any": [
  {"Any": [
  {"Any": [
  {"Any": [
  {"Any": [
  {"Any": [
- {"Literal": "nestednormalizeme"},
+ {"Any": [
+ {"Original": ()},
  ]},
  ]},
  ]},
  ]},
  ]},
  ]},
  ]},
+ ]},
+ ]}),
+ // many items
+ ("o", {"Any": [
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
+ {"Any": [{"Original": ()}]},
  ]}),
  ],
 )

benches/concat.ron

@@ -1,7 +1,13 @@
 (
  patterns: [
- ("a", {"Concat": ({"Literal": "first"}, {"Original": ()})}),
- ("VeryLongNonExistent12344343243244234", {"Concat": ({"Original": ()}, {"Literal": "first"})}),
- ("you", {"Concat": ({"Literal": "left"}, {"Literal": "right"})}),
+ // use \w+ and \W+ to vary string lengths
+ (r"\w+", {"Concat": (
+ {"Original": ()},
+ {"Original": ()},
+ )}),
+ (r"\W+", {"Concat": (
+ {"Original": ()},
+ {"Original": ()},
+ )}),
  ],
 )

benches/literal.ron

@@ -1,7 +1,7 @@
 (
  patterns: [
- ("a", {"Literal": "B"}),
- ("VeryLongNonExistent12344343243244234", {"Literal": "wdwdffhskhfkshekfhKFE"}),
- ("you", {"Literal": "normalizeme"}),
+ ("a", {"Literal": "A"}),
+ ("o", {"Literal": "short"}),
+ (r"\d+", {"Literal": "veryLongStringaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1234123412344rhrkghsghkgshal;ghaslfnkhsgkshgshgsjdgjkdngkjgh"}),
  ],
 )

benches/lower.ron

@@ -1,7 +1,5 @@
 (
  patterns: [
- ("a", {"Lower": {"Original": ()}}),
- ("VeryLongNonExistent12344343243244234", {"Lower": {"Original": ()}}),
- ("you", {"Lower": {"Original": ()}}),
+ (r"\w+", {"Lower": {"Lower": {"Lower": {"Lower": {"Lower": {"Original": ()}}}}}}),
  ],
 )

benches/original.ron

@@ -1,7 +1,7 @@
 (
  patterns: [
- ("a", {"Original": ()}),
- ("VeryLongNonExistent12344343243244234", {"Original": ()}),
- ("you", {"Original": ()}),
+ // varying string lenghts
+ (r"\w+", {"Original": ()}),
+ (r"\W+", {"Original": ()}),
  ],
 )

benches/upper.ron

@@ -1,7 +1,5 @@
 (
  patterns: [
- ("a", {"Upper": {"Original": ()}}),
- ("VeryLongNonExistent12344343243244234", {"Upper": {"Original": ()}}),
- ("you", {"Upper": {"Original": ()}}),
+ (r"\w+", {"Upper": {"Upper": {"Upper": {"Upper": {"Upper": {"Original": ()}}}}}}),
  ],
 )

benches/weights.ron

@@ -1,8 +1,8 @@
 (
  patterns: [
- ("a", {"Weights": [(1, {"Literal": "B"})]}),
- ("VeryLongNonExistent12344343243244234", {"Weights": [(10000, {"Original": ()})]}),
- ("you", {"Weights": [
+ ("a", {"Weights": [(1, {"Literal": "single"})]}),
+ ("o", {"Weights": [
+  (0, {"Weights": [(1, {"Literal": "many variants"})]}),
  (1, {"Weights": [(1, {"Literal": "1"})]}),
  (2, {"Weights": [(1, {"Literal": "2"})]}),
  (3, {"Weights": [(1, {"Literal": "3"})]}),
@@ -12,6 +12,17 @@
  (7, {"Weights": [(1, {"Literal": "7"})]}),
  (8, {"Weights": [(1, {"Literal": "8"})]}),
  (9, {"Weights": [(1, {"Literal": "9"})]}),
+ (10, {"Weights": [(1, {"Literal": "10"})]}),
+ (11, {"Weights": [(1, {"Literal": "11"})]}),
+ (12, {"Weights": [(1, {"Literal": "12"})]}),
+ (13, {"Weights": [(1, {"Literal": "13"})]}),
+ (14, {"Weights": [(1, {"Literal": "14"})]}),
+ (15, {"Weights": [(1, {"Literal": "15"})]}),
+ (16, {"Weights": [(1, {"Literal": "16"})]}),
+ (17, {"Weights": [(1, {"Literal": "17"})]}),
+ (18, {"Weights": [(1, {"Literal": "18"})]}),
+ (19, {"Weights": [(1, {"Literal": "19"})]}),
+ (20, {"Weights": [(1, {"Literal": "20"})]}),
  ]}),
  ],
 )

examples/spurdo.json

@@ -0,0 +1,70 @@
+{
+ "words": [
+ ["epic", {"Literal": "ebin"}],
+ [":?\\]", {"Any": [
+ {"Literal": ":D"},
+ {"Literal": ":DD"},
+ {"Literal": ":DDD"}
+ ]}]
+ ],
+ "patterns": [
+ ["xc", {"Literal": "gg"}],
+ ["c", {"Literal": "g"}],
+ ["k", {"Literal": "g"}],
+ ["t", {"Literal": "d"}],
+ ["p", {"Literal": "b"}],
+ ["x", {"Literal": "gs"}],
+ ["\\Bng\\b", {"Literal": "gn"}],
+ ["$", {"Weights": [
+ [1, {"Original": null}],
+ [1, {"Any": [
+ {"Literal": " :D"},
+ {"Literal": " :DD"},
+ {"Literal": " :DDD"},
+ {"Literal": " :DDDD"},
+ {"Literal": " :DDDDD"}
+ ]}]
+ ]}]
+ ],
+ "intensities": {
+ "1": {"Extend": {
+ "patterns": [
+ ["$", {"Weights": [
+ [1, {"Original": null}],
+ [2, {"Any": [
+ {"Literal": " :DD"},
+ {"Literal": " :DDD"},
+ {"Literal": " :DDDD"},
+ {"Literal": " :DDDDD"},
+ {"Literal": " :DDDDDD"}
+ ]}]
+ ]}]
+ ],
+ "words": [
+ [":?\\]", {"Any": [
+ {"Literal": ":DD"},
+ {"Literal": ":DDD"},
+ {"Literal": ":DDDD"}
+ ]}]
+ ]
+ }},
+ "2": {"Extend": {
+ "patterns": [
+ ["$", {"Any": [
+ {"Literal": " :DDDD"},
+ {"Literal": " :DDDDD"},
+ {"Literal": " :DDDDDD"},
+ {"Literal": " :DDDDDDD"},
+ {"Literal": " :DDDDDDDD"}
+ ]}]
+ ],
+ "words": [
+ [":?\\]", {"Any": [
+ {"Literal": ":DDDD"},
+ {"Literal": ":DDDDD"},
+ {"Literal": ":DDDDDD"}
+ ]}]
+ ]
+ }}
+ }
+}

src/deserialize.rs

@@ -172,7 +172,6 @@ impl TryFrom<AccentDef> for Accent {
 #[cfg(test)]
 mod tests {
  use regex::Regex;
- use std::fs;
 
  use crate::{
  replacement::{Any, Literal, Original, Weights},
@@ -628,24 +627,6 @@ mod tests {
  assert_eq!(accent.say_it("intensity", 9000 + 1), "5");
  }
 
- #[test]
- fn example_accents() {
- let sample_text = fs::read_to_string("tests/sample_text.txt").expect("reading sample text");
-
- for file in fs::read_dir("examples").expect("read symlinked accents folder") {
- let filename = file.expect("getting file info").path();
- println!("parsing {}", filename.display());
-
- let accent =
- ron::from_str::<Accent>(&fs::read_to_string(filename).expect("reading file"))
- .unwrap();
-
- for intensity in accent.intensities() {
- let _ = accent.say_it(&sample_text, intensity);
- }
- }
- }
-
  #[test]
  fn custom_replacement_works() {
  use crate::replacement::Replacement;

tests/json.rs

@@ -0,0 +1,41 @@
+mod utils;
+
+use sayit::Accent;
+use std::{fs, path::PathBuf};
+use utils::read_sample_file_lines;
+
+pub fn read_accent(filename: PathBuf) -> Accent {
+ let content = fs::read_to_string(&filename).unwrap();
+ serde_json::from_str::<Accent>(&content)
+ .expect(&format!("parsing accent {}", filename.display()))
+}
+
+#[test]
+fn json_examples_work() {
+ let lines = read_sample_file_lines();
+
+ let mut tested_at_least_one = false;
+
+ for entry in fs::read_dir("examples").unwrap() {
+ let path = entry.unwrap().path();
+
+ if !path.is_file() {
+ continue;
+ }
+
+ if !path.extension().is_some_and(|ext| ext == "json") {
+ continue;
+ }
+
+ println!("running {}", path.display());
+ let accent = read_accent(path);
+ for line in &lines {
+ for intensity in accent.intensities() {
+ accent.say_it(&line, intensity);
+ }
+ }
+ tested_at_least_one = true;
+ }
+
+ assert!(tested_at_least_one);
+}

tests/ron.rs

@@ -0,0 +1,41 @@
+mod utils;
+
+use sayit::Accent;
+use std::{fs, path::PathBuf};
+use utils::read_sample_file_lines;
+
+pub fn read_accent(filename: PathBuf) -> Accent {
+ let content = fs::read_to_string(&filename).unwrap();
+ ron::from_str::<Accent>(&content)
+ .expect(&format!("parsing accent {}", filename.display()))
+}
+
+#[test]
+fn ron_examples_work() {
+ let lines = read_sample_file_lines();
+
+ let mut tested_at_least_one = false;
+
+ for entry in fs::read_dir("examples").unwrap() {
+ let path = entry.unwrap().path();
+
+ if !path.is_file() {
+ continue;
+ }
+
+ if !path.extension().is_some_and(|ext| ext == "ron") {
+ continue;
+ }
+
+ println!("running {}", path.display());
+ let accent = read_accent(path);
+ for line in &lines {
+ for intensity in accent.intensities() {
+ accent.say_it(&line, intensity);
+ }
+ }
+ tested_at_least_one = true;
+ }
+
+ assert!(tested_at_least_one);
+}