read_dir/

lib.rs

use std::io::Read;

use std::os::unix::fs::MetadataExt;
use std::os::unix::fs::PermissionsExt;

pub mod args;

mod color;
use color::Colorize;

// File permissions in octal notation
const OWNER_READ: u16 = 0o0400;
const OWNER_WRITE: u16 = 0o0200;
const OWNER_EXECUTE: u16 = 0o0100;

const GROUP_READ: u16 = 0o0040;
const GROUP_WRITE: u16 = 0o0020;
const GROUP_EXECUTE: u16 = 0o0010;

const OTHER_READ: u16 = 0o0004;
const OTHER_WRITE: u16 = 0o0002;
const OTHER_EXECUTE: u16 = 0o0001;

pub enum Format {
    // Files will be .join()ed with a ' '
    Horizontal,

    // Files will be capped vertically at `.0`
    // NOTE: I have no clue how to do this
    // HorizontalMatrix(u32),

    // Files will be .join()ed with a '\n'
    Vertical,

    // Files will be capped horizontally at `.0` as well as vertically aligned
    // NOTE: Horizontal capping will be done by inserting a '\n' at each `.0`th index
    VerticalMatrix(usize),

    // Files will have additional metadata tacked on and be .join()ed with a '\n'
    // Metadata: permissions owner group size
    // NOTE: size will be in bytes
    Long,
}

pub struct ReadDirOptions {
    // Show files beginning with a '.'
    pub dotfiles: bool,

    // Show '.' and '..' (overriden by `dotfiles`)
    pub implied: bool,

    // Should the files be sorted
    pub sort: bool,

    // Reverse the finalized vector
    pub reverse: bool,

    // Directories will be blue & bold
    pub colored: bool,

    // See `Format` enum (no formating will be some if `None`)
    pub format: Option<Format>,

    // Directory to read from (relative)
    pub directory: String,
}

impl ReadDirOptions {
    pub fn new() -> Self {
        Self {
            dotfiles: false,
            implied: false,
            sort: true,
            reverse: false,
            colored: true,
            format: Some(Format::VerticalMatrix(5)),
            directory: String::from("./"),
        }
    }
}

