ingraph 0.1.0

A declaration-driven indexing framework: records and nodes are written as Rust types, and the storage rows, the dataflow between them and the GraphQL query surface are emitted from the declaration.
Documentation
use super::{RANGES, of};

use crate::WritingSystem;

/// **THE DATA SUPPORTS THE SEARCH**: ascending, disjoint, and never inverted.
///
/// A binary search over a table that overlapped or ran backwards would answer wrongly rather than
/// loudly, so the shape the search assumes is asserted rather than assumed.
#[test]
fn the_ranges_are_sorted_and_disjoint() {
  let mut previous: Option<(u32, u32)> = None;

  for (first, last, script) in RANGES {
    assert!(first <= last, "range {first:#X}..={last:#X} runs backwards");
    assert!(
      !script.is_other(),
      "the table never names the word's escape, and {first:#X} does"
    );
    if let Some((_, previous_last)) = previous {
      assert!(
        previous_last < *first,
        "{previous_last:#X} and {first:#X} overlap or are out of order"
      );
    }
    previous = Some((*first, *last));
  }
}

/// The ASCII branch and the table agree about the stretch they both describe.
#[test]
fn ascii_is_answered_without_the_table() {
  for codepoint in 0..0x80_u32 {
    let character = char::from_u32(codepoint).expect("ASCII is a character");
    let expected = match codepoint {
      0x41..=0x5A | 0x61..=0x7A => WritingSystem::Latn,
      _ => WritingSystem::Zyyy,
    };
    assert_eq!(of(character), expected, "at {codepoint:#X}");
  }
}

/// The classifications the segmenter's own rules are written against.
#[test]
fn the_landmarks_classify() {
  assert_eq!(WritingSystem::of('a'), WritingSystem::Latn);
  assert_eq!(WritingSystem::of('é'), WritingSystem::Latn);
  assert_eq!(WritingSystem::of('中'), WritingSystem::Hani);
  assert_eq!(WritingSystem::of('漢'), WritingSystem::Hani);
  assert_eq!(WritingSystem::of('の'), WritingSystem::Hira);
  assert_eq!(WritingSystem::of('テ'), WritingSystem::Kana);
  assert_eq!(WritingSystem::of('한'), WritingSystem::Hang);
  assert_eq!(WritingSystem::of('Я'), WritingSystem::Cyrl);
  assert_eq!(WritingSystem::of('ع'), WritingSystem::Arab);
  assert_eq!(WritingSystem::of('א'), WritingSystem::Hebr);
  assert_eq!(WritingSystem::of('Ω'), WritingSystem::Grek);
  assert_eq!(WritingSystem::of('क'), WritingSystem::Deva);
  assert_eq!(WritingSystem::of('ก'), WritingSystem::Thai);

  // THE SWEPT-IN SCRIPTS, one landmark each — every one of them a living script whose segmentation
  // habit an existing member's analyzer would get wrong.
  assert_eq!(WritingSystem::of('Ա'), WritingSystem::Armn);
  assert_eq!(WritingSystem::of('আ'), WritingSystem::Beng);
  assert_eq!(WritingSystem::of('ㄅ'), WritingSystem::Bopo);
  assert_eq!(WritingSystem::of('ᐊ'), WritingSystem::Cans);
  assert_eq!(WritingSystem::of('አ'), WritingSystem::Ethi);
  assert_eq!(WritingSystem::of('ა'), WritingSystem::Geor);
  assert_eq!(WritingSystem::of('અ'), WritingSystem::Gujr);
  assert_eq!(WritingSystem::of('ਅ'), WritingSystem::Guru);
  assert_eq!(WritingSystem::of('ក'), WritingSystem::Khmr);
  assert_eq!(WritingSystem::of('ಅ'), WritingSystem::Knda);
  assert_eq!(WritingSystem::of('ກ'), WritingSystem::Laoo);
  assert_eq!(WritingSystem::of('അ'), WritingSystem::Mlym);
  assert_eq!(WritingSystem::of('ᠠ'), WritingSystem::Mong);
  assert_eq!(WritingSystem::of('က'), WritingSystem::Mymr);
  assert_eq!(WritingSystem::of('ଅ'), WritingSystem::Orya);
  assert_eq!(WritingSystem::of('අ'), WritingSystem::Sinh);
  assert_eq!(WritingSystem::of('ܐ'), WritingSystem::Syrc);
  assert_eq!(WritingSystem::of('அ'), WritingSystem::Taml);
  assert_eq!(WritingSystem::of('అ'), WritingSystem::Telu);
  assert_eq!(WritingSystem::of('ހ'), WritingSystem::Thaa);
  assert_eq!(WritingSystem::of('ཀ'), WritingSystem::Tibt);

  // The three that belong to every script or to none.
  assert_eq!(WritingSystem::of(' '), WritingSystem::Zyyy);
  assert_eq!(WritingSystem::of('7'), WritingSystem::Zyyy);
  assert_eq!(WritingSystem::of('!'), WritingSystem::Zyyy);
  assert_eq!(WritingSystem::of('\u{0301}'), WritingSystem::Zinh);

  // STILL THE UNCODED REST: a script the sweep deliberately did not take — Runic is historic — and a
  // private-use codepoint. One bucket, by design.
  assert_eq!(WritingSystem::of('\u{16A0}'), WritingSystem::Zzzz, "runic");
  assert_eq!(
    WritingSystem::of('\u{E000}'),
    WritingSystem::Zzzz,
    "private use"
  );
}

