Permkit

https://docs.rs/permkit/latest/
Admin
Permkit provides generic permission primitives, designed to be application-agnostic, allowing...
Tokens:21,500
Snippets:271
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Derive Macro Permission Example

Source: https://docs.rs/permkit/latest/permkit/derive.Permission.html

This is a basic example of how to use the `#[derive(Permission)]` macro. It shows the structure and the available `#[permission]` attribute.

```rust
#[derive(Permission)]
{
    // Attributes available to this derive:
    #[permission]
}

```

--------------------------------

### Example Search: std::vec

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=

Demonstrates a common search pattern using `std::vec`.

```rust
std::vec
```

--------------------------------

### Example Search: u32 to bool

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=

Illustrates a search pattern for type conversions from `u32` to `bool`.

```rust
u32 -> bool
```

--------------------------------

### Example Search Patterns

Source: https://docs.rs/permkit/latest/permkit/fn.permission_pattern_matches.html?search=

These are examples of common search patterns that can be used with permission matching functionalities. They illustrate different types of matches, such as simple types, type conversions, and generic type transformations.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Search: Option<T> mapping

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=

Shows a search pattern for mapping operations on `Option<T>`.

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Create an empty EffectivePermissions set

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=u32+-%3E+bool

Initializes an empty set of effective permissions. This is the starting point before adding any permission grants.

```Rust
use permkit::EffectivePermissions;

let permissions = EffectivePermissions::empty();
assert!(permissions.allows("any.permission")); // Initially allows everything if no grants are added
```

--------------------------------

### all_permission_names

Source: https://docs.rs/permkit/latest/permkit/fn.all_permission_names.html

This function returns a `Vec<Cow<'static, str>>` containing all the permission names that are recognized by the permkit. It's a straightforward way to get a list of all available permissions.

```APIDOC
## Function all_permission_names

### Description
Retrieves all available permission names within the permkit.

### Signature
```rust
pub fn all_permission_names() -> Vec<Cow<'static, str>>
```

### Returns
A `Vec<Cow<'static, str>>` where each element is a permission name.
```

--------------------------------

### Iterate Over All Registered Permissions

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Use this function to get a vector of all registered permission entries. Note that the order is not guaranteed to be stable, so sort the result if deterministic output is required. This function also adds synthetic wildcard entries for `Domain.Action` permissions.

```rust
pub fn all_permissions() -> Vec<PermissionEntry>
```

--------------------------------

### Get all permission names

Source: https://docs.rs/permkit/latest/permkit/fn.all_permission_names.html

Call the `all_permission_names` function to retrieve a list of all defined permission names. This function returns a `Vec<Cow<'static, str>>`.

```rust
use permkit::all_permission_names;

fn main() {
    let permission_names = all_permission_names();
    println!("Available permissions: {:?}", permission_names);
}
```

--------------------------------

### all_permission_names

Source: https://docs.rs/permkit/latest/permkit/fn.all_permission_names.html?search=

Retrieves a list of all available permission names. This function is part of the permkit library and is used to get a comprehensive list of permissions.

```APIDOC
## Function all_permission_names

### Description
Retrieves a list of all available permission names. This function is part of the permkit library and is used to get a comprehensive list of permissions.

### Signature
```rust
pub fn all_permission_names() -> Vec<Cow<'static, str>>
```

### Returns
A `Vec<Cow<'static, str>>` containing all permission names.
```

--------------------------------

### Getting Sorted and Deduped Permission Names

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

This function retrieves all permission names, sorts them, and removes duplicates, providing a clean, ordered list of unique permission identifiers.

```rust
pub fn all_permission_names() -> Vec<Cow<'static, str>> {
    all_permissions()
        .into_iter()
        .map(|entry| entry.name)
        .sorted()
        .dedup()
        .collect()
}
```

--------------------------------

### Registering and Retrieving All Permissions

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

This snippet demonstrates how to register permission entries using `inventory::submit!` and retrieve all registered permissions using the `all_permissions` function. It also shows the generation of synthetic wildcard entries.

```rust
/// Static metadata about a single permission variant.
///
/// Every `#[derive(Permission)]` enum emits one `inventory::submit!` per variant
/// pointing at this type, so the full set of permissions linked into the final
/// binary can be discovered via [`all_permissions`].
#[derive(Debug, Clone)]
pub struct PermissionEntry {
    pub name: Cow<'static, str>,
    pub enum_name: &'static str,
    pub roles: &'static [&'static str],
}

inventory::collect!(PermissionEntry);

/// Iterate over every registered permission.
///
/// Entries are yielded in linker order, which is not guaranteed stable. Sort the
/// result if deterministic output matters. For every `Domain.Action` permission, 
/// this also adds a synthetic `Domain.*` wildcard entry without role grants.
pub fn all_permissions() -> Vec<PermissionEntry> {
    let all: Vec<PermissionEntry> = inventory::iter::<PermissionEntry>().cloned().collect();

    let wildcards: Vec<PermissionEntry> = all
        .iter()
        .filter_map(|entry| {
            let (prefix, _) = entry.name.split_once('.')?;
            Some(PermissionEntry {
                name: Cow::Owned(format!("{prefix}.*")), 
                enum_name: entry.enum_name,
                roles: &[],
            })
        })
        .unique_by(|entry| entry.name.clone())
        .collect();

    all.into_iter().chain(wildcards).collect()
}
```

--------------------------------

### From and Into Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html

Illustrates the blanket implementations of From and Into traits, facilitating type conversions where a From implementation exists.

```rust
impl<T> From<T> for T

