ript_config/

lib.rs

//! The single place for `ript.toml` configuration.
//!
//! Any crates that want to read the config file can do so here to prevent one place having
//! to load the config and pass it around everywhere.

use std::collections::HashMap;
use std::fs::File;
use std::io::{self, Write};
use std::path::PathBuf;
use std::str::FromStr;
use std::{env, fs};

use anyhow::Context;
use serde::{Deserialize, Serialize};

/// The config file itself.
#[derive(Deserialize, Serialize)]
pub struct RiptDotToml {
    /// The path to the TypeScript file that will be generated by the compiler driver.
    #[serde(default = "default_outfile")]
    outfile: PathBuf,

    /// Types are already pascal case, and fields have casings determined by serde.
    /// Namespace names come from module names, which are always snake case.
    /// Setting this to true will automatically camelize the namespace names.
    #[serde(default = "default_camelize_namespaces")]
    camelize_namespaces: bool,

    /// Override a output with a typescript keyword type. In the future there should definitely be
    /// a more detailed way to do this, but this works well for now.
    ///
    /// The key should be a fully qualified rust path; for example: `my_crate::my_module::MyType`
    #[serde(default = "default_overrides")]
    overrides: HashMap<String, TsKeywordType>,

    /// The package name of the InertiaJS wrapper. We have an officially supported one, but this can be
    /// overridden to use a different base.
    #[serde(default = "default_wrapper_package_import")]
    wrapper_package_import: String,
}

impl FromStr for RiptDotToml {
    type Err = toml::de::Error;

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

fn default_outfile() -> PathBuf {
    PathBuf::from("target/inertia.ts")
}

fn default_camelize_namespaces() -> bool {
    true
}

fn default_overrides() -> HashMap<String, TsKeywordType> {
    HashMap::new()
}

fn default_wrapper_package_import() -> String {
    "ript".to_string()
}

impl Default for RiptDotToml {
    fn default() -> Self {
        Self {
            outfile: default_outfile(),
            camelize_namespaces: default_camelize_namespaces(),
            overrides: default_overrides(),
            wrapper_package_import: default_wrapper_package_import(),
        }
    }
}

impl RiptDotToml {
    /// Provision the config file if it doesn't exist and return its path.
    ///
    /// This deliberately does not create an instance of `Self`, as we don't want to read the source files
    /// yet. Instead, the driver is responsible for creating them through the compiler sess. We could technically
    /// do that here and bring in the driver as a dep, but that would prevent `ript-cli` from using this,
    /// and we want the CLI to remain usable on stable hence the reason for this existing as a separate crate
    /// and offloading the reading / writing to consumers.
    pub fn provision() -> anyhow::Result<PathBuf> {
        let path = ript_dot_doml()?;

        if !path.exists() {
            std::fs::write(&path, toml::to_string(&Self::default())?)?;
        }

        Ok(path)
    }

    /// Get a writer for the generated TypeScript file
    pub fn outfile_writer(&self) -> anyhow::Result<TsWriter> {
        TsWriter::new(&self.outfile)
    }

    /// Returns the generated TS path. This should not be used directly
    /// by the compiler driver for output, but should be used by the driver
    /// to add this file to the sourcemap so that changing it will trigger
    /// rebuilds.
    pub fn outfile(&self) -> &PathBuf {
        &self.outfile
    }

    // /// The path of the opened config file itself.
    // pub fn path(&self) -> &PathBuf {
    //     &self.path
    // }

    /// Whether to camelize the namespace names.
    pub fn camelize_namespaces(&self) -> bool {
        self.camelize_namespaces
    }

    pub fn overrides(&self) -> &HashMap<String, TsKeywordType> {
        &self.overrides
    }

    pub fn wrapper_package_import(&self) -> &str {
        &self.wrapper_package_import
    }
}

fn ript_dot_doml() -> anyhow::Result<PathBuf> {
    let workspace_root = detect_workspace_root()?;
    Ok(workspace_root.join("ript.toml"))
}

/// Attempt to find the workspace root, or just the crate directory itself
/// if running in a non-workspace
pub fn detect_workspace_root() -> anyhow::Result<PathBuf> {
    let mut current_dir =
        env::current_dir().context("failed to determine the current working directory")?;

    let mut last_cargo_toml: Option<PathBuf> = None;

    loop {
        let cargo_toml_path = current_dir.join("Cargo.toml");
        if cargo_toml_path.exists() {
            // record this Cargo.toml in case we don't find a `[workspace]` anywhere
            last_cargo_toml = Some(cargo_toml_path.clone());

            // Naive check for `[workspace]` in the contents
            if let Ok(contents) = fs::read_to_string(&cargo_toml_path) {
                // If any line, trimmed of leading space, starts with "[workspace]" we assume it's a workspace root
                if contents
                    .lines()
                    .any(|line| line.trim_start().starts_with("[workspace]"))
                {
                    return Ok(current_dir);
                }
            }
        }

        // move one directory up; if we can't then we're done searching
        if !current_dir.pop() {
            break;
        }
    }

    // if we found at least one Cargo.toml return its directory
    if let Some(path) = last_cargo_toml {
        return Ok(path.parent().context("no parent")?.to_path_buf());
    }

    // otherwise just fall back to the current working directory
    // env::current_dir()

    anyhow::bail!("could not find a Cargo.toml in any parent directories")
}

/// A writer for the generated TypeScript file that implements std::io::Write
pub struct TsWriter {
    file: File,
}

impl TsWriter {
    /// Create a new TsWriter from a path
    fn new(path: &PathBuf) -> anyhow::Result<Self> {
        // create required directories for the generated ts if they don't exist
        if let Some(parent_dir) = path.parent() {
            fs::create_dir_all(parent_dir)?;
        }

        Ok(Self {
            file: File::create(path)?,
        })
    }
}

impl Write for TsWriter {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.file.write(buf)
    }

    fn flush(&mut self) -> io::Result<()> {
        self.file.flush()
    }
}

/// A configurable TS keyword type
#[derive(Deserialize, Serialize, Clone, Copy)]
#[serde(rename_all = "camelCase")]
pub enum TsKeywordType {
    /// A string
    String,
    /// A number
    Number,
}