LsColors

https://docs.rs/lscolors/0.21.0/lscolors/
Admin
LsColors is a Rust library for colorizing paths according to the LS_COLORS environment variable.
Tokens:10,582
Snippets:69
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Convert Style to nu-ansi-term

Source: https://docs.rs/lscolors/0.21.0/lscolors/style/struct.Style.html

Examples demonstrating conversion to nu_ansi_term styles under different feature flags.

```rust
use lscolors::{Color, FontStyle, Style};

let style = Style {
    font_style: FontStyle {
        bold: true,
        ..Default::default()
    },
    foreground: Some(Color::Blue),
    ..Default::default()
};
let nu_ansi = style.to_nu_ansi_term_style();
assert_eq!("[1;34mwow[0m", nu_ansi.paint("wow").to_string());
```

```rust
use lscolors::{Color, FontStyle, Style};

let style = Style {
    font_style: FontStyle {
        bold: true,
        ..Default::default()
    },
    foreground: Some(Color::Blue),
    ..Default::default()
};
let nu_ansi = style.to_nu_ansi_term_style();
assert_eq!(
    "[0m[01;34mwow[0m",
    nu_ansi.paint("wow").to_string()
);
```

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

### Get Style for Colorable File

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves the ANSI style for a colorable file type.

```rust
pub fn style_for<F: Colorable>(&self, file: &F) -> Option<&Style>
```

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

### Get Style for String Path

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves the ANSI style for a given string, which does not necessarily need to be a valid file path.

```rust
pub fn style_for_str(&self, file_str: &str) -> Option<&Style>
```

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

### Get Styles for Path Components

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves ANSI styles for each component of a given path. Path components include the path separator. For 'foo/bar/test.md', it yields styles for 'foo/', 'bar/', and 'test.md'.

```rust
pub fn style_for_path_components<'a>( &'a self, path: &'a Path, ) -> StyledComponents<'a>
```

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

### Get Full Path for Colorable

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

Implementations of the Colorable trait must provide a method to retrieve the complete path to the file.

```rust
fn path(&self) -> PathBuf;
```

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

### Get Metadata for Colorable

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

Implementations of the Colorable trait must provide a method to attempt retrieval of the file's metadata.

```rust
fn metadata(&self) -> Option<Metadata>;
```

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

### Get Type ID

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Gets the TypeId of the LsColors instance.

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

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

### Get Style for Path

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves the ANSI style for a given path. Internally calls Path::symlink_metadata. Use style_for_path_with_metadata if Metadata is already available.

```rust
pub fn style_for_path<P: AsRef<Path>>(&self, path: P) -> Option<&Style>
```

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

### Get File Name for Colorable

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

Implementations of the Colorable trait must provide a method to retrieve the name of the file.

```rust
fn file_name(&self) -> OsString;
```

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

### Get Style for Path with Metadata

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves the ANSI style for a path, given its associated Metadata. The Metadata must be acquired via Path::symlink_metadata for correct symbolic link handling.

```rust
pub fn style_for_path_with_metadata<P: AsRef<Path>>( &self, path: P, metadata: Option<&Metadata>, ) -> Option<&Style>
```

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

### Get Style for Indicator

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Retrieves the ANSI style for a specific Indicator (e.g., regular file, directory). Implements fallback logic similar to 'ls', where missing file style falls back to orphaned symbolic link style if not explicitly set.

```rust
pub fn style_for_indicator(&self, indicator: Indicator) -> Option<&Style>
```

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

### Get File Type for Colorable

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

Implementations of the Colorable trait must provide a method to attempt retrieval of the file's type.

```rust
fn file_type(&self) -> Option<FileType>;
```

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

### LsColors Library Usage

Source: https://docs.rs/lscolors

Demonstrates how to initialize LsColors from the environment and apply styles to a file path.

```APIDOC
## Library Usage: LsColors

### Description
This library provides the `LsColors` struct to parse the system's `LS_COLORS` environment variable and determine the appropriate style for a given file path.

### Usage Example
```rust
use lscolors::{LsColors, Style};

// Initialize from environment
let lscolors = LsColors::from_env().unwrap_or_default();

// Get style for a specific path
let path = "some/folder/archive.zip";
let style = lscolors.style_for_path(path);

// Apply style using nu_ansi_term
let ansi_style = style.map(Style::to_nu_ansi_term_style).unwrap_or_default();
println!("{}", ansi_style.paint(path));
```
```

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

### LsColors Library Usage