impl<T, U> Into<U> for T
where U: From<T>,
```

--------------------------------

### Registering and Retrieving Permission Entries

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=

This snippet demonstrates how to register static metadata about permission variants using `inventory::submit!` and how to retrieve all registered permissions using `all_permissions`. It also shows the generation of synthetic wildcard entries.

```rust
/// Static metadata about a single permission variant.
///
/// Every `#[derive(Permission)]` enum emits one `inventory::submit!` per variant
/// pointing at this type, so the full set of permissions linked into the final
/// binary can be discovered via [`all_permissions`].
#[derive(Debug, Clone)]
pub struct PermissionEntry {
    pub name: Cow<'static, str>,
    pub enum_name: &'static str,
    pub roles: &'static [&'static str],
}

inventory::collect!(PermissionEntry);

/// Iterate over every registered permission.
///
/// Entries are yielded in linker order, which is not guaranteed stable. Sort the
/// result if deterministic output matters. For every `Domain.Action` permission, 
/// this also adds a synthetic `Domain.*` wildcard entry without role grants.
pub fn all_permissions() -> Vec<PermissionEntry> {
    let all: Vec<PermissionEntry> = inventory::iter::<PermissionEntry>().cloned().collect();

    let wildcards: Vec<PermissionEntry> = all
        .iter()
        .filter_map(|entry| {
            let (prefix, _) = entry.name.split_once('.')?;
            Some(PermissionEntry {
                name: Cow::Owned(format!("{prefix}.*")),
                enum_name: entry.enum_name,
                roles: &[],
            })
        })
        .unique_by(|entry| entry.name.clone())
        .collect();

    all.into_iter().chain(wildcards).collect()
}
```

--------------------------------

### Discovering All Registered Permissions

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves all registered permission entries from the inventory. It also generates synthetic wildcard entries for each domain (e.g., 'Domain.*') based on existing 'Domain.Action' permissions. The output is sorted by linker order and may not be stable.

```rust
pub fn all_permissions() -> Vec<PermissionEntry> {
    let all: Vec<PermissionEntry> = inventory::iter::<PermissionEntry>().cloned().collect();

    let wildcards: Vec<PermissionEntry> = all
        .iter()
        .filter_map(|entry| {
            let (prefix, _) = entry.name.split_once('.')?;
            Some(PermissionEntry {
                name: Cow::Owned(format!({"prefix"}.*)),
                enum_name: entry.enum_name,
                roles: &[],
            })
        })
        .unique_by(|entry| entry.name.clone())
        .collect();

    all.into_iter().chain(wildcards).collect()
}
```

--------------------------------

### Discover All Registered Permissions

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=std%3A%3Avec

Retrieves all permission entries registered in the application. It also generates synthetic wildcard entries for each domain (e.g., 'Domain.*') if a specific permission like 'Domain.Action' exists. The order is not guaranteed, so sort if needed.

```rust
use permkit::all_permissions;

fn main() {
    let permissions = all_permissions();
    for perm in permissions {
        println!("{}: {:?}", perm.name, perm.roles);
    }
}
```

--------------------------------

### CloneToUninit Blanket Implementation

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html

Demonstrates the clone_to_uninit method available for types implementing Clone, allowing copying to uninitialized memory. Note: This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### all_permissions

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=u32+-%3E+bool

Iterates over every registered permission in the permkit system. The entries are yielded in linker order, which is not guaranteed to be stable. If deterministic output is required, the result should be sorted. For every `Domain.Action` permission, a synthetic `Domain.*` wildcard entry without role grants is also added.

```APIDOC
## Function all_permissions

### Description
Iterate over every registered permission. Entries are yielded in linker order, which is not guaranteed stable. Sort the result if deterministic output matters. For every `Domain.Action` permission, this also adds a synthetic `Domain.*` wildcard entry without role grants.

### Signature
```rust
pub fn all_permissions() -> Vec<PermissionEntry>
```
```

--------------------------------

### TryFrom and TryInto Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionEntry.html?search=

Enables fallible conversions to and from PermissionEntry, returning a Result to handle potential errors.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### all_permissions

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html

Iterates over every registered permission. Entries are yielded in linker order, which is not guaranteed stable. Sort the result if deterministic output matters. For every `Domain.Action` permission, this also adds a synthetic `Domain.*` wildcard entry without role grants.

```APIDOC
## Function all_permissions

### Description
Iterate over every registered permission. Entries are yielded in linker order, which is not guaranteed stable. Sort the result if deterministic output matters. For every `Domain.Action` permission, this also adds a synthetic `Domain.*` wildcard entry without role grants.

### Signature
```
pub fn all_permissions() -> Vec<PermissionEntry>
```
```

--------------------------------

### all_permissions

Source: https://docs.rs/permkit/latest/permkit/fn.all_permissions.html?search=

Retrieves all registered permissions within the permkit system. This function iterates over every permission and yields entries in linker order. For permissions in the `Domain.Action` format, a synthetic `Domain.*` wildcard entry is also included. Users should sort the results if a deterministic order is required.

```APIDOC
## Function all_permissions

### Description
Iterate over every registered permission. Entries are yielded in linker order, which is not guaranteed stable. Sort the result if deterministic output matters. For every `Domain.Action` permission, this also adds a synthetic `Domain.*` wildcard entry without role grants.

