arch/orgize
1
0
Fork 0
Code Issues Pull requests 1 Packages Projects Releases Wiki Activity

feat: pre_blank and post_blank

Browse source
This commit is contained in:
PoiScript 2019-10-28 13:33:18 +08:00
parent 1a0240a747
commit 948b1be2db
19 changed files with 678 additions and 211 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

60
src/elements/block.rs
View file

@ -5,7 +5,7 @@ use nom::{
sequence::preceded, IResult,
};
use crate::parsers::{line, take_lines_while};
use crate::parsers::{blank_lines, line, take_lines_while};
/// Special Block Element
#[derive(Debug)]
@ -13,9 +13,14 @@ use crate::parsers::{line, take_lines_while};
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct SpecialBlock<'a> {
/// Optional block parameters
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub parameters: Option<Cow<'a, str>>,
/// Block name
pub name: Cow<'a, str>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl SpecialBlock<'_> {
@ -23,6 +28,8 @@ impl SpecialBlock<'_> {
SpecialBlock {
name: self.name.into_owned().into(),
parameters: self.parameters.map(Into::into).map(Cow::Owned),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -33,13 +40,20 @@ impl SpecialBlock<'_> {
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct QuoteBlock<'a> {
/// Optional block parameters
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub parameters: Option<Cow<'a, str>>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl QuoteBlock<'_> {
pub fn into_owned(self) -> QuoteBlock<'static> {
QuoteBlock {
parameters: self.parameters.map(Into::into).map(Cow::Owned),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -50,13 +64,20 @@ impl QuoteBlock<'_> {
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct CenterBlock<'a> {
/// Optional block parameters
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub parameters: Option<Cow<'a, str>>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl CenterBlock<'_> {
pub fn into_owned(self) -> CenterBlock<'static> {
CenterBlock {
parameters: self.parameters.map(Into::into).map(Cow::Owned),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -67,13 +88,20 @@ impl CenterBlock<'_> {
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct VerseBlock<'a> {
/// Optional block parameters
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub parameters: Option<Cow<'a, str>>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl VerseBlock<'_> {
pub fn into_owned(self) -> VerseBlock<'static> {
VerseBlock {
parameters: self.parameters.map(Into::into).map(Cow::Owned),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -83,9 +111,12 @@ impl VerseBlock<'_> {
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct CommentBlock<'a> {
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub data: Option<Cow<'a, str>>,
/// Comment, without block's boundaries
pub contents: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl CommentBlock<'_> {
@ -93,6 +124,7 @@ impl CommentBlock<'_> {
CommentBlock {
data: self.data.map(Into::into).map(Cow::Owned),
contents: self.contents.into_owned().into(),
post_blank: self.post_blank,
}
}
}
@ -102,9 +134,12 @@ impl CommentBlock<'_> {
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct ExampleBlock<'a> {
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub data: Option<Cow<'a, str>>,
/// Block contents
pub contents: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl ExampleBlock<'_> {
@ -112,6 +147,7 @@ impl ExampleBlock<'_> {
ExampleBlock {
data: self.data.map(Into::into).map(Cow::Owned),
contents: self.contents.into_owned().into(),
post_blank: self.post_blank,
}
}
}
@ -124,6 +160,8 @@ pub struct ExportBlock<'a> {
pub data: Cow<'a, str>,
/// Block contents
pub contents: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl ExportBlock<'_> {
@ -131,12 +169,13 @@ impl ExportBlock<'_> {
ExportBlock {
data: self.data.into_owned().into(),
contents: self.contents.into_owned().into(),
post_blank: self.post_blank,
}
}
}
/// Src Block Element
#[derive(Debug)]
#[derive(Debug, Default)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct SourceBlock<'a> {
@ -145,6 +184,8 @@ pub struct SourceBlock<'a> {
/// Language of the code in the block
pub language: Cow<'a, str>,
pub arguments: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl SourceBlock<'_> {
@ -153,6 +194,7 @@ impl SourceBlock<'_> {
language: self.language.into_owned().into(),
arguments: self.arguments.into_owned().into(),
contents: self.contents.into_owned().into(),
post_blank: self.post_blank,
}
}
@ -164,20 +206,21 @@ impl SourceBlock<'_> {
}
#[inline]
pub fn parse_block_element(input: &str) -> Option<(&str, (&str, Option<&str>, &str))> {
pub fn parse_block_element(input: &str) -> Option<(&str, (&str, Option<&str>, &str, usize))> {
parse_block_element_internal::<()>(input).ok()
}
#[inline]
fn parse_block_element_internal<'a, E: ParseError<&'a str>>(
input: &'a str,
) -> IResult<&str, (&str, Option<&str>, &str), E> {
) -> IResult<&str, (&str, Option<&str>, &str, usize), E> {
let (input, name) = preceded(tag_no_case("#+BEGIN_"), alpha1)(input)?;
let (input, args) = line(input)?;
let end_line = format!("#+END_{}", name);
let (input, contents) =
take_lines_while(|line| !line.trim().eq_ignore_ascii_case(&end_line))(input);
let (input, _) = line(input)?;
let (input, blank) = blank_lines(input);
Ok((
input,
@ -189,6 +232,7 @@ fn parse_block_element_internal<'a, E: ParseError<&'a str>>(
Some(args.trim())
},
contents,
blank,
),
))
}
@ -202,20 +246,21 @@ fn parse() {
r#"#+BEGIN_SRC
#+END_SRC"#
),
Ok(("", ("SRC".into(), None, "")))
Ok(("", ("SRC".into(), None, "", 0)))
);
assert_eq!(
parse_block_element_internal::<VerboseError<&str>>(
r#"#+begin_src
#+end_src"#
),
Ok(("", ("src".into(), None, "")))
Ok(("", ("src".into(), None, "", 0)))
);
assert_eq!(
parse_block_element_internal::<VerboseError<&str>>(
r#"#+BEGIN_SRC javascript
console.log('Hello World!');
#+END_SRC
"#
),
Ok((
@ -223,7 +268,8 @@ console.log('Hello World!');
(
"SRC".into(),
Some("javascript".into()),
"console.log('Hello World!');\n"
"console.log('Hello World!');\n",
1
)
))
);

19
src/elements/clock.rs
View file