Source: https://docs.rs/lscolors/0.21.0/lscolors/index.html

Demonstrates how to initialize LsColors from the environment and apply styles to a file path.

```APIDOC
## LsColors Usage

### Description
Initializes the LsColors configuration from the system environment and retrieves the style for a specific file path.

### Request Example
```rust
use lscolors::{LsColors, Style};

let lscolors = LsColors::from_env().unwrap_or_default();
let path = "some/folder/archive.zip";
let style = lscolors.style_for_path(path);
```

### Response
- **style** (Option<Style>) - The style associated with the path, if any.
```

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

### LsColors Initialization

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Methods for creating new LsColors instances.

```APIDOC
## LsColors Initialization

### `pub fn empty() -> Self`
Construct an empty `LsColors` instance with no pre-defined styles.

### `pub fn from_env() -> Option<Self>`
Creates a new `LsColors` instance from the `LS_COLORS` environment variable. The basis for this is a default style as constructed via the `Default` implementation.

### `pub fn from_string(input: &str) -> Self`
Creates a new `LsColors` instance from the given string.
```

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

### Colorize Path with LS_COLORS

Source: https://docs.rs/lscolors/0.21.0/lscolors/index.html

Initializes LsColors from the environment, styles a given path, and prints it using either nu_ansi_term or ansi_term. Ensure the LS_COLORS environment variable is set for custom styling.

```rust
use lscolors::{LsColors, Style};

let lscolors = LsColors::from_env().unwrap_or_default();

let path = "some/folder/archive.zip";
let style = lscolors.style_for_path(path);

// If you want to use `nu_ansi_term`:
let ansi_style = style.map(Style::to_nu_ansi_term_style).unwrap_or_default();
println!("{}", ansi_style.paint(path));

// If you want to use `ansi_term`:
let ansi_style = style.map(Style::to_ansi_term_style).unwrap_or_default();
println!("{}", ansi_style.paint(path));
```

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

### Create Empty LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Constructs an empty LsColors instance with no pre-defined styles.

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

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

### Create LsColors from LS_COLORS Environment Variable

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Creates a new LsColors instance from the LS_COLORS environment variable. Uses a default style as a basis.

```rust
pub fn from_env() -> Option<Self>
```

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

### LsColors Default Implementation

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Provides a default LsColors instance with pre-defined styles.

```APIDOC
## Default Implementation

### `impl Default for LsColors`

#### `fn default() -> Self`
Constructs a default `LsColors` instance with some default styles. See `man dircolors` for information about the default styles and colors.
```

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

### LsColors Styling Methods

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Methods for retrieving ANSI styles for file system paths and indicators.

```APIDOC
## LsColors Styling Methods

### `pub fn style_for_path<P: AsRef<Path>>(&self, path: P) -> Option<&Style>`
Get the ANSI style for a given path. This function calls `Path::symlink_metadata` internally.

### `pub fn has_explicit_style_for(&self, indicator: Indicator) -> bool`
Check if an indicator has an associated color.

### `pub fn style_for<F: Colorable>(&self, file: &F) -> Option<&Style>`
Get the ANSI style for a colorable path.

### `pub fn style_for_str(&self, file_str: &str) -> Option<&Style>`
Get the ANSI style for a string. This does not have to be a valid filepath.

### `pub fn style_for_path_with_metadata<P: AsRef<Path>>(&self, path: P, metadata: Option<&Metadata>) -> Option<&Style>`
Get the ANSI style for a path, given the corresponding `Metadata` struct. The `Metadata` struct must have been acquired via `Path::symlink_metadata` in order to colorize symbolic links correctly.

### `pub fn style_for_path_components<'a>(&'a self, path: &'a Path) -> StyledComponents<'a>`
Get ANSI styles for each component of a given path. Components already include the path separator symbol, if required. For a path like `foo/bar/test.md`, this would return an iterator over three pairs for the three path components `foo/`, `bar/` and `test.md` together with their respective styles.

### `pub fn style_for_indicator(&self, indicator: Indicator) -> Option<&Style>`
Get the ANSI style for a certain `Indicator` (regular file, directory, symlink, …). This function implements a fallback logic for some of the indicators (just like `ls`). For example, the style for `mi` (missing file) falls back to `or` (orphaned symbolic link) if it has not been specified explicitly.
```

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

### Create LsColors from String

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Creates a new LsColors instance from a given string input.

```rust
pub fn from_string(input: &str) -> Self
```

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

### impl Style