### Signature
```rust
pub fn all_permissions() -> Vec<PermissionEntry>
```

### Returns
- `Vec<PermissionEntry>`: A vector containing all registered permission entries.
```

--------------------------------

### Discover all registered permissions

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=u32+-%3E+bool

Iterates over all registered permission entries. Entries are yielded in linker order, which is not guaranteed to be stable. Wildcard entries are automatically added for each permission.

```Rust
use permkit::all_permissions;

let mut permissions = all_permissions();
permissions.sort_by_key(|p| p.name.clone());

println!("Found {} permissions:", permissions.len());
for p in permissions {
    println!("- {} (from {})", p.name, p.enum_name);
}
```

--------------------------------

### all_permissions

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=std%3A%3Avec

Retrieves all registered permission entries. This function iterates over all permissions defined in the binary, including synthetic wildcard entries for domain-level permissions. The order of returned entries is not guaranteed to be stable, so sorting is recommended for deterministic output.

```APIDOC
## Function: all_permissions

### Description
Retrieves all registered permission entries. This function iterates over all permissions defined in the binary, including synthetic wildcard entries for domain-level permissions. The order of returned entries is not guaranteed to be stable, so sorting is recommended for deterministic output.

### Returns
- `Vec<PermissionEntry>` - A vector containing all discovered permission entries.
```

--------------------------------

### EffectivePermissions Methods

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for creating and querying effective permissions.

```APIDOC
## EffectivePermissions

### Description
Represents a set of effective permissions.

### Methods

#### `empty()`

*   **Description**: Creates an empty `EffectivePermissions` instance.
*   **Returns**: `Self` (an empty `EffectivePermissions` instance).

#### `from_grants(grants: impl IntoIterator<Item = PermissionGrant>)`

*   **Description**: Creates an `EffectivePermissions` instance from an iterator of `PermissionGrant`.
*   **Parameters**:
    *   `grants` (impl IntoIterator<Item = PermissionGrant>) - An iterator yielding `PermissionGrant` items.
*   **Returns**: `Self` (an `EffectivePermissions` instance populated with the provided grants).

#### `allows(&self, permission_key: &str) -> bool`

*   **Description**: Checks if the given permission key is allowed by the effective permissions.
*   **Parameters**:
    *   `permission_key` (&str) - The key of the permission to check.
*   **Returns**: `bool` - `true` if the permission is allowed, `false` otherwise.
```

--------------------------------

### EffectivePermissions::empty

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Creates an empty EffectivePermissions instance, representing no permissions.

```APIDOC
## EffectivePermissions::empty

### Description
Creates an empty `EffectivePermissions` instance, which signifies that no permissions are granted.

### Returns
- `Self`: An instance of `EffectivePermissions` with no permissions.

### Example
```rust
let permissions = EffectivePermissions::empty();
```
```

--------------------------------

### EffectivePermissions::empty

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=std%3A%3Avec

Creates an empty EffectivePermissions instance, representing no permissions.

```APIDOC
## EffectivePermissions::empty

### Description
Creates an empty EffectivePermissions instance, representing no permissions.

### Returns
- `Self`: An empty EffectivePermissions instance.
```

--------------------------------

### PartialEq and Eq Implementations for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html?search=u32+-%3E+bool

Enables comparison of PermissionGrant instances for equality.

```rust
fn eq(&self, other: &PermissionGrant) -> bool
```

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

--------------------------------

### From and Into Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=std%3A%3Avec

Provides blanket implementations for converting between types using From and Into traits. `from` creates a new instance, and `into` converts an existing instance.

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

--------------------------------

### EffectivePermissions::empty

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html

Creates an empty EffectivePermissions instance with no grants.

```APIDOC
## EffectivePermissions::empty

### Description
Creates an empty EffectivePermissions instance with no grants.

### Method
Associated Function

### Signature
pub fn empty() -> Self
```

--------------------------------

### EffectivePermissions::empty() Constructor

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Creates an empty EffectivePermissions instance, representing no granted permissions.

```rust
pub fn empty() -> Self
```

--------------------------------

### PartialEq Implementation for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html

Enables comparison of two PermissionGrant instances for equality. This is used to check if two permission grants are identical.

```rust
fn eq(&self, other: &PermissionGrant) -> bool
```

--------------------------------

### Combining Permissions with 'and' and 'or'

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html

Provides methods to chain permission checks using 'and' and 'or' logic, creating new composite permission structures.

```rust
fn and<R>(self, right: R) -> And<Self, R>
where Self: Sized, R: HasPermission<Context, Error = Self::Error>,
{
    // ... implementation details ...
}

fn or<R>(self, right: R) -> Or<Self, R>
where Self: Sized, R: HasPermission<Context, Error = Self::Error>,
{
    // ... implementation details ...
}
```

--------------------------------

### Any Trait Implementation for Generic Types

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=

Demonstrates the Any trait implementation, which allows treating any type that implements 'static + ?Sized as a trait object.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### EffectivePermissions::empty

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=

Creates an empty EffectivePermissions instance, meaning no permissions are granted.

```APIDOC
## EffectivePermissions::empty

### Description
Creates an empty EffectivePermissions instance, signifying that no permissions are granted by default.

### Method
`empty()`

### Returns
- `Self`: An instance of `EffectivePermissions` with no permissions.

