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

chore: rename feature serde to ser

Browse source
This commit is contained in:
PoiScript 2019-08-06 14:29:32 +08:00
parent 3e4772a896
commit e3c7e9897c
26 changed files with 96 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

@ -16,7 +16,8 @@ all-features = true
travis-ci = { repository = "PoiScript/orgize" } travis-ci = { repository = "PoiScript/orgize" }
[features] [features]
default = ["serde"] default = ["ser"]
ser = ["serde", "serde_indextree"]
[dependencies] [dependencies]
bytecount = "0.5.1" bytecount = "0.5.1"
@ -26,6 +27,7 @@ jetscii = "0.4.4"
memchr = "2.2.1" memchr = "2.2.1"
nom = "5.0.0" nom = "5.0.0"
serde = { version = "1.0.98", optional = true, features = ["derive"] } serde = { version = "1.0.98", optional = true, features = ["derive"] }
serde_indextree = { version = "0.1.0", optional = true }
[dev-dependencies] [dev-dependencies]
lazy_static = "1.3.0" lazy_static = "1.3.0"

2
README.md
View file

@ -195,7 +195,7 @@ println!("{}", to_string(&org).unwrap());
By now, orgize provides two features: By now, orgize provides two features:
+ `serde`: adds the ability to serialize `Org` and other elements using `serde`, enabled by default. + `ser`: adds the ability to serialize `Org` and other elements using `serde`, enabled by default.
+ `chrono`: adds the ability to convert `Datetime` into `chrono` structs, disabled by default. + `chrono`: adds the ability to convert `Datetime` into `chrono` structs, disabled by default.

16
src/elements/block.rs
View file

@ -64,7 +64,7 @@ fn parse() {
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct SpecialBlock<'a> { pub struct SpecialBlock<'a> {
pub parameters: Option<&'a str>, pub parameters: Option<&'a str>,
pub name: &'a str, pub name: &'a str,
@ -72,28 +72,28 @@ pub struct SpecialBlock<'a> {
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct QuoteBlock<'a> { pub struct QuoteBlock<'a> {
pub parameters: Option<&'a str>, pub parameters: Option<&'a str>,
} }
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct CenterBlock<'a> { pub struct CenterBlock<'a> {
pub parameters: Option<&'a str>, pub parameters: Option<&'a str>,
} }
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct VerseBlock<'a> { pub struct VerseBlock<'a> {
pub parameters: Option<&'a str>, pub parameters: Option<&'a str>,
} }
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct CommentBlock<'a> { pub struct CommentBlock<'a> {
pub data: Option<&'a str>, pub data: Option<&'a str>,
pub contents: &'a str, pub contents: &'a str,
@ -101,7 +101,7 @@ pub struct CommentBlock<'a> {
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct ExampleBlock<'a> { pub struct ExampleBlock<'a> {
pub data: Option<&'a str>, pub data: Option<&'a str>,
pub contents: &'a str, pub contents: &'a str,
@ -109,7 +109,7 @@ pub struct ExampleBlock<'a> {
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct ExportBlock<'a> { pub struct ExportBlock<'a> {
pub data: &'a str, pub data: &'a str,
pub contents: &'a str, pub contents: &'a str,
@ -117,7 +117,7 @@ pub struct ExportBlock<'a> {
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
pub struct SourceBlock<'a> { pub struct SourceBlock<'a> {
pub contents: &'a str, pub contents: &'a str,
pub language: &'a str, pub language: &'a str,

12
src/elements/clock.rs
View file

@ -13,26 +13,26 @@ use crate::parsers::eol;
/// ///
/// there are two types of clock: *closed* clock and *running* clock. /// there are two types of clock: *closed* clock and *running* clock.
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(untagged))] #[cfg_attr(feature = "ser", serde(untagged))]
#[derive(Debug)] #[derive(Debug)]
pub enum Clock<'a> { pub enum Clock<'a> {
/// closed Clock /// closed Clock
Closed { Closed {
start: Datetime<'a>, start: Datetime<'a>,
end: Datetime<'a>, end: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
duration: &'a str, duration: &'a str,
}, },
/// running Clock /// running Clock
Running { Running {
start: Datetime<'a>, start: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
}, },
} }

2
src/elements/cookie.rs
View file

@ -8,7 +8,7 @@ use nom::{
}; };
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Cookie<'a> { pub struct Cookie<'a> {
pub value: &'a str, pub value: &'a str,

2
src/elements/drawer.rs
View file

@ -7,7 +7,7 @@ use nom::{
}; };
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Drawer<'a> { pub struct Drawer<'a> {
pub name: &'a str, pub name: &'a str,

4
src/elements/dyn_block.rs
View file

@ -8,11 +8,11 @@ use nom::{
}; };
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct DynBlock<'a> { pub struct DynBlock<'a> {
pub block_name: &'a str, pub block_name: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub arguments: Option<&'a str>, pub arguments: Option<&'a str>,
} }

