Remove native HelpPage enum

Also remove oneof from pb enum and handle strs in Python.

proto/anki/links.proto

@@ -31,8 +31,5 @@ message HelpPageLinkRequest {
     DECK_OPTIONS = 15;
     EDITING_FEATURES = 16;
   }
-  oneof page {
+  HelpPage page = 1;
-    HelpPage variant = 1;
-    string literal = 2;
-  }
 }

qt/aqt/utils.py

@@ -74,10 +74,10 @@ HelpPageArgument = Union["HelpPage.HelpPage.V", str]
 
 def openHelp(section: HelpPageArgument) -> None:
     if isinstance(section, str):
-        page = HelpPage(literal=section)
+        link = tr.backend().help_page_link(page=HelpPage.INDEX) + section
     else:
-        page = HelpPage(variant=section)
+        link = tr.backend().help_page_link(page=section)
-    openLink(tr.backend().help_page_link(page))
+    openLink(link)
 
 
 def openLink(link: Union[str, QUrl]) -> None:

rslib/build/protobuf.rs

@@ -105,6 +105,10 @@ pub fn write_backend_proto_rs() {
             "Deck.Filtered.SearchTerm.Order",
             "#[derive(strum::EnumIter)]",
         )
+        .type_attribute(
+            "HelpPageLinkRequest.HelpPage",
+            "#[derive(strum::EnumIter)]",
+        )
         .compile_protos(paths.as_slice(), &[proto_dir])
         .unwrap();
 }

rslib/src/backend/links.rs

