chore: rename feature serde to ser

src/elements/block.rs

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

src/elements/clock.rs

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

src/elements/cookie.rs

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

src/elements/drawer.rs

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

src/elements/dyn_block.rs

@@ -8,11 +8,11 @@ use nom::{
 };
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct DynBlock<'a> {
     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>,
 }
 

src/elements/fn_def.rs

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

src/elements/fn_ref.rs

@@ -9,11 +9,11 @@ use nom::{
 };
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct FnRef<'a> {
     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>,
 }
 

src/elements/inline_call.rs

@@ -8,14 +8,14 @@ use nom::{
 use crate::elements::Element;
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct InlineCall<'a> {
     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 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>,
 }
 

src/elements/inline_src.rs

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

src/elements/keyword.rs

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

src/elements/link.rs

@@ -8,11 +8,11 @@ use nom::{
 use crate::elements::Element;
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct Link<'a> {
     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>,
 }
 

src/elements/list.rs

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

src/elements/macros.rs

@@ -8,11 +8,11 @@ use nom::{
 use crate::elements::Element;
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct Macros<'a> {
     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>,
 }
 

src/elements/mod.rs

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

src/elements/planning.rs

@@ -4,17 +4,17 @@ use crate::elements::Timestamp;
 
 /// palnning elements
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct Planning<'a> {
     /// 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>>,
     /// 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>>,
     /// 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>>,
 }
 

src/elements/radio_target.rs

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

src/elements/snippet.rs

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

src/elements/table.rs

@@ -1,19 +1,19 @@
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(tag = "table_type"))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", serde(tag = "table_type"))]
 pub enum Table<'a> {
-    #[cfg_attr(feature = "serde", serde(rename = "org"))]
+    #[cfg_attr(feature = "ser", serde(rename = "org"))]
     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 },
 }
 
 #[derive(Debug)]
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[cfg_attr(
-    feature = "serde",
+    feature = "ser",
     serde(tag = "table_row_type", rename_all = "kebab-case")
 )]
 pub enum TableRow {

src/elements/target.rs

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

src/elements/timestamp.rs

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

src/elements/title.rs

@@ -17,24 +17,24 @@ use crate::elements::{Drawer, Planning};
 use crate::parsers::{skip_empty_lines, take_one_word, take_until_eol};
 
 #[cfg_attr(test, derive(PartialEq))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 #[derive(Debug)]
 pub struct Title<'a> {
     /// headline level, number of stars
     pub level: usize,
     /// 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>,
     /// 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>,
     /// 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 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>>>,
-    #[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>,
 }