2
src/elements/fn_def.rs
View file

@ -6,7 +6,7 @@ use nom::{
}; };
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct FnDef<'a> { pub struct FnDef<'a> {
pub label: &'a str, pub label: &'a str,

4
src/elements/fn_ref.rs
View file

@ -9,11 +9,11 @@ use nom::{
}; };
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct FnRef<'a> { pub struct FnRef<'a> {
pub label: &'a str, pub label: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub definition: Option<&'a str>, pub definition: Option<&'a str>,
} }

6
src/elements/inline_call.rs
View file

@ -8,14 +8,14 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct InlineCall<'a> { pub struct InlineCall<'a> {
pub name: &'a str, pub name: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub inside_header: Option<&'a str>, pub inside_header: Option<&'a str>,
pub arguments: &'a str, pub arguments: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub end_header: Option<&'a str>, pub end_header: Option<&'a str>,
} }

4
src/elements/inline_src.rs
View file

@ -8,11 +8,11 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct InlineSrc<'a> { pub struct InlineSrc<'a> {
pub lang: &'a str, pub lang: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub options: Option<&'a str>, pub options: Option<&'a str>,
pub body: &'a str, pub body: &'a str,
} }

6
src/elements/keyword.rs
View file

@ -9,17 +9,17 @@ use crate::elements::Element;
use crate::parsers::take_until_eol; use crate::parsers::take_until_eol;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Keyword<'a> { pub struct Keyword<'a> {
pub key: &'a str, pub key: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub optional: Option<&'a str>, pub optional: Option<&'a str>,
pub value: &'a str, pub value: &'a str,
} }
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct BabelCall<'a> { pub struct BabelCall<'a> {
pub value: &'a str, pub value: &'a str,

4
src/elements/link.rs
View file

@ -8,11 +8,11 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Link<'a> { pub struct Link<'a> {
pub path: &'a str, pub path: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub desc: Option<&'a str>, pub desc: Option<&'a str>,
} }

4
src/elements/list.rs
View file

@ -2,7 +2,7 @@ use memchr::memchr_iter;
use std::iter::once; use std::iter::once;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct List { pub struct List {
pub indent: usize, pub indent: usize,
@ -62,7 +62,7 @@ impl List {
} }
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct ListItem<'a> { pub struct ListItem<'a> {
pub bullet: &'a str, pub bullet: &'a str,

4
src/elements/macros.rs
View file

@ -8,11 +8,11 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Macros<'a> { pub struct Macros<'a> {
pub name: &'a str, pub name: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub arguments: Option<&'a str>, pub arguments: Option<&'a str>,
} }

4
src/elements/mod.rs
View file

@ -56,8 +56,8 @@ pub use self::{
/// Org-mode element enum /// Org-mode element enum
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "type", rename_all = "kebab-case"))] #[cfg_attr(feature = "ser", serde(tag = "type", rename_all = "kebab-case"))]
pub enum Element<'a> { pub enum Element<'a> {
SpecialBlock(SpecialBlock<'a>), SpecialBlock(SpecialBlock<'a>),
QuoteBlock(QuoteBlock<'a>), QuoteBlock(QuoteBlock<'a>),

8
src/elements/planning.rs
View file

@ -4,17 +4,17 @@ use crate::elements::Timestamp;
/// palnning elements /// palnning elements
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Planning<'a> { pub struct Planning<'a> {
/// the date when the task should be done /// the date when the task should be done
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub deadline: Option<Timestamp<'a>>, pub deadline: Option<Timestamp<'a>>,
/// the date when you should start working on the task /// the date when you should start working on the task
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub scheduled: Option<Timestamp<'a>>, pub scheduled: Option<Timestamp<'a>>,
/// the date when the task is closed /// the date when the task is closed
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub closed: Option<Timestamp<'a>>, pub closed: Option<Timestamp<'a>>,
} }

2
src/elements/radio_target.rs
View file

@ -9,7 +9,7 @@ use crate::elements::Element;
// TODO: text-markup, entities, latex-fragments, subscript and superscript // TODO: text-markup, entities, latex-fragments, subscript and superscript
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct RadioTarget; pub struct RadioTarget;

2
src/elements/snippet.rs
View file