Source: https://docs.rs/lscolors/0.21.0/lscolors/style/struct.Style.html

Implementations for the Style struct, including parsing and conversion methods.

```APIDOC
## impl Style

### pub fn from_ansi_sequence(code: &str) -> Option<Style>

#### Description
Parse ANSI escape sequences like `38;2;255;0;100;1;4` (pink, bold, underlined).

### Method
POST

### Endpoint
/style/from_ansi_sequence

### Parameters
#### Query Parameters
- **code** (str) - Required - The ANSI escape sequence string to parse.
```

```APIDOC
### pub fn to_nu_ansi_term_style(&self) -> Style

#### Description
Convert to a `nu_ansi_term::Style` (if the `nu-ansi-term` or `gnu_legacy` feature is enabled).

#### Example for nu-ansi-term feature
```rust
use lscolors::{Color, FontStyle, Style};

let style = Style {
    font_style: FontStyle {
        bold: true,
        ..Default::default()
    },
    foreground: Some(Color::Blue),
    ..Default::default()
};
let nu_ansi = style.to_nu_ansi_term_style();
assert_eq!("\x1b[1;34mwow\x1b[0m", nu_ansi.paint("wow").to_string());
```

#### Example for gnu_legacy feature
```rust
use lscolors::{Color, FontStyle, Style};

let style = Style {
    font_style: FontStyle {
        bold: true,
        ..Default::default()
    },
    foreground: Some(Color::Blue),
    ..Default::default()
};
let nu_ansi = style.to_nu_ansi_term_style();
assert_eq!("\u{1b}[0m\u{1b}[01;34mwow\u{1b}[0m", nu_ansi.paint("wow").to_string());
```
```

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

### Default LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Constructs a default LsColors instance with pre-defined styles, similar to 'man dircolors'.

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

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

### Iterator Collection and Partitioning

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for collecting iterator items into collections and partitioning them.

```APIDOC
## Iterator Collection and Partitioning

### Description
Methods for collecting iterator items into collections and partitioning them.

### Methods

#### `collect<B>()`
- **Description**: Transforms an iterator into a collection.
- **Version**: Not specified

#### `try_collect<B>()`
- **Description**: Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.
- **Note**: This is a nightly-only experimental API (`iterator_try_collect`).
- **Version**: Not specified

#### `collect_into<E>(collection: &mut E)`
- **Description**: Collects all the items from an iterator into a collection.
- **Note**: This is a nightly-only experimental API (`iter_collect_into`).
- **Version**: 1.0.0

#### `partition<B, F>(f: F)`
- **Description**: Consumes an iterator, creating two collections from it.
- **Version**: Not specified

#### `is_partitioned<P>(predicate: P)`
- **Description**: Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return `true` precede all those that return `false`.
- **Note**: This is a nightly-only experimental API (`iter_is_partitioned`).
- **Version**: 1.27.0
```

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

### TryInto Trait Methods

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Documentation for the try_into conversion method and associated error type.

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

### Description
Performs the conversion from type T to type U.

### Parameters
- **self** (T) - Required - The instance to be converted.

### Response
- **Result<U, Error>** (Result) - Returns the converted value or an error if the conversion fails.
```

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.
```

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

### Iterator Ordering and Comparison

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for finding the maximum or minimum elements, and for lexicographically comparing iterators.

