darklua_core/frontend/

configuration.rs

use std::{
    collections::HashSet,
    path::{Path, PathBuf},
    str::FromStr,
};

use serde::{Deserialize, Serialize};

use crate::{
    frontend::Loader,
    generator::{DenseLuaGenerator, LuaGenerator, ReadableLuaGenerator, TokenBasedLuaGenerator},
    nodes::Block,
    rules::{
        bundle::{BundleRequireMode, Bundler},
        get_default_rules, Rule,
    },
    utils::{deserialize_one_or_many, deserialize_vec_of_pairs, FilterPattern},
    DarkluaError, Parser,
};

const DEFAULT_COLUMN_SPAN: usize = 80;

fn get_default_column_span() -> usize {
    DEFAULT_COLUMN_SPAN
}

/// Configuration for processing files (rules, generator, bundling).
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Configuration {
    #[serde(alias = "process", default = "get_default_rules")]
    rules: Vec<Box<dyn Rule>>,
    #[serde(default, deserialize_with = "crate::utils::string_or_struct")]
    generator: GeneratorParameters,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    bundle: Option<BundleConfiguration>,
    #[serde(default, skip)]
    location: Option<PathBuf>,
    #[serde(
        default,
        skip_serializing_if = "Vec::is_empty",
        deserialize_with = "deserialize_one_or_many"
    )]
    apply_to_files: Vec<FilterPattern>,
    #[serde(
        default,
        skip_serializing_if = "Vec::is_empty",
        deserialize_with = "deserialize_one_or_many"
    )]
    skip_files: Vec<FilterPattern>,
    #[serde(flatten)]
    loaders: LoaderConfiguration,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    lua_extension: Option<LuaExtension>,
}

impl Configuration {
    /// Creates a configuration object without any rules and with the default generator.
    pub fn empty() -> Self {
        Self {
            rules: Vec::new(),
            generator: GeneratorParameters::default(),
            bundle: None,
            location: None,
            apply_to_files: Vec::new(),
            skip_files: Vec::new(),
            loaders: Default::default(),
            lua_extension: None,
        }
    }

    /// Sets the generator parameters for this configuration.
    #[inline]
    pub fn with_generator(mut self, generator: GeneratorParameters) -> Self {
        self.generator = generator;
        self
    }

    /// Sets the generator parameters for this configuration.
    #[inline]
    pub fn set_generator(&mut self, generator: GeneratorParameters) {
        self.generator = generator;
    }

    /// Adds a rule to this configuration.
    #[inline]
    pub fn with_rule(mut self, rule: impl Into<Box<dyn Rule>>) -> Self {
        self.push_rule(rule);
        self
    }

    /// Sets the bundle configuration for this configuration.
    #[inline]
    pub fn with_bundle_configuration(mut self, configuration: BundleConfiguration) -> Self {
        self.bundle = Some(configuration);
        self
    }

    /// Sets the location of this configuration.
    #[inline]
    pub fn with_location(mut self, location: impl Into<PathBuf>) -> Self {
        self.location = Some(location.into());
        self
    }

    /// Adds a rule to this configuration.
    #[inline]
    pub fn push_rule(&mut self, rule: impl Into<Box<dyn Rule>>) {
        self.rules.push(rule.into());
    }

    /// Adds a glob pattern so that rules will be only applied to files matching it.
    /// Returns an error if the pattern is invalid.
    pub fn with_apply_to_filter(mut self, apply_to_files: &str) -> Result<Self, DarkluaError> {
        self.push_apply_to_filter(apply_to_files)?;
        Ok(self)
    }

    /// Adds a glob pattern so that rules will be only applied to files matching it.
    /// Returns an error if the pattern is invalid.
    pub fn push_apply_to_filter(&mut self, apply_to_files: &str) -> Result<(), DarkluaError> {
        let pattern = FilterPattern::new(apply_to_files.to_owned())?;
        self.apply_to_files.push(pattern);
        Ok(())
    }

    /// Adds a glob pattern so that rules will be skipped for files matching it.
    /// Returns an error if the pattern is invalid.
    pub fn with_skip_filter(mut self, skip_files: &str) -> Result<Self, DarkluaError> {
        self.push_skip_filter(skip_files)?;
        Ok(self)
    }

    /// Adds a glob pattern so that rules will be skipped for files matching it.
    /// Returns an error if the pattern is invalid.
    pub fn push_skip_filter(&mut self, skip_files: &str) -> Result<(), DarkluaError> {
        let pattern = FilterPattern::new(skip_files.to_owned())?;
        self.skip_files.push(pattern);
        Ok(())
    }

    /// Attaches a loader to a glob pattern and returns the configuration.
    pub fn with_loader(mut self, loader: Loader, pattern: &str) -> Result<Self, DarkluaError> {
        self.add_loader(loader, pattern)?;
        Ok(self)
    }

