Add sync object pause controls

crates/ely_browser_core/src/state.rs

@@ -8,6 +8,7 @@ use ely_domain::{
 };
 
 use crate::{CoreError, navigation::tab_title};
+use sync::SyncObjectPolicies;
 
 mod bookmarks;
 mod commands;
@@ -98,6 +99,7 @@ pub struct BrowserCore {
     new_tab_destination: NewTabDestination,
     history_recording_policy: HistoryRecordingPolicy,
     favorite_limit: FavoriteLimit,
+    sync_object_policies: SyncObjectPolicies,
     command_query: String,
 }
 
@@ -134,6 +136,7 @@ impl BrowserCore {
             new_tab_destination,
             history_recording_policy: HistoryRecordingPolicy::default(),
             favorite_limit: FavoriteLimit::default(),
+            sync_object_policies: SyncObjectPolicies::default(),
             spaces: vec![space],
             profiles: vec![profile],
             tabs: vec![tab],

crates/ely_browser_core/src/state/sync.rs

@@ -1,50 +1,129 @@
-use ely_domain::{SyncObjectKind, SyncObjectState, SyncObjectStatus, SyncStatus};
+use ely_domain::{SyncObjectKind, SyncObjectPolicy, SyncObjectState, SyncObjectStatus, SyncStatus};
 
 use super::BrowserCore;
 
+#[derive(Clone, Debug)]
+pub(super) struct SyncObjectPolicies {
+    spaces: SyncObjectPolicy,
+    tabs: SyncObjectPolicy,
+    bookmarks: SyncObjectPolicy,
+    reading_list: SyncObjectPolicy,
+    profiles: SyncObjectPolicy,
+    site_permissions: SyncObjectPolicy,
+    history: SyncObjectPolicy,
+    plugin_settings: SyncObjectPolicy,
+}
+
+impl Default for SyncObjectPolicies {
+    fn default() -> Self {
+        Self {
+            spaces: SyncObjectPolicy::Enabled,
+            tabs: SyncObjectPolicy::Enabled,
+            bookmarks: SyncObjectPolicy::Enabled,
+            reading_list: SyncObjectPolicy::Enabled,
+            profiles: SyncObjectPolicy::Enabled,
+            site_permissions: SyncObjectPolicy::Enabled,
+            history: SyncObjectPolicy::Enabled,
+            plugin_settings: SyncObjectPolicy::Enabled,
+        }
+    }
+}
+
+impl SyncObjectPolicies {
+    fn get(&self, kind: SyncObjectKind) -> SyncObjectPolicy {
+        match kind {
+            SyncObjectKind::Spaces => self.spaces,
+            SyncObjectKind::Tabs => self.tabs,
+            SyncObjectKind::Bookmarks => self.bookmarks,
+            SyncObjectKind::ReadingList => self.reading_list,
+            SyncObjectKind::Profiles => self.profiles,
+            SyncObjectKind::SitePermissions => self.site_permissions,
+            SyncObjectKind::History => self.history,
+            SyncObjectKind::PluginSettings => self.plugin_settings,
+        }
+    }
+
+    fn set(&mut self, kind: SyncObjectKind, policy: SyncObjectPolicy) {
+        match kind {
+            SyncObjectKind::Spaces => self.spaces = policy,
+            SyncObjectKind::Tabs => self.tabs = policy,
+            SyncObjectKind::Bookmarks => self.bookmarks = policy,
+            SyncObjectKind::ReadingList => self.reading_list = policy,
+            SyncObjectKind::Profiles => self.profiles = policy,
+            SyncObjectKind::SitePermissions => self.site_permissions = policy,
+            SyncObjectKind::History => self.history = policy,
+            SyncObjectKind::PluginSettings => self.plugin_settings = policy,
+        }
+    }
+}
+
 impl BrowserCore {
+    pub fn set_sync_object_policy(&mut self, kind: SyncObjectKind, policy: SyncObjectPolicy) {
+        self.sync_object_policies.set(kind, policy);
+    }
+
+    #[must_use]
+    pub fn sync_object_policy(&self, kind: SyncObjectKind) -> SyncObjectPolicy {
+        self.sync_object_policies.get(kind)
+    }
+
     pub(super) fn sync_status(&self) -> SyncStatus {
         SyncStatus::signed_out(vec![
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::Spaces,
                 self.spaces.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::Tabs,
                 self.tabs.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::Bookmarks,
                 self.bookmarks.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::ReadingList,
                 self.reading_list.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::Profiles,
                 self.profiles.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::SitePermissions,
                 self.site_permissions.len(),
                 SyncObjectState::LocalOnly,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::History,
                 self.history_entries.len(),
                 SyncObjectState::PrivacyControlled,
             ),
-            SyncObjectStatus::new(
+            self.sync_object_status(
                 SyncObjectKind::PluginSettings,
                 self.installed_plugins.len(),
                 SyncObjectState::LocalOnly,
             ),
         ])
     }
+
+    fn sync_object_status(
+        &self,
+        kind: SyncObjectKind,
+        local_count: usize,
+        enabled_state: SyncObjectState,
+    ) -> SyncObjectStatus {
+        let policy = self.sync_object_policies.get(kind);
+        let state = match policy {
+            SyncObjectPolicy::Enabled => enabled_state,
+            SyncObjectPolicy::Paused => SyncObjectState::Paused,
+        };
+
+        SyncObjectStatus::with_policy(kind, local_count, state, policy)
+    }
 }

crates/ely_browser_core/tests/sync.rs

@@ -1,7 +1,10 @@
 use std::error::Error;
 
 use ely_browser_core::{BrowserCore, InitialBrowserConfig};
-use ely_domain::{SyncConnectionState, SyncObjectKind, SyncObjectState, SyncObjectStatus, UrlText};
+use ely_domain::{
+    SyncConnectionState, SyncObjectKind, SyncObjectPolicy, SyncObjectState, SyncObjectStatus,
+    UrlText,
+};
 
 #[test]
 fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Error>> {
@@ -32,3 +35,31 @@ fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Erro
     );
     Ok(())
 }
+
+#[test]
+fn sync_object_policy_pauses_object_kind() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+    core.set_sync_object_policy(SyncObjectKind::Tabs, SyncObjectPolicy::Paused);
+
+    let snapshot = core.snapshot()?;
+    let Some(tabs_status) =
+        snapshot.sync_status.objects().iter().find(|status| status.kind() == SyncObjectKind::Tabs)
+    else {
+        return Err("missing tabs sync status".into());
+    };
+    let Some(spaces_status) = snapshot
+        .sync_status
+        .objects()
+        .iter()
+        .find(|status| status.kind() == SyncObjectKind::Spaces)
+    else {
+        return Err("missing spaces sync status".into());
+    };
+
+    assert_eq!(core.sync_object_policy(SyncObjectKind::Tabs), SyncObjectPolicy::Paused);
+    assert_eq!(tabs_status.policy(), SyncObjectPolicy::Paused);
+    assert_eq!(tabs_status.state(), SyncObjectState::Paused);
+    assert_eq!(spaces_status.policy(), SyncObjectPolicy::Enabled);
+    assert_eq!(spaces_status.state(), SyncObjectState::LocalOnly);
+    Ok(())
+}