@ -11,7 +11,7 @@ use nom::{
use crate::elements::timestamp::{parse_inactive, Datetime, Timestamp};
use crate::parsers::eol;
use crate::parsers::{blank_lines, eol};
/// Clock Element
#[cfg_attr(test, derive(PartialEq))]
@ -31,6 +31,8 @@ pub enum Clock<'a> {
delay: Option<Cow<'a, str>>,
/// Clock duration
duration: Cow<'a, str>,
/// Numbers of blank lines
post_blank: usize,
},
/// Running Clock
Running {
@ -40,6 +42,8 @@ pub enum Clock<'a> {
repeater: Option<Cow<'a, str>>,
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<Cow<'a, str>>,
/// Numbers of blank lines
post_blank: usize,
},
}
@ -56,21 +60,25 @@ impl Clock<'_> {
repeater,
delay,
duration,
post_blank,
} => Clock::Closed {
start: start.into_owned(),
end: end.into_owned(),
repeater: repeater.map(Into::into).map(Cow::Owned),
delay: delay.map(Into::into).map(Cow::Owned),
duration: duration.into_owned().into(),
post_blank,
},
Clock::Running {
start,
repeater,
delay,
post_blank,
} => Clock::Running {
start: start.into_owned(),
repeater: repeater.map(Into::into).map(Cow::Owned),
delay: delay.map(Into::into).map(Cow::Owned),
post_blank,
},
}
}
@ -118,6 +126,7 @@ impl Clock<'_> {
start,
repeater,
delay,
..
} => Timestamp::Inactive {
start: start.clone(),
repeater: repeater.clone(),
@ -144,6 +153,7 @@ fn parse_clock<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, Cloc
let (input, _) = space0(input)?;
let (input, duration) = recognize(separated_pair(digit1, char(':'), digit1))(input)?;
let (input, _) = eol(input)?;
let (input, blank) = blank_lines(input);
Ok((
input,
Clock::Closed {
@ -152,6 +162,7 @@ fn parse_clock<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, Cloc
repeater,
delay,
duration: duration.into(),
post_blank: blank,
},
))
}
@ -161,12 +172,14 @@ fn parse_clock<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, Cloc
delay,
} => {
let (input, _) = eol(input)?;
let (input, blank) = blank_lines(input);
Ok((
input,
Clock::Running {
start,
repeater,
delay,
post_blank: blank,
},
))
}
@ -195,12 +208,13 @@ fn parse() {
},
repeater: None,
delay: None,
post_blank: 0,
}
))
);
assert_eq!(
parse_clock::<VerboseError<&str>>(
"CLOCK: [2003-09-16 Tue 09:39]--[2003-09-16 Tue 10:39] => 1:00"
"CLOCK: [2003-09-16 Tue 09:39]--[2003-09-16 Tue 10:39] => 1:00\n\n"
),
Ok((
"",
@ -224,6 +238,7 @@ fn parse() {
repeater: None,
delay: None,
duration: "1:00".into(),
post_blank: 1,
}
))
);

36
src/elements/comment.rs Normal file
View file

@ -0,0 +1,36 @@
use std::borrow::Cow;
use crate::parsers::{blank_lines, take_lines_while};
#[derive(Debug, Default)]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct Comment<'a> {
pub value: Cow<'a, str>,
pub post_blank: usize,
}
impl Comment<'_> {
pub(crate) fn parse(input: &str) -> Option<(&str, Comment<'_>)> {
let (input, value) = take_lines_while(|line| line == "#" || line.starts_with("# "))(input);
let (input, blank) = blank_lines(input);
if value.is_empty() {
return None;
}
Some((
input,
Comment {
value: value.into(),
post_blank: blank,
},
))
}
pub fn into_owned(self) -> Comment<'static> {
Comment {
value: self.value.into_owned().into(),
post_blank: self.post_blank,
}
}
}

59
src/elements/drawer.rs
View file

