natter/src/intermediate/heading.rs

use crate::error::CustomError;

use super::IObject;

#[derive(Debug)]
pub(crate) struct IHeading {
    pub(crate) level: organic::types::HeadlineLevel,
    pub(crate) title: Vec<IObject>,
}

impl IHeading {
    pub(crate) fn new(heading: &organic::types::Heading<'_>) -> Result<IHeading, CustomError> {
        let title = heading
            .title
            .iter()
            .map(IObject::new)
            .collect::<Result<Vec<_>, _>>()?;
        Ok(IHeading {
            title,
            level: heading.level,
        })
    }
}
Introduce the corresponding non-render types. 2023-10-24 00:36:08 -04:00			`use crate::error::CustomError;`

Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`use super::IObject;`
Only print the contexts. This allows us to pipe the output to jq to see the context easier. We can see the rendered output in the files written to disk. 2023-10-24 00:51:28 -04:00
Introduce the corresponding non-render types. 2023-10-24 00:36:08 -04:00			`#[derive(Debug)]`
Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`pub(crate) struct IHeading {`
Convert intermediate objects into render objects. 2023-10-27 12:47:12 -04:00			`pub(crate) level: organic::types::HeadlineLevel,`
Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`pub(crate) title: Vec<IObject>,`
Only print the contexts. This allows us to pipe the output to jq to see the context easier. We can see the rendered output in the files written to disk. 2023-10-24 00:51:28 -04:00			`}`
Introduce the corresponding non-render types. 2023-10-24 00:36:08 -04:00
Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`impl IHeading {`
			`pub(crate) fn new(heading: &organic::types::Heading<'_>) -> Result<IHeading, CustomError> {`
Create intermediate representation for plain text. 2023-10-27 10:23:05 -04:00			`let title = heading`
			`.title`
			`.iter()`
Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`.map(IObject::new)`
Create intermediate representation for plain text. 2023-10-27 10:23:05 -04:00			`.collect::<Result<Vec<_>, _>>()?;`
Rename blog_post module to intermediate. This module is mostly the intermediate representation of the AST, so the renaming is to make that more clear. The three forms are parsed => intermediate => render. Parsed comes from Organic and is a direct translation of the org-mode text. Intermediate converts the parsed data into owned values and does any calculations that are needed on the data (for example: assigning numbers to footnotes.) Render takes intermediate and translates it into the format expected by the dust templates. The processing in this step should be minimal since all the logic should be in the intermediate step. 2023-10-27 13:05:34 -04:00			`Ok(IHeading {`
Copy heading level. 2023-10-27 12:14:07 -04:00			`title,`
			`level: heading.level,`
			`})`
Introduce the corresponding non-render types. 2023-10-24 00:36:08 -04:00			`}`
			`}`