move mod

lib/komainu/src/code_grant.rs

@@ -1,5 +1,5 @@
 use crate::{
-    error::Error, flow::pkce, params::ParamStorage, primitive::Scopes, AuthInstruction, Client,
+    error::Error, flow::pkce, params::ParamStorage, scope::Scope, AuthInstruction, Client,
     ClientExtractor,
 };
 use std::{borrow::Cow, future::Future, ops::Deref, str::FromStr};
@@ -83,8 +83,8 @@ where
             return Err(GrantError::AccessDenied);
         }
 
-        let request_scopes = scope.split_whitespace().collect::<Scopes>();
-        let client_scopes = client.scopes.iter().map(Deref::deref).collect::<Scopes>();
+        let request_scopes = scope.parse().unwrap();
+        let client_scopes = client.scopes.iter().map(Deref::deref).collect::<Scope>();
 
         // Check whether the client can actually perform the grant
         if !client_scopes.can_perform(&request_scopes) {

lib/komainu/src/lib.rs

@@ -10,7 +10,7 @@ pub mod error;
 pub mod extract;
 pub mod flow;
 pub mod params;
-pub mod primitive;
+pub mod scope;
 
 pub struct Authorization<'a> {
     pub code: Cow<'a, str>,

lib/komainu/src/primitive/scope.rs → lib/komainu/src/scope.rs

@@ -8,19 +8,19 @@ use std::{
 
 #[derive(Default, Deserialize)]
 #[serde(transparent)]
-pub struct Scopes {
+pub struct Scope {
     inner: HashSet<CompactString>,
 }
 
-impl FromStr for Scopes {
+impl FromStr for Scope {
     type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(s.split_whitespace().collect())
     }
 }
 
-impl Scopes {
+impl Scope {
     #[inline]
     #[must_use]
     pub fn new() -> Self {
@@ -58,24 +58,24 @@ impl Scopes {
     }
 }
 
-impl<Item> FromIterator<Item> for Scopes
+impl<Item> FromIterator<Item> for Scope
 where
     Item: Into<CompactString>,
 {
     #[inline]
     fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self {
-        let mut collection = Self::new();
-        for item in iter {
-            collection.insert(item.into());
-        }
-        collection
+        iter.into_iter().fold(Scope::new(), |mut acc, item| {
+            acc.insert(item.into());
+            acc
+        })
     }
 }
 
-impl IntoIterator for Scopes {
+impl IntoIterator for Scope {
     type Item = CompactString;
     type IntoIter = hash_set::IntoIter<Self::Item>;
 
+    #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.inner.into_iter()
     }

lib/komainu/tests/scope.rs

@@ -1,13 +1,13 @@
-use komainu::primitive::Scopes;
+use komainu::scope::Scope;
 use rstest::rstest;
 
 #[rstest]
 #[case("read", "read write")]
 #[case("read write", "read write")]
 #[case("read write follow", "read write follow push")]
 fn can_perform(#[case] request: &str, #[case] client: &str) {
-    let request: Scopes = request.parse().unwrap();
-    let client: Scopes = client.parse().unwrap();
+    let request: Scope = request.parse().unwrap();
+    let client: Scope = client.parse().unwrap();
 
     assert!(client.can_perform(&request));
 }
@@ -17,8 +17,8 @@ fn can_perform(#[case] request: &str, #[case] client: &str) {
 #[case("read follow", "write")]
 #[case("write push", "read")]
 fn cant_perform(#[case] request: &str, #[case] client: &str) {
-    let request: Scopes = request.parse().unwrap();
-    let client: Scopes = client.parse().unwrap();
+    let request: Scope = request.parse().unwrap();
+    let client: Scope = client.parse().unwrap();
 
     assert!(!client.can_perform(&request));
 }
@@ -29,8 +29,8 @@ fn cant_perform(#[case] request: &str, #[case] client: &str) {
 #[case("follow", "read follow")]
 #[case("write follow", "follow write")]
 fn can_access(#[case] endpoint: &str, #[case] client: &str) {
-    let endpoint: Scopes = endpoint.parse().unwrap();
-    let client: Scopes = client.parse().unwrap();
+    let endpoint: Scope = endpoint.parse().unwrap();
+    let client: Scope = client.parse().unwrap();
 
     assert!(endpoint.can_be_accessed_by(&client));
 }
@@ -40,8 +40,8 @@ fn can_access(#[case] endpoint: &str, #[case] client: &str) {
 #[case("follow", "read write")]
 #[case("write follow", "read follow")]
 fn cant_access(#[case] endpoint: &str, #[case] client: &str) {
-    let endpoint: Scopes = endpoint.parse().unwrap();
-    let client: Scopes = client.parse().unwrap();
+    let endpoint: Scope = endpoint.parse().unwrap();
+    let client: Scope = client.parse().unwrap();
 
     assert!(!endpoint.can_be_accessed_by(&client));
 }