talexander/organic
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Add a lifetime for data in the parsed result but not from the source.

Browse Source
This commit is contained in:
Tom Alexander 2023-12-27 11:36:47 -05:00
parent abf066701e
commit 1a70b3d2c0
No known key found for this signature in database
GPG Key ID: D3A179C9A53C0EDE
63 changed files with 276 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/wasm/angle_link.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::AngleLink;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::AngleLink;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmAngleLink<'s> {
pub(crate) struct WasmAngleLink<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmAngleLink<'s>,
WasmAngleLink<'s, 'p>,
AngleLink<'s>,
original,
wasm_context,

120
src/wasm/ast_node.rs
View File

@ -61,68 +61,68 @@ use super::verse_block::WasmVerseBlock;
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum WasmAstNode<'s> {
pub enum WasmAstNode<'s, 'p> {
// Document Nodes
Document(WasmDocument<'s>),
Headline(WasmHeadline<'s>),
Section(WasmSection<'s>),
Document(WasmDocument<'s, 'p>),
Headline(WasmHeadline<'s, 'p>),
Section(WasmSection<'s, 'p>),
// Elements
Paragraph(WasmParagraph<'s>),
PlainList(WasmPlainList<'s>),
PlainListItem(WasmPlainListItem<'s>),
CenterBlock(WasmCenterBlock<'s>),
QuoteBlock(WasmQuoteBlock<'s>),
SpecialBlock(WasmSpecialBlock<'s>),
DynamicBlock(WasmDynamicBlock<'s>),
FootnoteDefinition(WasmFootnoteDefinition<'s>),
Comment(WasmComment<'s>),
Drawer(WasmDrawer<'s>),
PropertyDrawer(WasmPropertyDrawer<'s>),
NodeProperty(WasmNodeProperty<'s>),
Table(WasmTable<'s>),
TableRow(WasmTableRow<'s>),
VerseBlock(WasmVerseBlock<'s>),
CommentBlock(WasmCommentBlock<'s>),
ExampleBlock(WasmExampleBlock<'s>),
ExportBlock(WasmExportBlock<'s>),
SrcBlock(WasmSrcBlock<'s>),
Clock(WasmClock<'s>),
DiarySexp(WasmDiarySexp<'s>),
Planning(WasmPlanning<'s>),
FixedWidthArea(WasmFixedWidthArea<'s>),
HorizontalRule(WasmHorizontalRule<'s>),
Keyword(WasmKeyword<'s>),
BabelCall(WasmBabelCall<'s>),
LatexEnvironment(WasmLatexEnvironment<'s>),
Paragraph(WasmParagraph<'s, 'p>),
PlainList(WasmPlainList<'s, 'p>),
PlainListItem(WasmPlainListItem<'s, 'p>),
CenterBlock(WasmCenterBlock<'s, 'p>),
QuoteBlock(WasmQuoteBlock<'s, 'p>),
SpecialBlock(WasmSpecialBlock<'s, 'p>),
DynamicBlock(WasmDynamicBlock<'s, 'p>),
FootnoteDefinition(WasmFootnoteDefinition<'s, 'p>),
Comment(WasmComment<'s, 'p>),
Drawer(WasmDrawer<'s, 'p>),
PropertyDrawer(WasmPropertyDrawer<'s, 'p>),
NodeProperty(WasmNodeProperty<'s, 'p>),
Table(WasmTable<'s, 'p>),
TableRow(WasmTableRow<'s, 'p>),
VerseBlock(WasmVerseBlock<'s, 'p>),
CommentBlock(WasmCommentBlock<'s, 'p>),
ExampleBlock(WasmExampleBlock<'s, 'p>),
ExportBlock(WasmExportBlock<'s, 'p>),
SrcBlock(WasmSrcBlock<'s, 'p>),
Clock(WasmClock<'s, 'p>),
DiarySexp(WasmDiarySexp<'s, 'p>),
Planning(WasmPlanning<'s, 'p>),
FixedWidthArea(WasmFixedWidthArea<'s, 'p>),
HorizontalRule(WasmHorizontalRule<'s, 'p>),
Keyword(WasmKeyword<'s, 'p>),
BabelCall(WasmBabelCall<'s, 'p>),
LatexEnvironment(WasmLatexEnvironment<'s, 'p>),
// Objects
Bold(WasmBold<'s>),
Italic(WasmItalic<'s>),
Underline(WasmUnderline<'s>),
StrikeThrough(WasmStrikeThrough<'s>),
Code(WasmCode<'s>),
Verbatim(WasmVerbatim<'s>),
PlainText(WasmPlainText<'s>),
RegularLink(WasmRegularLink<'s>),
RadioLink(WasmRadioLink<'s>),
RadioTarget(WasmRadioTarget<'s>),
PlainLink(WasmPlainLink<'s>),
AngleLink(WasmAngleLink<'s>),
OrgMacro(WasmOrgMacro<'s>),
Entity(WasmEntity<'s>),
LatexFragment(WasmLatexFragment<'s>),
ExportSnippet(WasmExportSnippet<'s>),
FootnoteReference(WasmFootnoteReference<'s>),
Citation(WasmCitation<'s>),
CitationReference(WasmCitationReference<'s>),
InlineBabelCall(WasmInlineBabelCall<'s>),
InlineSourceBlock(WasmInlineSourceBlock<'s>),
LineBreak(WasmLineBreak<'s>),
Target(WasmTarget<'s>),
StatisticsCookie(WasmStatisticsCookie<'s>),
Subscript(WasmSubscript<'s>),
Superscript(WasmSuperscript<'s>),
TableCell(WasmTableCell<'s>),
Timestamp(WasmTimestamp<'s>),
Bold(WasmBold<'s, 'p>),
Italic(WasmItalic<'s, 'p>),
Underline(WasmUnderline<'s, 'p>),
StrikeThrough(WasmStrikeThrough<'s, 'p>),
Code(WasmCode<'s, 'p>),
Verbatim(WasmVerbatim<'s, 'p>),
PlainText(WasmPlainText<'s, 'p>),
RegularLink(WasmRegularLink<'s, 'p>),
RadioLink(WasmRadioLink<'s, 'p>),
RadioTarget(WasmRadioTarget<'s, 'p>),
PlainLink(WasmPlainLink<'s, 'p>),
AngleLink(WasmAngleLink<'s, 'p>),
OrgMacro(WasmOrgMacro<'s, 'p>),
Entity(WasmEntity<'s, 'p>),
LatexFragment(WasmLatexFragment<'s, 'p>),
ExportSnippet(WasmExportSnippet<'s, 'p>),
FootnoteReference(WasmFootnoteReference<'s, 'p>),
Citation(WasmCitation<'s, 'p>),
CitationReference(WasmCitationReference<'s, 'p>),
InlineBabelCall(WasmInlineBabelCall<'s, 'p>),
InlineSourceBlock(WasmInlineSourceBlock<'s, 'p>),
LineBreak(WasmLineBreak<'s, 'p>),
Target(WasmTarget<'s, 'p>),
StatisticsCookie(WasmStatisticsCookie<'s, 'p>),
Subscript(WasmSubscript<'s, 'p>),
Superscript(WasmSuperscript<'s, 'p>),
TableCell(WasmTableCell<'s, 'p>),
Timestamp(WasmTimestamp<'s, 'p>),
}
impl<'s> WasmAstNode<'s> {}
impl<'s, 'p> WasmAstNode<'s, 'p> {}

7
src/wasm/babel_call.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::BabelCall;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::BabelCall;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmBabelCall<'s> {
pub(crate) struct WasmBabelCall<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmBabelCall<'s>,
WasmBabelCall<'s, 'p>,
BabelCall<'s>,
original,
wasm_context,

5
src/wasm/bold.rs
View File

@ -1,6 +1,5 @@
use std::marker::PhantomData;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
@ -12,14 +11,14 @@ use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmBold<'s> {
pub(crate) struct WasmBold<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmBold<'s>,
WasmBold<'s, 'p>,
Bold<'s>,
original,
wasm_context,

7
src/wasm/center_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::CenterBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::CenterBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmCenterBlock<'s> {
pub(crate) struct WasmCenterBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmCenterBlock<'s>,
WasmCenterBlock<'s, 'p>,
CenterBlock<'s>,
original,
wasm_context,

7
src/wasm/citation.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Citation;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Citation;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmCitation<'s> {
pub(crate) struct WasmCitation<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmCitation<'s>,
WasmCitation<'s, 'p>,
Citation<'s>,
original,
wasm_context,

7
src/wasm/citation_reference.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::CitationReference;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::CitationReference;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmCitationReference<'s> {
pub(crate) struct WasmCitationReference<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmCitationReference<'s>,
WasmCitationReference<'s, 'p>,
CitationReference<'s>,
original,
wasm_context,

7
src/wasm/clock.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Clock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Clock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmClock<'s> {
pub(crate) struct WasmClock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmClock<'s>,
WasmClock<'s, 'p>,
Clock<'s>,
original,
wasm_context,

7
src/wasm/code.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Code;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Code;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmCode<'s> {
pub(crate) struct WasmCode<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmCode<'s>,
WasmCode<'s, 'p>,
Code<'s>,
original,
wasm_context,

7
src/wasm/comment.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Comment;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Comment;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmComment<'s> {
pub(crate) struct WasmComment<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmComment<'s>,
WasmComment<'s, 'p>,
Comment<'s>,
original,
wasm_context,

7
src/wasm/comment_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::CommentBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::CommentBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmCommentBlock<'s> {
pub(crate) struct WasmCommentBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmCommentBlock<'s>,
WasmCommentBlock<'s, 'p>,
CommentBlock<'s>,
original,
wasm_context,

7
src/wasm/diary_sexp.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::DiarySexp;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::DiarySexp;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmDiarySexp<'s> {
pub(crate) struct WasmDiarySexp<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmDiarySexp<'s>,
WasmDiarySexp<'s, 'p>,
DiarySexp<'s>,
original,
wasm_context,

14
src/wasm/document.rs
View File

@ -12,22 +12,22 @@ use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub struct WasmDocument<'s> {
pub struct WasmDocument<'s, 'p> {
standard_properties: WasmStandardProperties,
additional_properties: Vec<(String, &'s str)>,
children: Vec<WasmAstNode<'s>>,
category: Option<String>,
children: Vec<WasmAstNode<'s, 'p>>,
category: Option<&'p str>,
path: Option<PathBuf>,
}
to_wasm!(
WasmDocument<'s>,
WasmDocument<'s, 'p>,
Document<'s>,
original,
wasm_context,
standard_properties,
{
let category = original.category.clone();
let category = original.category.as_ref().map(String::as_str);
let path = original.path.clone();
let additional_properties: Vec<(String, &str)> = original
@ -65,8 +65,8 @@ to_wasm!(
}
);
impl<'s> Into<WasmAstNode<'s>> for WasmDocument<'s> {
fn into(self) -> WasmAstNode<'s> {
impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmDocument<'s, 'p> {
fn into(self) -> WasmAstNode<'s, 'p> {
WasmAstNode::Document(self)
}
}

7
src/wasm/drawer.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Drawer;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Drawer;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmDrawer<'s> {
pub(crate) struct WasmDrawer<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmDrawer<'s>,
WasmDrawer<'s, 'p>,
Drawer<'s>,
original,
wasm_context,

7
src/wasm/dynamic_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::DynamicBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::DynamicBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmDynamicBlock<'s> {
pub(crate) struct WasmDynamicBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmDynamicBlock<'s>,
WasmDynamicBlock<'s, 'p>,
DynamicBlock<'s>,
original,
wasm_context,

7
src/wasm/entity.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Entity;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Entity;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmEntity<'s> {
pub(crate) struct WasmEntity<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmEntity<'s>,
WasmEntity<'s, 'p>,
Entity<'s>,
original,
wasm_context,

7
src/wasm/example_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::ExampleBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::ExampleBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmExampleBlock<'s> {
pub(crate) struct WasmExampleBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmExampleBlock<'s>,
WasmExampleBlock<'s, 'p>,
ExampleBlock<'s>,
original,
wasm_context,

7
src/wasm/export_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::ExportBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::ExportBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmExportBlock<'s> {
pub(crate) struct WasmExportBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmExportBlock<'s>,
WasmExportBlock<'s, 'p>,
ExportBlock<'s>,
original,
wasm_context,

7
src/wasm/export_snippet.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::ExportSnippet;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::ExportSnippet;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmExportSnippet<'s> {
pub(crate) struct WasmExportSnippet<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmExportSnippet<'s>,
WasmExportSnippet<'s, 'p>,
ExportSnippet<'s>,
original,
wasm_context,

7
src/wasm/fixed_width_area.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::FixedWidthArea;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::FixedWidthArea;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmFixedWidthArea<'s> {
pub(crate) struct WasmFixedWidthArea<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmFixedWidthArea<'s>,
WasmFixedWidthArea<'s, 'p>,
FixedWidthArea<'s>,
original,
wasm_context,

7
src/wasm/footnote_definition.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::FootnoteDefinition;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::FootnoteDefinition;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmFootnoteDefinition<'s> {
pub(crate) struct WasmFootnoteDefinition<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmFootnoteDefinition<'s>,
WasmFootnoteDefinition<'s, 'p>,
FootnoteDefinition<'s>,
original,
wasm_context,

7
src/wasm/footnote_reference.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::FootnoteReference;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::FootnoteReference;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmFootnoteReference<'s> {
pub(crate) struct WasmFootnoteReference<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmFootnoteReference<'s>,
WasmFootnoteReference<'s, 'p>,
FootnoteReference<'s>,
original,
wasm_context,

10
src/wasm/headline.rs
View File

@ -1,25 +1,25 @@
use std::marker::PhantomData;
use crate::types::Heading;
use serde::Serialize;
use super::ast_node::WasmAstNode;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Heading;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "headline")]
pub(crate) struct WasmHeadline<'s> {
pub(crate) struct WasmHeadline<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmHeadline<'s>,
WasmHeadline<'s, 'p>,
Heading<'s>,
original,
wasm_context,
@ -33,8 +33,8 @@ to_wasm!(
}
);
impl<'s> Into<WasmAstNode<'s>> for WasmHeadline<'s> {
fn into(self) -> WasmAstNode<'s> {
impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmHeadline<'s, 'p> {
fn into(self) -> WasmAstNode<'s, 'p> {
WasmAstNode::Headline(self)
}
}

7
src/wasm/horizontal_rule.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::HorizontalRule;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::HorizontalRule;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmHorizontalRule<'s> {
pub(crate) struct WasmHorizontalRule<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmHorizontalRule<'s>,
WasmHorizontalRule<'s, 'p>,
HorizontalRule<'s>,
original,
wasm_context,

7
src/wasm/inline_babel_call.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::InlineBabelCall;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::InlineBabelCall;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmInlineBabelCall<'s> {
pub(crate) struct WasmInlineBabelCall<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmInlineBabelCall<'s>,
WasmInlineBabelCall<'s, 'p>,
InlineBabelCall<'s>,
original,
wasm_context,

7
src/wasm/inline_source_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::InlineSourceBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::InlineSourceBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmInlineSourceBlock<'s> {
pub(crate) struct WasmInlineSourceBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmInlineSourceBlock<'s>,
WasmInlineSourceBlock<'s, 'p>,
InlineSourceBlock<'s>,
original,
wasm_context,

7
src/wasm/italic.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Italic;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Italic;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmItalic<'s> {
pub(crate) struct WasmItalic<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmItalic<'s>,
WasmItalic<'s, 'p>,
Italic<'s>,
original,
wasm_context,

7
src/wasm/keyword.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Keyword;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Keyword;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmKeyword<'s> {
pub(crate) struct WasmKeyword<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmKeyword<'s>,
WasmKeyword<'s, 'p>,
Keyword<'s>,
original,
wasm_context,

7
src/wasm/latex_environment.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::LatexEnvironment;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::LatexEnvironment;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmLatexEnvironment<'s> {
pub(crate) struct WasmLatexEnvironment<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmLatexEnvironment<'s>,
WasmLatexEnvironment<'s, 'p>,
LatexEnvironment<'s>,
original,
wasm_context,

7
src/wasm/latex_fragment.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::LatexFragment;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::LatexFragment;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmLatexFragment<'s> {
pub(crate) struct WasmLatexFragment<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmLatexFragment<'s>,
WasmLatexFragment<'s, 'p>,
LatexFragment<'s>,
original,
wasm_context,

7
src/wasm/line_break.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::LineBreak;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::LineBreak;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmLineBreak<'s> {
pub(crate) struct WasmLineBreak<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmLineBreak<'s>,
WasmLineBreak<'s, 'p>,
LineBreak<'s>,
original,
wasm_context,

2
src/wasm/macros.rs
View File

@ -3,7 +3,7 @@
/// This exists to make changing the type signature easier.
macro_rules! to_wasm {
($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $standard_properties:ident, $fnbody:tt) => {
impl<'s> ToWasm for $istruct {
impl<'s, 'p> ToWasm for $istruct {
type Output = $ostruct;
fn to_wasm(

7
src/wasm/node_property.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::NodeProperty;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::NodeProperty;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmNodeProperty<'s> {
pub(crate) struct WasmNodeProperty<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmNodeProperty<'s>,
WasmNodeProperty<'s, 'p>,
NodeProperty<'s>,
original,
wasm_context,

7
src/wasm/org_macro.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::OrgMacro;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::OrgMacro;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmOrgMacro<'s> {
pub(crate) struct WasmOrgMacro<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmOrgMacro<'s>,
WasmOrgMacro<'s, 'p>,
OrgMacro<'s>,
original,
wasm_context,

7
src/wasm/paragraph.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Paragraph;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Paragraph;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmParagraph<'s> {
pub(crate) struct WasmParagraph<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmParagraph<'s>,
WasmParagraph<'s, 'p>,
Paragraph<'s>,
original,
wasm_context,

6
src/wasm/parse_result.rs
View File

@ -8,15 +8,15 @@ use crate::settings::GlobalSettings;
#[derive(Debug, Serialize)]
#[serde(tag = "status", content = "content")]
pub enum ParseResult<'s> {
pub enum ParseResult<'s, 'p> {
#[serde(rename = "success")]
Success(WasmDocument<'s>),
Success(WasmDocument<'s, 'p>),
#[serde(rename = "error")]
Error(String),
}
pub fn wasm_parse_org(org_contents: &str) -> ParseResult<'_> {
pub fn wasm_parse_org(org_contents: &str) -> ParseResult<'_, '_> {
let global_settings = GlobalSettings::default();
let to_wasm_context = ToWasmContext::new(org_contents);
let rust_parsed = match parse_with_settings(org_contents, &global_settings)

7
src/wasm/plain_link.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::PlainLink;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::PlainLink;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPlainLink<'s> {
pub(crate) struct WasmPlainLink<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPlainLink<'s>,
WasmPlainLink<'s, 'p>,
PlainLink<'s>,
original,
wasm_context,

7
src/wasm/plain_list.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::PlainList;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::PlainList;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPlainList<'s> {
pub(crate) struct WasmPlainList<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPlainList<'s>,
WasmPlainList<'s, 'p>,
PlainList<'s>,
original,
wasm_context,

7
src/wasm/plain_list_item.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::PlainListItem;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::PlainListItem;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPlainListItem<'s> {
pub(crate) struct WasmPlainListItem<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPlainListItem<'s>,
WasmPlainListItem<'s, 'p>,
PlainListItem<'s>,
original,
wasm_context,

7
src/wasm/plain_text.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::PlainText;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::PlainText;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPlainText<'s> {
pub(crate) struct WasmPlainText<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPlainText<'s>,
WasmPlainText<'s, 'p>,
PlainText<'s>,
original,
wasm_context,

7
src/wasm/planning.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Planning;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Planning;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPlanning<'s> {
pub(crate) struct WasmPlanning<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPlanning<'s>,
WasmPlanning<'s, 'p>,
Planning<'s>,
original,
wasm_context,

7
src/wasm/property_drawer.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::PropertyDrawer;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::PropertyDrawer;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmPropertyDrawer<'s> {
pub(crate) struct WasmPropertyDrawer<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmPropertyDrawer<'s>,
WasmPropertyDrawer<'s, 'p>,
PropertyDrawer<'s>,
original,
wasm_context,

7
src/wasm/quote_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::QuoteBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::QuoteBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmQuoteBlock<'s> {
pub(crate) struct WasmQuoteBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmQuoteBlock<'s>,
WasmQuoteBlock<'s, 'p>,
QuoteBlock<'s>,
original,
wasm_context,

7
src/wasm/radio_link.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::RadioLink;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::RadioLink;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmRadioLink<'s> {
pub(crate) struct WasmRadioLink<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmRadioLink<'s>,
WasmRadioLink<'s, 'p>,
RadioLink<'s>,
original,
wasm_context,

7
src/wasm/radio_target.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::RadioTarget;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::RadioTarget;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmRadioTarget<'s> {
pub(crate) struct WasmRadioTarget<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmRadioTarget<'s>,
WasmRadioTarget<'s, 'p>,
RadioTarget<'s>,
original,
wasm_context,

7
src/wasm/regular_link.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::RegularLink;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::RegularLink;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmRegularLink<'s> {
pub(crate) struct WasmRegularLink<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmRegularLink<'s>,
WasmRegularLink<'s, 'p>,
RegularLink<'s>,
original,
wasm_context,

10
src/wasm/section.rs
View File

@ -1,25 +1,25 @@
use std::marker::PhantomData;
use crate::types::Section;
use serde::Serialize;
use super::ast_node::WasmAstNode;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Section;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "section")]
pub(crate) struct WasmSection<'s> {
pub(crate) struct WasmSection<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmSection<'s>,
WasmSection<'s, 'p>,
Section<'s>,
original,
wasm_context,
@ -33,8 +33,8 @@ to_wasm!(
}
);
impl<'s> Into<WasmAstNode<'s>> for WasmSection<'s> {
fn into(self) -> WasmAstNode<'s> {
impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSection<'s, 'p> {
fn into(self) -> WasmAstNode<'s, 'p> {
WasmAstNode::Section(self)
}
}

7
src/wasm/special_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::SpecialBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::SpecialBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmSpecialBlock<'s> {
pub(crate) struct WasmSpecialBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmSpecialBlock<'s>,
WasmSpecialBlock<'s, 'p>,
SpecialBlock<'s>,
original,
wasm_context,

7
src/wasm/src_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::SrcBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::SrcBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmSrcBlock<'s> {
pub(crate) struct WasmSrcBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmSrcBlock<'s>,
WasmSrcBlock<'s, 'p>,
SrcBlock<'s>,
original,
wasm_context,

5
src/wasm/standard_properties.rs
View File

@ -1,10 +1,9 @@
use crate::types::PostBlank;
use crate::types::StandardProperties;
use serde::Deserialize;
use serde::Serialize;
use super::to_wasm::ToWasmContext;
use super::to_wasm::ToWasmStandardProperties;
use crate::types::PostBlank;
use crate::types::StandardProperties;
#[derive(Debug, Serialize)]
pub(crate) struct WasmStandardProperties {

7
src/wasm/statistics_cookie.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::StatisticsCookie;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::StatisticsCookie;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmStatisticsCookie<'s> {
pub(crate) struct WasmStatisticsCookie<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmStatisticsCookie<'s>,
WasmStatisticsCookie<'s, 'p>,
StatisticsCookie<'s>,
original,
wasm_context,

7
src/wasm/strike_through.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::StrikeThrough;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::StrikeThrough;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmStrikeThrough<'s> {
pub(crate) struct WasmStrikeThrough<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmStrikeThrough<'s>,
WasmStrikeThrough<'s, 'p>,
StrikeThrough<'s>,
original,
wasm_context,

7
src/wasm/subscript.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Subscript;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Subscript;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmSubscript<'s> {
pub(crate) struct WasmSubscript<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmSubscript<'s>,
WasmSubscript<'s, 'p>,
Subscript<'s>,
original,
wasm_context,

7
src/wasm/superscript.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Superscript;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Superscript;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmSuperscript<'s> {
pub(crate) struct WasmSuperscript<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmSuperscript<'s>,
WasmSuperscript<'s, 'p>,
Superscript<'s>,
original,
wasm_context,

7
src/wasm/table.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Table;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Table;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmTable<'s> {
pub(crate) struct WasmTable<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmTable<'s>,
WasmTable<'s, 'p>,
Table<'s>,
original,
wasm_context,

7
src/wasm/table_cell.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::TableCell;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::TableCell;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmTableCell<'s> {
pub(crate) struct WasmTableCell<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmTableCell<'s>,
WasmTableCell<'s, 'p>,
TableCell<'s>,
original,
wasm_context,

7
src/wasm/table_row.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::TableRow;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::TableRow;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmTableRow<'s> {
pub(crate) struct WasmTableRow<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmTableRow<'s>,
WasmTableRow<'s, 'p>,
TableRow<'s>,
original,
wasm_context,

7
src/wasm/target.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Target;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Target;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmTarget<'s> {
pub(crate) struct WasmTarget<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmTarget<'s>,
WasmTarget<'s, 'p>,
Target<'s>,
original,
wasm_context,

7
src/wasm/timestamp.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Timestamp;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Timestamp;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmTimestamp<'s> {
pub(crate) struct WasmTimestamp<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmTimestamp<'s>,
WasmTimestamp<'s, 'p>,
Timestamp<'s>,
original,
wasm_context,

7
src/wasm/underline.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Underline;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Underline;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmUnderline<'s> {
pub(crate) struct WasmUnderline<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmUnderline<'s>,
WasmUnderline<'s, 'p>,
Underline<'s>,
original,
wasm_context,

7
src/wasm/verbatim.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::Verbatim;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::Verbatim;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmVerbatim<'s> {
pub(crate) struct WasmVerbatim<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmVerbatim<'s>,
WasmVerbatim<'s, 'p>,
Verbatim<'s>,
original,
wasm_context,

7
src/wasm/verse_block.rs
View File

@ -1,25 +1,24 @@
use std::marker::PhantomData;
use crate::types::VerseBlock;
use serde::Deserialize;
use serde::Serialize;
use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use crate::types::VerseBlock;
use crate::wasm::to_wasm::ToWasmStandardProperties;
#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "org-data")]
pub(crate) struct WasmVerseBlock<'s> {
pub(crate) struct WasmVerseBlock<'s, 'p> {
standard_properties: WasmStandardProperties,
children: Vec<()>,
phantom: PhantomData<&'s ()>,
}
to_wasm!(
WasmVerseBlock<'s>,
WasmVerseBlock<'s, 'p>,
VerseBlock<'s>,
original,
wasm_context,

35
src/wasm_test/compare.rs
View File

@ -4,10 +4,10 @@ use crate::compare::Token;
use crate::wasm::WasmAstNode;
use crate::wasm::WasmDocument;
pub fn wasm_compare_document<'b, 's>(
pub fn wasm_compare_document<'b, 's, 'p>(
source: &'s str,
emacs: &'b Token<'s>,
wasm: WasmDocument<'s>,
wasm: WasmDocument<'s, 'p>,
) -> Result<WasmDiffEntry<'b, 's>, Box<dyn std::error::Error>> {
// wasm_compare_ast_node(
todo!()
@ -85,10 +85,10 @@ impl<'b, 's> WasmDiffEntry<'b, 's> {
}
}
fn wasm_compare_ast_node<'b, 's>(
fn wasm_compare_ast_node<'b, 's, 'p>(
source: &'s str,
emacs: &'b Token<'s>,
wasm: WasmAstNode<'s>,
wasm: WasmAstNode<'s, 'p>,
) -> Result<WasmDiffEntry<'b, 's>, Box<dyn std::error::Error>> {
match wasm {
WasmAstNode::Document(_) => todo!(),
@ -153,10 +153,33 @@ fn wasm_compare_ast_node<'b, 's>(
todo!()
}
fn impl_wasm_compare_document<'b, 's>(
// fn wasm_compare_list<'b, 's, EI, WI, WC>(
// source: &'s str,
// emacs: EI,
// wasm: WI,
// // emacs: &'b Token<'s>,
// // wasm: WasmDocument<'s>,
// ) -> Result<WasmDiffEntry<'b, 's>, Box<dyn std::error::Error>>
// where
// EI: Iterator<Item = &'b Token<'s>> + ExactSizeIterator,
// WI: Iterator<Item = WC>,
// WasmAstNode<'b, 's>: From<WC>,
// {
// let mut this_status = WasmDiffStatus::Good;
// let mut child_status = Vec::new();
// let mut message = None;
// todo!()
// }
fn impl_wasm_compare_document<'b, 's, 'p>(
source: &'s str,
emacs: &'b Token<'s>,
wasm: WasmDocument<'s>,
wasm: WasmDocument<'s, 'p>,
) -> Result<WasmDiffEntry<'b, 's>, Box<dyn std::error::Error>> {
let mut this_status = WasmDiffStatus::Good;
// let mut child_status = Vec::new();
// let mut message = None;
todo!()
}