    /// Attaches a loader to a glob pattern.
    pub fn add_loader(&mut self, loader: Loader, pattern: &str) -> Result<(), DarkluaError> {
        self.loaders
            .loaders
            .push((FilterPattern::new(pattern.to_owned())?, loader));
        Ok(())
    }

    /// Clears all registered loaders.
    pub fn clear_loaders(&mut self) {
        self.loaders.loaders.clear();
    }

    #[inline]
    pub(crate) fn rules<'a, 'b: 'a>(&'b self) -> impl Iterator<Item = &'a dyn Rule> {
        self.rules.iter().map(AsRef::as_ref)
    }

    #[inline]
    pub(crate) fn build_parser(&self) -> Parser {
        self.generator.build_parser()
    }

    #[inline]
    pub(crate) fn generate_lua(&self, block: &Block, code: &str) -> String {
        self.generator.generate_lua(block, code)
    }

    pub(crate) fn bundle(&self) -> Option<Bundler> {
        if let Some(bundle_config) = self.bundle.as_ref() {
            let bundler = Bundler::new(
                self.build_parser(),
                bundle_config.require_mode().clone(),
                bundle_config.excludes(),
                self.loaders.clone(),
            )
            .with_modules_identifier(bundle_config.modules_identifier());
            Some(bundler)
        } else {
            None
        }
    }

    #[inline]
    pub(crate) fn rules_len(&self) -> usize {
        self.rules.len()
    }

    #[inline]
    pub(crate) fn location(&self) -> Option<&Path> {
        self.location.as_deref()
    }

    pub(crate) fn should_apply_rule(&self, path: &Path) -> bool {
        if !self.apply_to_files.is_empty() && self.apply_to_files.iter().all(|f| !f.matches(path)) {
            return false;
        }

        if !self.skip_files.is_empty() && self.skip_files.iter().any(|f| f.matches(path)) {
            return false;
        }

        true
    }

    pub(crate) fn loaders(&self) -> &LoaderConfiguration {
        &self.loaders
    }

    pub(crate) fn preferred_lua_extension(&self) -> &'static str {
        self.lua_extension
            .as_ref()
            .unwrap_or(&Default::default())
            .as_str()
    }
}

impl Default for Configuration {
    fn default() -> Self {
        Self {
            rules: get_default_rules(),
            generator: Default::default(),
            bundle: None,
            location: None,
            apply_to_files: Vec::new(),
            skip_files: Vec::new(),
            loaders: Default::default(),
            lua_extension: None,
        }
    }
}

impl std::fmt::Debug for Configuration {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Config")
            .field("location", &self.location)
            .field("generator", &self.generator)
            .field("apply_to_files", &self.apply_to_files)
            .field("skip_files", &self.skip_files)
            .field("loaders", &self.loaders)
            .field("bundle", &self.bundle)
            .field(
                "rules",
                &self
                    .rules
                    .iter()
                    .map(|rule| {
                        json5::to_string(rule)
                            .ok()
                            .unwrap_or_else(|| rule.get_name().to_owned())
                    })
                    .collect::<Vec<_>>()
                    .join(", "),
            )
            .finish()
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub(crate) struct LoaderConfiguration {
    #[serde(
        default,
        skip_serializing_if = "Vec::is_empty",
        deserialize_with = "deserialize_vec_of_pairs"
    )]
    loaders: Vec<(FilterPattern, Loader)>,
}

impl LoaderConfiguration {
    pub(crate) fn get_loader(&self, path: &Path) -> Loader {
        self.loaders
            .iter()
            .find(|(pattern, _)| pattern.matches(path))
            .map(|(_, loader)| *loader)
            .or_else(|| Loader::from_path(path))
            .unwrap_or(Loader::Skip)
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub(crate) enum LuaExtension {
    #[default]
    Lua,
    Luau,
}

impl LuaExtension {
    const fn as_str(&self) -> &'static str {
        match self {
            Self::Lua => "lua",
            Self::Luau => "luau",
        }
    }
}

/// Parameters for configuring the Lua code generator.
///
/// This enum defines different modes for generating Lua code, each with its own
/// formatting characteristics.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "snake_case", tag = "name")]
pub enum GeneratorParameters {
    /// Retains the original line structure of the input code.
    #[serde(alias = "retain-lines")]
    #[default]
    RetainLines,
    /// Generates dense, compact code with a specified column span.
    Dense {
        /// The maximum number of characters per line.
        #[serde(
            default = "get_default_column_span",
            deserialize_with = "crate::utils::deserialize_usize_from_float"
        )]
        column_span: usize,
    },
    /// Attempts to generate readable code, with a specified column span.
    Readable {
        /// The maximum number of characters per line.
        #[serde(
            default = "get_default_column_span",
            deserialize_with = "crate::utils::deserialize_usize_from_float"
        )]
        column_span: usize,
    },
}

