shrink visibility of types/functions

Author: yuankunzhang

src/items/combined.rs

@@ -27,12 +27,12 @@ use super::{
 };
 
 #[derive(PartialEq, Debug, Clone, Default)]
-pub struct DateTime {
+pub(crate) struct DateTime {
     pub(crate) date: Date,
     pub(crate) time: Time,
 }
 
-pub fn parse(input: &mut &str) -> ModalResult<DateTime> {
+pub(super) fn parse(input: &mut &str) -> ModalResult<DateTime> {
     seq!(DateTime {
         date: trace("date iso", alt((date::iso1, date::iso2))),
         // Note: the `T` is lowercased by the main parse function

src/items/date.rs

@@ -39,20 +39,20 @@ use super::{dec_uint, s};
 use crate::ParseDateTimeError;
 
 #[derive(PartialEq, Eq, Clone, Debug, Default)]
-pub struct Date {
-    pub day: u32,
-    pub month: u32,
-    pub year: Option<u32>,
+pub(crate) struct Date {
+    pub(crate) day: u32,
+    pub(crate) month: u32,
+    pub(crate) year: Option<u32>,
 }
 
-pub fn parse(input: &mut &str) -> ModalResult<Date> {
+pub(super) fn parse(input: &mut &str) -> ModalResult<Date> {
     alt((iso1, iso2, us, literal1, literal2)).parse_next(input)
 }
 
 /// Parse `YYYY-MM-DD` or `YY-MM-DD`
 ///
 /// This is also used by [`combined`](super::combined).
-pub fn iso1(input: &mut &str) -> ModalResult<Date> {
+pub(super) fn iso1(input: &mut &str) -> ModalResult<Date> {
     seq!(Date {
         year: year.map(Some),
         _: s('-'),
@@ -66,7 +66,7 @@ pub fn iso1(input: &mut &str) -> ModalResult<Date> {
 /// Parse `YYYYMMDD`
 ///
 /// This is also used by [`combined`](super::combined).
-pub fn iso2(input: &mut &str) -> ModalResult<Date> {
+pub(super) fn iso2(input: &mut &str) -> ModalResult<Date> {
     s((
         take(4usize).try_map(|s: &str| s.parse::<u32>()),
         take(2usize).try_map(|s: &str| s.parse::<u32>()),
@@ -114,7 +114,7 @@ fn literal2(input: &mut &str) -> ModalResult<Date> {
     .parse_next(input)
 }
 
-pub fn year(input: &mut &str) -> ModalResult<u32> {
+pub(super) fn year(input: &mut &str) -> ModalResult<u32> {
     // 2147485547 is the maximum value accepted
     // by GNU, but chrono only behaves like GNU
     // for years in the range: [0, 9999], so we

src/items/mod.rs

@@ -38,7 +38,7 @@ mod epoch {
     use winnow::{combinator::preceded, ModalResult, Parser};
 
     use super::{dec_int, s};
-    pub fn parse(input: &mut &str) -> ModalResult<i32> {
+    pub(super) fn parse(input: &mut &str) -> ModalResult<i32> {
         s(preceded("@", dec_int)).parse_next(input)
     }
 }
@@ -47,7 +47,7 @@ mod timezone {
     use super::time;
     use winnow::ModalResult;
 
-    pub(crate) fn parse(input: &mut &str) -> ModalResult<time::Offset> {
+    pub(super) fn parse(input: &mut &str) -> ModalResult<time::Offset> {
         time::timezone(input)
     }
 }
@@ -67,7 +67,7 @@ use winnow::{
 use crate::ParseDateTimeError;
 
 #[derive(PartialEq, Debug)]
-pub enum Item {
+pub(crate) enum Item {
     Timestamp(i32),
     Year(u32),
     DateTime(combined::DateTime),
@@ -177,7 +177,7 @@ where
 }
 
 // Parse an item
-pub fn parse_one(input: &mut &str) -> ModalResult<Item> {
+fn parse_one(input: &mut &str) -> ModalResult<Item> {
     trace(
         "parse_one",
         alt((
@@ -202,7 +202,7 @@ fn expect_error(input: &mut &str, reason: &'static str) -> ErrMode<ContextError>
     )
 }
 
-pub fn parse(input: &mut &str) -> ModalResult<Vec<Item>> {
+pub(crate) fn parse(input: &mut &str) -> ModalResult<Vec<Item>> {
     let mut items = Vec::new();
     let mut date_seen = false;
     let mut time_seen = false;

src/items/ordinal.rs

@@ -8,7 +8,7 @@ use winnow::{
     ModalResult, Parser,
 };
 
-pub fn ordinal(input: &mut &str) -> ModalResult<i32> {
+pub(super) fn ordinal(input: &mut &str) -> ModalResult<i32> {
     alt((text_ordinal, number_ordinal)).parse_next(input)
 }
 

src/items/relative.rs

@@ -40,7 +40,7 @@ use winnow::{
 use super::{ordinal::ordinal, s};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Relative {
+pub(crate) enum Relative {
     Years(i32),
     Months(i32),
     Days(i32),
@@ -63,7 +63,7 @@ impl Relative {
     }
 }
 
-pub fn parse(input: &mut &str) -> ModalResult<Relative> {
+pub(super) fn parse(input: &mut &str) -> ModalResult<Relative> {
     alt((
         s("tomorrow").value(Relative::Days(1)),
         s("yesterday").value(Relative::Days(-1)),

src/items/time.rs

@@ -53,18 +53,18 @@ use winnow::{
 use super::{dec_uint, relative, s};
 
 #[derive(PartialEq, Debug, Clone, Default)]
-pub struct Offset {
+pub(crate) struct Offset {
     pub(crate) negative: bool,
     pub(crate) hours: u32,
     pub(crate) minutes: u32,
 }
 
 #[derive(PartialEq, Clone, Debug, Default)]
-pub struct Time {
-    pub hour: u32,
-    pub minute: u32,
-    pub second: f64,
-    pub offset: Option<Offset>,
+pub(crate) struct Time {
+    pub(crate) hour: u32,
+    pub(crate) minute: u32,
+    pub(crate) second: f64,
+    pub(crate) offset: Option<Offset>,
 }
 
 impl Offset {
@@ -132,14 +132,14 @@ enum Suffix {
     Pm,
 }
 
-pub fn parse(input: &mut &str) -> ModalResult<Time> {
+pub(crate) fn parse(input: &mut &str) -> ModalResult<Time> {
     alt((am_pm_time, iso)).parse_next(input)
 }
 
 /// Parse an ISO 8601 time string
 ///
 /// Also used by the [`combined`](super::combined) module
-pub fn iso(input: &mut &str) -> ModalResult<Time> {
+pub(super) fn iso(input: &mut &str) -> ModalResult<Time> {
     alt((
         (hour24, timezone).map(|(hour, offset)| Time {
             hour,
@@ -213,7 +213,7 @@ fn second(input: &mut &str) -> ModalResult<f64> {
     s(float).verify(|x| *x < 60.0).parse_next(input)
 }
 
-pub(crate) fn timezone(input: &mut &str) -> ModalResult<Offset> {
+pub(super) fn timezone(input: &mut &str) -> ModalResult<Offset> {
     alt((timezone_num, timezone_name_offset)).parse_next(input)
 }
 

src/items/weekday.rs

@@ -37,7 +37,7 @@ pub(crate) enum Day {
 }
 
 #[derive(PartialEq, Eq, Debug)]
-pub struct Weekday {
+pub(crate) struct Weekday {
     pub(crate) offset: i32,
     pub(crate) day: Day,
 }
@@ -55,7 +55,7 @@ impl From<Day> for chrono::Weekday {
         }
     }
 }
-pub fn parse(input: &mut &str) -> ModalResult<Weekday> {
+pub(super) fn parse(input: &mut &str) -> ModalResult<Weekday> {
     seq!(Weekday {
         offset: opt(ordinal).map(|o| o.unwrap_or_default()),
         day: day,