### Example
```rust
let permissions = EffectivePermissions::empty();
```
```

--------------------------------

### Into Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=u32+-%3E+bool

Shows the 'Into' trait implementation, which relies on the corresponding 'From' trait implementation for conversion.

```rust
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U {
        U::from(self)
    }
}
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html

Shows the blanket implementations of TryFrom and TryInto traits, enabling fallible type conversions with a defined error type.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    // ... implementation details ...
}

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    // ... implementation details ...
}
```

--------------------------------

### Test Cases for Permission Pattern Matching

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

Unit tests verifying the functionality of `permission_pattern_matches` with various wildcard and exact pattern combinations.

```rust
#[test]
fn matches_wildcard_patterns() {
    assert!(permission_pattern_matches("*", "Companies.List"));
    assert!(permission_pattern_matches("Companies.*", "Companies.List"));
    assert!(permission_pattern_matches("*.List", "Companies.List"));
    assert!(permission_pattern_matches(
        "Companies.List",
        "Companies.List"
    ));
    assert!(!permission_pattern_matches("Products.*", "Companies.List"));
}
```

--------------------------------

### Permission Pattern Matching Logic

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

Implements logic to match a permission pattern against a concrete permission key. Supports wildcard characters for flexible matching.

```rust
pub fn permission_pattern_matches(pattern: &str, concrete: &str) -> bool {
    if pattern == "*" {
        return true;
    }

    let Some((module, action)) = concrete.split_once('.') else {
        return false;
    };

    match pattern.split_once('.') {
        None => false,
        Some(("*", a)) => action == a,
        Some((m, "*")) => module == m,
        Some((m, a)) => m == module && a == action,
    }
}
```

--------------------------------

### Default Implementation for EffectivePermissions

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Provides a default value for EffectivePermissions, typically representing no permissions.

```rust
fn default() -> EffectivePermissions
```

--------------------------------

### StructuralPartialEq Implementation for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html?search=

Indicates structural partial equality for PermissionGrant.

--------------------------------

### Create Effective Permissions from Grants

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=std%3A%3Avec

Initializes an `EffectivePermissions` struct from an iterator of `PermissionGrant` objects. Each grant defines a scope, a permission pattern, and an effect (Allow or Deny).

```rust
use permkit::{EffectivePermissions, PermissionGrant, PermissionEffect};

fn main() {
    let grants = vec![
        PermissionGrant { scope: "user".to_string(), pattern: "read:users".to_string(), effect: PermissionEffect::Allow },
        PermissionGrant { scope: "user".to_string(), pattern: "write:users".to_string(), effect: PermissionEffect::Deny },
    ];
    let effective_permissions = EffectivePermissions::from_grants(grants);
    // effective_permissions can now be used to check permissions
}
```

--------------------------------

### Clone Implementation for PermissionEntry

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionEntry.html?search=

Provides methods to create a duplicate of a PermissionEntry or perform copy-assignment from another entry.

```rust
fn clone(&self) -> PermissionEntry
```

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

--------------------------------

### Clone Implementation for EffectivePermissions

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Provides methods to duplicate and copy-assign EffectivePermissions values.

```rust
fn clone(&self) -> EffectivePermissions
```

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

--------------------------------

### EffectivePermissions::allows

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html

Checks if the EffectivePermissions instance allows a specific permission key.

```APIDOC
## EffectivePermissions::allows

### Description
Checks if the EffectivePermissions instance allows a specific permission key.

### Method
Instance Method

### Parameters
#### Path Parameters
- **permission_key** (&str) - Required - The permission key to check.

### Returns
- bool - True if the permission is allowed, false otherwise.
```

--------------------------------

### EffectivePermissions::allows

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=std%3A%3Avec

Checks if the EffectivePermissions instance allows a specific permission key.

```APIDOC
## EffectivePermissions::allows

### Description
Checks if the EffectivePermissions instance allows a specific permission key.

### Parameters
#### Path Parameters
- `permission_key` (&str) - Required - The key of the permission to check.

### Returns
- `bool`: `true` if the permission is allowed, `false` otherwise.
```

--------------------------------

### EffectivePermissions::from_grants() Constructor

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Creates an EffectivePermissions instance from an iterator of PermissionGrant items.

```rust
pub fn from_grants(grants: impl IntoIterator<Item = PermissionGrant>) -> Self
```

--------------------------------

### Borrow and BorrowMut Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html

Shows the blanket implementations of Borrow and BorrowMut traits, allowing immutable and mutable borrowing of values.

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
{
    fn borrow(&self) -> &T
    // ... implementation details ...
}

impl<T> BorrowMut<T> for T
where T: ?Sized,
{
    fn borrow_mut(&mut self) -> &mut T
    // ... implementation details ...
}
```

--------------------------------

### all_permission_names

Source: https://docs.rs/permkit/latest/permkit/fn.all_permission_names.html?search=std%3A%3Avec

Retrieves a list of all available permission names. This function returns a `Vec<Cow<'static, str>>` containing static string slices that represent the permissions.

```APIDOC
## Function all_permission_names

### Description
Retrieves a list of all available permission names. This function returns a `Vec<Cow<'static, str>>` containing static string slices that represent the permissions.

### Signature
`pub fn all_permission_names() -> Vec<Cow<'static, str>>`