impl GeneratorParameters {
    /// Creates a new dense generator with default column span.
    pub fn default_dense() -> Self {
        Self::Dense {
            column_span: DEFAULT_COLUMN_SPAN,
        }
    }

    /// Creates a new readable generator with default column span.
    pub fn default_readable() -> Self {
        Self::Readable {
            column_span: DEFAULT_COLUMN_SPAN,
        }
    }

    fn generate_lua(&self, block: &Block, code: &str) -> String {
        match self {
            Self::RetainLines => {
                let mut generator = TokenBasedLuaGenerator::new(code);
                generator.write_block(block);
                generator.into_string()
            }
            Self::Dense { column_span } => {
                let mut generator = DenseLuaGenerator::new(*column_span);
                generator.write_block(block);
                generator.into_string()
            }
            Self::Readable { column_span } => {
                let mut generator = ReadableLuaGenerator::new(*column_span);
                generator.write_block(block);
                generator.into_string()
            }
        }
    }

    fn build_parser(&self) -> Parser {
        match self {
            Self::RetainLines => Parser::default().preserve_tokens(),
            Self::Dense { .. } | Self::Readable { .. } => Parser::default(),
        }
    }
}

impl FromStr for GeneratorParameters {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            // keep "retain-lines" for back-compatibility
            "retain_lines" | "retain-lines" => Self::RetainLines,
            "dense" => Self::Dense {
                column_span: DEFAULT_COLUMN_SPAN,
            },
            "readable" => Self::Readable {
                column_span: DEFAULT_COLUMN_SPAN,
            },
            _ => return Err(format!("invalid generator name `{}`", s)),
        })
    }
}

/// Configuration for bundling modules.
///
/// This struct defines how modules should be bundled together, including
/// how requires are handled.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "snake_case")]
pub struct BundleConfiguration {
    #[serde(deserialize_with = "crate::utils::string_or_struct")]
    require_mode: BundleRequireMode,
    #[serde(skip_serializing_if = "Option::is_none")]
    modules_identifier: Option<String>,
    #[serde(default, skip_serializing_if = "HashSet::is_empty")]
    excludes: HashSet<String>,
}

impl BundleConfiguration {
    /// Creates a new bundle configuration with the specified require mode.
    pub fn new(require_mode: impl Into<BundleRequireMode>) -> Self {
        Self {
            require_mode: require_mode.into(),
            modules_identifier: None,
            excludes: Default::default(),
        }
    }

    /// Sets the modules identifier for this bundle configuration.
    pub fn with_modules_identifier(mut self, modules_identifier: impl Into<String>) -> Self {
        self.modules_identifier = Some(modules_identifier.into());
        self
    }

    /// Adds a module to exclude from bundling.
    pub fn with_exclude(mut self, exclude: impl Into<String>) -> Self {
        self.excludes.insert(exclude.into());
        self
    }

    pub(crate) fn require_mode(&self) -> &BundleRequireMode {
        &self.require_mode
    }

    pub(crate) fn modules_identifier(&self) -> &str {
        self.modules_identifier
            .as_ref()
            .map(AsRef::as_ref)
            .unwrap_or("__DARKLUA_BUNDLE_MODULES")
    }

    pub(crate) fn excludes(&self) -> impl Iterator<Item = &str> {
        self.excludes.iter().map(AsRef::as_ref)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    mod generator_parameters {
        use super::*;

        #[test]
        fn deserialize_retain_lines_params() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'retain_lines' } }").unwrap();

