Reorganize top-level directories with clearer naming convention

app -> app-desktop-macos, presets -> app-presets, server -> remote-server,
daw-config-reaper -> osc-config-daw, plugin-reaper-realearn -> plugin-reaper-relearn.
Updated run.py and presets.py path references accordingly.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

plugin-reaper-relearn/rx-util/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "rx-util"
+version = "0.1.0"
+authors = ["Benjamin Klum <benjamin.klum@helgoboss.org>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+rxrust.workspace = true
+
+
+[lints.clippy]
+enum_glob_use = "deny"

plugin-reaper-relearn/rx-util/src/invocation_mock.rs

@@ -0,0 +1,58 @@
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+/// A simple mock which counts the number of invocations and remembers the last argument.
+pub struct InvocationMock<O: Clone> {
+    count: Cell<u32>,
+    last_arg: RefCell<Option<O>>,
+}
+
+impl<O: Clone> InvocationMock<O> {
+    pub fn invoke(&self, arg: O) {
+        self.count.replace(self.count.get() + 1);
+        self.last_arg.replace(Some(arg));
+    }
+
+    /// Returns how many times `invoke()` has been called.
+    pub fn invocation_count(&self) -> u32 {
+        self.count.get()
+    }
+
+    /// Returns a copy of the last argument passed to `invoke()`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if there was no invocation at all.
+    pub fn last_arg(&self) -> O {
+        self.last_arg
+            .borrow()
+            .clone()
+            .expect("There were no invocations")
+    }
+}
+
+/// Executes the given closure `op`, passing it a shared invocation mock.
+///
+/// The `op` closure can take ownership of the invocation mock and pass it to another 'static
+/// closure, which is supposed to call the invocation mock. It also returns a pointer to the same
+/// mock, which can be used later to check the number of invocations and the last passed argument.
+pub fn observe_invocations<O: Clone, R>(
+    op: impl FnOnce(Rc<InvocationMock<O>>) -> R,
+) -> (Rc<InvocationMock<O>>, R) {
+    let (mock_one, mock_two) = create_invocation_mock();
+    (mock_one, op(mock_two))
+}
+
+/// Creates two pointers referring to the same invocation mock.
+///
+/// This is useful for testing 'static closures, that is, closures which need captured references to
+/// be 'static. Which makes tests like "this closure did run n times" non-trivial. So instead of
+/// using references, we can use shared pointers.
+pub fn create_invocation_mock<O: Clone>() -> (Rc<InvocationMock<O>>, Rc<InvocationMock<O>>) {
+    let mock = InvocationMock {
+        count: Cell::new(0),
+        last_arg: RefCell::new(None),
+    };
+    let shared_mock = Rc::new(mock);
+    (shared_mock.clone(), shared_mock)
+}

plugin-reaper-relearn/rx-util/src/lib.rs

@@ -0,0 +1,5 @@
+mod property;
+pub use property::*;
+
+mod invocation_mock;
+pub use invocation_mock::*;

plugin-reaper-relearn/rx-util/src/property.rs

@@ -0,0 +1,547 @@
+use rxrust::prelude::*;
+use std::fmt;
+use std::marker::PhantomData;
+
+/// The lifetime parameter determines the scope of the subscribe closure, which is relevant when
+/// capturing references.
+///
+/// In many real-world cases you should choose 'static. But check the unit tests below. If you use
+/// 'static in them, the closure would require all of its captured references to be 'static. In that
+/// case we would be forced to use shared ownership (e.g. `Rc`) instead of &mut references to do
+/// the test.
+pub type LocalProp<'a, T, I, N, N2> =
+    Prop<T, I, LocalPropSubject<'a, Option<I>>, LocalPropSubject<'a, T>, N, N2>;
+pub type LocalPropSubject<'a, T> = LocalSubject<'a, T, ()>;
+
+pub type SharedProp<T, I, N, N2> =
+    Prop<T, I, SharedPropSubject<Option<I>>, SharedPropSubject<T>, N, N2>;
+pub type SharedPropSubject<T> = SharedSubject<T, ()>;
+
+/// A reactive property which has the following characteristics:
+///
+/// - It can be initialized with a transformer, which is an fn that transforms the value passed to
+///   the setter before actually setting the value. It's good for restricting the value range of
+///   that property. It's not good for maintaining object-wide invariants because transformers which
+///   enclose over surrounding state are not advisable and therefore currently disabled by taking fn
+///   only.
+/// - It's cloneable if its value is cloneable (cloning it clones the value and the transformer, not
+///   the change listeners)
+/// - Equality operators are based just on the value, not on transformers and listeners
+///
+/// # Type parameters
+///
+/// - `T`: value type
+/// - `I`: initiator type
+/// - `S`: subject type
+/// - `N`: notifier (not a function pointer because the notifier is usually everywhere the same in
+///   one application, so we save memory by attaching it to the type instead of the instance)
+pub struct Prop<T, I, S, S2, N, N2>
+where
+    // Incomparable values don't make sense because change notification is
+    // what properties are all about!
+    T: PartialEq + Clone,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    value: T,
+    subject: S,
+    value_subject: S2,
+    transformer: fn(T) -> T,
+    p: PhantomData<(I, N, N2)>,
+}
+
+pub trait Notifier {
+    type T;
+    type Subject: Observer<Item = Self::T, Err = ()>;
+
+    fn notify(subject: &mut Self::Subject, value: &Self::T);
+}
+
+pub struct LocalSyncNotifier<'a, T>(PhantomData<&'a T>);
+
+impl<'a, T> Notifier for LocalSyncNotifier<'a, T>
+where
+    T: Clone,
+{
+    type T = T;
+    type Subject = LocalPropSubject<'a, T>;
+
+    fn notify(subject: &mut Self::Subject, value: &Self::T) {
+        subject.next(value.clone())
+    }
+}
+
+impl<T, I, S, S2, N, N2> Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    /// Creates the property with an initial value and identity transformer.
+    pub fn new(initial_value: T) -> Self {
+        Self {
+            value: initial_value,
+            subject: Default::default(),
+            value_subject: Default::default(),
+            transformer: |v| v,
+            p: PhantomData,
+        }
+    }
+
+    /// Creates the property with an initial value and a custom transformer. The transformer is not
+    /// applied to the initial value.
+    pub fn new_with_transformer(initial_value: T, transformer: fn(T) -> T) -> Self {
+        Self {
+            value: initial_value,
+            subject: Default::default(),
+            value_subject: Default::default(),
+            transformer,
+            p: PhantomData,
+        }
+    }
+
+    /// Returns a copy of the current value of this property.
+    pub fn get(&self) -> T
+    where
+        T: Copy,
+    {
+        self.value
+    }
+
+    /// Returns the current value of this property.
+    pub const fn get_ref(&self) -> &T {
+        &self.value
+    }
+
+    /// Sets this property to the given value. If a transformer has been defined, the given value
+    /// might be changed into another one before. Observers are notified only if the given value
+    /// is different from the current value.
+    pub fn set(&mut self, value: T) {
+        self.internal_set(value, None);
+    }
+
+    /// Sets this property to the given value using the given initiator.
+    pub fn set_with_initiator(&mut self, value: T, initiator: Option<I>) {
+        self.internal_set(value, initiator);
+    }
+
+    fn internal_set(&mut self, value: T, initiator: Option<I>) {
+        let transformed_value = (self.transformer)(value);
+        if transformed_value == self.value {
+            return;
+        }
+        self.value = transformed_value;
+        self.notify(initiator);
+    }
+
+    fn notify(&mut self, initiator: Option<I>) {
+        N::notify(&mut self.subject, &initiator);
+        N2::notify(&mut self.value_subject, &self.value);
+    }
+
+    pub fn set_without_notification(&mut self, value: T) {
+        let transformed_value = (self.transformer)(value);
+        if transformed_value == self.value {
+            return;
+        }
+        self.value = transformed_value;
+    }
+
+    pub fn set_with_optional_notification(&mut self, value: T, with_notification: bool) {
+        if with_notification {
+            self.set(value);
+        } else {
+            self.set_without_notification(value);
+        }
+    }
+
+    pub fn set_with_optional_notification_and_initiator(
+        &mut self,
+        value: T,
+        with_notification: bool,
+        initiator: Option<I>,
+    ) {
+        if with_notification {
+            self.set_with_initiator(value, initiator);
+        } else {
+            self.set_without_notification(value);
+        }
+    }
+
+    /// Like `set` but returns old value.
+    pub fn replace(&mut self, value: T) -> T {
+        let old_value = self.value.clone();
+        self.set(value);
+        old_value
+    }
+
+    /// Sets the value of this property to the value of the given one, invoking listeners.
+    ///
+    /// Consumes the given property.
+    pub fn apply_from(&mut self, other: Self) {
+        self.set(other.value)
+    }
+
+    /// Like `set()`, but lets you use the previous value for calculating the new one.
+    pub fn set_with(&mut self, f: impl Fn(&T) -> T) {
+        let value = f(&self.value);
+        self.set(value);
+    }
+
+    /// Modifies the value in place and notifies listeners.
+    pub fn mut_in_place(&mut self, f: impl Fn(&mut T)) {
+        f(&mut self.value);
+        self.notify(None);
+    }
+
+    pub fn set_with_with_initiator(&mut self, f: impl Fn(&T) -> T, initiator: Option<I>) {
+        let value = f(&self.value);
+        self.internal_set(value, initiator);
+    }
+}
+
+impl<'a, T, I, N, N2> LocalProp<'a, T, I, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy + 'a,
+    N: Notifier<T = Option<I>, Subject = LocalPropSubject<'a, Option<I>>>,
+    N2: Notifier<T = T, Subject = LocalPropSubject<'a, T>>,
+{
+    /// Fires whenever the value has changed.
+    ///
+    /// Event always contains a unit value instead of the
+    /// new value. This is perfect for combining observables because observables can be combined
+    /// much easier if they have the same type. UI event handlers for example are often not
+    /// interested in the new value anyway because they will just call some reusable
+    /// invalidation code that queries the new value itself.
+    pub fn changed(&self) -> impl LocalObservable<'a, Item = (), Err = ()> {
+        self.subject.clone().map_to(())
+    }
+
+    /// Fires whenever the value has changed. Also delivers the initiator of the change, if any.
+    pub fn changed_with_initiator(&self) -> impl LocalObservable<'a, Item = Option<I>, Err = ()> {
+        self.subject.clone()
+    }
+
+    /// Fires whenever the value has changed to the given value.
+    pub fn changed_to(&self, value: T) -> impl LocalObservable<'a, Item = (), Err = ()>
+    where
+        T: Clone + 'static,
+    {
+        self.value_subject
+            .clone()
+            .filter(move |v| *v == value)
+            .map_to(())
+    }
+
+    pub fn values(&self) -> impl LocalObservable<'a, Item = T, Err = ()>
+    where
+        T: Clone + 'static,
+    {
+        self.value_subject.clone()
+    }
+}
+
+impl<T, I, N, N2> SharedProp<T, I, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy + 'static,
+    N: Notifier<T = Option<I>, Subject = SharedPropSubject<Option<I>>>,
+    N2: Notifier<T = T, Subject = SharedPropSubject<T>>,
+{
+    pub fn changed(
+        &self,
+    ) -> impl SharedObservable<Unsub = SharedSubscription, Item = (), Err = ()> + 'static + Send + Sync
+    {
+        self.subject.clone().map_to(())
+    }
+}
+
+impl<T, I, S, S2, N, N2> fmt::Debug for Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone + fmt::Debug,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Property")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
+impl<T, I, S, S2, N, N2> Clone for Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    fn clone(&self) -> Self {
+        Self {
+            value: self.value.clone(),
+            subject: Default::default(),
+            value_subject: Default::default(),
+            transformer: self.transformer,
+            p: PhantomData,
+        }
+    }
+}
+
+impl<T, I, S, S2, N, N2> Default for Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone + Default,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    fn default() -> Self {
+        Self {
+            value: Default::default(),
+            subject: Default::default(),
+            value_subject: Default::default(),
+            transformer: |v| v,
+            p: PhantomData,
+        }
+    }
+}
+
+impl<T, I, S, S2, N, N2> From<T> for Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
+
+impl<T, I, S, S2, N, N2> PartialEq for Prop<T, I, S, S2, N, N2>
+where
+    T: PartialEq + Clone,
+    I: Copy,
+    S: Observer<Item = Option<I>, Err = ()> + Default,
+    S2: Observer<Item = T, Err = ()> + Default,
+    N: Notifier<T = Option<I>, Subject = S>,
+    N2: Notifier<T = T, Subject = S2>,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.value == other.value
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get() {
+        // Given
+        let p = prop(5);
+        // When
+        // Then
+        assert_eq!(p.get(), 5);
+    }
+
+    #[test]
+    fn set() {
+        // Given
+        let mut p = prop(5);
+        // When
+        p.set(6);
+        // Then
+        assert_eq!(p.get(), 6);
+    }
+
+    #[test]
+    fn clone() {
+        // Given
+        let p = prop(5);
+        // When
+        let p2 = p.clone();
+        // Then
+        assert_eq!(p.get(), 5);
+        assert_eq!(p2.get(), 5);
+    }
+
+    #[test]
+    fn clone_set_independent() {
+        // Given
+        let mut p = prop(5);
+        // When
+        let mut p2 = p.clone();
+        p.set(2);
+        p2.set(7);
+        // Then
+        assert_eq!(p.get(), 2);
+        assert_eq!(p2.get(), 7);
+    }
+
+    #[test]
+    fn transformer() {
+        // Given
+        let mut p = local_prop_with_transformer(5, |v| v.min(100));
+        // When
+        p.set(105);
+        // Then
+        assert_eq!(p.get(), 100);
+    }
+
+    #[test]
+    fn clone_transformer_works() {
+        // Given
+        let p = local_prop_with_transformer(5, |v| v.min(100));
+        // When
+        let mut p2 = p.clone();
+        p2.set(105);
+        // Then
+        assert_eq!(p2.get(), 100);
+    }
+
+    #[test]
+    fn observe() {
+        // Given
+        let mut invocation_count = 0;
+        // When
+        {
+            let mut p = prop(5);
+            p.changed().subscribe(|_v| invocation_count += 1);
+            p.set(6);
+        }
+        // Then
+        assert_eq!(invocation_count, 1);
+    }
+
+    #[test]
+    fn clone_observe_independent() {
+        // Given
+        let mut p_invocation_count = 0;
+        let mut p2_invocation_count = 0;
+        // When
+        {
+            let mut p = prop(5);
+            p.changed().subscribe(|_v| p_invocation_count += 1);
+            let mut p2 = p.clone();
+            p2.changed().subscribe(|_v| p2_invocation_count += 1);
+            p.set(6);
+            p2.set(6);
+        }
+        // Then
+        assert_eq!(p_invocation_count, 1);
+        assert_eq!(p2_invocation_count, 1);
+    }
+
+    /// In C++ ReaLearn, we used to automatically adjust other fields in a struct whenever the
+    /// value of a property in that struct has changed by subscribing to it in the constructor.
+    /// Either to ensure that min value is always <= max value, or to keep the
+    /// processor in sync with the model. Each of those cases boils down to having a
+    /// self-referential struct: The struct holds an rx subject which holds a subscriber which
+    /// points "back" to a field of the very same struct.
+    ///
+    /// In Rust, such self references would turn invalid as soon as the type moves, because moving
+    /// in Rust means memcpy to a different place in memory - which would let pointers/references
+    /// dangle. This is shown in the test.
+    ///
+    /// In C++ this was possible because C++ has a move constructor called when moving an object, in
+    /// which all self references can be reestablished. Rust intentionally doesn't have such move
+    /// constructors because always doing a simple memcpy has a multitude of advantages.
+    ///
+    /// In Rust, we can achieve the same by making sure the self-referenced data will stay where it
+    /// is, even if moved. We do that by putting it on the heap (e.g. using Box or Rc).
+    ///
+    /// Another way is to always calculate the memory address of the self-referenced data
+    /// on-the-fly:
+    ///
+    /// > So, to recap: instead of storing a pointer to an object itself, store some
+    /// > information so that you can calculate the pointer later. This is also commonly called
+    /// using > “handles”. (https://blog.sentry.io/2018/04/05/you-cant-rust-that)
+    ///
+    /// Or we use this opportunity to reconsider the design. Instead of enforcing that min value is
+    /// <= max value, we could just let it happen and instead provide an additional method which
+    /// returns the fixed value ... a more functional style. After all, the models are not the kind
+    /// of core domain objects for which it is important that they keep invariants. They are
+    /// made specifically for UI and (de)serialization needs. That's also why we have domain
+    /// counterparts without the suffix `Model`, which have no properties, are immutable and
+    /// therefore don't have this kind of issues by definition.
+    ///
+    /// Regarding use case 2, the "cached" processor to keep in sync with the model: An `Rc` would
+    /// certainly do the job, in our case with totally neglectable overhead. Or we don't expose
+    /// the properties directly and use setter methods which take care of updating the cached
+    /// processor. However, at first we might just want to go without caching the processor at all!
+    #[test]
+    fn update_other_member_on_change_fail() {
+        struct Combination<'a> {
+            value: TestProp<'a, i32>,
+            _derived_value: i32,
+        }
+
+        impl<'a> Combination<'a> {
+            fn new(initial_value: i32) -> Combination<'a> {
+                let mut c = Combination {
+                    value: prop(initial_value),
+                    _derived_value: initial_value,
+                };
+                let c_ptr = to_ptr(&mut c);
+                c.value.changed().subscribe(move |_| {
+                    // This won't work because at the time we move c out of this `new` function,
+                    // it will move to a different address in memory. In the old C++ code, this
+                    // only worked because we did the subscription in a move/copy constructor, which
+                    // was called whenever this value was moved.
+                    // Related to discussion here: https://internals.rust-lang.org/t/idea-limited-custom-move-semantics-through-explicitly-specified-relocations/6704/12
+                    let c = unsafe { &mut *c_ptr };
+                    c._derived_value = c.value.get() * 2;
+                });
+                c
+            }
+        }
+
+        fn to_ptr<T>(value: &mut T) -> *mut T {
+            value as *mut T
+        }
+
+        // Given
+        let mut c = Combination::new(5);
+        to_ptr(&mut c);
+        // The following would most likely crash!
+        // c.value.set(8);
+    }
+
+    // TODO-low Add some SharedProp tests
+
+    type TestProp<'a, T> =
+        LocalProp<'a, T, u32, LocalSyncNotifier<'a, Option<u32>>, LocalSyncNotifier<'a, T>>;
+
+    fn prop<'a, T>(initial_value: T) -> TestProp<'a, T>
+    where
+        T: PartialEq + Clone,
+    {
+        TestProp::new(initial_value)
+    }
+
+    fn local_prop_with_transformer<'a, T>(
+        initial_value: T,
+        transformer: fn(T) -> T,
+    ) -> TestProp<'a, T>
+    where
+        T: PartialEq + Clone,
+    {
+        TestProp::new_with_transformer(initial_value, transformer)
+    }
+}