nmd_core/compilation/compilation_rule/

replacement_rule.rs

pub mod replacement_rule_part;


use std::fmt::Debug;
use std::sync::Arc;
use getset::{Getters, Setters};
use log;
use regex::Regex;
use replacement_rule_part::ReplacementRuleReplacerPart;
use crate::compilable_text::CompilableText;
use crate::compilation::compilation_configuration::compilation_configuration_overlay::CompilationConfigurationOverLay;
use crate::compilation::compilation_configuration::CompilationConfiguration;
use crate::output_format::OutputFormat;
use super::CompilationRule;
use crate::compilation::compilation_error::CompilationError;


pub type ReplacementRuleParts = Vec<Arc<dyn ReplacementRuleReplacerPart>>;


/// Rule to replace a NMD text based on a specific pattern matching rule
#[derive(Debug, Clone, Getters, Setters)]
pub struct ReplacementRule {

    #[getset(set)]
    search_pattern: String,

    #[getset(set)]
    search_pattern_regex: Regex,

    #[getset(get = "pub", set = "pub")]
    replacer_parts: ReplacementRuleParts,
}

impl ReplacementRule {
    
    /// Returns a new instance having a search pattern and a replication pattern
    pub fn new(searching_pattern: String, replacers: ReplacementRuleParts) -> Self {

        log::debug!("created new compilation rule with search_pattern: '{}'", searching_pattern);

        Self {
            search_pattern_regex: Regex::new(&searching_pattern).unwrap(),
            search_pattern: searching_pattern,
            replacer_parts: replacers,
        }
    }

}

impl CompilationRule for ReplacementRule {

    /// Compile the content using internal search and replacement pattern
    fn standard_compile(&self, compilable: &CompilableText, format: &OutputFormat, compilation_configuration: &CompilationConfiguration, compilation_configuration_overlay: CompilationConfigurationOverLay) -> Result<CompilableText, CompilationError> {

        log::debug!("compile:\n{:#?}\nusing '{}'->'{:?}'", compilable, self.search_pattern(), self.replacer_parts);

        let mut compiled_parts = Vec::new();

        let compilable_content = compilable.compilable_content();

        let captures_matches = self.search_pattern_regex.captures_iter(&compilable_content);

        for captures in captures_matches {

            for replacer_part in &self.replacer_parts {

                compiled_parts.append(&mut replacer_part.compile(&captures, compilable, format, compilation_configuration, compilation_configuration_overlay.clone())?.into())
            }   
        }

        Ok(CompilableText::new(compiled_parts))
    }
    
    fn search_pattern(&self) -> &String {
        &self.search_pattern
    }
    
    fn search_pattern_regex(&self) -> &Regex {
        &self.search_pattern_regex
    }
}



#[cfg(test)]
mod test {

    use std::sync::Arc;

    use crate::{codex::modifier::{standard_text_modifier::StandardTextModifier, ModifiersBucket}, compilable_text::{compilable_text_part::{CompilableTextPart, CompilableTextPartType}, CompilableText}, compilation::{compilation_configuration::{compilation_configuration_overlay::CompilationConfigurationOverLay, CompilationConfiguration}, compilation_rule::{constants::ESCAPE_HTML, replacement_rule::{replacement_rule_part::{closure_replacement_rule_part::ClosureReplacementRuleReplacerPart, fixed_replacement_rule_part::FixedReplacementRuleReplacerPart, single_capture_group_replacement_rule_part::SingleCaptureGroupReplacementRuleReplacerPart, ReplacementRuleReplacerPart}, ReplacementRule}, CompilationRule}}, output_format::OutputFormat};


    #[test]
    fn bold_compiling() {

        // valid pattern with a valid text modifier
        let replacement_rule = ReplacementRule::new(StandardTextModifier::BoldStarVersion.modifier_pattern(), vec![
            Arc::new(FixedReplacementRuleReplacerPart::new(String::from("<strong>"))) as Arc<dyn ReplacementRuleReplacerPart>,
            Arc::new(ClosureReplacementRuleReplacerPart::new(Arc::new(|captures, compilable, _, _, _| {
                
                let capture1 = captures.get(1).unwrap();
                
                let slice = compilable.parts_slice(capture1.start(), capture1.end())?;

                Ok(CompilableText::new(slice))
            }))),
            Arc::new(FixedReplacementRuleReplacerPart::new(String::from("</strong>"))),
        ]);

        let text_to_compile = r"A piece of **bold text** and **bold text2**";
        let compilation_configuration = CompilationConfiguration::default();

        let compilable = CompilableText::new(
            vec![
                CompilableTextPart::new(
                    text_to_compile.to_string(),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                )
        ]);
        
        let outcome = replacement_rule.compile(&compilable, &OutputFormat::Html, &compilation_configuration, CompilationConfigurationOverLay::default()).unwrap();

        assert_eq!(outcome.content(), r"<strong>bold text</strong><strong>bold text2</strong>");

        // without text modifier
        let text_to_compile = r"A piece of text without bold text";

        let compilable = CompilableText::new(
            vec![
                CompilableTextPart::new(
                    text_to_compile.to_string(),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                )
        ]);

        let outcome = replacement_rule.compile(&compilable, &OutputFormat::Html, &compilation_configuration, CompilationConfigurationOverLay::default()).unwrap();

        assert_eq!(outcome.content(), r"");


    }