### Returns
A `Vec<Cow<'static, str>>` where each element is a permission name.
```

--------------------------------

### and Method for Combining Permissions

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=

Creates a new 'And' struct by combining the current permission check with another 'R' permission check. This is used to chain permission checks with a logical AND.

```rust
fn and<R>(self, right: R) -> And<Self, R>
where Self: Sized, R: HasPermission<Context, Error = Self::Error>,
```

--------------------------------

### TryInto Blanket Implementation

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html

Illustrates the TryInto trait implementation, allowing fallible conversion from PermissionCheckError into another type.

```rust
type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Clone Implementation for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html

Provides functionality to create a duplicate of a PermissionGrant instance. This is useful for copying permission configurations.

```rust
fn clone(&self) -> PermissionGrant
```

--------------------------------

### Function Signature: permission_pattern_matches

Source: https://docs.rs/permkit/latest/permkit/fn.permission_pattern_matches.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines the signature for the permission_pattern_matches function, indicating it takes two string slices and returns a boolean.

```rust
pub fn permission_pattern_matches(pattern: &str, concrete: &str) -> bool
```

--------------------------------

### TryInto Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=u32+-%3E+bool

Shows the 'TryInto' trait implementation, which is the inverse of 'TryFrom' and allows attempting a conversion that might fail.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> {
        // Implementation details omitted
        unimplemented!()
    }
}
```

--------------------------------

### Create EffectivePermissions from grants

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=u32+-%3E+bool

Constructs a set of effective permissions by processing an iterator of `PermissionGrant` objects. Each grant defines a scope, a pattern, and an effect (Allow or Deny).

```Rust
use permkit::{EffectivePermissions, PermissionGrant, PermissionEffect};

let grants = vec![
    PermissionGrant {
        scope: "user".to_string(),
        pattern: "read.users".to_string(),
        effect: PermissionEffect::Allow,
    },
    PermissionGrant {
        scope: "user".to_string(),
        pattern: "write.users".to_string(),
        effect: PermissionEffect::Deny,
    },
];

let permissions = EffectivePermissions::from_grants(grants);

assert!(permissions.allows("read.users"));
assert!(!permissions.allows("write.users"));
assert!(permissions.allows("read.posts")); // Other permissions are not explicitly denied
```

--------------------------------

### Chaining Permissions with Or

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html?search=u32+-%3E+bool

Provides a method to chain permission checks using a logical OR. This allows creating complex permission logic by combining existing permission objects.

```rust
fn or<R>(self, right: R) -> Or<Self, R>
where Self: Sized, R: HasPermission<Context, Error = Self::Error>,
```

--------------------------------

### BorrowMut Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=u32+-%3E+bool

Illustrates the implementation of the 'BorrowMut' trait, enabling mutable borrowing of a value.

```rust
impl<T> BorrowMut<T> for T
where
    T: ?Sized,
{
    fn borrow_mut(&mut self) -> &mut T {
        // Implementation details omitted
        unimplemented!()
    }
}
```

--------------------------------

### EffectivePermissions::allows() Method

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Checks if the EffectivePermissions grants a specific permission identified by a string key.

```rust
pub fn allows(&self, permission_key: &str) -> bool
```

--------------------------------

### From Trait Implementation for Generic Types

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=

Demonstrates the From trait, which allows converting a type into itself.

```rust
fn from(t: T) -> T
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html

Implements the Any trait, which provides runtime type information. This is a blanket implementation for any type T.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId
    {
        todo!()
    }
}
```

--------------------------------

### And Combinator for HasPermission

Source: https://docs.rs/permkit/latest/permkit/trait.HasPermission.html?search=std%3A%3Avec

Implementation of HasPermission for the And combinator, which requires both left and right permissions to be true. This is used to combine two HasPermission implementors.

```rust
impl<Context, L, R> HasPermission<Context> for And<L, R>
where Context: Sync, L: HasPermission<Context>, R: HasPermission<Context, Error = L::Error>,
Source§
#### type Error = <L as HasPermission<Context>>::Error
```

--------------------------------

### EffectivePermissions::allows

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=

Checks if the EffectivePermissions instance grants a specific permission key.

```APIDOC
## EffectivePermissions::allows

### Description
Determines whether a given permission key is allowed by this `EffectivePermissions` instance.

### Method
`allows(&self, permission_key: &str) -> bool`

### Parameters
- **permission_key** (`&str`): The key of the permission to check.

### Returns
- `bool`: `true` if the permission is allowed, `false` otherwise.

### Example
```rust
let permissions = EffectivePermissions::empty();
if permissions.allows("read") {
    println!("Read permission is allowed.");
}
```
```

--------------------------------

### Permission Grant Structure

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

Represents a single permission grant, specifying the scope, the permission pattern, and the effect (allow or deny).

```rust
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PermissionGrant {
    pub scope: String,
    pub pattern: String,
    pub effect: PermissionEffect,
}
```

--------------------------------

### Clone From Another EffectivePermissions

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html

Performs copy-assignment from a source EffectivePermissions value to the current one. This is an efficient way to update an existing permission set.

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

--------------------------------

### TryFrom Blanket Implementation

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html

Shows the TryFrom trait implementation, enabling fallible conversion from another type into PermissionCheckError.

```rust
type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Generating OpenAPI Schema for PermissionName

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the `PartialSchema` and `ToSchema` traits for `PermissionName` to generate an OpenAPI schema. This schema represents permissions as a string enum with all available permission names.

