feat: sub extension can set 'platforms' now (#847)

Before this commit, sub extensions were not allowed to set their
"platforms" field, this restriction is lifted in this commit.

By allowing this, a group extension can have sub extensions for
different platforms, here is an example (irrelavent fields are omitted
for the sake of simplicity):

```json
{
  "name": "Suspend my machine",
  "type": "Group",
  "platforms": ["macos", "windows"],
  "commands": [
    {
      "name": "Suspend macOS":
      "platforms": ["macos"],
      "action": {...}
    },
    {
      "name": "Suspend Windows":
      "platforms": ["windows"],
      "action": {...}
    }
  ]
}
```

While loading or installing extensions, incompatible sub extensions will
be filtered out by Coco, e.g., you won't see that "Suspend Windows"
command if you are on macOS.

An extra check is added in this commit to ensure a sub extensions won't
support the platforms that are incompatible with its main extension.

Even though main extensions and sub extensions can both have "platforms"
specified, the semantics of this field, when not set, differs between them.
For main extensions, it means this extension is compatible with all the
platforms supported by Coco (null == all).  For sub extensions, having it
not set implicitly says that this field has the same value as the main
extension's "platforms" field.

The primary reason behind this design is that if we choose the semantics used
by the main extension, treating null as all, all the extensions we currently
have will become invalid, because they are all macOS-only, the main extensions's
"platforms" field is "macos" and sub extensions' "platforms" is not set (null),
they will be equivalent to:

```json
{
  "name": "this is macOS-only",
  "type": "Group",
  "platforms": ["macos"],
  "commands": [
    {
      "name": "How the fxxk can this support all the platforms!"
      "platforms": ["macos", "windows", "linux"],
      "type": "Command",
      "action": {...}
    }
  ]
}
```
This hits exactly the check we mentioned earlier and will be rejected by
Coco.  If we have users installed them, the installed extensions will be
treated invalid and rejected by future Coco release, boom, we break backward
compatibility.

Also, the current design actually makes sense.  Nobody wants to repeatedly
tell Coco that all the sub extensions support macOS if this can be said only
once:

```json
{
  "name": "this is macOS-only",
  "platforms": ["macos"],
  "commands": [
    {
      "name": "This supports macOS"
      "platforms": ["macos"],
    },
    {
      "name": "This supports macOS too"
      "platforms": ["macos"],
    },
    {
      "name": "Guess what! this also supports macOS"
      "platforms": ["macos"],
    },
    {
      "name": "Come on dude, do I really to say this platform=macos so many times"
      "platforms": ["macos"],
    }
  ]
}
```

Author: SteveLauC

docs/content.en/docs/release-notes/_index.md

@@ -16,6 +16,7 @@ Information about release notes of Coco App is provided here.
 - feat: enhance ui for skipped version #834
 - feat: support installing local extensions #749
 - feat: support sending files in chat messages #764
+- feat: sub extension can set 'platforms' now #847
 
 ### 🐛 Bug fix
 

src-tauri/Cargo.lock

@@ -106,6 +106,7 @@ tokio-stream = { version = "0.1.17", features = ["io-util"] }
 cfg-if = "1.0.1"
 sysinfo = "0.35.2"
 indexmap = { version = "2.10.0", features = ["serde"] }
+strum = { version = "0.27.2", features = ["derive"] }
 
 [target."cfg(target_os = \"macos\")".dependencies]
 tauri-nspanel = { git = "https://github.com/ahkohd/tauri-nspanel", branch = "v2" }

src-tauri/Cargo.toml

@@ -25,7 +25,7 @@ fn default_true() -> bool {
     true
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub struct Extension {
     /// Extension ID.
     ///
@@ -275,13 +275,13 @@ impl Extension {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub(crate) struct CommandAction {
     pub(crate) exec: String,
     pub(crate) args: Option<Vec<String>>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub struct Quicklink {
     // NOTE that `struct QuicklinkLink` (not `struct Quicklink`) has its own
     // derived `Deserialize/Serialize` impl, which deserializes/serializes
@@ -328,7 +328,7 @@ pub(crate) fn quicklink_link_arguments(
 }
 
 /// A quicklink consists of a sequence of components.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub(crate) struct QuicklinkLink {
     components: Vec<QuicklinkLinkComponent>,
 }
@@ -440,7 +440,7 @@ where
 /// The above link can be split into the following components:
 ///
 /// [StaticStr("https://www.google.com/search?q="), DynamicPlaceholder { argument_name: "query", default: None }]
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub(crate) enum QuicklinkLinkComponent {
     StaticStr(String),
     /// For the valid formats of dynamic placeholder, see the doc comments of `fn parse_dynamic_placeholder()`

src-tauri/src/extension/mod.rs

@@ -14,13 +14,26 @@
 
 use crate::extension::Extension;
 use crate::extension::ExtensionType;
+use crate::util::platform::Platform;
 use std::collections::HashSet;
 
 pub(crate) fn general_check(extension: &Extension) -> Result<(), String> {
     // Check main extension
     check_main_extension_only(extension)?;
     check_main_extension_or_sub_extension(extension, &format!("extension [{}]", extension.id))?;
 
+    // `None` if `extension` is compatible with all the platforms. Otherwise `Some(limited_platforms)`
+    let limited_supported_platforms = match extension.platforms.as_ref() {
+        Some(platforms) => {
+            if platforms.len() == Platform::num_of_supported_platforms() {
+                None
+            } else {
+                Some(platforms)
+            }
+        }
+        None => None,
+    };
+
     // Check sub extensions
     let commands = match extension.commands {
         Some(ref v) => v.as_slice(),
@@ -38,7 +51,7 @@ pub(crate) fn general_check(extension: &Extension) -> Result<(), String> {
     let mut sub_extension_ids = HashSet::new();
 
     for sub_extension in sub_extensions.iter() {
-        check_sub_extension_only(&extension.id, sub_extension)?;
+        check_sub_extension_only(&extension.id, sub_extension, limited_supported_platforms)?;
         check_main_extension_or_sub_extension(
             extension,
             &format!("sub-extension [{}-{}]", extension.id, sub_extension.id),
@@ -94,7 +107,11 @@ fn check_main_extension_only(extension: &Extension) -> Result<(), String> {
     Ok(())
 }
 
-fn check_sub_extension_only(extension_id: &str, sub_extension: &Extension) -> Result<(), String> {
+fn check_sub_extension_only(
+    extension_id: &str,
+    sub_extension: &Extension,
+    limited_platforms: Option<&HashSet<Platform>>,
+) -> Result<(), String> {
     if sub_extension.r#type == ExtensionType::Group
         || sub_extension.r#type == ExtensionType::Extension
     {
@@ -104,13 +121,6 @@ fn check_sub_extension_only(extension_id: &str, sub_extension: &Extension) -> Re
         ));
     }
 
-    if sub_extension.platforms.is_some() {
-        return Err(format!(
-            "invalid sub-extension [{}-{}]: field [platforms] should not be set in sub-extensions",
-            extension_id, sub_extension.id
-        ));
-    }
-
     if sub_extension.commands.is_some()
         || sub_extension.scripts.is_some()
         || sub_extension.quicklinks.is_some()
@@ -128,6 +138,29 @@ fn check_sub_extension_only(extension_id: &str, sub_extension: &Extension) -> Re
         ));
     }
 
+    if let Some(platforms_supported_by_main_extension) = limited_platforms {
+        match sub_extension.platforms {
+            Some(ref platforms_supported_by_sub_extension) => {
+                let diff = platforms_supported_by_sub_extension
+                    .difference(&platforms_supported_by_main_extension)
+                    .into_iter()
+                    .map(|p| p.to_string())
+                    .collect::<Vec<String>>();
+
+                if !diff.is_empty() {
+                    return Err(format!(
+                        "invalid sub-extension [{}-{}]: it supports platforms {:?} that are not supported by the main extension",
+                        extension_id, sub_extension.id, diff
+                    ));
+                }
+            }
+            None => {
+                // if `sub_extension.platform` is None, it means it has the same value
+                // as main extension's `platforms` field, so we don't need to check it.
+            }
+        }
+    }
+
     Ok(())
 }
 
@@ -172,8 +205,6 @@ fn check_main_extension_or_sub_extension(
 mod tests {
     use super::*;
     use crate::extension::{CommandAction, Quicklink, QuicklinkLink, QuicklinkLinkComponent};
-    use crate::util::platform::Platform;
-    use std::collections::HashSet;
 
     /// Helper function to create a basic valid extension
     fn create_basic_extension(id: &str, extension_type: ExtensionType) -> Extension {
@@ -368,27 +399,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_sub_extension_cannot_have_platforms() {
-        let mut extension = create_basic_extension("test-group", ExtensionType::Group);
-        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
-        sub_cmd.action = Some(create_command_action());
-
-        let mut platforms = HashSet::new();
-        platforms.insert(Platform::Macos);
-        sub_cmd.platforms = Some(platforms);
-
-        extension.commands = Some(vec![sub_cmd]);
-
-        let result = general_check(&extension);
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .contains("field [platforms] should not be set in sub-extensions")
-        );
-    }
-
     #[test]
     fn test_sub_extension_cannot_have_developer() {
         let mut extension = create_basic_extension("test-group", ExtensionType::Group);
@@ -542,4 +552,143 @@ mod tests {
 
         assert!(general_check(&extension).is_ok());
     }
+
+    /*
+     * Tests for check that sub extension cannot support extensions that are not
+     * supported by the main extension
+     *
+     * Start here
+     */
+    #[test]
+    fn test_platform_validation_both_none() {
+        // Case 1: main extension's platforms = None, sub extension's platforms = None
+        // Should return Ok(())
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = None;
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = None;
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_platform_validation_main_all_sub_none() {
+        // Case 2: main extension's platforms = Some(all platforms), sub extension's platforms = None
+        // Should return Ok(())
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = Some(Platform::all());
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = None;
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_platform_validation_main_none_sub_some() {
+        // Case 3: main extension's platforms = None, sub extension's platforms = Some([Platform::Macos])
+        // Should return Ok(()) because None means supports all platforms
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = None;
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = Some(HashSet::from([Platform::Macos]));
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_platform_validation_main_all_sub_subset() {
+        // Case 4: main extension's platforms = Some(all platforms), sub extension's platforms = Some([Platform::Macos])
+        // Should return Ok(()) because sub extension supports a subset of main extension's platforms
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = Some(Platform::all());
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = Some(HashSet::from([Platform::Macos]));
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_platform_validation_main_limited_sub_unsupported() {
+        // Case 5: main extension's platforms = Some([Platform::Macos]), sub extension's platforms = Some([Platform::Linux])
+        // Should return Err because sub extension supports a platform not supported by main extension
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = Some(HashSet::from([Platform::Macos]));
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = Some(HashSet::from([Platform::Linux]));
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err();
+        assert!(error_msg.contains("it supports platforms"));
+        assert!(error_msg.contains("that are not supported by the main extension"));
+        assert!(error_msg.contains("Linux")); // Should mention the unsupported platform
+    }
+
+    #[test]
+    fn test_platform_validation_main_partial_sub_unsupported() {
+        // Case 6: main extension's platforms = Some([Platform::Macos, Platform::Windows]), sub extension's platforms = Some([Platform::Linux])
+        // Should return Err because sub extension supports a platform not supported by main extension
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = Some(HashSet::from([Platform::Macos, Platform::Windows]));
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = Some(HashSet::from([Platform::Linux]));
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err();
+        assert!(error_msg.contains("it supports platforms"));
+        assert!(error_msg.contains("that are not supported by the main extension"));
+        assert!(error_msg.contains("Linux")); // Should mention the unsupported platform
+    }
+
+    #[test]
+    fn test_platform_validation_main_limited_sub_none() {
+        // Case 7: main extension's platforms = Some([Platform::Macos]), sub extension's platforms = None
+        // Should return Ok(()) because when sub extension's platforms is None, it inherits main extension's platforms
+        let mut main_extension = create_basic_extension("main-ext", ExtensionType::Group);
+        main_extension.platforms = Some(HashSet::from([Platform::Macos]));
+
+        let mut sub_cmd = create_basic_extension("sub-cmd", ExtensionType::Command);
+        sub_cmd.action = Some(create_command_action());
+        sub_cmd.platforms = None;
+
+        main_extension.commands = Some(vec![sub_cmd]);
+
+        let result = general_check(&main_extension);
+        assert!(result.is_ok());
+    }
+    /*
+     * Tests for check that sub extension cannot support extensions that are not
+     * supported by the main extension
+     *
+     * End here
+     */
 }