```APIDOC
## max()

### Description
Returns the maximum element of an iterator.

### Method
`max`

### Response
- `Option<Self::Item>` - Returns `Some(max_element)` if the iterator is not empty, otherwise `None`.

## min()

### Description
Returns the minimum element of an iterator.

### Method
`min`

### Response
- `Option<Self::Item>` - Returns `Some(min_element)` if the iterator is not empty, otherwise `None`.

## max_by_key<B, F>

### Description
Returns the element that yields the maximum value based on a key extraction function.

### Method
`max_by_key`

### Parameters
- `f` (FnMut(&Self::Item) -> B) - A closure that extracts a key of type `B` (which must implement `Ord`) from an item.

### Response
- `Option<Self::Item>` - Returns `Some(element)` corresponding to the maximum key, otherwise `None`.

## max_by<F>

### Description
Returns the element that is considered the maximum according to a custom comparison function.

### Method
`max_by`

### Parameters
- `compare` (FnMut(&Self::Item, &Self::Item) -> Ordering) - A closure that compares two elements and returns an `Ordering`.

### Response
- `Option<Self::Item>` - Returns `Some(element)` that is maximum according to the comparison, otherwise `None`.

## min_by_key<B, F>

### Description
Returns the element that yields the minimum value based on a key extraction function.

### Method
`min_by_key`

### Parameters
- `f` (FnMut(&Self::Item) -> B) - A closure that extracts a key of type `B` (which must implement `Ord`) from an item.

### Response
- `Option<Self::Item>` - Returns `Some(element)` corresponding to the minimum key, otherwise `None`.

## min_by<F>

### Description
Returns the element that is considered the minimum according to a custom comparison function.

### Method
`min_by`

### Parameters
- `compare` (FnMut(&Self::Item, &Self::Item) -> Ordering) - A closure that compares two elements and returns an `Ordering`.

### Response
- `Option<Self::Item>` - Returns `Some(element)` that is minimum according to the comparison, otherwise `None`.

## cmp<I>

### Description
Lexicographically compares the elements of this `Iterator` with those of another.

### Method
`cmp`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.

### Response
- `Ordering` - The result of the lexicographical comparison.

## cmp_by<I, F>

### Description
Lexicographically compares the elements of this `Iterator` with those of another, using a specified comparison function. This is a nightly-only experimental API.

### Method
`cmp_by`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.
- `cmp` (FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering) - A closure for comparing elements.

### Response
- `Ordering` - The result of the lexicographical comparison.

## partial_cmp<I>

### Description
Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison stops as soon as an order can be determined.

### Method
`partial_cmp`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.

### Response
- `Option<Ordering>` - Returns `Some(Ordering)` if an order can be determined, otherwise `None`.

## partial_cmp_by<I, F>

### Description
Lexicographically compares the elements of this `Iterator` with those of another, using a specified partial comparison function. This is a nightly-only experimental API.

### Method
`partial_cmp_by`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.
- `partial_cmp` (FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>) - A closure for partial comparison.

### Response
- `Option<Ordering>` - Returns `Some(Ordering)` if an order can be determined, otherwise `None`.
```

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

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Nightly-only experimental API. Performs copy-assignment from self to uninitialized memory.

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

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

### Struct Style

Source: https://docs.rs/lscolors/0.21.0/lscolors/style/struct.Style.html

Represents styling attributes including foreground color, background color, font style, and underline.

```APIDOC
## Struct Style

### Description
A foreground color, background color and font-style.

### Fields
- **foreground** (Option<Color>) - The foreground color.
- **background** (Option<Color>) - The background color.
- **font_style** (FontStyle) - The font style attributes.
- **underline** (Option<Color>) - The underline color.
```

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

### Clone LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Returns a duplicate of the LsColors instance.

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

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

### Clone From LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Performs copy-assignment from a source LsColors instance.

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

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

### Indicator::from Method

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

Converts a string slice into an `Option<Indicator>`.

```APIDOC
## impl Indicator

### pub fn from(indicator: &str) -> Option<Indicator>

Converts a string slice into an `Option<Indicator>`.
```

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

### From T for T Conversion

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Returns the argument unchanged. This is a blanket implementation.

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

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

### Borrow LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Immutably borrows the LsColors instance.

```rust
fn borrow(&self) -> &T
```

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

### Trait Colorable

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

Defines the required methods for any type that represents a colorable file path.

```APIDOC
## Trait: Colorable

### Description
A trait representing a colorable file path, providing access to file system information.

### Required Methods
- **path()** (PathBuf) - Returns the full path to the file.
- **file_name()** (OsString) - Returns the name of the file.
- **file_type()** (Option<FileType>) - Returns the type of the file if available.
- **metadata()** (Option<Metadata>) - Returns the metadata for the file if available.

### Implementations
- **DirEntry**: Implements all required methods for directory entries.
```

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

### Indicator Trait Implementations

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

Details on the trait implementations for the Indicator enum, including Clone, Debug, Hash, PartialEq, Copy, Eq, and StructuralPartialEq.

```APIDOC
## Trait Implementations

### impl Clone for Indicator

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

### impl Debug for Indicator

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

### impl Hash for Indicator

- `fn hash<__H: Hasher>(&self, state: &mut __H)`: Feeds this value into the given `Hasher`.
- `fn hash_slice<H>(data: &[Self], state: &mut H)`: Feeds a slice of this type into the given `Hasher`.

### impl PartialEq for Indicator

- `fn eq(&self, other: &Indicator) -> bool`: Tests for `self` and `other` values to be equal.
- `fn ne(&self, other: &Rhs) -> bool`: Tests for `!=`.

### impl Copy for Indicator

### impl Eq for Indicator

### impl StructuralPartialEq for Indicator
```

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

