plum

// plum-core/src/formatter.rs

use std::io::Cursor;

use topiary_core::{formatter, Language, Operation, TopiaryQuery};

const FORMAT_QUERY: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/format.scm");

#[derive(Debug)]

pub enum FormatterError {

    TopiaryCoreError(topiary_core::FormatterError),

}

impl std::fmt::Display for FormatterError {

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

        match self {

            FormatterError::TopiaryCoreError(e) => write!(f, "Topiary error: {e}"),

        }

    }

}

impl std::error::Error for FormatterError {

    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

        match self {

            FormatterError::TopiaryCoreError(e) => Some(e),

        }

    }

}

impl From<topiary_core::FormatterError> for FormatterError {

    fn from(e: topiary_core::FormatterError) -> Self {

        FormatterError::TopiaryCoreError(e)

    }

}

pub fn formatSource(source: &str) -> Result<String, FormatterError> {

    formatSourceWithOpts(source, false)

}

pub fn formatSourceWithOpts(source: &str, skip_idempotence: bool) -> Result<String, FormatterError> {

    let ts_language: tree_sitter::Language = tree_sitter_plum::LANGUAGE.into();

    let facade_grammar: topiary_tree_sitter_facade::Language = ts_language.into();

    let query = TopiaryQuery::new(&facade_grammar, FORMAT_QUERY)?;

    let language = Language {

        name: "plum".to_owned(),

        query,

        grammar: facade_grammar,

        indent: None,

    };

    let mut input = Cursor::new(source.as_bytes());

    let mut output = Vec::new();

    formatter(

        &mut input,

        &mut output,

        &language,

        Operation::Format {

            skip_idempotence,

            tolerate_parsing_errors: false,

        },

    )?;

    Ok(String::from_utf8(output).expect("Topiary output is valid UTF-8"))

}