```rust
impl utoipa::PartialSchema for PermissionName {
    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
        let names = all_permission_names();

        utoipa::openapi::RefOr::T(utoipa::openapi::schema::Schema::Object(
            utoipa::openapi::schema::ObjectBuilder::new()
                .schema_type(utoipa::openapi::schema::SchemaType::Type(
                    utoipa::openapi::schema::Type::String,
                ))
                .enum_values(Some(names))
                .description(Some("Identifier of permissions."))
                .build(),
        ))
    }
}
```

```rust
impl utoipa::ToSchema for PermissionName {
    fn name() -> Cow<'static, str> {
        Cow::Borrowed("PermissionName")
    }
}
```

--------------------------------

### Effective Permissions Calculation

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

Calculates and stores the effective permissions based on a collection of `PermissionGrant`s. It provides a method to check if a given permission key is allowed.

```rust
#[derive(Debug, Clone, Default)]
pub struct EffectivePermissions {
    scopes: HashMap<String, Vec<ScopedPermission>>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct ScopedPermission {
    pattern: String,
    effect: PermissionEffect,
}

impl EffectivePermissions {
    pub fn empty() -> Self {
        Self::default()
    }

    pub fn from_grants(grants: impl IntoIterator<Item = PermissionGrant>) -> Self {
        let scopes = grants
            .into_iter()
            .map(|grant| {
                (
                    grant.scope,
                    ScopedPermission {
                        pattern: grant.pattern,
                        effect: grant.effect,
                    },
                )
            })
            .into_group_map();

        Self { scopes }
    }

    pub fn allows(&self, permission_key: &str) -> bool {
        self.scopes
            .values()
            .any(|grants| allows_in_scope(grants, permission_key))
    }
}

fn allows_in_scope(grants: &[ScopedPermission], permission_key: &str) -> bool {
    let denied = grants.iter().any(|permission| {
        permission.effect == PermissionEffect::Deny
    });
    // Note: The original code snippet was truncated here. The full logic for `allows_in_scope` is not provided.
```

--------------------------------

### all_permission_names Function Signature

Source: https://docs.rs/permkit/latest/permkit/fn.all_permission_names.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This snippet shows the function signature for `all_permission_names`. It returns a `Vec<Cow<'static, str>>`, indicating a vector of static string slices.

```rust
pub fn all_permission_names() -> Vec<Cow<'static, str>>
```

--------------------------------

### Test Case for Deny Wins Logic

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html

Tests the scenario where a specific deny permission overrides a broader allow permission within the same scope.

```rust
#[test]
fn deny_wins_inside_scope() {
    let permissions = EffectivePermissions::from_grants([
        PermissionGrant {
            scope: "role".to_owned(),
            pattern: "Companies.*".to_owned(),
            effect: PermissionEffect::Allow,
        },
        PermissionGrant {
            scope: "role".to_owned(),
            pattern: "Companies.Delete".to_owned(),
            effect: PermissionEffect::Deny,
        },
    ]);

    assert!(permissions.allows("Companies.List"));
    assert!(!permissions.allows("Companies.Delete"));
}
```

--------------------------------

### Clone EffectivePermissions

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html

Returns a duplicate of the EffectivePermissions value. This allows for creating independent copies of permission sets.

```rust
fn clone(&self) -> EffectivePermissions
```

--------------------------------

### Clone Implementation for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html?search=u32+-%3E+bool

Provides methods to clone PermissionGrant instances, enabling duplication of permission grant values.

```rust
fn clone(&self) -> PermissionGrant
```

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

--------------------------------

### permission_pattern_matches

Source: https://docs.rs/permkit/latest/permkit/fn.permission_pattern_matches.html?search=

Checks if a concrete string matches a permission pattern. This is a utility function for pattern matching in permissions.

```APIDOC
## permission_pattern_matches

### Description
Checks if a concrete string matches a permission pattern. This is a utility function for pattern matching in permissions.

### Signature
`pub fn permission_pattern_matches(pattern: &str, concrete: &str) -> bool`

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The permission pattern to match against.
- **concrete** (string) - Required - The concrete string to check for a match.

### Return Value
- **bool** - Returns `true` if the concrete string matches the pattern, `false` otherwise.
```

--------------------------------

### EffectivePermissions Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Details the trait implementations for the EffectivePermissions struct.

```APIDOC
## EffectivePermissions Trait Implementations

### `Clone`

*   `clone(&self) -> EffectivePermissions`: Returns a duplicate of the value.
*   `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.

### `Debug`

*   `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the value using the given formatter.

### `Default`

*   `default() -> EffectivePermissions`: Returns the default value for the type.
```

--------------------------------

### From Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html

Implements the From trait, allowing conversion into a type from itself. This is a blanket implementation.

```rust
impl<T> From<T> for T
{
    fn from(t: T) -> T
    {
        t
    }
}
```

--------------------------------

### Auto Trait Implementations for And

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=u32+-%3E+bool

Lists the auto-trait implementations for the And struct, indicating its thread-safety and memory safety characteristics.