### Format LsColors Instance for Debug

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Formats the LsColors instance using the given formatter for debugging purposes.

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

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

### Clone Into Target

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Uses borrowed data to replace owned data, usually by cloning.

```rust
fn clone_into(&self, target: &mut T)
```

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

### FontStyle Trait Implementations

Source: https://docs.rs/lscolors/0.21.0/lscolors/style/struct.FontStyle.html

Details on the traits implemented for the FontStyle struct.

```APIDOC
### Trait Implementations for FontStyle

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

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

#### impl Default for FontStyle
- **default()** -> FontStyle: Returns the default value for the type.

#### impl Hash for FontStyle
- **hash<__H: Hasher>(&self, state: &mut __H)**: Feeds this value into the given `Hasher`.
- **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 FontStyle
- **eq(&self, other: &FontStyle)** -> bool: Tests for equality.
- **ne(&self, other: &Rhs)** -> bool: Tests for inequality.

#### impl Copy for FontStyle
(Indicates that the type is copyable)

#### impl Eq for FontStyle
(Indicates that the type implements total equality)

#### impl StructuralPartialEq for FontStyle
(Indicates structural partial equality)
```

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

### Mutably Borrow LsColors Instance

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Mutably borrows the LsColors instance.

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

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

### LsColors Struct

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

The LsColors struct holds information about how different file system entries should be colorized or styled.

```APIDOC
## Struct LsColors

### Description
Holds information about how different file system entries should be colorized / styled.

### Fields
(Private fields, not exposed for direct manipulation)
```

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

### Define Style Structure

Source: https://docs.rs/lscolors/0.21.0/lscolors/style/struct.Style.html

The definition of the Style struct containing optional colors and font styles.

```rust
pub struct Style {
    pub foreground: Option<Color>,
    pub background: Option<Color>,
    pub font_style: FontStyle,
    pub underline: Option<Color>,
}
```

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

### Iterator Aggregation and Transformation

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for collecting iterator elements into containers, summing, multiplying, and transforming elements.

```APIDOC
## unzip<A, B, FromA, FromB>

### Description
Converts an iterator of pairs into a pair of containers.

### Method
`unzip`

### Response
- `(FromA, FromB)` - A tuple containing two containers, each populated with elements from the corresponding position in the pairs.

## copied<'a, T>

### Description
Creates an iterator that copies all of its elements. Requires elements to implement `Copy`.

### Method
`copied`

### Response
- `Copied<Self>` - An iterator that yields copied elements.

## cloned<'a, T>

### Description
Creates an iterator that `clone`s all of its elements. Requires elements to implement `Clone`.

### Method
`cloned`

### Response
- `Cloned<Self>` - An iterator that yields cloned elements.

## array_chunks<const N: usize>

### Description
Returns an iterator over `N` elements of the iterator at a time. This is a nightly-only experimental API.

### Method
`array_chunks`

### Parameters
- `N` (const usize) - The size of each chunk.

### Response
- `ArrayChunks<Self, N>` - An iterator that yields slices of size `N`.

## sum<S>

### Description
Sums the elements of an iterator. The element type must implement `Sum`.

### Method
`sum`

### Response
- `S` - The sum of the elements in the iterator.

## product<P>

### Description
Iterates over the entire iterator, multiplying all the elements. The element type must implement `Product`.

### Method
`product`

### Response
- `P` - The product of the elements in the iterator.
```

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

### To Owned Data

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Creates owned data from borrowed data, usually by cloning.

```rust
fn to_owned(&self) -> T
```

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

### TryFrom Trait

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

The `TryFrom` trait is used to perform fallible conversions from one type into another. It is the reciprocal of `TryInto`.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
This implementation block defines the `TryFrom` trait for converting a type `U` into a type `T`.

### Method
`try_from`

