feat: add support for include and copy fence attributes

Author: cestef

components/content/src/page.rs

@@ -223,6 +223,7 @@ impl Page {
         );
         context.set_shortcode_definitions(shortcode_definitions);
         context.set_current_page_path(&self.file.relative);
+        context.set_parent_absolute(&self.file.parent);
         context.tera_context.insert("page", &SerializingPage::new(self, None, false));
 
         let res = render_content(&self.raw_content, &context)

components/content/src/section.rs

@@ -161,6 +161,7 @@ impl Section {
         );
         context.set_shortcode_definitions(shortcode_definitions);
         context.set_current_page_path(&self.file.relative);
+        context.set_parent_absolute(&self.file.parent);
         context
             .tera_context
             .insert("section", &SerializingSection::new(self, SectionSerMode::ForMarkdown));

components/markdown/src/codeblock/fence.rs

@@ -25,6 +25,8 @@ pub struct FenceSettings<'a> {
     pub highlight_lines: Vec<RangeInclusive<usize>>,
     pub hide_lines: Vec<RangeInclusive<usize>>,
     pub name: Option<&'a str>,
+    pub enable_copy: bool,
+    pub include: Option<&'a str>,
 }
 
 impl<'a> FenceSettings<'a> {
@@ -36,6 +38,8 @@ impl<'a> FenceSettings<'a> {
             highlight_lines: Vec::new(),
             hide_lines: Vec::new(),
             name: None,
+            enable_copy: false,
+            include: None,
         };
 
         for token in FenceIter::new(fence_info) {
@@ -46,6 +50,8 @@ impl<'a> FenceSettings<'a> {
                 FenceToken::HighlightLines(lines) => me.highlight_lines.extend(lines),
                 FenceToken::HideLines(lines) => me.hide_lines.extend(lines),
                 FenceToken::Name(n) => me.name = Some(n),
+                FenceToken::EnableCopy => me.enable_copy = true,
+                FenceToken::Include(file) => me.include = Some(file),
             }
         }
 
@@ -61,6 +67,8 @@ enum FenceToken<'a> {
     HighlightLines(Vec<RangeInclusive<usize>>),
     HideLines(Vec<RangeInclusive<usize>>),
     Name(&'a str),
+    EnableCopy,
+    Include(&'a str),
 }
 
 struct FenceIter<'a> {
@@ -112,6 +120,12 @@ impl<'a> Iterator for FenceIter<'a> {
                         return Some(FenceToken::Name(n));
                     }
                 }
+                "copy" => return Some(FenceToken::EnableCopy),
+                "include" => {
+                    if let Some(file) = tok_split.next() {
+                        return Some(FenceToken::Include(file));
+                    }
+                }
                 lang => {
                     if tok_split.next().is_some() {
                         eprintln!("Warning: Unknown annotation {}", lang);

components/markdown/src/codeblock/mod.rs

@@ -2,9 +2,11 @@ mod fence;
 mod highlight;
 
 use std::ops::RangeInclusive;
+use std::path::PathBuf;
 
 use errors::{bail, Result};
 use libs::syntect::util::LinesWithEndings;
+use utils::fs::read_file;
 
 use crate::codeblock::highlight::SyntaxHighlighter;
 use config::highlighting::{resolve_syntax_and_theme, HighlightSource};
@@ -17,11 +19,15 @@ fn opening_html(
     pre_style: Option<String>,
     pre_class: Option<String>,
     line_numbers: bool,
+    enable_copy: bool,
 ) -> String {
     let mut html = String::from("<pre");
     if line_numbers {
         html.push_str(" data-linenos");
     }
+    if enable_copy {
+        html.push_str(" data-copy");
+    }
     let mut classes = String::new();
 
     if let Some(lang) = language {
@@ -81,11 +87,12 @@ pub struct CodeBlock<'config> {
     line_number_start: usize,
     highlight_lines: Vec<RangeInclusive<usize>>,
     hide_lines: Vec<RangeInclusive<usize>>,
+    include: Option<String>,
 }
 
 impl<'config> CodeBlock<'config> {
     pub fn new<'fence_info>(
-        fence: FenceSettings<'fence_info>,
+        fence: &FenceSettings<'fence_info>,
         config: &'config Config,
         // path to the current file if there is one, to point where the error is
         path: Option<&'config str>,
@@ -112,19 +119,33 @@ impl<'config> CodeBlock<'config> {
             highlighter.pre_style(),
             highlighter.pre_class(),
             fence.line_numbers,
+            fence.enable_copy,
         );
         Ok((
             Self {
                 highlighter,
                 line_numbers: fence.line_numbers,
                 line_number_start: fence.line_number_start,
-                highlight_lines: fence.highlight_lines,
-                hide_lines: fence.hide_lines,
+                highlight_lines: fence.highlight_lines.clone(),
+                hide_lines: fence.hide_lines.clone(),
+                include: fence.include.map(|s| s.to_string()),
             },
             html_start,
         ))
     }
 
+    pub fn include(&self, base: Option<&PathBuf>) -> Option<String> {
+        let path = base?.join(self.include.as_ref()?);
+        let res = read_file(&path);
+        match res {
+            Ok(content) => Some(content),
+            Err(e) => {
+                eprintln!("Warning: Failed to include {:?}: {}", path, e);
+                None
+            }
+        }
+    }
+
     pub fn highlight(&mut self, content: &str) -> String {
         let mut buffer = String::new();
         let mark_style = self.highlighter.mark_style();

components/markdown/src/context.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::path::PathBuf;
 
 use config::Config;
 use libs::tera::{Context, Tera};
@@ -13,6 +14,7 @@ pub struct RenderContext<'a> {
     pub config: &'a Config,
     pub tera_context: Context,
     pub current_page_path: Option<&'a str>,
+    pub parent_absolute: Option<&'a PathBuf>,
     pub current_page_permalink: &'a str,
     pub permalinks: Cow<'a, HashMap<String, String>>,
     pub insert_anchor: InsertAnchor,
@@ -43,6 +45,7 @@ impl<'a> RenderContext<'a> {
             config,
             lang,
             shortcode_definitions: Cow::Owned(HashMap::new()),
+            parent_absolute: None,
         }
     }
 
@@ -57,6 +60,11 @@ impl<'a> RenderContext<'a> {
         self.current_page_path = Some(path);
     }
 
+    /// Same as above
+    pub fn set_parent_absolute(&mut self, path: &'a PathBuf) {
+        self.parent_absolute = Some(path);
+    }
+
     // In use in the markdown filter
     // NOTE: This RenderContext is not i18n-aware, see MarkdownFilter::filter for details
     // If this function is ever used outside of MarkdownFilter, take this into consideration
@@ -71,6 +79,7 @@ impl<'a> RenderContext<'a> {
             config,
             lang: &config.default_language,
             shortcode_definitions: Cow::Owned(HashMap::new()),
+            parent_absolute: None,
         }
     }
 }

components/markdown/src/markdown.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::fmt::Write;
+use std::path::PathBuf;
 
 use crate::markdown::cmark::CowStr;
 use errors::bail;
@@ -564,7 +565,7 @@ pub fn markdown_to_html(
                         cmark::CodeBlockKind::Fenced(fence_info) => FenceSettings::new(fence_info),
                         _ => FenceSettings::new(""),
                     };
-                    let (block, begin) = match CodeBlock::new(fence, context.config, path) {
+                    let (block, begin) = match CodeBlock::new(&fence, context.config, path) {
                         Ok(cb) => cb,
                         Err(e) => {
                             error = Some(e);
@@ -576,14 +577,25 @@ pub fn markdown_to_html(
                 }
                 Event::End(TagEnd::CodeBlock { .. }) => {
                     if let Some(ref mut code_block) = code_block {
-                        let html = code_block.highlight(&accumulated_block);
+                        let inner = code_block
+                            .include(
+                                context
+                                    .parent_absolute
+                                    .map(|e| {
+                                        path.map(|p| e.join(PathBuf::from(p).parent().unwrap()))
+                                    })
+                                    .flatten()
+                                    .as_ref(),
+                            )
+                            .unwrap_or(accumulated_block.clone());
+                        let html = code_block.highlight(&inner);
                         events.push(Event::Html(html.into()));
                         accumulated_block.clear();
+                        events.push(Event::Html("</code></pre>\n".into()));
                     }
 
                     // reset highlight and close the code block
                     code_block = None;
-                    events.push(Event::Html("</code></pre>\n".into()));
                 }
                 Event::Start(Tag::Image { link_type, dest_url, title, id }) => {
                     let link = if is_colocated_asset_link(&dest_url) {