Remve redundant org_spaces functions.

Turns out the nom space0/space1 parsers accept tab characters already.

src/parser/fixed_width_area.rs

@@ -3,6 +3,7 @@ use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
+use nom::character::complete::space1;
 use nom::combinator::eof;
 use nom::combinator::not;
 use nom::combinator::recognize;
@@ -12,8 +13,6 @@ use nom::sequence::tuple;
 
 use super::org_source::OrgSource;
 use super::util::org_line_ending;
-use super::util::org_spaces0;
-use super::util::org_spaces1;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::Res;
@@ -51,7 +50,7 @@ fn fixed_width_area_line<'b, 'g, 'r, 's>(
     let (remaining, _indent) = space0(input)?;
     let (remaining, _) = tuple((
         tag(":"),
-        alt((recognize(tuple((org_spaces1, is_not("\r\n")))), org_spaces0)),
+        alt((recognize(tuple((space1, is_not("\r\n")))), space0)),
         org_line_ending,
     ))(remaining)?;
     let source = get_consumed(input, remaining);

src/parser/headline.rs

@@ -1,6 +1,7 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
+use nom::character::complete::space0;
 use nom::character::complete::space1;
 use nom::combinator::map;
 use nom::combinator::not;
@@ -20,8 +21,6 @@ use super::util::get_consumed;
 use super::util::org_line_ending;
 use super::util::org_space;
 use super::util::org_space_or_line_ending;
-use super::util::org_spaces0;
-use super::util::org_spaces1;
 use super::util::start_of_line;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
@@ -134,27 +133,27 @@ fn headline<'b, 'g, 'r, 's>(
     ))(input)?;
 
     let (remaining, maybe_todo_keyword) = opt(tuple((
-        org_spaces1,
+        space1,
         parser_with_context!(heading_keyword)(&parser_context),
         peek(org_space_or_line_ending),
     )))(remaining)?;
 
-    let (remaining, maybe_priority) = opt(tuple((org_spaces1, priority_cookie)))(remaining)?;
+    let (remaining, maybe_priority) = opt(tuple((space1, priority_cookie)))(remaining)?;
 
     let (remaining, maybe_comment) = opt(tuple((
-        org_spaces1,
+        space1,
         tag("COMMENT"),
         peek(org_space_or_line_ending),
     )))(remaining)?;
 
     let (remaining, maybe_title) = opt(tuple((
-        org_spaces1,
+        space1,
         many1(parser_with_context!(standard_set_object)(&parser_context)),
     )))(remaining)?;
 
-    let (remaining, maybe_tags) = opt(tuple((org_spaces0, tags)))(remaining)?;
+    let (remaining, maybe_tags) = opt(tuple((space0, tags)))(remaining)?;
 
-    let (remaining, _) = tuple((org_spaces0, org_line_ending))(remaining)?;
+    let (remaining, _) = tuple((space0, org_line_ending))(remaining)?;
 
     Ok((
         remaining,
@@ -180,11 +179,7 @@ fn headline_title_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    recognize(tuple((
-        org_spaces0,
-        opt(tuple((tags, org_spaces0))),
-        org_line_ending,
-    )))(input)
+    recognize(tuple((space0, opt(tuple((tags, space0))), org_line_ending)))(input)
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/parser/planning.rs

@@ -1,6 +1,8 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::bytes::complete::tag_no_case;
+use nom::character::complete::space0;
+use nom::character::complete::space1;
 use nom::multi::many1;
 use nom::sequence::tuple;
 
@@ -8,8 +10,6 @@ use super::org_source::OrgSource;
 use super::timestamp::timestamp;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use super::util::org_line_ending;
-use super::util::org_spaces0;
-use super::util::org_spaces1;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::Res;
@@ -23,10 +23,10 @@ pub(crate) fn planning<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Planning<'s>> {
     start_of_line(input)?;
-    let (remaining, _leading_whitespace) = org_spaces0(input)?;
+    let (remaining, _leading_whitespace) = space0(input)?;
     let (remaining, _planning_parameters) =
         many1(parser_with_context!(planning_parameter)(context))(remaining)?;
-    let (remaining, _trailing_ws) = tuple((org_spaces0, org_line_ending))(remaining)?;
+    let (remaining, _trailing_ws) = tuple((space0, org_line_ending))(remaining)?;
 
     let (remaining, _trailing_ws) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
@@ -50,7 +50,7 @@ fn planning_parameter<'b, 'g, 'r, 's>(
         tag_no_case("SCHEDULED"),
         tag_no_case("CLOSED"),
     ))(input)?;
-    let (remaining, _gap) = tuple((tag(":"), org_spaces1))(remaining)?;
+    let (remaining, _gap) = tuple((tag(":"), space1))(remaining)?;
     let (remaining, _timestamp) = timestamp(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((remaining, source))

src/parser/util.rs

@@ -1,5 +1,4 @@
 use nom::branch::alt;
-use nom::bytes::complete::is_a;
 use nom::character::complete::anychar;
 use nom::character::complete::line_ending;
 use nom::character::complete::none_of;
@@ -10,11 +9,9 @@ use nom::combinator::not;
 use nom::combinator::opt;
 use nom::combinator::peek;
 use nom::combinator::recognize;
-use nom::combinator::verify;
 use nom::multi::many0;
 use nom::multi::many_till;
 use nom::sequence::tuple;
-use nom::Slice;
 
 use super::org_source::OrgSource;
 use crate::context::parser_with_context;
@@ -246,24 +243,6 @@ pub(crate) fn org_space_or_line_ending<'s>(
     alt((recognize(one_of(" \t")), org_line_ending))(input)
 }
 
-/// Match as many spaces and tabs as possible. No minimum match.
-///
-/// In org-mode syntax, spaces and tabs are interchangeable.
-pub(crate) fn org_spaces0<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    let found = is_a(" \t")(input);
-    if found.is_ok() {
-        return found;
-    }
-    Ok((input, input.slice(..0)))
-}
-
-/// Match as many spaces and tabs as possible. Minimum 1 character.
-///
-/// In org-mode syntax, spaces and tabs are interchangeable.
-pub(crate) fn org_spaces1<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    verify(is_a(" \t"), |res: &OrgSource<'_>| res.len() > 0)(input)
-}
-
 /// Match a line break or the end of the file.
 ///
 /// In org-mode syntax, the end of the file can serve the same purpose as a line break syntactically.