### Endpoint
N/A (This is a trait implementation, not an API endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let value: u8 = 10;
let result: Result<String, _> = String::try_from(value);
```

### Response
#### Success Response (Result<T, E>)
- **T** (type) - The target type after successful conversion.
- **E** (type) - The error type returned if the conversion fails.

#### Response Example
```json
// Success:
// Ok("10")

// Failure:
// Err(ConversionError::ValueTooLarge)
```

#### type Error = <U as TryFrom<T>>::Error

### Description
Defines the associated `Error` type for the `TryFrom` trait. This type represents the error that can occur during the conversion process.

### Method
N/A (This is an associated type definition)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response (Type Definition)
- **Error** (type) - The specific error type associated with the conversion failure.
```

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

### Into U Conversion

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Calls U::from(self). The conversion behavior is determined by the From<T> for U implementation.

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

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

### Iterator Comparison Methods

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for comparing elements of an iterator against another iterator or using custom logic.

```APIDOC
## eq<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are equal to those of another.

## eq_by<I, F>(self, other: I, eq: F) -> bool

### Description
Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function. (Nightly-only experimental API)

## ne<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are not equal to those of another.

## lt<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are lexicographically less than those of another.

## le<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are lexicographically less or equal to those of another.

## gt<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are lexicographically greater than those of another.

## ge<I>(self, other: I) -> bool

### Description
Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.
```

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

### Iterator Folding and Reduction

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for folding and reducing iterator elements into a single value.

```APIDOC
## Iterator Folding and Reduction

### Description
Methods for folding and reducing iterator elements into a single value.

### Methods

#### `try_fold<B, F, R>(&mut self, init: B, f: F)`
- **Description**: An iterator method that applies a function as long as it returns successfully, producing a single, final value.
- **Version**: 1.27.0

#### `try_for_each<F, R>(&mut self, f: F)`
- **Description**: An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.
- **Version**: 1.0.0

#### `fold<B, F>(self, init: B, f: F)`
- **Description**: Folds every element into an accumulator by applying an operation, returning the final result.
- **Version**: 1.51.0

#### `reduce<F>(self, f: F)`
- **Description**: Reduces the elements to a single one, by repeatedly applying a reducing operation.
- **Version**: Not specified

#### `try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R)`
- **Description**: Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.
- **Note**: This is a nightly-only experimental API (`iterator_try_reduce`).
- **Version**: 1.0.0
```

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

### Iterator Predicate Testing

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for testing conditions on iterator elements.

```APIDOC
## Iterator Predicate Testing

### Description
Methods for testing conditions on iterator elements.

### Methods

#### `all<F>(&mut self, f: F)`
- **Description**: Tests if every element of the iterator matches a predicate.
- **Version**: 1.0.0

#### `any<F>(&mut self, f: F)`
- **Description**: Tests if any element of the iterator matches a predicate.
- **Version**: 1.0.0
```

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

### Check for Explicit Style for Indicator

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Checks if a specific indicator (e.g., file type) has an explicitly defined color style.

```rust
pub fn has_explicit_style_for(&self, indicator: Indicator) -> bool
```

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

### LsColors Struct Definition

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Defines the LsColors struct, which holds private fields for file system entry styling.

```rust
pub struct LsColors { /* private fields */ }
```

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

### StyledComponents Struct

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Information about the StyledComponents struct, which provides an iterator over path components with their respective styles.

```APIDOC
## Struct StyledComponents

### Summary
```rust
pub struct StyledComponents<'a> {
    /* private fields */
}
```

### Description
Iterator over the path components with their respective style.
```

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

### Iterator for StyledComponents

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Details on the Iterator trait implementation for StyledComponents, including its item type and available methods.