pub fn read_dir_to_string(options: ReadDirOptions) -> String {
    let mut paths: Vec<String> = match std::fs::read_dir(options.directory.as_str()) {
        Ok(entry) => entry,
        Err(err) => match err.kind() {
            std::io::ErrorKind::PermissionDenied => {
                eprintln!("Error: you don't have permission to read {}", &options.directory);
                std::process::exit(1);
            }
            _ => {
                eprintln!("Internal Error: failed to directory {}", &options.directory);
                std::process::exit(1);
            }
        },
    }
    .map(|entry| match entry {
        Ok(entry) => entry
            .file_name()
            .into_string()
            .unwrap_or(String::from("invalid unicode").blue_fg().red_bg().bold()),
        Err(_) => {
            eprintln!("Internal Error: failed to read entry");
            std::process::exit(1);
        }
    })
    .collect();

    if !options.dotfiles {
        paths = paths
            .into_iter()
            .filter(|path| path.as_bytes()[0] != b'.')
            .collect();
    }

    if options.sort {
        paths.sort();
    }

    if options.reverse {
        paths.reverse();
    }

    let paths_bland = paths.clone(); // This must be cloned otherwise trying to build a vertical
                                     // matrix would be a huge hassle
    if options.colored {
        for path in &mut paths {
            if std::path::Path::new(&(format!("{}/{path}", &options.directory))).is_dir() {
                *path = path.bold().blue_fg();
            }
        }
    }

    match options.format {
        Some(format) => match format {
            Format::Horizontal => paths.join(" "),

            // Format::HorizontalMatrix => {}

            Format::Long => std::iter::zip(paths, paths_bland)
                .map(|(path, bland)| {
                    let metadata = std::fs::metadata(&bland).unwrap_or_else(|_| {
                        eprintln!("Internal Error: unable to read metadata for file {bland:?}");
                        std::process::exit(1);
                    });

                    let is_dir = if metadata.is_dir() { 'd' } else { '-' };

                    let mode = metadata.permissions().mode() as u16;

                    // u = "Owner"
                    let ur = if mode & OWNER_READ == 0 { '-' } else { 'r' };
                    let uw = if mode & OWNER_WRITE == 0 { '-' } else { 'w' };
                    let ux = if mode & OWNER_EXECUTE == 0 { '-' } else { 'x' };

                    // g = "Group"
                    let gr = if mode & GROUP_READ == 0 { '-' } else { 'r' };
                    let gw = if mode & GROUP_WRITE == 0 { '-' } else { 'w' };
                    let gx = if mode & GROUP_EXECUTE == 0 { '-' } else { 'x' };

                    // o = "Other"
                    let or = if mode & OTHER_READ == 0 { '-' } else { 'r' };
                    let ow = if mode & OTHER_WRITE == 0 { '-' } else { 'w' };
                    let ox = if mode & OTHER_EXECUTE == 0 { '-' } else { 'x' };

                    let owner = match uid_to_user(metadata.uid()) {
                        Ok(user) => user,
                        Err(err) => match err.kind() {
                            std::io::ErrorKind::NotFound => {
                                eprintln!("Internal Error: could not open /etc/passwd; file not found");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            std::io::ErrorKind::PermissionDenied => {
                                eprintln!("Internal Error: could not open /etc/passwd; permission denied;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            std::io::ErrorKind::InvalidData => {
                                eprintln!("Internal Error: /etc/passwd did not contain UTF-8 valid data;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            _ => {
                                eprintln!("Internal Error: unknown error opening /etc/passwd;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }
                        }
                    };

                    let group = match gid_to_group(metadata.uid()) {
                        Ok(group) => group,
                        Err(err) => match err.kind() {
                            std::io::ErrorKind::NotFound => {
                                eprintln!("Internal Error: could not open /etc/group; file not found");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            std::io::ErrorKind::PermissionDenied => {
                                eprintln!("Internal Error: could not open /etc/group; permission denied;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            std::io::ErrorKind::InvalidData => {
                                eprintln!("Internal Error: /etc/group did not contain UTF-8 valid data;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }

                            _ => {
                                eprintln!("Internal Error: unknown error opening /etc/group;");
                                eprintln!("opened due to -l needing user id information");
                                std::process::exit(1);
                            }
                        }
                    };

                    let size = metadata.size();

                    format!("{is_dir}{ur}{uw}{ux}{gr}{gw}{gx}{or}{ow}{ox} {owner} {group} {size} {path}")
                })
                .collect::<Vec<String>>()
                .join("\n"),

            Format::Vertical => paths.join("\n"),

            Format::VerticalMatrix(length) => {
                paths
                    .into_iter()
                    .enumerate()
                    .map(|(i, mut path)| {
                        if i % length != 0 {
                            // Add new lines
                            if (i + 1) % length == 0 {
                                path.push('\n');
                            }

                            // Align to matrix
                            let longest = paths_bland
                                .iter()
                                .enumerate()
                                .filter(|(j, _)| (i - 1) % length == j % length)
                                .map(|(_, path)| path.len())
                                .max()
                                .expect("Iterator should never be empty");

                            return String::from(
                                " ".repeat(longest - paths_bland[i - 1].len() + 1),
                            ) + &path;
                        }

                        path
                    })
                    .collect::<Vec<String>>()
                    .join("")
            }
        }

        None => paths.join(""),
    }
}

fn uid_to_user(id: u32) -> Result<String, std::io::Error> {
    let mut etc_passwd_file = std::fs::File::open("/etc/passwd")?;
    let mut etc_passwd = String::new();

    etc_passwd_file.read_to_string(&mut etc_passwd)?;

    let mut users: Vec<(String, u32)> = Vec::new();
    let mut user = (String::new(), 0);

    for entry in etc_passwd.split("\n") {
        for str in entry
            .split_inclusive(":")
            .enumerate()
            .filter(|(i, _)| i % 7 == 2 || i % 7 == 0)
            .map(|(_, str)| str.to_string())
            .collect::<String>()
            .split(":")
        {
            if str.chars().all(|char| char.is_numeric()) && !str.is_empty() {
                user.1 = str.parse().expect("This should be a number");
                users.push(user.clone());
            } else {
                user.0 = str.to_string();
            }
        }
    }

    for user in users {
        if user.1 == id {
            return Ok(user.0);
        }
    }

    Ok(String::new())
}

fn gid_to_group(id: u32) -> Result<String, std::io::Error> {
    let mut etc_group_file = std::fs::File::open("/etc/passwd")?;
    let mut etc_group = String::new();

    etc_group_file.read_to_string(&mut etc_group)?;

    let mut groups: Vec<(String, u32)> = Vec::new();
    let mut group = (String::new(), 0);

    for entry in etc_group.split("\n") {
        for str in entry
            .split_inclusive(":")
            .enumerate()
            .filter(|(i, _)| i % 7 == 2 || i % 7 == 0)
            .map(|(_, str)| str.to_string())
            .collect::<String>()
            .split(":")
        {
            if str.chars().all(|char| char.is_numeric()) && !str.is_empty() {
                group.1 = str.parse().expect("This should be a number");
                groups.push(group.clone());
            } else {
                group.0 = str.to_string();
            }
        }
    }

    for group in groups {
        if group.1 == id {
            return Ok(group.0);
        }
    }

    Ok(String::new())
}