List & retrieve /taxonomies endpoint (#456)

* List & retrieve `/taxonomies` endpoint

* Add nav_menu_item & wp_block post type tests to list taxonomies

* Implement FromStr for PostType::Custom

* Address clippy warning to use unwrap_or_else over expect with format!

* Replace FromStr error types with Infallible where possible

native/kotlin/api/kotlin/src/integrationTest/kotlin/TaxonomiesEndpointTest.kt

@@ -0,0 +1,34 @@
+package rs.wordpress.api.kotlin
+
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import uniffi.wp_api.TaxonomyListParams
+import uniffi.wp_api.TaxonomyType
+import uniffi.wp_api.wpAuthenticationFromUsernameAndPassword
+import kotlin.test.assertEquals
+
+class TaxonomiesEndpointTest {
+    private val testCredentials = TestCredentials.INSTANCE
+    private val siteUrl = testCredentials.parsedSiteUrl
+    private val authentication = wpAuthenticationFromUsernameAndPassword(
+        username = testCredentials.adminUsername, password = testCredentials.adminPassword
+    )
+    private val client = WpApiClient(siteUrl, authentication)
+
+    @Test
+    fun testTaxonomyListRequest() = runTest {
+        val taxonomyList = client.request { requestBuilder ->
+            requestBuilder.taxonomies().listWithEditContext(params = TaxonomyListParams())
+        }.assertSuccessAndRetrieveData().data
+        assert(taxonomyList.taxonomyTypes.isNotEmpty())
+    }
+
+    @Test
+    fun testRetrieveCategoryTaxonomyRequest() = runTest {
+        val taxonomy = client.request { requestBuilder ->
+            requestBuilder.taxonomies().retrieveWithEditContext(TaxonomyType.Category)
+        }.assertSuccessAndRetrieveData().data
+        assertEquals("Categories", taxonomy.name)
+    }
+
+}

wp_api/src/api_client.rs

@@ -9,6 +9,7 @@ use crate::request::{
         post_types_endpoint::{PostTypesRequestBuilder, PostTypesRequestExecutor},
         posts_endpoint::{PostsRequestBuilder, PostsRequestExecutor},
         site_settings_endpoint::{SiteSettingsRequestBuilder, SiteSettingsRequestExecutor},
+        taxonomies_endpoint::{TaxonomiesRequestBuilder, TaxonomiesRequestExecutor},
         users_endpoint::{UsersRequestBuilder, UsersRequestExecutor},
         wp_site_health_tests_endpoint::{
             WpSiteHealthTestsRequestBuilder, WpSiteHealthTestsRequestExecutor,
@@ -47,6 +48,7 @@ pub struct WpApiRequestBuilder {
     post_types: Arc<PostTypesRequestBuilder>,
     posts: Arc<PostsRequestBuilder>,
     site_settings: Arc<SiteSettingsRequestBuilder>,
+    taxonomies: Arc<TaxonomiesRequestBuilder>,
     users: Arc<UsersRequestBuilder>,
     wp_site_health_tests: Arc<WpSiteHealthTestsRequestBuilder>,
 }
@@ -63,6 +65,7 @@ impl WpApiRequestBuilder {
             plugins,
             post_types,
             posts,
+            taxonomies,
             users,
             site_settings,
             wp_site_health_tests
@@ -98,6 +101,7 @@ pub struct WpApiClient {
     post_types: Arc<PostTypesRequestExecutor>,
     posts: Arc<PostsRequestExecutor>,
     site_settings: Arc<SiteSettingsRequestExecutor>,
+    taxonomies: Arc<TaxonomiesRequestExecutor>,
     users: Arc<UsersRequestExecutor>,
     wp_site_health_tests: Arc<WpSiteHealthTestsRequestExecutor>,
 }
@@ -121,6 +125,7 @@ impl WpApiClient {
             post_types,
             posts,
             site_settings,
+            taxonomies,
             users,
             wp_site_health_tests
         )
@@ -134,6 +139,7 @@ api_client_generate_endpoint_impl!(WpApi, plugins);
 api_client_generate_endpoint_impl!(WpApi, post_types);
 api_client_generate_endpoint_impl!(WpApi, posts);
 api_client_generate_endpoint_impl!(WpApi, site_settings);
+api_client_generate_endpoint_impl!(WpApi, taxonomies);
 api_client_generate_endpoint_impl!(WpApi, users);
 api_client_generate_endpoint_impl!(WpApi, wp_site_health_tests);
 

wp_api/src/api_error.rs

@@ -211,6 +211,8 @@ pub enum WpErrorCode {
     PostInvalidId,
     #[serde(rename = "rest_post_invalid_page_number")]
     PostInvalidPageNumber,
+    #[serde(rename = "rest_taxonomy_invalid")]
+    TaxonomyInvalid,
     #[serde(rename = "rest_type_invalid")]
     TypeInvalid,
     #[serde(rename = "rest_not_logged_in")]

wp_api/src/comments.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, num::ParseIntError, str::FromStr};
+use std::{collections::HashMap, convert::Infallible, num::ParseIntError, str::FromStr};
 
 use serde::{Deserialize, Serialize};
 use strum_macros::IntoStaticStr;
@@ -117,7 +117,7 @@ impl CommentType {
 }
 
 impl FromStr for CommentType {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
@@ -632,7 +632,7 @@ impl CommentStatus {
 }
 
 impl FromStr for CommentStatus {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {

wp_api/src/lib.rs

@@ -27,6 +27,7 @@ pub mod post_types;
 pub mod posts;
 pub mod request;
 pub mod site_settings;
+pub mod taxonomies;
 pub mod url_query;
 pub mod users;
 pub mod wordpress_org;

wp_api/src/media.rs

@@ -8,10 +8,10 @@ use crate::{
         AppendUrlQueryPairs, AsQueryValue, FromUrlQueryPairs, QueryPairs, QueryPairsExtension,
         UrlQueryPairsMap,
     },
-    EnumFromStrParsingError, JsonValue, UserId, WpApiParamOrder,
+    JsonValue, UserId, WpApiParamOrder,
 };
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, num::ParseIntError, str::FromStr};
+use std::{collections::HashMap, convert::Infallible, num::ParseIntError, str::FromStr};
 use strum_macros::IntoStaticStr;
 use wp_contextual::WpContextual;
 
@@ -58,7 +58,7 @@ impl MediaType {
 }
 
 impl FromStr for MediaType {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
@@ -102,7 +102,7 @@ impl MediaTypeParam {
 }
 
 impl FromStr for MediaTypeParam {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
@@ -153,7 +153,7 @@ impl MediaStatus {
 }
 
 impl FromStr for MediaStatus {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {

wp_api/src/post_types.rs

@@ -1,5 +1,8 @@
-use std::{collections::HashMap, fmt::Display};
+use std::convert::Infallible;
+use std::{collections::HashMap, fmt::Display, str::FromStr};
 
+use crate::impl_as_query_value_from_as_str;
+use crate::url_query::AsQueryValue;
 use serde::{Deserialize, Serialize};
 use wp_contextual::WpContextual;
 
@@ -22,9 +25,9 @@ pub enum PostType {
     Custom(String),
 }
 
-impl Display for PostType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
+impl PostType {
+    fn as_str(&self) -> &str {
+        match self {
             Self::Post => "post",
             Self::Page => "page",
             Self::Attachment => "attachment",
@@ -36,11 +39,38 @@ impl Display for PostType {
             Self::WpFontFamily => "wp_font_family",
             Self::WpFontFace => "wp_font_face",
             Self::Custom(name) => name.as_str(),
-        };
-        write!(f, "{}", s)
+        }
+    }
+}
+
+impl FromStr for PostType {
+    type Err = Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "post" => Ok(Self::Post),
+            "page" => Ok(Self::Page),
+            "attachment" => Ok(Self::Attachment),
+            "nav_menu_item" => Ok(Self::NavMenuItem),
+            "wp_block" => Ok(Self::WpBlock),
+            "wp_template" => Ok(Self::WpTemplate),
+            "wp_template_part" => Ok(Self::WpTemplatePart),
+            "wp_navigation" => Ok(Self::WpNavigation),
+            "wp_font_family" => Ok(Self::WpFontFamily),
+            "wp_font_face" => Ok(Self::WpFontFace),
+            value => Ok(Self::Custom(value.to_string())),
+        }
     }
 }
 
+impl Display for PostType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl_as_query_value_from_as_str!(PostType);
+
 #[derive(Debug, Serialize, Deserialize, uniffi::Record, WpContextual)]
 #[serde(transparent)]
 pub struct SparsePostTypesResponse {

wp_api/src/posts.rs

@@ -1,4 +1,4 @@
-use std::{num::ParseIntError, str::FromStr};
+use std::{convert::Infallible, num::ParseIntError, str::FromStr};
 
 use serde::{Deserialize, Serialize};
 use strum_macros::IntoStaticStr;
@@ -715,7 +715,7 @@ impl PostStatus {
 }
 
 impl FromStr for PostStatus {
-    type Err = EnumFromStrParsingError;
+    type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {

wp_api/src/request/endpoint.rs

@@ -9,6 +9,7 @@ pub mod plugins_endpoint;
 pub mod post_types_endpoint;
 pub mod posts_endpoint;
 pub mod site_settings_endpoint;
+pub mod taxonomies_endpoint;
 pub mod users_endpoint;
 pub mod wp_site_health_tests_endpoint;
 

wp_api/src/request/endpoint/taxonomies_endpoint.rs

@@ -0,0 +1,31 @@
+use super::{AsNamespace, DerivedRequest, WpNamespace};
+use crate::taxonomies::{
+    SparseTaxonomyTypeDetailsFieldWithEditContext, SparseTaxonomyTypeDetailsFieldWithEmbedContext,
+    SparseTaxonomyTypeDetailsFieldWithViewContext, TaxonomyListParams, TaxonomyType,
+};
+use crate::SparseField;
+use wp_derive_request_builder::WpDerivedRequest;
+
+#[derive(WpDerivedRequest)]
+enum TaxonomiesRequest {
+    #[contextual_get(url = "/taxonomies", params = &TaxonomyListParams, output = crate::taxonomies::SparseTaxonomyTypesResponse)]
+    List,
+    #[contextual_get(url = "/taxonomies/<taxonomy_type>", output = crate::taxonomies::SparseTaxonomyTypeDetails, filter_by = crate::taxonomies::SparseTaxonomyTypeDetailsField)]
+    Retrieve,
+}
+
+impl DerivedRequest for TaxonomiesRequest {
+    fn namespace() -> impl AsNamespace {
+        WpNamespace::WpV2
+    }
+}
+
+super::macros::default_sparse_field_implementation_from_field_name!(
+    SparseTaxonomyTypeDetailsFieldWithEditContext
+);
+super::macros::default_sparse_field_implementation_from_field_name!(
+    SparseTaxonomyTypeDetailsFieldWithEmbedContext
+);
+super::macros::default_sparse_field_implementation_from_field_name!(
+    SparseTaxonomyTypeDetailsFieldWithViewContext
+);