@ -7,15 +7,19 @@ use nom::{
IResult,
};
use crate::parsers::{eol, line, take_lines_while};
use crate::parsers::{blank_lines, eol, line, take_lines_while};
/// Drawer Element
#[derive(Debug, Default)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)]
pub struct Drawer<'a> {
/// Drawer name
pub name: Cow<'a, str>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl Drawer<'_> {
@ -26,6 +30,8 @@ impl Drawer<'_> {
pub fn into_owned(self) -> Drawer<'static> {
Drawer {
name: self.name.into_owned().into(),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -33,6 +39,20 @@ impl Drawer<'_> {
#[inline]
pub fn parse_drawer<'a, E: ParseError<&'a str>>(
input: &'a str,
) -> IResult<&str, (Drawer, &str), E> {
let (input, (mut drawer, content)) = parse_drawer_without_blank(input)?;
let (content, blank) = blank_lines(content);
drawer.pre_blank = blank;
let (input, blank) = blank_lines(input);
drawer.post_blank = blank;
Ok((input, (drawer, content)))
}
pub fn parse_drawer_without_blank<'a, E: ParseError<&'a str>>(
input: &'a str,
) -> IResult<&str, (Drawer, &str), E> {
let (input, name) = delimited(
tag(":"),
@ -44,7 +64,17 @@ pub fn parse_drawer<'a, E: ParseError<&'a str>>(
take_lines_while(|line| !line.trim().eq_ignore_ascii_case(":END:"))(input);
let (input, _) = line(input)?;
Ok((input, (Drawer { name: name.into() }, contents)))
Ok((
input,
(
Drawer {
name: name.into(),
pre_blank: 0,
post_blank: 0,
},
contents,
),
))
}
#[test]
@ -52,24 +82,39 @@ fn parse() {
use nom::error::VerboseError;
assert_eq!(
parse_drawer::<VerboseError<&str>>(":PROPERTIES:\n :CUSTOM_ID: id\n :END:"),
parse_drawer::<VerboseError<&str>>(
r#":PROPERTIES:
:CUSTOM_ID: id
:END:"#
),
Ok((
"",
(
Drawer {
name: "PROPERTIES".into()
name: "PROPERTIES".into(),
pre_blank: 0,
post_blank: 0
},
" :CUSTOM_ID: id\n"
)
))
);
assert_eq!(
parse_drawer::<VerboseError<&str>>(":PROPERTIES:\n :END:"),
parse_drawer::<VerboseError<&str>>(
r#":PROPERTIES:
:END:
"#
),
Ok((
"",
(
Drawer {
name: "PROPERTIES".into()
name: "PROPERTIES".into(),
pre_blank: 2,
post_blank: 1,
},
""
)

19
src/elements/dyn_block.rs
View file

@ -7,18 +7,22 @@ use nom::{
IResult,
};
use crate::parsers::{line, take_lines_while};
use crate::parsers::{blank_lines, line, take_lines_while};
/// Dynamic Block Element
#[derive(Debug, Default)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)]
pub struct DynBlock<'a> {
/// Block name
pub block_name: Cow<'a, str>,
/// Block argument
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub arguments: Option<Cow<'a, str>>,
/// Numbers of blank lines
pub pre_blank: usize,
/// Numbers of blank lines
pub post_blank: usize,
}
impl DynBlock<'_> {
@ -30,6 +34,8 @@ impl DynBlock<'_> {
DynBlock {
block_name: self.block_name.into_owned().into(),
arguments: self.arguments.map(Into::into).map(Cow::Owned),
pre_blank: self.pre_blank,
post_blank: self.post_blank,
}
}
}
@ -44,7 +50,9 @@ fn parse_dyn_block<'a, E: ParseError<&'a str>>(
let (input, args) = line(input)?;
let (input, contents) =
take_lines_while(|line| !line.trim().eq_ignore_ascii_case("#+END:"))(input);
let (contents, pre_blank) = blank_lines(contents);
let (input, _) = line(input)?;
let (input, post_blank) = blank_lines(input);
Ok((
input,
@ -56,6 +64,8 @@ fn parse_dyn_block<'a, E: ParseError<&'a str>>(
} else {
Some(args.trim().into())
},
pre_blank,
post_blank,
},
contents,
),
@ -70,8 +80,11 @@ fn parse() {
assert_eq!(
parse_dyn_block::<VerboseError<&str>>(
r#"#+BEGIN: clocktable :scope file
CONTENTS
#+END:
"#
),
Ok((
@ -80,6 +93,8 @@ CONTENTS
DynBlock {
block_name: "clocktable".into(),
arguments: Some(":scope file".into()),
pre_blank: 2,
post_blank: 1,
},
"CONTENTS\n"
)

63
src/elements/fixed_width.rs Normal file
View file

@ -0,0 +1,63 @@
use std::borrow::Cow;
use crate::parsers::{blank_lines, take_lines_while};
#[derive(Debug, Default)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct FixedWidth<'a> {
pub value: Cow<'a, str>,
pub post_blank: usize,
}
impl FixedWidth<'_> {
pub(crate) fn parse(input: &str) -> Option<(&str, FixedWidth<'_>)> {
let (input, value) = take_lines_while(|line| line == ":" || line.starts_with(": "))(input);
let (input, blank) = blank_lines(input);
if value.is_empty() {
return None;
}
Some((
input,
FixedWidth {
value: value.into(),
post_blank: blank,
},
))
}
pub fn into_owned(self) -> FixedWidth<'static> {
FixedWidth {
value: self.value.into_owned().into(),
post_blank: self.post_blank,
}
}
}
#[test]
fn parse() {
assert_eq!(
FixedWidth::parse(
r#": A
:
: B
: C
"#
),
Some((
"",
FixedWidth {
value: r#": A
:
: B
: C
"#
.into(),
post_blank: 1
}
))
);
}

29
src/elements/fn_def.rs
View file

@ -7,15 +7,17 @@ use nom::{
IResult,
};
use crate::parsers::line;
use crate::parsers::{blank_lines, line};
/// Footnote Definition Element
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct FnDef<'a> {
/// Footnote label, used for refrence
pub label: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl FnDef<'_> {
@ -26,6 +28,7 @@ impl FnDef<'_> {
pub fn into_owned(self) -> FnDef<'static> {
FnDef {
label: self.label.into_owned().into(),
post_blank: self.post_blank,
}
}
}
@ -38,12 +41,14 @@ fn parse_fn_def<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, (Fn
tag("]"),
)(input)?;
let (input, content) = line(input)?;
let (input, blank) = blank_lines(input);
Ok((
input,
(
FnDef {
label: label.into(),
post_blank: blank,
},
content,
),
@ -56,7 +61,16 @@ fn parse() {
assert_eq!(
parse_fn_def::<VerboseError<&str>>("[fn:1] https://orgmode.org"),
Ok(("", (FnDef { label: "1".into() }, " https://orgmode.org")))
Ok((
"",
(
FnDef {
label: "1".into(),
post_blank: 0
},
" https://orgmode.org"
)
))
);
assert_eq!(
parse_fn_def::<VerboseError<&str>>("[fn:word_1] https://orgmode.org"),
@ -64,7 +78,8 @@ fn parse() {
"",
(
FnDef {
label: "word_1".into()
label: "word_1".into(),
post_blank: 0,
},
" https://orgmode.org"
)
@ -76,7 +91,8 @@ fn parse() {
"",
(
FnDef {
label: "WORD-1".into()
label: "WORD-1".into(),
post_blank: 0,
},
" https://orgmode.org"
)
@ -88,7 +104,8 @@ fn parse() {
"",
(
FnDef {
label: "WORD".into()
label: "WORD".into(),
post_blank: 0,
},
""
)

31
src/elements/keyword.rs
View file

@ -8,7 +8,7 @@ use nom::{
IResult,
};
use crate::parsers::line;
use crate::parsers::{blank_lines, line};
/// Keyword Elemenet
#[cfg_attr(test, derive(PartialEq))]
@ -21,6 +21,8 @@ pub struct Keyword<'a> {
pub optional: Option<Cow<'a, str>>,
/// Keyword value
pub value: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl Keyword<'_> {
@ -29,6 +31,7 @@ impl Keyword<'_> {
key: self.key.into_owned().into(),
optional: self.optional.map(Into::into).map(Cow::Owned),
value: self.value.into_owned().into(),
post_blank: self.post_blank,
}
}
}
@ -39,25 +42,28 @@ impl Keyword<'_> {
#[derive(Debug)]
pub struct BabelCall<'a> {
pub value: Cow<'a, str>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl BabelCall<'_> {
pub fn into_owned(self) -> BabelCall<'static> {
BabelCall {
value: self.value.into_owned().into(),
post_blank: self.post_blank,
}
}
}
#[inline]
pub fn parse_keyword(input: &str) -> Option<(&str, (&str, Option<&str>, &str))> {
pub fn parse_keyword(input: &str) -> Option<(&str, (&str, Option<&str>, &str, usize))> {
parse_keyword_internal::<()>(input).ok()
}
#[inline]
fn parse_keyword_internal<'a, E: ParseError<&'a str>>(
input: &'a str,
) -> IResult<&str, (&str, Option<&str>, &str), E> {
) -> IResult<&str, (&str, Option<&str>, &str, usize), E> {
let (input, _) = tag("#+")(input)?;
let (input, key) = take_till(|c: char| c.is_ascii_whitespace() || c == ':' || c == '[')(input)?;
let (input, optional) = opt(delimited(
@ -67,8 +73,9 @@ fn parse_keyword_internal<'a, E: ParseError<&'a str>>(
))(input)?;
let (input, _) = tag(":")(input)?;
let (input, value) = line(input)?;
let (input, blank) = blank_lines(input);
Ok((input, (key, optional, value.trim())))
Ok((input, (key, optional, value.trim(), blank)))
}
#[test]
@ -77,40 +84,40 @@ fn parse() {
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+KEY:"),
Ok(("", ("KEY", None, "")))
Ok(("", ("KEY", None, "", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+KEY: VALUE"),
Ok(("", ("KEY", None, "VALUE")))
Ok(("", ("KEY", None, "VALUE", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+K_E_Y: VALUE"),
Ok(("", ("K_E_Y", None, "VALUE")))
Ok(("", ("K_E_Y", None, "VALUE", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+KEY:VALUE\n"),
Ok(("", ("KEY", None, "VALUE")))
Ok(("", ("KEY", None, "VALUE", 0)))
);
assert!(parse_keyword_internal::<VerboseError<&str>>("#+KE Y: VALUE").is_err());
assert!(parse_keyword_internal::<VerboseError<&str>>("#+ KEY: VALUE").is_err());
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+RESULTS:"),
Ok(("", ("RESULTS", None, "")))
Ok(("", ("RESULTS", None, "", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+ATTR_LATEX: :width 5cm\n"),
Ok(("", ("ATTR_LATEX", None, ":width 5cm")))
Ok(("", ("ATTR_LATEX", None, ":width 5cm", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+CALL: double(n=4)"),
Ok(("", ("CALL", None, "double(n=4)")))
Ok(("", ("CALL", None, "double(n=4)", 0)))
);
assert_eq!(
parse_keyword_internal::<VerboseError<&str>>("#+CAPTION[Short caption]: Longer caption."),
Ok(("", ("CAPTION", Some("Short caption"), "Longer caption.",)))
Ok(("", ("CAPTION", Some("Short caption"), "Longer caption.", 0)))
);
}

39
src/elements/mod.rs
View file

@ -2,10 +2,12 @@
pub(crate) mod block;
pub(crate) mod clock;
pub(crate) mod comment;
pub(crate) mod cookie;
pub(crate) mod drawer;
pub(crate) mod dyn_block;
pub(crate) mod emphasis;
pub(crate) mod fixed_width;
pub(crate) mod fn_def;
pub(crate) mod fn_ref;
pub(crate) mod inline_call;
@ -29,9 +31,11 @@ pub use self::{
SpecialBlock, VerseBlock,
},
clock::Clock,
comment::Comment,
cookie::Cookie,
drawer::Drawer,
dyn_block::DynBlock,
fixed_width::FixedWidth,
fn_def::FnDef,
fn_ref::FnRef,
inline_call::InlineCall,
@ -41,6 +45,7 @@ pub use self::{
list::{List, ListItem},
macros::Macros,
planning::Planning,
rule::Rule,
snippet::Snippet,
table::{Table, TableRow},
target::Target,
@ -52,7 +57,6 @@ use std::borrow::Cow;
/// Element Enum
#[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr(feature = "ser", serde(tag = "type", rename_all = "kebab-case"))]
pub enum Element<'a> {
@ -70,7 +74,7 @@ pub enum Element<'a> {
Cookie(Cookie<'a>),
RadioTarget,
Drawer(Drawer<'a>),
Document,
Document { pre_blank: usize },
DynBlock(DynBlock<'a>),
FnDef(FnDef<'a>),
FnRef(FnRef<'a>),
@ -84,8 +88,8 @@ pub enum Element<'a> {
Macros(Macros<'a>),
Snippet(Snippet<'a>),
Text { value: Cow<'a, str> },
Paragraph,
Rule,
Paragraph { post_blank: usize },
Rule(Rule),
Timestamp(Timestamp<'a>),
Target(Target<'a>),
Bold,
@ -94,8 +98,8 @@ pub enum Element<'a> {
Underline,
Verbatim { value: Cow<'a, str> },
Code { value: Cow<'a, str> },
Comment { value: Cow<'a, str> },
FixedWidth { value: Cow<'a, str> },
Comment(Comment<'a>),
FixedWidth(FixedWidth<'a>),
Title(Title<'a>),
Table(Table<'a>),
TableRow(TableRow),
@ -112,13 +116,13 @@ impl Element<'_> {
| CenterBlock(_)
| VerseBlock(_)
| Bold
| Document
| Document { .. }
| DynBlock(_)
| Headline { .. }
| Italic
| List(_)
| ListItem(_)
| Paragraph
| Paragraph { .. }
| Section
| Strike
| Underline
@ -148,7 +152,7 @@ impl Element<'_> {
Cookie(e) => Cookie(e.into_owned()),
RadioTarget => RadioTarget,
Drawer(e) => Drawer(e.into_owned()),
Document => Document,
Document { pre_blank } => Document { pre_blank },
DynBlock(e) => DynBlock(e.into_owned()),
FnDef(e) => FnDef(e.into_owned()),
FnRef(e) => FnRef(e.into_owned()),
@ -164,8 +168,8 @@ impl Element<'_> {
Text { value } => Text {
value: value.into_owned().into(),
},
Paragraph => Paragraph,
Rule => Rule,
Paragraph { post_blank } => Paragraph { post_blank },
Rule(e) => Rule(e),
Timestamp(e) => Timestamp(e.into_owned()),
Target(e) => Target(e.into_owned()),
Bold => Bold,
@ -178,12 +182,8 @@ impl Element<'_> {
Code { value } => Code {
value: value.into_owned().into(),
},
Comment { value } => Comment {
value: value.into_owned().into(),
},
FixedWidth { value } => FixedWidth {
value: value.into_owned().into(),
},
Comment(e) => Comment(e.into_owned()),
FixedWidth(e) => FixedWidth(e.into_owned()),
Title(e) => Title(e.into_owned()),
Table(e) => Table(e.into_owned()),
TableRow(e) => TableRow(e),
@ -215,12 +215,14 @@ impl_from!(
BabelCall,
CenterBlock,
Clock,
Comment,
CommentBlock,
Cookie,
Drawer,
DynBlock,
ExampleBlock,
ExportBlock,
FixedWidth,
FnDef,
FnRef,
InlineCall,
@ -233,11 +235,12 @@ impl_from!(
Snippet,
SourceBlock,
SpecialBlock,
Table,
Target,
Timestamp,
Table,
Title,
VerseBlock;
List,
Rule,
TableRow
);

62
src/elements/rule.rs
View file

@ -1,19 +1,25 @@
use std::usize;
use nom::{bytes::complete::take_while_m_n, error::ParseError, IResult};
use crate::parsers::eol;
use crate::parsers::{blank_lines, eol};
pub fn parse_rule(input: &str) -> Option<&str> {
parse_rule_internal::<()>(input)
.ok()
.map(|(input, _)| input)
#[derive(Debug, Default)]
#[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct Rule {
pub post_blank: usize,
}
fn parse_rule_internal<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, (), E> {
let (input, _) = take_while_m_n(5, usize::MAX, |c| c == '-')(input)?;
impl Rule {
pub(crate) fn parse(input: &str) -> Option<(&str, Rule)> {
parse_rule::<()>(input).ok()
}
}
fn parse_rule<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, Rule, E> {
let (input, _) = take_while_m_n(5, usize::max_value(), |c| c == '-')(input)?;
let (input, _) = eol(input)?;
Ok((input, ()))
let (input, blank) = blank_lines(input);
Ok((input, Rule { post_blank: blank }))
}
#[test]
@ -21,29 +27,29 @@ fn parse() {
use nom::error::VerboseError;
assert_eq!(
parse_rule_internal::<VerboseError<&str>>("-----"),
Ok(("", ()))
parse_rule::<VerboseError<&str>>("-----"),
Ok(("", Rule { post_blank: 0 }))
);
assert_eq!(
parse_rule_internal::<VerboseError<&str>>("--------"),
Ok(("", ()))
parse_rule::<VerboseError<&str>>("--------"),
Ok(("", Rule { post_blank: 0 }))
);
assert_eq!(
parse_rule_internal::<VerboseError<&str>>("-----\n"),
Ok(("", ()))
parse_rule::<VerboseError<&str>>("-----\n\n\n"),
Ok(("", Rule { post_blank: 2 }))
);
assert_eq!(
parse_rule_internal::<VerboseError<&str>>("----- \n"),
Ok(("", ()))
parse_rule::<VerboseError<&str>>("----- \n"),
Ok(("", Rule { post_blank: 0 }))
);
assert!(parse_rule_internal::<VerboseError<&str>>("").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("None----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("None ----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("None------").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("----None----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("\t\t----").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("------None").is_err());
assert!(parse_rule_internal::<VerboseError<&str>>("----- None").is_err());
assert!(parse_rule::<VerboseError<&str>>("").is_err());
assert!(parse_rule::<VerboseError<&str>>("----").is_err());
assert!(parse_rule::<VerboseError<&str>>("----").is_err());
assert!(parse_rule::<VerboseError<&str>>("None----").is_err());
assert!(parse_rule::<VerboseError<&str>>("None ----").is_err());
assert!(parse_rule::<VerboseError<&str>>("None------").is_err());
assert!(parse_rule::<VerboseError<&str>>("----None----").is_err());
assert!(parse_rule::<VerboseError<&str>>("\t\t----").is_err());
assert!(parse_rule::<VerboseError<&str>>("------None").is_err());
assert!(parse_rule::<VerboseError<&str>>("----- None").is_err());
}

2
src/elements/table.rs
View file

@ -58,7 +58,7 @@ impl TableRow {
}
}
pub(crate) fn parse_table_el(input: &str) -> Option<(&str, &str)> {
pub fn parse_table_el(input: &str) -> Option<(&str, &str)> {
parse_table_el_internal::<()>(input).ok()
}

39
src/elements/title.rs
View file

@ -16,8 +16,8 @@ use nom::{
use crate::{
config::ParseConfig,
elements::{drawer::parse_drawer, Planning, Timestamp},
parsers::{line, skip_empty_lines, take_one_word},
elements::{drawer::parse_drawer_without_blank, Planning, Timestamp},
parsers::{blank_lines, line, skip_empty_lines, take_one_word},
};
/// Title Elemenet
@ -44,6 +44,8 @@ pub struct Title<'a> {
/// Property drawer associated to this headline
#[cfg_attr(feature = "ser", serde(skip_serializing_if = "HashMap::is_empty"))]
pub properties: HashMap<Cow<'a, str>, Cow<'a, str>>,
/// Numbers of blank lines
pub post_blank: usize,
}
impl Title<'_> {
@ -102,6 +104,7 @@ impl Title<'_> {
.into_iter()
.map(|(k, v)| (k.into_owned().into(), v.into_owned().into()))
.collect(),
post_blank: self.post_blank,
}
}
}
@ -116,6 +119,7 @@ impl Default for Title<'_> {
raw: Cow::Borrowed(""),
planning: None,
properties: HashMap::new(),
post_blank: 0,
}
}
}
@ -166,6 +170,7 @@ fn parse_title<'a, E: ParseError<&'a str>>(
.unwrap_or((input, None));
let (input, properties) = opt(parse_properties_drawer)(input)?;
let (input, blank) = blank_lines(input);
Ok((
input,
@ -178,6 +183,7 @@ fn parse_title<'a, E: ParseError<&'a str>>(
tags,
raw: raw.into(),
planning,
post_blank: blank,
},
raw,
),
@ -188,7 +194,7 @@ fn parse_title<'a, E: ParseError<&'a str>>(
fn parse_properties_drawer<'a, E: ParseError<&'a str>>(
input: &'a str,
) -> IResult<&str, HashMap<Cow<'_, str>, Cow<'_, str>>, E> {
let (input, (drawer, content)) = parse_drawer(input.trim_start())?;
let (input, (drawer, content)) = parse_drawer_without_blank(input.trim_start())?;
if drawer.name != "PROPERTIES" {
return Err(Err::Error(E::from_error_kind(input, ErrorKind::Tag)));
}
@ -236,7 +242,8 @@ fn parse_title_() {
raw: "COMMENT Title".into(),
tags: vec!["tag".into(), "a2%".into()],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"COMMENT Title"
)
@ -254,7 +261,8 @@ fn parse_title_() {
raw: "ToDO [#A] COMMENT Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"ToDO [#A] COMMENT Title"
)
@ -272,7 +280,8 @@ fn parse_title_() {
raw: "T0DO [#A] COMMENT Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"T0DO [#A] COMMENT Title"
)
@ -290,7 +299,8 @@ fn parse_title_() {
raw: "[#1] COMMENT Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"[#1] COMMENT Title"
)
@ -308,7 +318,8 @@ fn parse_title_() {
raw: "[#a] COMMENT Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"[#a] COMMENT Title"
)
@ -326,7 +337,8 @@ fn parse_title_() {
raw: "Title :tag:a2%".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"Title :tag:a2%"
)
@ -344,7 +356,8 @@ fn parse_title_() {
raw: "Title tag:a2%:".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"Title tag:a2%:"
)
@ -369,7 +382,8 @@ fn parse_title_() {
raw: "DONE Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"DONE Title"
)
@ -393,7 +407,8 @@ fn parse_title_() {
raw: "Title".into(),
tags: vec![],
planning: None,
properties: HashMap::new()
properties: HashMap::new(),
post_blank: 0,
},
"Title"
)

26
src/export/html.rs
View file

@ -60,7 +60,7 @@ pub trait HtmlHandler<E: From<Error>>: Default {
CenterBlock(_) => write!(w, "<div class=\"center\">")?,
VerseBlock(_) => write!(w, "<p class=\"verse\">")?,
Bold => write!(w, "<b>")?,
Document => write!(w, "<main>")?,
Document { .. } => write!(w, "<main>")?,
DynBlock(_dyn_block) => (),
Headline { .. } => (),
List(list) => {
@ -72,7 +72,7 @@ pub trait HtmlHandler<E: From<Error>>: Default {
}
Italic => write!(w, "<i>")?,
ListItem(_) => write!(w, "<li>")?,
Paragraph => write!(w, "<p>")?,
Paragraph { .. } => write!(w, "<p>")?,
Section => write!(w, "<section>")?,
Strike => write!(w, "<s>")?,
Underline => write!(w, "<u>")?,
@ -162,13 +162,15 @@ pub trait HtmlHandler<E: From<Error>>: Default {
Verbatim { value } => write!(&mut w, "<code>{}</code>", HtmlEscape(value))?,
FnDef(_fn_def) => (),
Clock(_clock) => (),
Comment { .. } => (),
FixedWidth { value } => {
write!(w, "<pre class=\"example\">{}</pre>", HtmlEscape(value))?
}
Comment(_) => (),
FixedWidth(fixed_width) => write!(
w,
"<pre class=\"example\">{}</pre>",
HtmlEscape(&fixed_width.value)
)?,
Keyword(_keyword) => (),
Drawer(_drawer) => (),
Rule => write!(w, "<hr>")?,
Rule(_) => write!(w, "<hr>")?,
Cookie(cookie) => write!(w, "<code>{}</code>", cookie.value)?,
Title(title) => write!(w, "<h{}>", if title.level <= 6 { title.level } else { 6 })?,
Table(_) => (),
@ -188,7 +190,7 @@ pub trait HtmlHandler<E: From<Error>>: Default {
CenterBlock(_) => write!(w, "</div>")?,
VerseBlock(_) => write!(w, "</p>")?,
Bold => write!(w, "</b>")?,
Document => write!(w, "</main>")?,
Document { .. } => write!(w, "</main>")?,
DynBlock(_dyn_block) => (),
Headline { .. } => (),
List(list) => {
@ -200,7 +202,7 @@ pub trait HtmlHandler<E: From<Error>>: Default {
}
Italic => write!(w, "</i>")?,
ListItem(_) => write!(w, "</li>")?,
Paragraph => write!(w, "</p>")?,
Paragraph { .. } => write!(w, "</p>")?,
Section => write!(w, "</section>")?,
Strike => write!(w, "</s>")?,
Underline => write!(w, "</u>")?,
@ -341,13 +343,13 @@ mod syntect_handler {
"<div class=\"org-src-container\"><pre class=\"src src-{}\">{}</pre></div>",
block.language,
self.highlight(Some(&block.language), &block.contents)
)?
)?;
}
}
Element::FixedWidth { value } => write!(
Element::FixedWidth(fixed_width) => write!(
w,
"<pre class=\"example\">{}</pre>",
self.highlight(None, value)
self.highlight(None, fixed_width.value)
)?,
Element::ExampleBlock(block) => write!(
w,

153
src/export/org.rs
View file

@ -9,46 +9,74 @@ pub trait OrgHandler<E: From<Error>>: Default {
match element {
// container elements
SpecialBlock(block) => writeln!(w, "#+BEGIN_{}", block.name)?,
QuoteBlock(_) => write!(w, "#+BEGIN_QUOTE")?,
CenterBlock(_) => write!(w, "#+BEGIN_CENTER")?,
VerseBlock(_) => write!(w, "#+BEGIN_VERSE")?,
SpecialBlock(block) => {
writeln!(w, "#+BEGIN_{}", block.name)?;
write_blank_lines(&mut w, block.pre_blank)?;
}
QuoteBlock(block) => {
writeln!(&mut w, "#+BEGIN_QUOTE")?;
write_blank_lines(&mut w, block.pre_blank)?;
}
CenterBlock(block) => {
writeln!(&mut w, "#+BEGIN_CENTER")?;
write_blank_lines(&mut w, block.pre_blank)?;
}
VerseBlock(block) => {
writeln!(&mut w, "#+BEGIN_VERSE")?;
write_blank_lines(&mut w, block.pre_blank)?;
}
Bold => write!(w, "*")?,
Document => (),
Document { pre_blank } => {
write_blank_lines(w, *pre_blank)?;
}
DynBlock(dyn_block) => {
write!(&mut w, "#+BEGIN: {}", dyn_block.block_name)?;
if let Some(parameters) = &dyn_block.arguments {
write!(&mut w, " {}", parameters)?;
}
writeln!(&mut w)?;
write_blank_lines(&mut w, dyn_block.pre_blank + 1)?;
}
Headline { .. } => (),
List(_list) => (),
Italic => write!(w, "/")?,
ListItem(list_item) => write!(w, "{}", list_item.bullet)?,
Paragraph => (),
Paragraph { .. } => (),
Section => (),
Strike => write!(w, "+")?,
Underline => write!(w, "_")?,
Drawer(drawer) => writeln!(w, ":{}:", drawer.name)?,
Drawer(drawer) => {
writeln!(&mut w, ":{}:", drawer.name)?;
write_blank_lines(&mut w, drawer.pre_blank)?;
}
// non-container elements
CommentBlock(block) => {
writeln!(w, "#+BEGIN_COMMENT\n{}\n#+END_COMMENT", block.contents)?
writeln!(&mut w, "#+BEGIN_COMMENT")?;
write!(&mut w, "{}", block.contents)?;
writeln!(&mut w, "#+END_COMMENT")?;
write_blank_lines(&mut w, block.post_blank)?;
}
ExampleBlock(block) => {
writeln!(w, "#+BEGIN_EXAMPLE\n{}\n#+END_EXAMPLE", block.contents)?
writeln!(&mut w, "#+BEGIN_EXAMPLE")?;
write!(&mut w, "{}", block.contents)?;
writeln!(&mut w, "#+END_EXAMPLE")?;
write_blank_lines(&mut w, block.post_blank)?;
}
ExportBlock(block) => {
writeln!(&mut w, "#+BEGIN_EXPORT {}", block.data)?;
write!(&mut w, "{}", block.contents)?;
writeln!(&mut w, "#+END_EXPORT")?;
write_blank_lines(&mut w, block.post_blank)?;
}
SourceBlock(block) => {
writeln!(&mut w, "#+BEGIN_SRC {}", block.language)?;
write!(&mut w, "{}", block.contents)?;
writeln!(&mut w, "#+END_SRC")?;
write_blank_lines(&mut w, block.post_blank)?;
}
BabelCall(call) => {
writeln!(&mut w, "#+CALL: {}", call.value)?;
write_blank_lines(w, call.post_blank)?;
}
ExportBlock(block) => writeln!(
w,
"#+BEGIN_EXPORT {}\n{}\n#+END_EXPORT",
block.data, block.contents
)?,
SourceBlock(block) => writeln!(
w,
"#+BEGIN_SRC {}\n{}\n#+END_SRC",
block.language, block.contents
)?,
BabelCall(_babel_call) => (),
InlineSrc(inline_src) => {
write!(&mut w, "src_{}", inline_src.lang)?;
if let Some(options) = &inline_src.options {
@ -90,7 +118,9 @@ pub trait OrgHandler<E: From<Error>>: Default {
write_timestamp(&mut w, &timestamp)?;
}
Verbatim { value } => write!(w, "={}=", value)?,
FnDef(_fn_def) => (),
FnDef(fn_def) => {
write_blank_lines(w, fn_def.post_blank)?;
}
Clock(clock) => {
use crate::elements::Clock;
@ -101,27 +131,42 @@ pub trait OrgHandler<E: From<Error>>: Default {
start,
end,
duration,
post_blank,
..
} => {
write_datetime(&mut w, "[", start, "]--")?;
write_datetime(&mut w, "[", end, "]")?;
writeln!(w, " => {}", duration)?;
write_datetime(&mut w, "[", &start, "]--")?;
write_datetime(&mut w, "[", &end, "]")?;
writeln!(&mut w, " => {}", duration)?;
write_blank_lines(&mut w, *post_blank)?;
}
Clock::Running { start, .. } => {
write_datetime(&mut w, "[", start, "]\n")?;
Clock::Running {
start, post_blank, ..
} => {
write_datetime(&mut w, "[", &start, "]\n")?;
write_blank_lines(&mut w, *post_blank)?;
}
}
}
Comment { value } => write!(w, "{}", value)?,
FixedWidth { value } => write!(w, "{}", value)?,
Comment(comment) => {
write!(w, "{}", comment.value)?;
write_blank_lines(&mut w, comment.post_blank)?;
}
FixedWidth(fixed_width) => {
write!(&mut w, "{}", fixed_width.value)?;
write_blank_lines(&mut w, fixed_width.post_blank)?;
}
Keyword(keyword) => {
write!(&mut w, "#+{}", keyword.key)?;
if let Some(optional) = &keyword.optional {
write!(&mut w, "[{}]", optional)?;
}
writeln!(&mut w, ": {}", keyword.value)?;
write_blank_lines(&mut w, keyword.post_blank)?;
}
Rule(rule) => {
writeln!(w, "-----")?;
write_blank_lines(&mut w, rule.post_blank)?;
}
Rule => writeln!(w, "-----")?,
Cookie(_cookie) => (),
Title(title) => {
for _ in 0..title.level {
@ -148,29 +193,49 @@ pub trait OrgHandler<E: From<Error>>: Default {
match element {
// container elements
SpecialBlock(block) => writeln!(w, "#+END_{}", block.name)?,
QuoteBlock(_) => writeln!(w, "#+END_QUOTE")?,
CenterBlock(_) => writeln!(w, "#+END_CENTER")?,
VerseBlock(_) => writeln!(w, "#+END_VERSE")?,
SpecialBlock(block) => {
writeln!(&mut w, "#+END_{}", block.name)?;
write_blank_lines(&mut w, block.post_blank)?;
}
QuoteBlock(block) => {
writeln!(&mut w, "#+END_QUOTE")?;
write_blank_lines(&mut w, block.post_blank)?;
}
CenterBlock(block) => {
writeln!(&mut w, "#+END_CENTER")?;
write_blank_lines(&mut w, block.post_blank)?;
}
VerseBlock(block) => {
writeln!(&mut w, "#+END_VERSE")?;
write_blank_lines(&mut w, block.post_blank)?;
}
Bold => write!(w, "*")?,
Document => (),
DynBlock(_dyn_block) => writeln!(w, "#+END:")?,
Document { .. } => (),
DynBlock(dyn_block) => {
writeln!(w, "#+END:")?;
write_blank_lines(w, dyn_block.post_blank)?;
}
Headline { .. } => (),
List(_list) => (),
Italic => write!(w, "/")?,
ListItem(_) => (),
Paragraph => write!(w, "\n\n")?,
Paragraph { post_blank } => {
write_blank_lines(w, post_blank + 1)?;
}
Section => (),
Strike => write!(w, "+")?,
Underline => write!(w, "_")?,
Drawer(_) => writeln!(w, ":END:")?,
Drawer(drawer) => {
writeln!(&mut w, ":END:")?;
write_blank_lines(&mut w, drawer.post_blank)?;
}
Title(title) => {
if !title.tags.is_empty() {
write!(&mut w, " :")?;
}
for tag in &title.tags {
write!(&mut w, "{}:", tag)?;
}
}
writeln!(&mut w)?;
if let Some(planning) = &title.planning {
if let Some(scheduled) = &planning.scheduled {
@ -200,6 +265,7 @@ pub trait OrgHandler<E: From<Error>>: Default {
}
writeln!(&mut w, ":END:")?;
}
write_blank_lines(&mut w, title.post_blank)?;
}
Table(_) => (),
TableRow(_) => (),
@ -212,7 +278,14 @@ pub trait OrgHandler<E: From<Error>>: Default {
}
}
fn write_timestamp<W: Write>(mut w: W, timestamp: &Timestamp) -> std::io::Result<()> {
fn write_blank_lines<W: Write>(mut w: W, count: usize) -> Result<(), Error> {
for _ in 0..count {
writeln!(w)?;
}
Ok(())
}
fn write_timestamp<W: Write>(mut w: W, timestamp: &Timestamp) -> Result<(), Error> {
match timestamp {
Timestamp::Active { start, .. } => {
write_datetime(w, "<", start, ">")?;

4
src/headline.rs
View file

@ -337,7 +337,7 @@ impl Headline {
pub fn new<'a>(ttl: Title<'a>, org: &mut Org<'a>) -> Headline {
let lvl = ttl.level;
let hdl_n = org.arena.new_node(Element::Headline { level: ttl.level });
let ttl_n = org.arena.new_node(Element::Document); // placeholder
let ttl_n = org.arena.new_node(Element::Document { pre_blank: 0 }); // placeholder
hdl_n.append(ttl_n, &mut org.arena);
match ttl.raw {
@ -685,7 +685,7 @@ impl Headline {
pub fn parent(self, org: &Org) -> Option<Headline> {
org.arena[self.hdl_n].parent().and_then(|n| match org[n] {
Element::Headline { level } => Some(Headline::from_node(n, level, org)),
Element::Document => None,
Element::Document { .. } => None,
_ => unreachable!(),
})
}

10
src/org.rs
View file

@ -6,7 +6,7 @@ use crate::{
config::{ParseConfig, DEFAULT_CONFIG},
elements::Element,
export::{DefaultHtmlHandler, DefaultOrgHandler, HtmlHandler, OrgHandler},
parsers::{parse_container, Container},
parsers::{blank_lines, parse_container, Container},
};
pub struct Org<'a> {
@ -24,8 +24,7 @@ impl<'a> Org<'a> {
/// Create a new empty `Org` struct
pub fn new() -> Org<'static> {
let mut arena = Arena::new();
let root = arena.new_node(Element::Document);
let root = arena.new_node(Element::Document { pre_blank: 0 });
Org { arena, root }
}
@ -36,7 +35,10 @@ impl<'a> Org<'a> {
/// Create a new Org struct from parsing `text`, using a custom ParseConfig
pub fn parse_with_config(text: &'a str, config: &ParseConfig) -> Org<'a> {
let mut org = Org::new();
let mut arena = Arena::new();
let (text, blank) = blank_lines(text);
let root = arena.new_node(Element::Document { pre_blank: blank });
let mut org = Org { arena, root };
parse_container(
&mut org.arena,

156
src/parsers.rs
View file

@ -12,10 +12,11 @@ use nom::{bytes::complete::take_while1, combinator::verify, error::ParseError, I
use crate::config::ParseConfig;
use crate::elements::{
block::parse_block_element, emphasis::parse_emphasis, keyword::parse_keyword,
radio_target::parse_radio_target, rule::parse_rule, table::parse_table_el, BabelCall,
CenterBlock, Clock, CommentBlock, Cookie, Drawer, DynBlock, Element, ExampleBlock, ExportBlock,
FnDef, FnRef, InlineCall, InlineSrc, Keyword, Link, List, ListItem, Macros, QuoteBlock,
Snippet, SourceBlock, SpecialBlock, Table, TableRow, Target, Timestamp, Title, VerseBlock,
radio_target::parse_radio_target, table::parse_table_el, BabelCall, CenterBlock, Clock,
Comment, CommentBlock, Cookie, Drawer, DynBlock, Element, ExampleBlock, ExportBlock,
FixedWidth, FnDef, FnRef, InlineCall, InlineSrc, Keyword, Link, List, ListItem, Macros,
QuoteBlock, Rule, Snippet, SourceBlock, SpecialBlock, Table, TableRow, Target, Timestamp,
Title, VerseBlock,
};
pub trait ElementArena<'a> {
@ -216,23 +217,32 @@ pub fn parse_blocks<'a, T: ElementArena<'a>>(
.map(|i| i + 1)
.unwrap_or_else(|| tail.len());
if tail.as_bytes()[0..i].iter().all(u8::is_ascii_whitespace) {
let node = arena.append_element(Element::Paragraph, parent);
let (tail_, blank) = blank_lines(&tail[i..]);
debug_assert_ne!(tail, tail_);
tail = tail_;
let node = arena.append_element(
Element::Paragraph {
// including current line (&tail[0..i])
post_blank: blank + 1,
},
parent,
);
containers.push(Container::Inline {
content: &text[0..pos].trim_end_matches('\n'),
content: &text[0..pos].trim_end(),
node,
});
pos = 0;
debug_assert_ne!(tail, skip_empty_lines(&tail[i..]));
tail = skip_empty_lines(&tail[i..]);
text = tail;
} else if let Some(new_tail) = parse_block(tail, arena, parent, containers) {
if pos != 0 {
let node = arena.insert_before_last_child(Element::Paragraph, parent);
let node =
arena.insert_before_last_child(Element::Paragraph { post_blank: 0 }, parent);
containers.push(Container::Inline {
content: &text[0..pos].trim_end_matches('\n'),
content: &text[0..pos].trim_end(),
node,
});
@ -249,10 +259,10 @@ pub fn parse_blocks<'a, T: ElementArena<'a>>(
}
if !text.is_empty() {
let node = arena.append_element(Element::Paragraph, parent);
let node = arena.append_element(Element::Paragraph { post_blank: 0 }, parent);
containers.push(Container::Inline {
content: &text[0..pos].trim_end_matches('\n'),
content: &text[0..pos].trim_end(),
node,
});
}
@ -264,11 +274,14 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
parent: NodeId,
containers: &mut Vec<Container<'a>>,
) -> Option<&'a str> {
// footnote definitions must be start at column 0
if let Some((tail, (fn_def, content))) = FnDef::parse(contents) {
let node = arena.append_element(fn_def, parent);
containers.push(Container::Block { content, node });
return Some(tail);
} else if let Some((tail, list, content)) = List::parse(contents) {
}
if let Some((tail, list, content)) = List::parse(contents) {
let indent = list.indent;
let node = arena.append_element(list, parent);
containers.push(Container::List {
@ -292,8 +305,8 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
None
}
b'-' => {
let tail = parse_rule(contents)?;
arena.append_element(Element::Rule, parent);
let (tail, rule) = Rule::parse(contents)?;
arena.append_element(rule, parent);
Some(tail)
}
b':' => {
@ -302,9 +315,8 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
containers.push(Container::Block { content, node });
Some(tail)
} else {
let (tail, value) = parse_fixed_width(contents)?;
let value = value.into();
arena.append_element(Element::FixedWidth { value }, parent);
let (tail, fixed_width) = FixedWidth::parse(contents)?;
arena.append_element(fixed_width, parent);
Some(tail)
}
}
@ -313,7 +325,7 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
Some(tail)
}
b'#' => {
if let Some((tail, (name, args, content))) = parse_block_element(contents) {
if let Some((tail, (name, args, content, blank))) = parse_block_element(contents) {
match_block(
arena,
parent,
@ -321,17 +333,19 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
name.into(),
args.map(Into::into),
content,
blank,
);
Some(tail)
} else if let Some((tail, (dyn_block, content))) = DynBlock::parse(contents) {
let node = arena.append_element(dyn_block, parent);
containers.push(Container::Block { content, node });
Some(tail)
} else if let Some((tail, (key, optional, value))) = parse_keyword(contents) {
} else if let Some((tail, (key, optional, value, blank))) = parse_keyword(contents) {
if (&*key).eq_ignore_ascii_case("CALL") {
arena.append_element(
BabelCall {
value: value.into(),
post_blank: blank,
},
parent,
);
@ -341,15 +355,15 @@ pub fn parse_block<'a, T: ElementArena<'a>>(
key: key.into(),
optional: optional.map(Into::into),
value: value.into(),
post_blank: blank,
},
parent,
);
}
Some(tail)
} else {
let (tail, value) = parse_comment(contents)?;
let value = value.into();
arena.append_element(Element::Comment { value }, parent);
let (tail, comment) = Comment::parse(contents)?;
arena.append_element(comment, parent);
Some(tail)
}
}
@ -364,14 +378,43 @@ pub fn match_block<'a, T: ElementArena<'a>>(
name: Cow<'a, str>,
parameters: Option<Cow<'a, str>>,
content: &'a str,
post_blank: usize,
) {
match &*name.to_uppercase() {
"CENTER" => {
let node = arena.append_element(CenterBlock { parameters }, parent);
let (content, pre_blank) = blank_lines(content);
let node = arena.append_element(
CenterBlock {
parameters,
pre_blank,
post_blank,
},
parent,
);
containers.push(Container::Block { content, node });
}
"QUOTE" => {
let node = arena.append_element(QuoteBlock { parameters }, parent);
let (content, pre_blank) = blank_lines(content);
let node = arena.append_element(
QuoteBlock {
parameters,
pre_blank,
post_blank,
},
parent,
);
containers.push(Container::Block { content, node });
}
"VERSE" => {
let (content, pre_blank) = blank_lines(content);
let node = arena.append_element(
VerseBlock {
parameters,
pre_blank,
post_blank,
},
parent,
);
containers.push(Container::Block { content, node });
}
"COMMENT" => {
@ -379,6 +422,7 @@ pub fn match_block<'a, T: ElementArena<'a>>(
CommentBlock {
data: parameters,
contents: content.into(),
post_blank,
},
parent,
);
@ -388,6 +432,7 @@ pub fn match_block<'a, T: ElementArena<'a>>(
ExampleBlock {
data: parameters,
contents: content.into(),
post_blank,
},
parent,
);
@ -397,6 +442,7 @@ pub fn match_block<'a, T: ElementArena<'a>>(
ExportBlock {
data: parameters.unwrap_or_default(),
contents: content.into(),
post_blank,
},
parent,
);
@ -416,16 +462,22 @@ pub fn match_block<'a, T: ElementArena<'a>>(
arguments,
language,
contents: content.into(),
post_blank,
},
parent,
);
}
"VERSE" => {
let node = arena.append_element(VerseBlock { parameters }, parent);
containers.push(Container::Block { content, node });
}
_ => {
let node = arena.append_element(SpecialBlock { parameters, name }, parent);
let (content, pre_blank) = blank_lines(content);
let node = arena.append_element(
SpecialBlock {
parameters,
name,
pre_blank,
post_blank,
},
parent,
);
containers.push(Container::Block { content, node });
}
}
@ -727,26 +779,6 @@ pub fn parse_headline_level(input: &str) -> Option<(&str, usize)> {
}
}
pub fn parse_fixed_width(input: &str) -> Option<(&str, &str)> {
let (input, content) = take_lines_while(|line| line == ":" || line.starts_with(": "))(input);
if !content.is_empty() {
Some((input, content))
} else {
None
}
}
pub fn parse_comment(input: &str) -> Option<(&str, &str)> {
let (input, content) = take_lines_while(|line| line == "#" || line.starts_with("# "))(input);
if !content.is_empty() {
Some((input, content))
} else {
None
}
}
pub fn take_one_word<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&str, &str, E> {
take_while1(|c: char| !c.is_ascii_whitespace())(input)
}
@ -760,3 +792,27 @@ pub fn test_skip_empty_lines() {
assert_eq!(skip_empty_lines(" \n \n\nfoo\n"), "foo\n");
assert_eq!(skip_empty_lines(" \n \n\n foo\n"), " foo\n");
}
pub fn blank_lines(input: &str) -> (&str, usize) {
let bytes = input.as_bytes();
let mut blank = 0;
let mut last_end = 0;
for i in memchr_iter(b'\n', bytes) {
if bytes[last_end..i].iter().all(u8::is_ascii_whitespace) {
blank += 1;
} else {
break;
}
last_end = 1 + i;
}
(&input[last_end..], blank)
}
#[test]
pub fn test_blank_lines() {
assert_eq!(blank_lines("foo"), ("foo", 0));
assert_eq!(blank_lines(" foo"), (" foo", 0));
assert_eq!(blank_lines(" \t\nfoo\n"), ("foo\n", 1));
assert_eq!(blank_lines("\n \r\n\nfoo\n"), ("foo\n", 3));
assert_eq!(blank_lines("\r\n \n \r\n foo\n"), (" foo\n", 3));
}

4
src/validate.rs
View file

@ -64,7 +64,7 @@ impl Org<'_> {
for node_id in self.root.descendants(&self.arena) {
let node = &self.arena[node_id];
match node.get() {
Element::Document => {
Element::Document { .. } => {
let mut children = node_id.children(&self.arena);
if let Some(node) = children.next() {
expect!(
@ -132,7 +132,7 @@ impl Org<'_> {
| Element::Comment { .. }
| Element::FixedWidth { .. }
| Element::Keyword(_)
| Element::Rule
| Element::Rule(_)
| Element::Cookie(_)
| Element::Table(Table::TableEl { .. })
| Element::TableRow(TableRow::Rule) => {

66
tests/blank.rs Normal file
View file

@ -0,0 +1,66 @@
use orgize::Org;
const ORG_STR: &str = r#"
#+TITLE: org
#+BEGIN_QUOTE
CONTENTS
#+END_QUOTE
* Headline 1
SCHEDULED: <2019-10-28 Mon>
:PROPERTIES:
:ID: headline-1
:END:
:LOGBOOK:
CLOCK: [2019-10-28 Mon 08:53]
CLOCK: [2019-10-28 Mon 08:53]--[2019-10-28 Mon 08:53] => 0:00
:END:
-----
#+CALL: VALUE
#
# Comment
#
#+BEGIN: NAME PARAMETERS
CONTENTS
#+END:
:
: Fixed width
:
#+BEGIN_COMMENT
COMMENT
#+END_COMMENT
#+BEGIN_EXAMPLE
#+END_EXAMPLE
"#;
#[test]
fn blank() {
let org = Org::parse(ORG_STR);
let mut writer = Vec::new();
org.org(&mut writer).unwrap();
// eprintln!("{}", serde_json::to_string_pretty(&org).unwrap());
assert_eq!(String::from_utf8(writer).unwrap(), ORG_STR);
}