@ -7,7 +7,7 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Snippet<'a> { pub struct Snippet<'a> {
pub name: &'a str, pub name: &'a str,

12
src/elements/table.rs
View file

@ -1,19 +1,19 @@
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "table_type"))] #[cfg_attr(feature = "ser", serde(tag = "table_type"))]
pub enum Table<'a> { pub enum Table<'a> {
#[cfg_attr(feature = "serde", serde(rename = "org"))] #[cfg_attr(feature = "ser", serde(rename = "org"))]
Org { tblfm: Option<&'a str> }, Org { tblfm: Option<&'a str> },
#[cfg_attr(feature = "serde", serde(rename = "table.el"))] #[cfg_attr(feature = "ser", serde(rename = "table.el"))]
TableEl { value: &'a str }, TableEl { value: &'a str },
} }
#[derive(Debug)] #[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr( #[cfg_attr(
feature = "serde", feature = "ser",
serde(tag = "table_row_type", rename_all = "kebab-case") serde(tag = "table_row_type", rename_all = "kebab-case")
)] )]
pub enum TableRow { pub enum TableRow {

2
src/elements/target.rs
View file

@ -8,7 +8,7 @@ use nom::{
use crate::elements::Element; use crate::elements::Element;
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Target<'a> { pub struct Target<'a> {
pub target: &'a str, pub target: &'a str,

39
src/elements/timestamp.rs
View file

@ -15,16 +15,16 @@ use nom::{
/// ``` /// ```
/// ///
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Datetime<'a> { pub struct Datetime<'a> {
pub year: u16, pub year: u16,
pub month: u8, pub month: u8,
pub day: u8, pub day: u8,
pub dayname: &'a str, pub dayname: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub hour: Option<u8>, pub hour: Option<u8>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub minute: Option<u8>, pub minute: Option<u8>,
} }
@ -104,38 +104,41 @@ mod chrono {
} }
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "timestamp_type", rename_all = "kebab-case"))] #[cfg_attr(
feature = "ser",
serde(tag = "timestamp_type", rename_all = "kebab-case")
)]
#[derive(Debug)] #[derive(Debug)]
pub enum Timestamp<'a> { pub enum Timestamp<'a> {
Active { Active {
start: Datetime<'a>, start: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
}, },
Inactive { Inactive {
start: Datetime<'a>, start: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
}, },
ActiveRange { ActiveRange {
start: Datetime<'a>, start: Datetime<'a>,
end: Datetime<'a>, end: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
}, },
InactiveRange { InactiveRange {
start: Datetime<'a>, start: Datetime<'a>,
end: Datetime<'a>, end: Datetime<'a>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
repeater: Option<&'a str>, repeater: Option<&'a str>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
delay: Option<&'a str>, delay: Option<&'a str>,
}, },
Diary { Diary {
@ -261,7 +264,7 @@ impl Timestamp<'_> {
// TODO // TODO
// #[cfg_attr(test, derive(PartialEq))] // #[cfg_attr(test, derive(PartialEq))]
// #[cfg_attr(feature = "serde", derive(serde::Serialize))] // #[cfg_attr(feature = "ser", derive(serde::Serialize))]
// #[derive(Debug, Copy, Clone)] // #[derive(Debug, Copy, Clone)]
// pub enum RepeaterType { // pub enum RepeaterType {
// Cumulate, // Cumulate,
@ -270,7 +273,7 @@ impl Timestamp<'_> {
// } // }
// #[cfg_attr(test, derive(PartialEq))] // #[cfg_attr(test, derive(PartialEq))]
// #[cfg_attr(feature = "serde", derive(serde::Serialize))] // #[cfg_attr(feature = "ser", derive(serde::Serialize))]
// #[derive(Debug, Copy, Clone)] // #[derive(Debug, Copy, Clone)]
// pub enum DelayType { // pub enum DelayType {
// All, // All,
@ -278,7 +281,7 @@ impl Timestamp<'_> {
// } // }
// #[cfg_attr(test, derive(PartialEq))] // #[cfg_attr(test, derive(PartialEq))]
// #[cfg_attr(feature = "serde", derive(serde::Serialize))] // #[cfg_attr(feature = "ser", derive(serde::Serialize))]
// #[derive(Debug, Copy, Clone)] // #[derive(Debug, Copy, Clone)]
// pub enum TimeUnit { // pub enum TimeUnit {
// Hour, // Hour,
@ -289,7 +292,7 @@ impl Timestamp<'_> {
// } // }
// #[cfg_attr(test, derive(PartialEq))] // #[cfg_attr(test, derive(PartialEq))]
// #[cfg_attr(feature = "serde", derive(serde::Serialize))] // #[cfg_attr(feature = "ser", derive(serde::Serialize))]
// #[derive(Debug, Copy, Clone)] // #[derive(Debug, Copy, Clone)]
// pub struct Repeater { // pub struct Repeater {
// pub ty: RepeaterType, // pub ty: RepeaterType,
@ -298,7 +301,7 @@ impl Timestamp<'_> {
// } // }
// #[cfg_attr(test, derive(PartialEq))] // #[cfg_attr(test, derive(PartialEq))]
// #[cfg_attr(feature = "serde", derive(serde::Serialize))] // #[cfg_attr(feature = "ser", derive(serde::Serialize))]
// #[derive(Debug, Copy, Clone)] // #[derive(Debug, Copy, Clone)]
// pub struct Delay { // pub struct Delay {
// pub ty: DelayType, // pub ty: DelayType,

12
src/elements/title.rs
View file

@ -17,24 +17,24 @@ use crate::elements::{Drawer, Planning};
use crate::parsers::{skip_empty_lines, take_one_word, take_until_eol}; use crate::parsers::{skip_empty_lines, take_one_word, take_until_eol};
#[cfg_attr(test, derive(PartialEq))] #[cfg_attr(test, derive(PartialEq))]
#[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "ser", derive(serde::Serialize))]
#[derive(Debug)] #[derive(Debug)]
pub struct Title<'a> { pub struct Title<'a> {
/// headline level, number of stars /// headline level, number of stars
pub level: usize, pub level: usize,
/// priority cookie /// priority cookie
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub priority: Option<char>, pub priority: Option<char>,
/// headline tags, including the sparated colons /// headline tags, including the sparated colons
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Vec::is_empty"))]
pub tags: Vec<&'a str>, pub tags: Vec<&'a str>,
/// headline keyword /// headline keyword
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub keyword: Option<&'a str>, pub keyword: Option<&'a str>,
pub raw: &'a str, pub raw: &'a str,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "Option::is_none"))]
pub planning: Option<Box<Planning<'a>>>, pub planning: Option<Box<Planning<'a>>>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "HashMap::is_empty"))] #[cfg_attr(feature = "ser", serde(skip_serializing_if = "HashMap::is_empty"))]
pub properties: HashMap<&'a str, &'a str>, pub properties: HashMap<&'a str, &'a str>,
} }