/// **THE ROSTER'S OWN CRITERION**, spent as an assertion: every concrete member classifies at least
/// one real character, so a variant cannot be added without the ranges that make it reachable.
#[test]
fn every_rostered_script_classifies_something() {
  let landmarks = [
    ('ع', WritingSystem::Arab),
    ('Ա', WritingSystem::Armn),
    ('আ', WritingSystem::Beng),
    ('ㄅ', WritingSystem::Bopo),
    ('ᐊ', WritingSystem::Cans),
    ('Я', WritingSystem::Cyrl),
    ('क', WritingSystem::Deva),
    ('አ', WritingSystem::Ethi),
    ('ა', WritingSystem::Geor),
    ('Ω', WritingSystem::Grek),
    ('અ', WritingSystem::Gujr),
    ('ਅ', WritingSystem::Guru),
    ('한', WritingSystem::Hang),
    ('中', WritingSystem::Hani),
    ('א', WritingSystem::Hebr),
    ('の', WritingSystem::Hira),
    ('テ', WritingSystem::Kana),
    ('ក', WritingSystem::Khmr),
    ('ಅ', WritingSystem::Knda),
    ('ກ', WritingSystem::Laoo),
    ('a', WritingSystem::Latn),
    ('അ', WritingSystem::Mlym),
    ('ᠠ', WritingSystem::Mong),
    ('က', WritingSystem::Mymr),
    ('ଅ', WritingSystem::Orya),
    ('අ', WritingSystem::Sinh),
    ('ܐ', WritingSystem::Syrc),
    ('அ', WritingSystem::Taml),
    ('అ', WritingSystem::Telu),
    ('ހ', WritingSystem::Thaa),
    ('ก', WritingSystem::Thai),
    ('ཀ', WritingSystem::Tibt),
  ];

  for (character, script) in &landmarks {
    assert_eq!(&WritingSystem::of(*character), script, "at {character}");
  }
  // Every VARIANTS entry is accounted for: the concrete ones above, plus the standard's three.
  assert_eq!(WritingSystem::VARIANTS.len(), landmarks.len() + 3);
}

/// **HAN IS UNIFIED**, so both spellings of one character answer the same script.
#[test]
fn simplified_and_traditional_are_one_script() {
  for character in ['发', '發', '髮', '国', '國', '中'] {
    assert_eq!(
      WritingSystem::of(character),
      WritingSystem::Hani,
      "at {character}"
    );
  }
}