```rust
impl<L, R> Freeze for And<L, R>
where
    L: Freeze,
    R: Freeze,
{
    // ...
}

impl<L, R> RefUnwindSafe for And<L, R>
where
    L: RefUnwindSafe,
    R: RefUnwindSafe,
{
    // ...
}

impl<L, R> Send for And<L, R>
where
    L: Send,
    R: Send,
{
    // ...
}

impl<L, R> Sync for And<L, R>
where
    L: Sync,
    R: Sync,
{
    // ...
}

impl<L, R> Unpin for And<L, R>
where
    L: Unpin,
    R: Unpin,
{
    // ...
}

impl<L, R> UnsafeUnpin for And<L, R>
where
    L: UnsafeUnpin,
    R: UnsafeUnpin,
{
    // ...
}

impl<L, R> UnwindSafe for And<L, R>
where
    L: UnwindSafe,
    R: UnwindSafe,
{
    // ...
}
```

--------------------------------

### Creating EffectivePermissions from Grants

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs an `EffectivePermissions` instance from an iterator of `PermissionGrant` objects. It groups grants by scope and stores them for efficient lookup.

```rust
pub fn from_grants(grants: impl IntoIterator<Item = PermissionGrant>) -> Self {
    let scopes = grants
        .into_iter()
        .map(|grant| {
            (
                grant.scope,
                ScopedPermission {
                    pattern: grant.pattern,
                    effect: grant.effect,
                },
            )
        })
        .into_group_map();

    Self { scopes }
}
```

--------------------------------

### Borrow Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=u32+-%3E+bool

Shows the implementation of the 'Borrow' trait, allowing immutable borrowing of a value.

```rust
impl<T> Borrow<T> for T
where
    T: ?Sized,
{
    fn borrow(&self) -> &T {
        // Implementation details omitted
        unimplemented!()
    }
}
```

--------------------------------

### and Method for HasPermission

Source: https://docs.rs/permkit/latest/permkit/struct.And.html

Provides a method to chain permission checks using a logical AND. This method is available when the type implements HasPermission and is Sized.

```rust
fn and<R>(self, right: R) -> And<Self, R>
where Self: Sized,
 R: HasPermission<Context, Error = Self::Error>,
{
    todo!()
}
```

--------------------------------

### Or Combinator for HasPermission

Source: https://docs.rs/permkit/latest/permkit/trait.HasPermission.html?search=std%3A%3Avec

Implementation of HasPermission for the Or combinator, which requires at least one of the left or right permissions to be true. This is used to combine two HasPermission implementors.

```rust
impl<Context, L, R> HasPermission<Context> for Or<L, R>
where Context: Sync, L: HasPermission<Context>, R: HasPermission<Context, Error = L::Error>,
Source§
#### type Error = <L as HasPermission<Context>>::Error
```

--------------------------------

### try_from Method for TryFrom Trait

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=

Performs the conversion from U to T. This is part of the TryFrom trait implementation.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### TryInto Trait Implementation

Source: https://docs.rs/permkit/latest/permkit/struct.And.html

Implements the TryInto trait for fallible conversions. This is a blanket implementation that leverages TryFrom.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    {
        U::try_from(self)
    }
}
```

--------------------------------

### And Method for Or

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html?search=std%3A%3Avec

The 'and' method is available on 'Or' to chain another permission check, creating an 'And' combination. This is part of the 'HasPermission' trait implementation.

```rust
fn and<R>(self, right: R) -> And<Self, R>
where
    Self: Sized,
    R: HasPermission<Context, Error = Self::Error>,

```

--------------------------------

### PermissionEntry Struct Definition

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionEntry.html?search=

Defines the structure for static metadata of a single permission variant. It includes the permission's name, its enum name, and associated roles.

```rust
pub struct PermissionEntry {
    pub name: Cow<'static, str>,
    pub enum_name: &'static str,
    pub roles: &'static [&'static str],
}
```

--------------------------------

### And Struct Definition

Source: https://docs.rs/permkit/latest/permkit/struct.And.html

Defines the And struct which combines two permission checkers L and R. It has private fields.

```rust
pub struct And<L, R> {
/* private fields */
}
```

--------------------------------

### Into Trait Implementation for Generic Types

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=

Shows the Into trait, enabling conversion from one type to another if the target type implements From.

```rust
fn into(self) -> U
```

--------------------------------

### Auto Trait Implementations for PermissionGrant

Source: https://docs.rs/permkit/latest/permkit/struct.PermissionGrant.html?search=

Lists automatic trait implementations for PermissionGrant, including Send, Sync, Unpin, etc.

```rust
impl Freeze for PermissionGrant
```

```rust
impl RefUnwindSafe for PermissionGrant
```

```rust
impl Send for PermissionGrant
```

```rust
impl Sync for PermissionGrant
```

```rust
impl Unpin for PermissionGrant
```

```rust
impl UnsafeUnpin for PermissionGrant
```

```rust
impl UnwindSafe for PermissionGrant
```

--------------------------------

### PartialEq::eq for PermissionCheckError

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=u32+-%3E+bool

Implementation of the PartialEq trait's eq method for PermissionCheckError. This allows comparing two PermissionCheckError instances for equality.

```rust
fn eq(&self, other: &PermissionCheckError) -> bool
```

--------------------------------

### try_into Method for TryInto Trait

Source: https://docs.rs/permkit/latest/permkit/struct.And.html?search=

Performs the conversion from T to U. This is part of the TryInto trait implementation.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### EffectivePermissions::allows

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Checks if the EffectivePermissions instance grants a specific permission.

```APIDOC
## EffectivePermissions::allows

### Description
Determines whether a specific permission, identified by its key, is granted by this `EffectivePermissions` instance.

### Parameters
- `permission_key` (&str): The string key representing the permission to check.