    #[test]
    fn input_with_fixed_parts() {
        let replacement_rule = ReplacementRule::new(StandardTextModifier::ItalicStarVersion.modifier_pattern(), vec![
            Arc::new(FixedReplacementRuleReplacerPart::new(String::from("<em>"))) as Arc<dyn ReplacementRuleReplacerPart>,
            Arc::new(SingleCaptureGroupReplacementRuleReplacerPart::new(1, ESCAPE_HTML.clone(), ModifiersBucket::None)),
            Arc::new(FixedReplacementRuleReplacerPart::new(String::from("</em>"))),
        ]);

        let compilation_configuration = CompilationConfiguration::default();

        // ==== case 1 ====
        let compilable = CompilableText::new(
            vec![
                CompilableTextPart::new(
                    String::from("*start "),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
                CompilableTextPart::new_fixed(String::from("<strong>")),
                CompilableTextPart::new_compilable(String::from("fixed"), ModifiersBucket::None),
                CompilableTextPart::new_fixed(String::from("</strong>")),
                CompilableTextPart::new(
                    String::from(" end*"),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
        ]);
        
        let outcome = replacement_rule.compile(&compilable, &OutputFormat::Html, &compilation_configuration, CompilationConfigurationOverLay::default()).unwrap();

        assert_eq!(outcome.content(), r"<em>start <strong>fixed</strong> end</em>");


        // ==== case 2 ====
        let compilable = CompilableText::new(
            vec![
                CompilableTextPart::new(
                    String::from("*start "),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
                CompilableTextPart::new_fixed(String::from("<strong>")),
                CompilableTextPart::new_compilable(String::from("fixed"), ModifiersBucket::None),
                CompilableTextPart::new_fixed(String::from("</strong>")),
                CompilableTextPart::new(
                    String::from("*"),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
        ]);
        
        let outcome = replacement_rule.compile(&compilable, &OutputFormat::Html, &compilation_configuration, CompilationConfigurationOverLay::default()).unwrap();

        assert_eq!(outcome.content(), r"<em>start <strong>fixed</strong></em>");


        // ==== case 3 ====
        let compilable = CompilableText::new(
            vec![
                CompilableTextPart::new(
                    String::from("*"),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
                CompilableTextPart::new_fixed(String::from("<strong>")),
                CompilableTextPart::new_compilable(String::from("fixed"), ModifiersBucket::None),
                CompilableTextPart::new_fixed(String::from("</strong>")),
                CompilableTextPart::new(
                    String::from(" end*"),
                    CompilableTextPartType::Compilable { incompatible_modifiers: ModifiersBucket::None }
                ),
        ]);
        
        let outcome = replacement_rule.compile(&compilable, &OutputFormat::Html, &compilation_configuration, CompilationConfigurationOverLay::default()).unwrap();

        assert_eq!(outcome.content(), r"<em><strong>fixed</strong> end</em>");

    }

    // #[test]
    // fn heading_parsing() {

    //     let codex = Codex::of_html(CodexConfiguration::default());

    //     let compilation_configuration = CompilationConfiguration::default();

    //     let parsing_rule = ReplacementRule::new(StandardHeading::HeadingGeneralExtendedVersion(6).modifier_pattern().clone(), vec![
    //         ReplacementRuleReplacerPart::new_fixed(String::from("<h6>")),
    //         ReplacementRuleReplacerPart::new_mutable(String::from("$1")),
    //         ReplacementRuleReplacerPart::new_fixed(String::from("</h6>")),
    //     ]);

    //     let text_to_parse = r"###### title 6";

    //     let compilable: Box<dyn Compilable> = Box::new(GenericCompilable::from(text_to_parse.to_string()));

    //     let parsed_text = parsing_rule.compile(&compilable, &OutputFormat::Html, &codex, &compilation_configuration, Arc::new(RwLock::new(CompilationConfigurationOverLay::default()))).unwrap();

    //     assert_eq!(parsed_text.content(), r"<h6>title 6</h6>");
    // }

    // #[test]
    // fn code_block() {

    //     let codex = Codex::of_html(CodexConfiguration::default());

    //     let compilation_configuration = CompilationConfiguration::default();

    //     let parsing_rule = ReplacementRule::new(StandardParagraphModifier::CodeBlock.modifier_pattern_with_paragraph_separator().clone(), vec![
    //         ReplacementRuleReplacerPart::new_fixed(String::from(r#"<pre><code class="language-$1 codeblock">"#)),
    //         ReplacementRuleReplacerPart::new_mutable(String::from("$2")),
    //         ReplacementRuleReplacerPart::new_fixed(String::from("</code></pre>")),
    //     ]);

    //     let text_to_parse = concat!(
    //         "\n\n",
    //         "```python\n\n",
    //         r#"print("hello world")"#,
    //         "\n\n```\n\n"
    //     );
        
    //     let compilable: Box<dyn Compilable> = Box::new(GenericCompilable::from(text_to_parse.to_string()));

    //     let parsed_text = parsing_rule.compile(&compilable, &OutputFormat::Html, &codex, &compilation_configuration, Arc::new(RwLock::new(CompilationConfigurationOverLay::default()))).unwrap();

    //     assert_eq!(parsed_text.content(), "<pre><code class=\"language-python codeblock\">print(\"hello world\")</code></pre>");
    // }

    
}