            pretty_assertions::assert_eq!(config.generator, GeneratorParameters::RetainLines);
        }

        #[test]
        fn deserialize_retain_lines_params_deprecated() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'retain-lines' } }").unwrap();

            pretty_assertions::assert_eq!(config.generator, GeneratorParameters::RetainLines);
        }

        #[test]
        fn deserialize_dense_params() {
            let config: Configuration = json5::from_str("{ generator: { name: 'dense' }}").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Dense {
                    column_span: DEFAULT_COLUMN_SPAN
                }
            );
        }

        #[test]
        fn deserialize_dense_params_with_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'dense', column_span: 110 } }").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Dense { column_span: 110 }
            );
        }

        #[test]
        fn deserialize_dense_params_with_float_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'dense', column_span: 120.0 } }").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Dense { column_span: 120 }
            );
        }

        #[test]
        fn deserialize_dense_params_with_infinite_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'dense', column_span: Infinity } }").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Dense {
                    column_span: usize::MAX
                }
            );
        }

        #[test]
        fn deserialize_readable_params() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'readable' } }").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Readable {
                    column_span: DEFAULT_COLUMN_SPAN
                }
            );
        }

        #[test]
        fn deserialize_readable_params_with_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'readable', column_span: 110 }}").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Readable { column_span: 110 }
            );
        }

        #[test]
        fn deserialize_readable_params_with_float_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'readable', column_span: 120.6 } }").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Readable { column_span: 120 }
            );
        }

        #[test]
        fn deserialize_readable_params_with_infinite_column_span() {
            let config: Configuration =
                json5::from_str("{ generator: { name: 'readable', column_span: Infinity } }")
                    .unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Readable {
                    column_span: usize::MAX
                }
            );
        }
        #[test]
        fn deserialize_retain_lines_params_as_string() {
            let config: Configuration = json5::from_str("{generator: 'retain_lines'}").unwrap();

            pretty_assertions::assert_eq!(config.generator, GeneratorParameters::RetainLines);
        }

        #[test]
        fn deserialize_dense_params_as_string() {
            let config: Configuration = json5::from_str("{generator: 'dense'}").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Dense {
                    column_span: DEFAULT_COLUMN_SPAN
                }
            );
        }

        #[test]
        fn deserialize_readable_params_as_string() {
            let config: Configuration = json5::from_str("{generator: 'readable'}").unwrap();

            pretty_assertions::assert_eq!(
                config.generator,
                GeneratorParameters::Readable {
                    column_span: DEFAULT_COLUMN_SPAN
                }
            );
        }

        #[test]
        fn deserialize_unknown_generator_name() {
            let result: Result<Configuration, _> = json5::from_str("{generator: 'oops'}");

            insta::assert_snapshot!(
                result.expect_err("deserialization should fail").to_string(),
                @"invalid generator name `oops` at line 1 column 13"
            );
        }
    }

    mod bundle_configuration {
        use crate::rules::require::PathRequireMode;

        use super::*;

        #[test]
        fn deserialize_path_require_mode_as_string() {
            let config: Configuration =
                json5::from_str("{ bundle: { require_mode: 'path' } }").unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::default())
            );
        }

        #[test]
        fn deserialize_path_require_mode_as_object() {
            let config: Configuration =
                json5::from_str("{bundle: { require_mode: { name: 'path' } } }").unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::default())
            );
        }

        #[test]
        fn deserialize_path_require_mode_with_custom_module_folder_name() {
            let config: Configuration = json5::from_str(
                "{bundle: { require_mode: { name: 'path', module_folder_name: '__INIT__' } } }",
            )
            .unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::new("__INIT__"))
            );
        }

        #[test]
        fn deserialize_path_require_mode_with_custom_module_identifier() {
            let config: Configuration =
                json5::from_str("{bundle: { require_mode: 'path', modules_identifier: '__M' } }")
                    .unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::default()).with_modules_identifier("__M")
            );
        }

        #[test]
        fn deserialize_path_require_mode_with_custom_module_identifier_and_module_folder_name() {
            let config: Configuration = json5::from_str(
                "{bundle: { require_mode: { name: 'path', module_folder_name: '__INIT__' }, modules_identifier: '__M' } }",
            )
            .unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::new("__INIT__"))
                    .with_modules_identifier("__M")
            );
        }

        #[test]
        fn deserialize_path_require_mode_with_excludes() {
            let config: Configuration = json5::from_str(
                "{bundle: { require_mode: { name: 'path' }, excludes: ['@lune', 'secrets'] } }",
            )
            .unwrap();

            pretty_assertions::assert_eq!(
                config.bundle.unwrap(),
                BundleConfiguration::new(PathRequireMode::default())
                    .with_exclude("@lune")
                    .with_exclude("secrets")
            );
        }

        #[test]
        fn deserialize_unknown_require_mode_name() {
            let result: Result<Configuration, _> =
                json5::from_str("{bundle: { require_mode: 'oops' } }");

            insta::assert_snapshot!(
                result.expect_err("deserialization should fail").to_string(),
                @"invalid require mode `oops` at line 1 column 26"
            );
        }
    }

    mod loaders {
        use super::*;

        #[test]
        fn deserialize_custom_loaders() {
            let config: Configuration =
                json5::from_str("{ loaders: { '**/*.luau': 'luau', '**/*.json': 'json', '**/*.jsonl': 'json_lines' } }").unwrap();

            insta::assert_debug_snapshot!(config.loaders, @r###"
            LoaderConfiguration {
                loaders: [
                    (
                        FilterPattern {
                            pattern: "**/*.luau",
                        },
                        Luau,
                    ),
                    (
                        FilterPattern {
                            pattern: "**/*.json",
                        },
                        Json,
                    ),
                    (
                        FilterPattern {
                            pattern: "**/*.jsonl",
                        },
                        JsonLines,
                    ),
                ],
            }
            "###);
        }
    }
}