Enum Scope 

pub enum Scope {
    Account(AccountScope),
    Identity(IdentityScope),
    Blob(BlobScope),
    Repo(RepoScope),
    Rpc(RpcScope),
    Atproto,
    Transition(TransitionScope),
    OpenId,
    Profile,
    Email,
}

Represents an AT Protocol OAuth scope

Variants

Account(AccountScope)

Account scope for accessing account information

Identity(IdentityScope)

Identity scope for accessing identity information

Blob(BlobScope)

Blob scope for blob operations with mime type constraints

Repo(RepoScope)

Repository scope for collection operations

Rpc(RpcScope)

RPC scope for method access

Atproto

AT Protocol scope - required to indicate that other AT Protocol scopes will be used

Transition(TransitionScope)

Transition scope for migration operations

OpenId

OpenID Connect scope - required for OpenID Connect authentication

Profile

Profile scope - access to user profile information

Email

Email scope - access to user email address

Implementations

impl Scope

pub fn parse_multiple(s: &str) -> Result<Vec<Self>, ParseError>

Parse multiple space-separated scopes from a string

Examples

let scopes = Scope::parse_multiple("atproto repo:*").unwrap();
assert_eq!(scopes.len(), 2);

pub fn parse_multiple_reduced(s: &str) -> Result<Vec<Self>, ParseError>

Parse multiple space-separated scopes and return the minimal set needed

This method removes duplicate scopes and scopes that are already granted by other scopes in the list, returning only the minimal set of scopes needed.

Examples

// repo:* grants repo:foo.bar, so only repo:* is kept
let scopes = Scope::parse_multiple_reduced("atproto repo:foo.bar repo:*").unwrap();
assert_eq!(scopes.len(), 2); // atproto and repo:*

pub fn serialize_multiple(scopes: &[Self]) -> String

Serialize a list of scopes into a space-separated OAuth scopes string

The scopes are sorted alphabetically by their string representation to ensure consistent output regardless of input order.

Examples

let scopes = vec![
    Scope::parse("repo:*").unwrap(),
    Scope::parse("atproto").unwrap(),
    Scope::parse("account:email").unwrap(),
];
let result = Scope::serialize_multiple(&scopes);
assert_eq!(result, "account:email atproto repo:*");

pub fn remove_scope(scopes: &[Self], scope_to_remove: &Self) -> Vec<Self>

Remove a scope from a list of scopes

Returns a new vector with all instances of the specified scope removed. If the scope doesn’t exist in the list, returns a copy of the original list.

Examples

let scopes = vec![
    Scope::parse("repo:*").unwrap(),
    Scope::parse("atproto").unwrap(),
    Scope::parse("account:email").unwrap(),
];
let to_remove = Scope::parse("atproto").unwrap();
let result = Scope::remove_scope(&scopes, &to_remove);
assert_eq!(result.len(), 2);
assert!(!result.contains(&to_remove));

pub fn parse(s: &str) -> Result<Self, ParseError>

Parse a scope from a string

pub fn to_string_normalized(&self) -> String

Convert the scope to its normalized string representation

pub fn grants(&self, other: &Scope) -> bool

Check if this scope grants the permissions of another scope

Trait Implementations

impl Clone for Scope

fn clone(&self) -> Scope

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Scope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Scope

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Scope

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Scope

fn eq(&self, other: &Scope) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Scope

impl StructuralPartialEq for Scope