```APIDOC
## Trait Implementations

### impl<'a> Iterator for StyledComponents<'a>

#### type Item = (OsString, Option<&'a Style>)

**Description**: The type of the elements being iterated over.

#### fn next(&mut self) -> Option<Self::Item>

**Description**: Advances the iterator and returns the next value.

#### fn next_chunk<const N: usize>(&mut self) -> Result<[Self::Item; N], IntoIter<Self::Item, N>> where Self: Sized,

**Description**: Advances the iterator and returns an array containing the next `N` values. This is a nightly-only experimental API.

#### fn size_hint(&self) -> (usize, Option<usize>)

**Description**: Returns the bounds on the remaining length of the iterator.

#### fn count(self) -> usize where Self: Sized,

**Description**: Consumes the iterator, counting the number of iterations and returning it.

#### fn last(self) -> Option<Self::Item> where Self: Sized,

**Description**: Consumes the iterator, returning the last element.

#### fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

**Description**: Advances the iterator by `n` elements. This is a nightly-only experimental API.

#### fn nth(&mut self, n: usize) -> Option<Self::Item>

**Description**: Returns the `n`th element of the iterator.

#### fn step_by(self, step: usize) -> StepBy<Self> where Self: Sized,

**Description**: Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

#### fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where Self: Sized, U: IntoIterator<Item = Self::Item>,

**Description**: Takes two iterators and creates a new iterator over both in sequence.

#### fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where Self: Sized, U: IntoIterator,

**Description**: Zips up two iterators into a single iterator of pairs.

#### fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where Self: Sized, Self::Item: Clone,

**Description**: Creates a new iterator which places a copy of `separator` between adjacent items of the original iterator. This is a nightly-only experimental API.

#### fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where Self: Sized, G: FnMut() -> Self::Item,

**Description**: Creates a new iterator which places an item generated by `separator` between adjacent items of the original iterator. This is a nightly-only experimental API.

#### fn map<B, F>(self, f: F) -> Map<Self, F> where Self: Sized, F: FnMut(Self::Item) -> B,

**Description**: Takes a closure and creates an iterator which calls that closure on each element.

#### fn for_each<F>(self, f: F) where Self: Sized, F: FnMut(Self::Item),

**Description**: Calls a closure on each element of an iterator.

#### fn filter<P>(self, predicate: P) -> Filter<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool,

**Description**: Creates an iterator which uses a closure to determine if an element should be yielded.

#### fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

**Description**: Creates an iterator that both filters and maps.

#### fn enumerate(self) -> Enumerate<Self> where Self: Sized,

**Description**: Creates an iterator which gives the current iteration count as well as the next value.

#### fn peekable(self) -> Peekable<Self> where Self: Sized,

**Description**: Creates an iterator which can use the `peek` and `peek_mut` methods to look at the next element of the iterator without consuming it.

#### fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool,

**Description**: Creates an iterator that `skip`s elements based on a predicate.

#### fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool,

**Description**: Creates an iterator that yields elements based on a predicate.

#### fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

**Description**: Creates an iterator that both yields elements based on a predicate and maps.

#### fn skip(self, n: usize) -> Skip<Self> where Self: Sized,

**Description**: Creates an iterator that skips the first `n` elements.
```

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

### Iterator Element Manipulation

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for taking, mapping, and flattening elements from an iterator.

```APIDOC
## Iterator Element Manipulation

### Description
Methods for taking, mapping, and flattening elements from an iterator.

### Methods

#### `take(n: usize)`
- **Description**: Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.
- **Version**: 1.0.0

#### `scan<St, B, F>(initial_state: St, f: F)`
- **Description**: An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator.
- **Version**: 1.0.0

#### `flat_map<U, F>(f: F)`
- **Description**: Creates an iterator that works like map, but flattens nested structure.
- **Version**: 1.29.0

#### `flatten()`
- **Description**: Creates an iterator that flattens nested structure.
- **Version**: Not specified

#### `map_windows<F, R, const N: usize>(f: F)`
- **Description**: Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.
- **Note**: This is a nightly-only experimental API (`iter_map_windows`).
- **Version**: 1.0.0

#### `fuse()`
- **Description**: Creates an iterator which ends after the first `None`.
- **Version**: 1.0.0

#### `inspect<F>(f: F)`
- **Description**: Does something with each element of an iterator, passing the value on.
- **Version**: 1.0.0

#### `by_ref()`
- **Description**: Creates a “by reference” adapter for this instance of `Iterator`.
- **Version**: 1.0.0
```

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

### TryInto Trait

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

The `TryInto` trait is used to perform fallible conversions from the implementor type into another type. It is the reciprocal of `TryFrom`.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
This implementation block defines the `TryInto` trait for converting a type `T` into a type `U`.

### Method
`try_into`

