mod basics;
mod concave;
mod editing;
mod meets;
mod series;
use super::{TIERS_MULTI_SELECTED, tiers};
use crate::{
EditorSession,
guide::{
EVENTS, Goal, GoalContext, Guide, GuideCategory, StartingState, goal_met, start,
static_guides,
},
loading::{TierFormFields, parse_tier_form, parse_tier_target},
tier_save::{other_tier_names_excluding, tier_save_edit_with_target},
};
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::{ConstraintTier, Design, Edit, EditError};
use std::time::Duration;
const IDS: [&str; 23] = [
"tiers-add-a-tier",
"tiers-edit-a-tier",
"tiers-index-shorthands",
"tiers-facet-chips",
"tiers-quick-add",
"tiers-inline-angle",
"tiers-meets-named-facets",
"tiers-meets-mm-targets",
"tiers-adopt-imported-meets",
"tiers-pin-to-mast",
"tiers-step-series",
"tiers-linked-series",
"tiers-mirror-to-other-block",
"tiers-relations",
"tiers-arithmetic",
"tiers-cheater-offset",
"tiers-tier-notes",
"tiers-duplicate",
"tiers-move",
"tiers-delete",
"tiers-multi-select",
"tiers-concave-cylinder-cone",
"tiers-concave-sphere-disc",
];
struct Sim {
session: EditorSession,
events: Vec<String>,
clock: Duration,
}
#[derive(Clone, Debug)]
struct Form {
angle: String,
kind: i32,
text: String,
name: String,
indices: String,
}
impl Form {
fn new(angle: &str, kind: i32, text: &str, name: &str, indices: &str) -> Self {
Self {
angle: angle.to_owned(),
kind,
text: text.to_owned(),
name: name.to_owned(),
indices: indices.to_owned(),
}
}
fn of(tier: &ConstraintTier) -> Self {
let (kind, text) = match &tier.constraint {
MeetConstraint::MeetExisting => (0, String::new()),
MeetConstraint::MeetNamed(names) => (1, names.join(", ")),
MeetConstraint::ScaleReference(value) => (2, value.to_string()),
};
Self {
angle: tier.angle_deg.to_string(),
kind,
text,
name: tier.name.clone(),
indices: tier
.indices
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(", "),
}
}
}
enum Move {
Read,
Act(fn(&mut Sim)),
}
const fn read() -> Move {
Move::Read
}
const fn act(play: fn(&mut Sim)) -> Move {
Move::Act(play)
}
fn started_session(state: &StartingState) -> EditorSession {
start::started_session(state).unwrap_or_else(|| panic!("{state:?} creates no design"))
}
impl Sim {
fn start(state: &StartingState) -> Self {
let session = match state {
StartingState::NewEmpty | StartingState::Template(_) => started_session(state),
StartingState::RequiresOpenDesign => started_session(&StartingState::Template(5)),
other => panic!("the tiers tutorials do not start from {other:?}"),
};
Self {
session,
events: Vec::new(),
clock: Duration::ZERO,
}
}
fn met(&self, goal: &Goal) -> bool {
let context = GoalContext::new(&self.session.design).events(&self.events);
goal_met(goal, &context)
}
fn row(&self, name: &str) -> usize {
self.session
.design
.tiers
.iter()
.position(|tier| {
tier.names()
.iter()
.any(|known| known.trim().eq_ignore_ascii_case(name))
})
.unwrap_or_else(|| panic!("no tier is called {name:?}"))
}
fn tick(&mut self) -> Duration {
self.clock += Duration::from_millis(100);
self.clock
}
fn apply(&mut self, edit: Edit) {
self.session.apply(edit).expect("the edit applies");
}
fn apply_built(&mut self, built: Result<Edit, EditError>) {
self.apply(built.expect("the edit builds"));
}
fn undo(&mut self) {
self.session
.undo()
.expect("undo works")
.expect("there was something to undo");
}
fn save(&mut self, index: i32, form: &Form) {
let design = &self.session.design;
let current = usize::try_from(index)
.ok()
.and_then(|at| design.tiers.get(at));
let tier = parse_tier_form(TierFormFields {
angle: &form.angle,
constraint_kind: form.kind,
constraint_text: &form.text,
name: &form.name,
indices: &form.indices,
gear_teeth_abs: design.meta.gear_teeth_abs(),
imported_meet: current.and_then(|found| found.imported_meet.clone()),
original_notes: current.and_then(|found| found.original_notes.clone()),
other_tier_names: other_tier_names_excluding(design, index),
})
.unwrap_or_else(|message| panic!("the tier form is refused: {message}"));
let target = parse_tier_target(form.kind, &form.text).expect("the target reads");
let (_, edit) = tier_save_edit_with_target(design, index, tier, target, None);
self.apply(edit);
}
fn add(&mut self, form: &Form) {
self.save(-1, form);
}
fn edit_tier(&mut self, name: &str, change: impl FnOnce(&mut Form)) {
let row = self.row(name);
let mut form = Form::of(&self.session.design.tiers[row]);
change(&mut form);
self.save(i32::try_from(row).expect("a small row"), &form);
}
fn orbit(&mut self, name: &str, build: impl FnOnce(&Design, usize) -> Result<Edit, EditError>) {
let row = self.row(name);
let built = build(&self.session.design, row);
self.apply_built(built);
}
fn set_angle(&mut self, name: &str, text: &str) {
let row = self.row(name);
self.session
.set_tier_angle_from_text(row, text)
.expect("the angle reads");
}
fn nudge(&mut self, name: &str, delta: f64) {
let row = self.row(name);
let now = self.tick();
self.session
.nudge_angles(&[row], delta, now)
.expect("the nudge applies");
}
}
fn guide_named(id: &str) -> Guide {
tiers::guides()
.into_iter()
.find(|guide| guide.id == id)
.unwrap_or_else(|| panic!("there is no tiers tutorial called {id:?}"))
}
fn walk(id: &str, moves: Vec<Move>) -> Sim {
let guide = guide_named(id);
assert_eq!(guide.problem(), None, "{id} is not fit to run");
assert_eq!(
moves.len(),
guide.steps.len(),
"{id} needs one move for each of its steps"
);
let mut sim = Sim::start(&guide.starting_state);
for (number, (step, play)) in guide.steps.iter().zip(moves).enumerate() {
let at = number + 1;
sim.events.clear();
match play {
Move::Read => assert!(
step.is_manual(),
"{id}, step {at} ({:?}) waits for something, but the walk does nothing",
step.title
),
Move::Act(play) => {
assert!(
!step.is_manual(),
"{id}, step {at} ({:?}) is a reading step",
step.title
);
assert!(
!sim.met(&step.goal),
"{id}, step {at} ({:?}) is already met before the learner does anything",
step.title
);
play(&mut sim);
assert!(
sim.met(&step.goal),
"{id}, step {at} ({:?}) is not met after the learner's edit",
step.title
);
}
}
}
sim
}
#[test]
fn the_tiers_tutorials_are_registered_in_order() {
let guides = tiers::guides();
let ids: Vec<&str> = guides.iter().map(|guide| guide.id.as_str()).collect();
assert_eq!(ids, IDS, "the lessons, in browser order");
for guide in &guides {
assert!(guide.id.starts_with("tiers-"), "{}", guide.id);
assert!(
matches!(guide.category, GuideCategory::Tiers),
"{} is not listed under Tiers",
guide.id
);
assert_eq!(guide.problem(), None, "{}", guide.id);
}
let catalogue = static_guides();
for id in IDS {
assert_eq!(
catalogue.iter().filter(|guide| guide.id == id).count(),
1,
"{id} is in the catalogue exactly once"
);
}
}
#[test]
fn the_multi_select_event_is_one_the_catalogue_knows() {
assert!(EVENTS.contains(&TIERS_MULTI_SELECTED));
let waiting: Vec<String> = guide_named("tiers-multi-select")
.steps
.iter()
.flat_map(|step| step.goal.events().into_iter().map(str::to_owned))
.collect();
assert_eq!(waiting, [TIERS_MULTI_SELECTED]);
}
#[test]
fn a_check_goal_is_judged_by_its_test_and_needs_a_label() {
let design = EditorSession::fresh().design;
let context = GoalContext::new(&design);
let empty = Goal::Check {
label: "the design has no tiers",
test: |ctx| ctx.design.tiers.is_empty(),
};
let never = Goal::Check {
label: "never",
test: |_| false,
};
assert!(goal_met(&empty, &context));
assert!(!goal_met(&never, &context));
assert!(goal_met(&Goal::All(vec![empty.clone()]), &context));
assert!(!goal_met(&Goal::All(vec![empty.clone(), never]), &context));
assert_eq!(empty.problem(), None);
let unlabelled = Goal::Check {
label: " ",
test: |_| true,
};
assert!(unlabelled.problem().is_some());
}