Rename constraints to observables

app-proto/src/outline.rs

@@ -12,33 +12,33 @@ use crate::{
     AppState,
     assembly,
     assembly::{
-        Constraint,
-        ConstraintKey,
-        ConstraintRole::*,
+        Observable,
+        ObservableKey,
+        ObservableRole::*,
         ElementKey
     }
 };
 
-// an editable view of the Lorentz product representing a constraint
+// an editable view of the Lorentz product representing an observable
 #[component(inline_props)]
-fn LorentzProductInput(constraint: Constraint) -> View {
+fn ObservableInput(observable: Observable) -> View {
     view! {
         input(
             r#type="text",
-            placeholder=constraint.measured.with(|result| result.to_string()),
-            bind:value=constraint.desired_text,
+            placeholder=observable.measured.with(|result| result.to_string()),
+            bind:value=observable.desired_text,
             on:change=move |event: Event| {
                 let target: HtmlInputElement = event.target().unwrap().unchecked_into();
                 let value = target.value();
                 if value.is_empty() {
-                    constraint.role.set(Measure);
+                    observable.role.set(Measure);
                 } else {
                     match target.value().parse::<f64>() {
                         Ok(desired) => batch(|| {
-                            constraint.desired.set(desired);
-                            constraint.role.set(Constrain);
+                            observable.desired.set(desired);
+                            observable.role.set(Constrain);
                         }),
-                        Err(_) => constraint.role.set(Invalid)
+                        Err(_) => observable.role.set(Invalid)
                     };
                 }
             }
@@ -46,29 +46,29 @@ fn LorentzProductInput(constraint: Constraint) -> View {
     }
 }
 
-// a list item that shows a constraint in an outline view of an element
+// a list item that shows an observable in an outline view of an element
 #[component(inline_props)]
-fn ConstraintOutlineItem(constraint_key: ConstraintKey, element_key: ElementKey) -> View {
+fn ObservableOutlineItem(observable_key: ObservableKey, element_key: ElementKey) -> View {
     let state = use_context::<AppState>();
     let assembly = &state.assembly;
-    let constraint = assembly.constraints.with(|csts| csts[constraint_key].clone());
-    let other_subject = if constraint.subjects.0 == element_key {
-        constraint.subjects.1
+    let observable = assembly.observables.with(|obsls| obsls[observable_key].clone());
+    let other_subject = if observable.subjects.0 == element_key {
+        observable.subjects.1
     } else {
-        constraint.subjects.0
+        observable.subjects.0
     };
     let other_subject_label = assembly.elements.with(|elts| elts[other_subject].label.clone());
-    let class = constraint.role.map(
+    let class = observable.role.map(
         |role| match role {
-            Measure => "constraint",
-            Constrain => "constraint constrained",
-            Invalid => "constraint invalid"
+            Measure => "observable",
+            Constrain => "observable constrained",
+            Invalid => "observable invalid"
         }
     );
     view! {
         li(class=class.get()) {
-            div(class="constraint-label") { (other_subject_label) }
-            LorentzProductInput(constraint=constraint)
+            div(class="observable-label") { (other_subject_label) }
+            ObservableInput(observable=observable)
             div(class="status")
         }
     }
@@ -92,9 +92,9 @@ fn ElementOutlineItem(key: ElementKey, element: assembly::Element) -> View {
             ).collect::<Vec<_>>()
         )
     };
-    let constrained = element.constraints.map(|csts| csts.len() > 0);
-    let constraint_list = element.constraints.map(
-        |csts| csts.clone().into_iter().collect()
+    let observed = element.observables.map(|obsls| obsls.len() > 0);
+    let observable_list = element.observables.map(
+        |obsls| obsls.clone().into_iter().collect()
     );
     let details_node = create_node_ref();
     view! {
@@ -109,7 +109,7 @@ fn ElementOutlineItem(key: ElementKey, element: assembly::Element) -> View {
                                     state.select(key, event.shift_key());
                                     event.prevent_default();
                                 },
-                                "ArrowRight" if constrained.get() => {
+                                "ArrowRight" if observed.get() => {
                                     let _ = details_node
                                         .get()
                                         .unchecked_into::<web_sys::Element>()
@@ -156,16 +156,16 @@ fn ElementOutlineItem(key: ElementKey, element: assembly::Element) -> View {
                         div(class="status")
                     }
                 }
-                ul(class="constraints") {
+                ul(class="observables") {
                     Keyed(
-                        list=constraint_list,
-                        view=move |cst_key| view! {
-                            ConstraintOutlineItem(
-                                constraint_key=cst_key,
+                        list=observable_list,
+                        view=move |obs_key| view! {
+                            ObservableOutlineItem(
+                                observable_key=obs_key,
                                 element_key=key
                             )
                         },
-                        key=|cst_key| cst_key.clone()
+                        key=|obs_key| obs_key.clone()
                     )
                 }
             }
@@ -174,8 +174,8 @@ fn ElementOutlineItem(key: ElementKey, element: assembly::Element) -> View {
 }
 
 // a component that lists the elements of the current assembly, showing the
-// constraints on each element as a collapsible sub-list. its implementation
-// is based on Kate Morley's HTML + CSS tree views:
+// observables associated with each element as a collapsible sub-list. its
+// implementation is based on Kate Morley's HTML + CSS tree views:
 //
 //   https://iamkate.com/code/tree-views/
 //