### Endpoint
N/A (This is a trait implementation, not an API endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let value: String = "10".to_string();
let result: Result<u8, _> = value.try_into();
```

### Response
#### Success Response (Result<U, E>)
- **U** (type) - The target type after successful conversion.
- **E** (type) - The error type returned if the conversion fails.

#### Response Example
```json
// Success:
// Ok(10)

// Failure:
// Err(ParseIntError { kind: Empty })
```
```

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

### Iterator Searching and Filtering

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods for finding elements within an iterator based on a predicate or transformation.

```APIDOC
## find<P>

### Description
Searches for an element of an iterator that satisfies a predicate.

### Method
`find`

### Parameters
- `predicate` (FnMut(&Self::Item) -> bool) - A closure that takes a reference to an item and returns a boolean.

### Response
- `Option<Self::Item>` - Returns `Some(element)` if found, otherwise `None`.

## find_map<B, F>

### Description
Applies a function to the elements of an iterator and returns the first non-none result.

### Method
`find_map`

### Parameters
- `f` (FnMut(Self::Item) -> Option<B>) - A closure that takes an item and returns an `Option<B>`.

### Response
- `Option<B>` - Returns the first `Some(value)` produced by the closure, otherwise `None`.

## try_find<R>

### Description
Applies a function to the elements of an iterator and returns the first true result or the first error. This is a nightly-only experimental API.

### Method
`try_find`

### Parameters
- `f` (impl FnMut(&Self::Item) -> R) - A closure that takes a reference to an item and returns a type `R` that implements `Try`.

### Response
- `<<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType` - The result of the `try_find` operation.

## position<P>

### Description
Searches for an element in an iterator and returns its index.

### Method
`position`

### Parameters
- `predicate` (FnMut(Self::Item) -> bool) - A closure that takes an item and returns a boolean.

### Response
- `Option<usize>` - Returns `Some(index)` if found, otherwise `None`.
```

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

### Iterator Sorting Checks

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.StyledComponents.html

Methods to verify if an iterator is sorted based on natural order or custom comparators.

```APIDOC
## is_sorted(self) -> bool

### Description
Checks if the elements of this iterator are sorted.

## is_sorted_by<F>(self, compare: F) -> bool

### Description
Checks if the elements of this iterator are sorted using the given comparator function.

## is_sorted_by_key<F, K>(self, f: F) -> bool

### Description
Checks if the elements of this iterator are sorted using the given key extraction function.
```

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

### Define Colorable Trait in lscolors

Source: https://docs.rs/lscolors/0.21.0/lscolors/trait.Colorable.html

This trait defines the interface for types that can be colored based on file path information. It requires methods to access the full path, file name, file type, and metadata.

```rust
pub trait Colorable {
    // Required methods
    fn path(&self) -> PathBuf;
    fn file_name(&self) -> OsString;
    fn file_type(&self) -> Option<FileType>;
    fn metadata(&self) -> Option<Metadata>;
}
```

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

### Indicator Enum

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

The Indicator enum represents various file types and special conditions for visual representation.

```APIDOC
## Enum Indicator

### Variants

- **Normal**: `no` - Normal (non-filename) text
- **RegularFile**: `fi` - Regular file
- **Directory**: `di` - Directory
- **SymbolicLink**: `ln` - Symbolic link
- **FIFO**: `pi` - Named pipe or FIFO
- **Socket**: `so` - Socket
- **Door**: `do` - Door (IPC connection to another program)
- **BlockDevice**: `bd` - Block-oriented device
- **CharacterDevice**: `cd` - Character-oriented device
- **OrphanedSymbolicLink**: `or` - A broken symbolic link
- **Setuid**: `su` - A file that is setuid (`u+s`)
- **Setgid**: `sg` - A file that is setgid (`g+s`)
- **Sticky**: `st` - A directory that is sticky and other-writable (`+t`, `o+w`)
- **OtherWritable**: `ow` - A directory that is not sticky and other-writeable (`o+w`)
- **StickyAndOtherWritable**: `tw` - A directory that is sticky and other-writable (`+t`, `o+w`)
- **ExecutableFile**: `ex` - Executable file
- **MissingFile**: `mi` - Missing file
- **Capabilities**: `ca` - File with capabilities set
- **MultipleHardLinks**: `mh` - File with multiple hard links
- **LeftCode**: `lc` - Code that is printed before the color sequence
- **RightCode**: `rc` - Code that is printed after the color sequence
- **EndCode**: `ec` - End code
- **Reset**: `rs` - Code to reset to ordinary colors
- **ClearLine**: `cl` - Code to clear to the end of the line
```

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

### Indicator Enum Definition

Source: https://docs.rs/lscolors/0.21.0/lscolors/enum.Indicator.html

The Indicator enum contains 24 variants representing file types and terminal control codes.

```rust
pub enum Indicator {
Show 24 variants    Normal,
    RegularFile,
    Directory,
    SymbolicLink,
    FIFO,
    Socket,
    Door,
    BlockDevice,
    CharacterDevice,
    OrphanedSymbolicLink,
    Setuid,
    Setgid,
    Sticky,
    OtherWritable,
    StickyAndOtherWritable,
    ExecutableFile,
    MissingFile,
    Capabilities,
    MultipleHardLinks,
    LeftCode,
    RightCode,
    EndCode,
    Reset,
    ClearLine,
}
```

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

### TryFrom Error Type

Source: https://docs.rs/lscolors/0.21.0/lscolors/struct.LsColors.html

Defines the error type for TryFrom conversions, which is Infallible when U: Into<T>.

```rust
type Error = Infallible
```
Tokens:
Raw