### Returns
- `bool`: `true` if the permission is allowed, `false` otherwise.

### Example
```rust
let permissions = EffectivePermissions::from_grants(...);
if permissions.allows("read_data") {
    println!("Read access is allowed.");
}
```
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=std%3A%3Avec

Enables fallible conversion between types. `try_from` attempts conversion and returns a Result, while `try_into` does the same in reverse.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
type Error = <U as TryFrom<T>>::Error
```

--------------------------------

### PartialEq Trait Implementation for PermissionEffect

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionEffect.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Allows comparison of PermissionEffect values for equality.

```rust
fn eq(&self, other: &PermissionEffect) -> bool
```

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

--------------------------------

### EffectivePermissions from Grants

Source: https://docs.rs/permkit/latest/src/permkit/lib.rs.html?search=

This snippet shows how to construct an `EffectivePermissions` object from an iterator of `PermissionGrant`s. It groups grants by scope and stores them internally.

```rust
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PermissionEffect {
    Allow,
    Deny,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PermissionGrant {
    pub scope: String,
    pub pattern: String,
    pub effect: PermissionEffect,
}

#[derive(Debug, Clone, Default)]
pub struct EffectivePermissions {
    scopes: HashMap<String, Vec<ScopedPermission>>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct ScopedPermission {
    pattern: String,
    effect: PermissionEffect,
}

impl EffectivePermissions {
    pub fn empty() -> Self {
        Self::default()
    }

    pub fn from_grants(grants: impl IntoIterator<Item = PermissionGrant>) -> Self {
        let scopes = grants
            .into_iter()
            .map(|grant| {
                (
                    grant.scope,
                    ScopedPermission {
                        pattern: grant.pattern,
                        effect: grant.effect,
                    },
                )
            })
            .into_group_map();

        Self { scopes }
    }

    pub fn allows(&self, permission_key: &str) -> bool {
        self.scopes
            .values()
            .any(|grants| allows_in_scope(grants, permission_key))
    }
}

fn allows_in_scope(grants: &[ScopedPermission], permission_key: &str) -> bool {
    let denied = grants.iter().any(|permission| {
        permission.effect == PermissionEffect::Deny

```

--------------------------------

### permission_pattern_matches

Source: https://docs.rs/permkit/latest/permkit/fn.permission_pattern_matches.html?search=std%3A%3Avec

Checks if a concrete string matches a given permission pattern. This function is useful for validating user permissions against defined patterns.

```APIDOC
## permission_pattern_matches

### Description
Checks if a concrete string matches a given permission pattern. This function is useful for validating user permissions against defined patterns.

### Signature
`pub fn permission_pattern_matches(pattern: &str, concrete: &str) -> bool`

### Parameters
* **pattern** (`&str`) - The permission pattern to match against.
* **concrete** (`&str`) - The concrete string to test against the pattern.

### Returns
* `bool` - Returns `true` if the `concrete` string matches the `pattern`, `false` otherwise.
```

--------------------------------

### BorrowMut Trait Implementation for Generic Types

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=

Illustrates the BorrowMut trait, enabling mutable borrowing of a value.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### TryFrom Trait Implementation for T from U

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Generic implementation of TryFrom for converting between types where U can be converted into T.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### EffectivePermissions::from_grants

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=

Constructs an EffectivePermissions instance from an iterator of PermissionGrant items.

```APIDOC
## EffectivePermissions::from_grants

### Description
Initializes an `EffectivePermissions` struct by processing a collection of `PermissionGrant` objects.

### Method
`from_grants(grants: impl IntoIterator<Item = PermissionGrant>) -> Self`

### Parameters
- **grants** (`impl IntoIterator<Item = PermissionGrant>`): An iterator yielding `PermissionGrant` items to populate the permissions.

### Returns
- `Self`: An instance of `EffectivePermissions` configured with the provided grants.

### Example
```rust
let grants = vec![...]; // Your PermissionGrant items
let permissions = EffectivePermissions::from_grants(grants);
```
```

--------------------------------

### Or Struct Definition

Source: https://docs.rs/permkit/latest/permkit/struct.Or.html?search=u32+-%3E+bool

Defines the generic `Or` struct used for combining two permission checks.

```rust
pub struct Or<L, R> { /* private fields */ }
```

--------------------------------

### PartialEq Trait Implementation for PermissionCheckError

Source: https://docs.rs/permkit/latest/permkit/enum.PermissionCheckError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for comparing PermissionCheckError values for equality.

```rust
fn eq(&self, other: &PermissionCheckError) -> bool
```

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

--------------------------------

### EffectivePermissions::from_grants

Source: https://docs.rs/permkit/latest/permkit/struct.EffectivePermissions.html?search=u32+-%3E+bool

Constructs an EffectivePermissions instance from an iterator of PermissionGrant objects.

```APIDOC
## EffectivePermissions::from_grants

### Description
Initializes an `EffectivePermissions` struct from a collection of `PermissionGrant` objects. This is useful for setting up permissions based on a predefined list of grants.

### Parameters
- `grants` (impl IntoIterator<Item = PermissionGrant>): An iterator yielding `PermissionGrant` objects.

### Returns
- `Self`: An `EffectivePermissions` instance populated with the provided grants.

### Example
```rust
let grants = vec![...]; // Your PermissionGrant objects
let permissions = EffectivePermissions::from_grants(grants);
```
```
Tokens:
Raw