4
src/lib.rs
View file

@ -206,7 +206,7 @@
//! //!
//! By now, orgize provides two features: //! By now, orgize provides two features:
//! //!
//! + `serde`: adds the ability to serialize `Org` and other elements using `serde`, enabled by default. //! + `ser`: adds the ability to serialize `Org` and other elements using `serde`, enabled by default.
//! //!
//! + `chrono`: adds the ability to convert `Datetime` into `chrono` structs, disabled by default. //! + `chrono`: adds the ability to convert `Datetime` into `chrono` structs, disabled by default.
//! //!
@ -221,8 +221,6 @@ pub mod elements;
pub mod export; pub mod export;
mod org; mod org;
mod parsers; mod parsers;
#[cfg(feature = "serde")]
mod serde;
pub use config::ParseConfig; pub use config::ParseConfig;
pub use elements::Element; pub use elements::Element;

16
src/org.rs
View file

@ -7,8 +7,8 @@ use crate::export::*;
use crate::parsers::*; use crate::parsers::*;
pub struct Org<'a> { pub struct Org<'a> {
pub(crate) arena: Arena<Element<'a>>, arena: Arena<Element<'a>>,
pub(crate) document: NodeId, document: NodeId,
} }
#[derive(Debug)] #[derive(Debug)]
@ -108,3 +108,15 @@ impl Org<'_> {
Ok(()) Ok(())
} }
} }
#[cfg(feature = "ser")]
use serde::{ser::Serializer, Serialize};
#[cfg(feature = "ser")]
impl Serialize for Org<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde_indextree::Node;
serializer.serialize_newtype_struct("Node", &Node::new(self.document, &self.arena))
}
}

48
src/serde.rs
View file

@ -1,48 +0,0 @@
use indextree::{Arena, NodeId};
use serde::ser::{SerializeSeq, Serializer};
use serde::Serialize;
use crate::elements::Element;
use crate::org::Org;
impl Serialize for Org<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer
.serialize_newtype_struct("ElementNode", &ElementNode::new(self.document, &self.arena))
}
}
#[derive(Serialize)]
struct ElementNode<'a> {
#[serde(flatten)]
element: &'a Element<'a>,
#[serde(skip_serializing_if = "Option::is_none")]
children: Option<ElementChildrenNode<'a>>,
}
impl<'a> ElementNode<'a> {
fn new(node_id: NodeId, arena: &'a Arena<Element<'a>>) -> Self {
let node = &arena[node_id];
ElementNode {
element: &node.data,
children: node
.first_child()
.map(|first| ElementChildrenNode { first, arena }),
}
}
}
struct ElementChildrenNode<'a> {
first: NodeId,
arena: &'a Arena<Element<'a>>,
}
impl Serialize for ElementChildrenNode<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut seq = serializer.serialize_seq(None)?;
for node in self.first.following_siblings(&self.arena) {
seq.serialize_element(&ElementNode::new(node, &self.arena))?;
}
seq.end()
}
}