@@ -4,43 +4,14 @@
 use super::Backend;
 pub(super) use crate::backend_proto::links_service::Service as LinksService;
 use crate::{
-    backend_proto as pb,
+    backend_proto as pb, backend_proto::links::help_page_link_request::HelpPage, prelude::*,
-    backend_proto::links::help_page_link_request::{HelpPage as ProtoHelpPage, Page},
-    links::{help_page_link, help_page_link_from_str, HelpPage},
-    prelude::*,
 };
 
 impl LinksService for Backend {
     fn help_page_link(&self, input: pb::HelpPageLinkRequest) -> Result<pb::String> {
-        Ok(match input.page {
+        Ok(HelpPage::from_i32(input.page)
-            Some(Page::Variant(var)) => help_page_link(var.into()),
+            .unwrap_or(HelpPage::Index)
-            Some(Page::Literal(s)) => help_page_link_from_str(&s),
+            .to_link()
-            None => help_page_link_from_str(""),
-        }
             .into())
     }
 }
-
-impl From<i32> for HelpPage {
-    fn from(page: i32) -> Self {
-        match ProtoHelpPage::from_i32(page).unwrap_or(ProtoHelpPage::Index) {
-            ProtoHelpPage::NoteType => HelpPage::Notetype,
-            ProtoHelpPage::Browsing => HelpPage::Browsing,
-            ProtoHelpPage::BrowsingFindAndReplace => HelpPage::BrowsingFindAndReplace,
-            ProtoHelpPage::BrowsingNotesMenu => HelpPage::BrowsingNotesMenu,
-            ProtoHelpPage::KeyboardShortcuts => HelpPage::KeyboardShortcuts,
-            ProtoHelpPage::Editing => HelpPage::Editing,
-            ProtoHelpPage::AddingCardAndNote => HelpPage::AddingCardAndNote,
-            ProtoHelpPage::AddingANoteType => HelpPage::AddingNotetype,
-            ProtoHelpPage::Latex => HelpPage::Latex,
-            ProtoHelpPage::Preferences => HelpPage::Preferences,
-            ProtoHelpPage::Index => HelpPage::Index,
-            ProtoHelpPage::Templates => HelpPage::Templates,
-            ProtoHelpPage::FilteredDeck => HelpPage::FilteredDeck,
-            ProtoHelpPage::Importing => HelpPage::Importing,
-            ProtoHelpPage::CustomizingFields => HelpPage::CustomizingFields,
-            ProtoHelpPage::DeckOptions => HelpPage::DeckOptions,
-            ProtoHelpPage::EditingFeatures => HelpPage::EditingFeatures,
-        }
-    }
-}

rslib/src/links.rs

@@ -1,54 +1,36 @@
 // Copyright: Ankitects Pty Ltd and contributors
 // License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
 
-use strum::{Display, EnumIter, EnumString};
+use crate::backend_proto::links::help_page_link_request::HelpPage;
 
 static HELP_SITE: &'static str = "https://docs.ankiweb.net/";
 
-#[derive(Debug, PartialEq, Clone, Copy, Display, EnumIter, EnumString)]
+impl HelpPage {
-pub enum HelpPage {
+    pub fn to_link(self) -> String {
-    #[strum(serialize = "getting-started#note-types")]
+        format!("{}{}", HELP_SITE, self.to_fragment())
-    Notetype,
+    }
-    #[strum(serialize = "browsing")]
-    Browsing,
-    #[strum(serialize = "browsing#find-and-replace")]
-    BrowsingFindAndReplace,
-    #[strum(serialize = "browsing#notes")]
-    BrowsingNotesMenu,
-    #[strum(serialize = "studying#keyboard-shortcuts")]
-    KeyboardShortcuts,
-    #[strum(serialize = "editing")]
-    Editing,
-    #[strum(serialize = "editing#adding-cards-and-notes")]
-    AddingCardAndNote,
-    #[strum(serialize = "editing#adding-a-note-type")]
-    AddingNotetype,
-    #[strum(serialize = "math#latex")]
-    Latex,
-    #[strum(serialize = "preferences")]
-    Preferences,
-    #[strum(serialize = "")]
-    Index,
-    #[strum(serialize = "templates/intro")]
-    Templates,
-    #[strum(serialize = "filtered-decks")]
-    FilteredDeck,
-    #[strum(serialize = "importing")]
-    Importing,
-    #[strum(serialize = "editing#customizing-fields")]
-    CustomizingFields,
-    #[strum(serialize = "deck-options")]
-    DeckOptions,
-    #[strum(serialize = "editing#features")]
-    EditingFeatures,
-}
 
-pub fn help_page_link(page: HelpPage) -> String {
+    fn to_fragment(self) -> &'static str {
-    format!("{}{}", HELP_SITE, page)
+        match self {
-}
+            HelpPage::NoteType => "getting-started#note-types",
-
+            HelpPage::Browsing => "browsing",
-pub fn help_page_link_from_str(page: &str) -> String {
+            HelpPage::BrowsingFindAndReplace => "browsing#find-and-replace",
-    format!("{}{}", HELP_SITE, page)
+            HelpPage::BrowsingNotesMenu => "browsing#notes",
+            HelpPage::KeyboardShortcuts => "studying#keyboard-shortcuts",
+            HelpPage::Editing => "editing",
+            HelpPage::AddingCardAndNote => "editing#adding-cards-and-notes",
+            HelpPage::AddingANoteType => "editing#adding-a-note-type",
+            HelpPage::Latex => "math#latex",
+            HelpPage::Preferences => "preferences",
+            HelpPage::Index => "",
+            HelpPage::Templates => "templates/intro",
+            HelpPage::FilteredDeck => "filtered-decks",
+            HelpPage::Importing => "importing",
+            HelpPage::CustomizingFields => "editing#customizing-fields",
+            HelpPage::DeckOptions => "deck-options",
+            HelpPage::EditingFeatures => "editing#features",
+        }
+    }
 }
 
 #[cfg(test)]
@@ -88,12 +70,14 @@ mod test {
     }
 
     async fn check_page(page: HelpPage, ctx: &BasicContext) -> Outcome {
-        match Url::parse(&help_page_link(page)) {
+        match Url::parse(&page.to_link()) {
             Ok(url) => match check_web(&url, ctx).await {
                 Ok(()) => Outcome::Valid,
-                Err(Reason::Dom) => {
+                Err(Reason::Dom) => Outcome::Invalid(format!(
-                    Outcome::Invalid(format!("'{}' not found on '{}'", page, HELP_SITE))
+                    "'{}' not found on '{}'",
-                }
+                    page.to_fragment(),
+                    HELP_SITE
+                )),
                 Err(Reason::Web(err)) => Outcome::Invalid(err.to_string()),
                 _ => unreachable!(),
             },