Merge #30

30: Handle panic from large integers r=bspeice a=gillespiecd

1. Opt to use `NaiveDate::from_ymd_opt` so that a panic can be avoided, this will handle the issue with large integers causing panics.

I added the test case from the issue (and another), which should hopefully fix #26 .

Co-authored-by: Chris Gillespie <6572184+gillespiecd@users.noreply.github.com>

.travis.yml

@@ -1,126 +1,40 @@
-# Based on the "trust" template v0.1.2
-# https://github.com/japaric/trust/tree/v0.1.2
-
-dist: trusty
 language: rust
-services: docker
-sudo: required
-addons:
-  chrome: stable
 
-env:
+jobs:
-  global:
-    - CRATE_NAME=dtparse
-
-matrix:
   include:
-    # Android
+  - rust: stable
-    - env: TARGET=aarch64-linux-android DISABLE_TESTS=1
+    os: linux
-    - env: TARGET=arm-linux-androideabi DISABLE_TESTS=1
+  - rust: 1.28.0
-    - env: TARGET=armv7-linux-androideabi DISABLE_TESTS=1
+    os: linux
-    - env: TARGET=i686-linux-android DISABLE_TESTS=1
+    env: DISABLE_TOOLS=true
-    - env: TARGET=x86_64-linux-android DISABLE_TESTS=1
+  - rust: stable
-
-    # iOS
-    - env: TARGET=aarch64-apple-ios DISABLE_TESTS=1
-      os: osx
-    - env: TARGET=armv7-apple-ios DISABLE_TESTS=1
-      os: osx
-    - env: TARGET=armv7s-apple-ios DISABLE_TESTS=1
-      os: osx
-    - env: TARGET=i386-apple-ios DISABLE_TESTS=1
-      os: osx
-    - env: TARGET=x86_64-apple-ios DISABLE_TESTS=1
     os: osx
+  - rust: stable-msvc
+    os: windows
+  - rust: stable
+    os: windows
 
-    # Linux
+cache:
-    - env: TARGET=aarch64-unknown-linux-gnu
+  - cargo
-    - env: TARGET=arm-unknown-linux-gnueabi
-    - env: TARGET=armv7-unknown-linux-gnueabihf
-    - env: TARGET=i686-unknown-linux-gnu
-    - env: TARGET=i686-unknown-linux-musl
-    - env: TARGET=mips-unknown-linux-gnu
-    - env: TARGET=mips64-unknown-linux-gnuabi64
-    - env: TARGET=mips64el-unknown-linux-gnuabi64
-    - env: TARGET=mipsel-unknown-linux-gnu
-    - env: TARGET=powerpc-unknown-linux-gnu
-    - env: TARGET=powerpc64-unknown-linux-gnu
-    - env: TARGET=powerpc64le-unknown-linux-gnu
-    - env: TARGET=s390x-unknown-linux-gnu DISABLE_TESTS=1
-    - env: TARGET=x86_64-unknown-linux-gnu
-    - env: TARGET=x86_64-unknown-linux-musl
 
-    # OSX
+before_script:
-    - env: TARGET=i686-apple-darwin
+  - rustup show
-      os: osx
+  # CMake doesn't like the `sh.exe` provided by Git being in PATH
-    - env: TARGET=x86_64-apple-darwin
+  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then rm "C:/Program Files/Git/usr/bin/sh.exe"; fi
-      os: osx
+  - if [[ "$DISABLE_TOOLS" == "" ]]; then rustup component add clippy; rustup component add rustfmt; fi
-
-    # *BSD
-    - env: TARGET=i686-unknown-freebsd DISABLE_TESTS=1
-    - env: TARGET=x86_64-unknown-freebsd DISABLE_TESTS=1
-    - env: TARGET=x86_64-unknown-netbsd DISABLE_TESTS=1
-
-    # Windows
-    - env: TARGET=x86_64-pc-windows-gnu
-
-    # Nightly and Beta
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: nightly
-    - env: TARGET=x86_64-apple-darwin
-      os: osx
-      rust: nightly
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: beta
-    - env: TARGET=x86_64-apple-darwin
-      os: osx
-      rust: beta
-
-    # Historical Rust versions
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.21.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.22.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.23.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.24.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.25.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.26.0
-    - env: TARGET=x86_64-unknown-linux-gnu
-      rust: 1.27.0
-
-    # WASM support
-    - env: TARGET=asmjs-unknown-emscripten USE_CARGO_WEB=true
-      rust: nightly
-    
-
-before_install:
-  - set -e
-  - rustup self update
-
-install:
-  - sh ci/install.sh
-  - source ~/.cargo/env || true
 
 script:
-  - bash ci/script.sh
+  - if [[ "$DISABLE_TOOLS" == "" ]]; then cargo clippy --all && cargo fmt --all -- --check; fi
 
-after_script: set +e
+  # For default build, split up compilation and tests so we can track build times
-
+  - cargo test --no-run
-cache: cargo
+  - cargo test
-before_cache:
+  - cargo test --release --no-run
-  # Travis can't cache files that are not readable by "others"
+  - cargo test --release
-  - chmod -R a+r $HOME/.cargo
 
 branches:
   only:
-    # release tags
-    - /^v\d+\.\d+\.\d+.*$/
     - master
+    - staging
+    - trying
     
-notifications:
-  email:
-    on_success: never

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dtparse"
-version = "1.0.3"
+version = "1.1.0"
 authors = ["Bradlee Speice <bradlee@speice.io>"]
 description = "A dateutil-compatible timestamp parser for Rust"
 repository = "https://github.com/bspeice/dtparse.git"
@@ -10,7 +10,6 @@ license = "Apache-2.0"
 
 [badges]
 travis-ci = { repository = "bspeice/dtparse" }
-appveyor = { repository = "bspeice/dtparse" }
 maintenance = { status = "passively-maintained" }
 
 [lib]
@@ -18,6 +17,7 @@ name = "dtparse"
 
 [dependencies]
 chrono = "0.4"
+chrono-tz = "0.5"
 lazy_static = "1.1"
 num-traits = "0.2"
 rust_decimal = "^0.10.1"

README.md

@@ -1,7 +1,6 @@
 # dtparse
 
 [![travisci](https://travis-ci.org/bspeice/dtparse.svg?branch=master)](https://travis-ci.org/bspeice/dtparse)
-[![appveyor](https://ci.appveyor.com/api/projects/status/r4de76tg9utfjva1/branch/master?svg=true)](https://ci.appveyor.com/project/bspeice/dtparse/branch/master)
 [![crates.io](https://img.shields.io/crates/v/dtparse.svg)](https://crates.io/crates/dtparse)
 [![docs.rs](https://docs.rs/dtparse/badge.svg)](https://docs.rs/dtparse/)
 
@@ -67,7 +66,7 @@ Further examples can be found in the [examples](examples) directory on internati
 
 # Usage
 
-`dtparse` requires a minimum Rust version of 1.21 to build, but is tested on Windows, OSX,
+`dtparse` requires a minimum Rust version of 1.28 to build, but is tested on Windows, OSX,
 BSD, Linux, and WASM. The build is also compiled against the iOS and Android SDK's, but is not
 tested against them.
 

appveyor.yml

@@ -1,121 +0,0 @@
-# Appveyor configuration template for Rust using rustup for Rust installation
-# https://github.com/starkat99/appveyor-rust
-
-## Operating System (VM environment) ##
-
-# Rust needs at least Visual Studio 2013 Appveyor OS for MSVC targets.
-os: Visual Studio 2017
-
-## Build Matrix ##
-
-# This configuration will setup a build for each channel & target combination (12 windows
-# combinations in all).
-#
-# There are 3 channels: stable, beta, and nightly.
-#
-# Alternatively, the full version may be specified for the channel to build using that specific
-# version (e.g. channel: 1.5.0)
-#
-# The values for target are the set of windows Rust build targets. Each value is of the form
-#
-# ARCH-pc-windows-TOOLCHAIN
-#
-# Where ARCH is the target architecture, either x86_64 or i686, and TOOLCHAIN is the linker
-# toolchain to use, either msvc or gnu. See https://www.rust-lang.org/downloads.html#win-foot for
-# a description of the toolchain differences.
-# See https://github.com/rust-lang-nursery/rustup.rs/#toolchain-specification for description of
-# toolchains and host triples.
-#
-# Comment out channel/target combos you do not wish to build in CI.
-#
-# You may use the `cargoflags` and `RUSTFLAGS` variables to set additional flags for cargo commands
-# and rustc, respectively. For instance, you can uncomment the cargoflags lines in the nightly
-# channels to enable unstable features when building for nightly. Or you could add additional
-# matrix entries to test different combinations of features.
-environment:
-  matrix:
-
-### MSVC Toolchains ###
-
-  # Stable 64-bit MSVC
-    - channel: stable
-      target: x86_64-pc-windows-msvc
-  # Stable 32-bit MSVC
-    - channel: stable
-      target: i686-pc-windows-msvc
-  # Beta 64-bit MSVC
-    - channel: beta
-      target: x86_64-pc-windows-msvc
-  # Beta 32-bit MSVC
-    - channel: beta
-      target: i686-pc-windows-msvc
-  # Nightly 64-bit MSVC
-    - channel: nightly
-      target: x86_64-pc-windows-msvc
-      #cargoflags: --features "unstable"
-  # Nightly 32-bit MSVC
-    - channel: nightly
-      target: i686-pc-windows-msvc
-      #cargoflags: --features "unstable"
-
-### GNU Toolchains ###
-
-  # Stable 64-bit GNU
-    - channel: stable
-      target: x86_64-pc-windows-gnu
-  # Stable 32-bit GNU
-    - channel: stable
-      target: i686-pc-windows-gnu
-  # Beta 64-bit GNU
-    - channel: beta
-      target: x86_64-pc-windows-gnu
-  # Beta 32-bit GNU
-    - channel: beta
-      target: i686-pc-windows-gnu
-  # Nightly 64-bit GNU
-    - channel: nightly
-      target: x86_64-pc-windows-gnu
-      #cargoflags: --features "unstable"
-  # Nightly 32-bit GNU
-    - channel: nightly
-      target: i686-pc-windows-gnu
-      #cargoflags: --features "unstable"
-
-### Allowed failures ###
-
-# See Appveyor documentation for specific details. In short, place any channel or targets you wish
-# to allow build failures on (usually nightly at least is a wise choice). This will prevent a build
-# or test failure in the matching channels/targets from failing the entire build.
-matrix:
-  allow_failures:
-    - channel: nightly
-
-# If you only care about stable channel build failures, uncomment the following line:
-    #- channel: beta
-
-## Install Script ##
-
-# This is the most important part of the Appveyor configuration. This installs the version of Rust
-# specified by the 'channel' and 'target' environment variables from the build matrix. This uses
-# rustup to install Rust.
-#
-# For simple configurations, instead of using the build matrix, you can simply set the
-# default-toolchain and default-host manually here.
-install:
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init -yv --default-toolchain %channel% --default-host %target%
-  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
-  - rustc -vV
-  - cargo -vV
-
-## Build Script ##
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage. This prevents
-# the "directory does not contain a project or solution file" error.
-build: false
-
-# Uses 'cargo test' to run tests and build. Alternatively, the project may call compiled programs
-#directly or perform other testing commands. Rust will automatically be placed in the PATH
-# environment variable.
-test_script:
-- cargo test --verbose %cargoflags%

bors.toml

@@ -0,0 +1,4 @@
+status = [
+  "continuous-integration/travis-ci/push",
+]
+delete_merged_branches = true

build_pycompat.py

@@ -81,7 +81,7 @@ tests = {
         'Thu Sep 25 10:36:28 BRST 2003', '1996.07.10 AD at 15:08:56 PDT',
         'Tuesday, April 12, 1952 AD 3:30:42pm PST',
         'November 5, 1994, 8:15:30 am EST', '1994-11-05T08:15:30-05:00',
-        '1994-11-05T08:15:30Z', '1976-07-04T00:01:02Z',
+        '1994-11-05T08:15:30Z', '1976-07-04T00:01:02Z', '1986-07-05T08:15:30z',
         'Tue Apr 4 00:22:12 PDT 1995'
     ],
     'test_fuzzy_tzinfo': [

examples/russian.rs

@@ -8,7 +8,6 @@ use dtparse::ParserInfo;
 use std::collections::HashMap;
 
 fn main() {
-
     // In this example, we'll just swap the default "months" parameter
     // with a version in Russian. Lovingly taken from:
     // https://github.com/dateutil/dateutil/blob/99f5770e7c63aa049b28abe465d7f1cc25b63fd2/dateutil/test/test_parser.py#L244
@@ -26,14 +25,24 @@ fn main() {
         vec!["сен", "Сентябрь"],
         vec!["окт", "Октябрь"],
         vec!["ноя", "Ноябрь"],
-        vec!["дек", "Декабрь"]
+        vec!["дек", "Декабрь"],
     ]);
 
-    let mut p = Parser::new(info);
+    let p = Parser::new(info);
 
     assert_eq!(
-        p.parse("10 Сентябрь 2015 10:20", None, None, false, false, None, false, &HashMap::new())
+        p.parse(
-            .unwrap().0,
+            "10 Сентябрь 2015 10:20",
+            None,
+            None,
+            false,
+            false,
+            None,
+            false,
+            &HashMap::new()
+        )
+        .unwrap()
+        .0,
         NaiveDate::from_ymd(2015, 9, 10).and_hms(10, 20, 0)
     );
 }

src/lib.rs

@@ -1,4 +1,5 @@
 #![deny(missing_docs)]
+#![cfg_attr(test, allow(unknown_lints))]
 #![cfg_attr(test, deny(warnings))]
 
 //! # dtparse
@@ -63,7 +64,7 @@
 //!
 //! # Usage
 //!
-//! `dtparse` requires a minimum Rust version of 1.21 to build, but is tested on Windows, OSX,
+//! `dtparse` requires a minimum Rust version of 1.28 to build, but is tested on Windows, OSX,
 //! BSD, Linux, and WASM. The build is also compiled against the iOS and Android SDK's, but is not
 //! tested against them.
 //!
@@ -73,6 +74,7 @@
 extern crate lazy_static;
 
 extern crate chrono;
+extern crate chrono_tz;
 extern crate num_traits;
 extern crate rust_decimal;
 
@@ -87,8 +89,10 @@ use chrono::Timelike;
 use num_traits::cast::ToPrimitive;
 use rust_decimal::Decimal;
 use rust_decimal::Error as DecimalError;
-use std::collections::HashMap;
 use std::cmp::min;
+use std::collections::HashMap;
+use std::error::Error;
+use std::fmt;
 use std::num::ParseIntError;
 use std::str::FromStr;
 use std::vec::Vec;
@@ -143,8 +147,18 @@ pub enum ParseError {
     /// Parser unable to make sense of year/month/day parameters in the time string;
     /// please report to maintainer as the timestring likely exposes a bug in implementation
     YearMonthDayError(&'static str),
+    /// Parser unable to find any date/time-related content in the supplied string
+    NoDate,
 }
 
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl Error for ParseError {}
+
 type ParseResult<I> = Result<I, ParseError>;
 
 pub(crate) fn tokenize(parse_string: &str) -> Vec<String> {
@@ -154,16 +168,15 @@ pub(crate) fn tokenize(parse_string: &str) -> Vec<String> {
 
 /// Utility function for `ParserInfo` that helps in constructing
 /// the attributes that make up the `ParserInfo` container
-#[cfg_attr(feature = "cargo-clippy", allow(get_unwrap))] // Recommended suggestion of &vec[0] doesn't compile
 pub fn parse_info(vec: Vec<Vec<&str>>) -> HashMap<String, usize> {
     let mut m = HashMap::new();
 
     if vec.len() == 1 {
-        for (i, val) in vec.get(0).unwrap().into_iter().enumerate() {
+        for (i, val) in vec.get(0).unwrap().iter().enumerate() {
             m.insert(val.to_lowercase(), i);
         }
     } else {
-        for (i, val_vec) in vec.into_iter().enumerate() {
+        for (i, val_vec) in vec.iter().enumerate() {
             for val in val_vec {
                 m.insert(val.to_lowercase(), i);
             }
@@ -228,12 +241,10 @@ impl Default for ParserInfo {
         let century = year / 100 * 100;
 
         ParserInfo {
-            jump: parse_info(vec![
+            jump: parse_info(vec![vec![
-                vec![
+                " ", ".", ",", ";", "-", "/", "'", "at", "on", "and", "ad", "m", "t", "of", "st",
-                    " ", ".", ",", ";", "-", "/", "'", "at", "on", "and", "ad", "m", "t", "of",
+                "nd", "rd", "th",
-                    "st", "nd", "rd", "th",
+            ]]),
-                ],
-            ]),
             weekday: parse_info(vec![
                 vec!["Mon", "Monday"],
                 vec!["Tue", "Tues", "Tuesday"],
@@ -338,10 +349,13 @@ impl ParserInfo {
             res.year = Some(self.convertyear(y, res.century_specified))
         };
 
-        if res.tzoffset == Some(0) && res.tzname.is_none() || res.tzname == Some("Z".to_owned()) {
+        if (res.tzoffset == Some(0) && res.tzname.is_none())
+            || (res.tzname == Some("Z".to_owned()) || res.tzname == Some("z".to_owned()))
+        {
             res.tzname = Some("UTC".to_owned());
             res.tzoffset = Some(0);
-        } else if res.tzoffset != Some(0) && res.tzname.is_some()
+        } else if res.tzoffset != Some(0)
+            && res.tzname.is_some()
             && self.utczone_index(res.tzname.as_ref().unwrap())
         {
             res.tzoffset = Some(0);
@@ -358,16 +372,16 @@ fn days_in_month(year: i32, month: i32) -> Result<u32, ParseError> {
     };
 
     match month {
-        2 => if leap_year {
+        2 => {
+            if leap_year {
                 Ok(29)
             } else {
                 Ok(28)
-        },
+            }
+        }
         1 | 3 | 5 | 7 | 8 | 10 | 12 => Ok(31),
         4 | 6 | 9 | 11 => Ok(30),
-        _ => {
+        _ => Err(ParseError::ImpossibleTimestamp("Invalid month")),
-            Err(ParseError::ImpossibleTimestamp("Invalid month"))
-        }
     }
 }
 
@@ -421,9 +435,7 @@ impl YMD {
                 Some(YMDLabel::Month) => {
                     return Err(ParseError::ImpossibleTimestamp("Invalid month"))
                 }
-                Some(YMDLabel::Day) => {
+                Some(YMDLabel::Day) => return Err(ParseError::ImpossibleTimestamp("Invalid day")),
-                    return Err(ParseError::ImpossibleTimestamp("Invalid day"))
-                }
             }
         }
 
@@ -435,9 +447,7 @@ impl YMD {
                 Some(YMDLabel::Month) => {
                     return Err(ParseError::ImpossibleTimestamp("Invalid month"))
                 }
-                Some(YMDLabel::Day) => {
+                Some(YMDLabel::Day) => return Err(ParseError::ImpossibleTimestamp("Invalid day")),
-                    return Err(ParseError::ImpossibleTimestamp("Invalid day"))
-                }
             }
         }
 
@@ -498,23 +508,19 @@ impl YMD {
         }
 
         if self._ymd.len() != strids.len() {
-            return Err(ParseError::YearMonthDayError("Tried to resolve year, month, and day without enough information"));
+            return Err(ParseError::YearMonthDayError(
+                "Tried to resolve year, month, and day without enough information",
+            ));
         }
 
         Ok((
-            strids
+            strids.get(&YMDLabel::Year).map(|i| self._ymd[*i]),
-                .get(&YMDLabel::Year)
+            strids.get(&YMDLabel::Month).map(|i| self._ymd[*i]),
-                .map(|i| self._ymd[*i]),
+            strids.get(&YMDLabel::Day).map(|i| self._ymd[*i]),
-            strids
-                .get(&YMDLabel::Month)
-                .map(|i| self._ymd[*i]),
-            strids
-                .get(&YMDLabel::Day)
-                .map(|i| self._ymd[*i]),
         ))
     }
 
-    #[cfg_attr(feature = "cargo-clippy", allow(needless_return))]
+    #[allow(clippy::needless_return)]
     fn resolve_ymd(
         &mut self,
         yearfirst: bool,
@@ -523,28 +529,24 @@ impl YMD {
         let len_ymd = self._ymd.len();
 
         let mut strids: HashMap<YMDLabel, usize> = HashMap::new();
-        self.ystridx
+        self.ystridx.map(|u| strids.insert(YMDLabel::Year, u));
-            .map(|u| strids.insert(YMDLabel::Year, u));
+        self.mstridx.map(|u| strids.insert(YMDLabel::Month, u));
-        self.mstridx
+        self.dstridx.map(|u| strids.insert(YMDLabel::Day, u));
-            .map(|u| strids.insert(YMDLabel::Month, u));
-        self.dstridx
-            .map(|u| strids.insert(YMDLabel::Day, u));
 
         // TODO: More Rustiomatic way of doing this?
-        if len_ymd == strids.len() && !strids.is_empty()
+        if len_ymd == strids.len() && !strids.is_empty() || (len_ymd == 3 && strids.len() == 2) {
-            || (len_ymd == 3 && strids.len() == 2)
-        {
             return self.resolve_from_stridxs(&mut strids);
         };
 
         // Received year, month, day, and ???
         if len_ymd > 3 {
-            return Err(ParseError::YearMonthDayError("Received extra tokens in resolving year, month, and day"));
+            return Err(ParseError::YearMonthDayError(
+                "Received extra tokens in resolving year, month, and day",
+            ));
         }
 
         match (len_ymd, self.mstridx) {
-            (1, Some(val)) |
+            (1, Some(val)) | (2, Some(val)) => {
-            (2, Some(val)) => {
                 let other = if len_ymd == 1 {
                     self._ymd[0]
                 } else {
@@ -554,7 +556,7 @@ impl YMD {
                     return Ok((Some(other), Some(self._ymd[val]), None));
                 }
                 return Ok((None, Some(self._ymd[val]), Some(other)));
-            },
+            }
             (2, None) => {
                 if self._ymd[0] > 31 {
                     return Ok((Some(self._ymd[0]), Some(self._ymd[1]), None));
@@ -566,28 +568,29 @@ impl YMD {
                     return Ok((None, Some(self._ymd[1]), Some(self._ymd[0])));
                 }
                 return Ok((None, Some(self._ymd[0]), Some(self._ymd[1])));
-            },
+            }
             (3, Some(0)) => {
                 if self._ymd[1] > 31 {
                     return Ok((Some(self._ymd[1]), Some(self._ymd[0]), Some(self._ymd[2])));
                 }
                 return Ok((Some(self._ymd[2]), Some(self._ymd[0]), Some(self._ymd[1])));
-            },
+            }
             (3, Some(1)) => {
                 if self._ymd[0] > 31 || (yearfirst && self._ymd[2] <= 31) {
                     return Ok((Some(self._ymd[0]), Some(self._ymd[1]), Some(self._ymd[2])));
                 }
                 return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
-            },
+            }
             (3, Some(2)) => {
                 // It was in the original docs, so: WTF!?
                 if self._ymd[1] > 31 {
                     return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
                 }
                 return Ok((Some(self._ymd[0]), Some(self._ymd[2]), Some(self._ymd[1])));
-            },
+            }
             (3, None) => {
-                if self._ymd[0] > 31 || self.ystridx == Some(0)
+                if self._ymd[0] > 31
+                    || self.ystridx == Some(0)
                     || (yearfirst && self._ymd[1] <= 12 && self._ymd[2] <= 31)
                 {
                     if dayfirst && self._ymd[2] <= 12 {
@@ -598,8 +601,10 @@ impl YMD {
                     return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
                 }
                 return Ok((Some(self._ymd[2]), Some(self._ymd[0]), Some(self._ymd[1])));
-            },
+            }
-            (_, _) => { return Ok((None, None, None)); },
+            (_, _) => {
+                return Ok((None, None, None));
+            }
         }
     }
 }
@@ -621,6 +626,31 @@ struct ParsingResult {
     any_unused_tokens: Vec<String>,
 }
 
+macro_rules! option_len {
+    ($o:expr) => {{
+        if $o.is_some() {
+            1
+        } else {
+            0
+        }
+    }};
+}
+
+impl ParsingResult {
+    fn len(&self) -> usize {
+        option_len!(self.year)
+            + option_len!(self.month)
+            + option_len!(self.day)
+            + option_len!(self.weekday)
+            + option_len!(self.hour)
+            + option_len!(self.minute)
+            + option_len!(self.second)
+            + option_len!(self.microsecond)
+            + option_len!(self.tzname)
+            + option_len!(self.ampm)
+    }
+}
+
 /// Parser is responsible for doing the actual work of understanding a time string.
 /// The root level `parse` function is responsible for constructing a default `Parser`
 /// and triggering its behavior.
@@ -669,7 +699,7 @@ impl Parser {
     /// timezone name support (i.e. "EST", "BRST") is not available by default
     /// at the moment, they must be added through `tzinfos` at the moment in
     /// order to be resolved.
-    #[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] // Need to release a 2.0 for changing public API
+    #[allow(clippy::too_many_arguments)]
     pub fn parse(
         &self,
         timestr: &str,
@@ -688,6 +718,10 @@ impl Parser {
         let (res, tokens) =
             self.parse_with_tokens(timestr, dayfirst, yearfirst, fuzzy, fuzzy_with_tokens)?;
 
+        if res.len() == 0 {
+            return Err(ParseError::NoDate);
+        }
+
         let naive = self.build_naive(&res, &default_ts)?;
 
         if !ignoretz {
@@ -698,7 +732,7 @@ impl Parser {
         }
     }
 
-    #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))] // Imitating Python API is priority
+    #[allow(clippy::cognitive_complexity)] // Imitating Python API is priority
     fn parse_with_tokens(
         &self,
         timestr: &str,
@@ -745,16 +779,18 @@ impl Parser {
                         // Jan-01[-99]
                         let sep = &l[i + 1];
                         // TODO: This seems like a very unsafe unwrap
-                        ymd.append(l[i + 2].parse::<i32>().unwrap(), &l[i + 2], None)?;
+                        ymd.append(l[i + 2].parse::<i32>()?, &l[i + 2], None)?;
 
                         if i + 3 < len_l && &l[i + 3] == sep {
                             // Jan-01-99
-                            ymd.append(l[i + 4].parse::<i32>().unwrap(), &l[i + 4], None)?;
+                            ymd.append(l[i + 4].parse::<i32>()?, &l[i + 4], None)?;
                             i += 2;
                         }
 
                         i += 2;
-                    } else if i + 4 < len_l && l[i + 1] == l[i + 3] && l[i + 3] == " "
+                    } else if i + 4 < len_l
+                        && l[i + 1] == l[i + 3]
+                        && l[i + 3] == " "
                         && self.info.pertain_index(&l[i + 2])
                     {
                         // Jan of 01
@@ -792,7 +828,7 @@ impl Parser {
                     } else {
                         "+".to_owned()
                     };
-                    l[i+1] = item;
+                    l[i + 1] = item;
 
                     res.tzoffset = None;
 
@@ -810,17 +846,17 @@ impl Parser {
                 // TODO: check that l[i + 1] is integer?
                 if len_li == 4 {
                     // -0300
-                    hour_offset = Some(l[i + 1][..2].parse::<i32>().unwrap());
+                    hour_offset = Some(l[i + 1][..2].parse::<i32>()?);
-                    min_offset = Some(l[i + 1][2..4].parse::<i32>().unwrap());
+                    min_offset = Some(l[i + 1][2..4].parse::<i32>()?);
                 } else if i + 2 < len_l && l[i + 2] == ":" {
                     // -03:00
-                    hour_offset = Some(l[i + 1].parse::<i32>().unwrap());
+                    hour_offset = Some(l[i + 1].parse::<i32>()?);
-                    min_offset = Some(l[i + 3].parse::<i32>().unwrap());
+                    min_offset = Some(l[i + 3].parse::<i32>()?);
                     i += 2;
                 } else if len_li <= 2 {
                     // -[0]3
                     let range_len = min(l[i + 1].len(), 2);
-                    hour_offset = Some(l[i + 1][..range_len].parse::<i32>().unwrap());
+                    hour_offset = Some(l[i + 1][..range_len].parse::<i32>()?);
                     min_offset = Some(0);
                 }
 
@@ -828,8 +864,11 @@ impl Parser {
                     Some(signal * (hour_offset.unwrap() * 3600 + min_offset.unwrap() * 60));
 
                 let tzname = res.tzname.clone();
-                if i + 5 < len_l && self.info.jump_index(&l[i + 2]) && l[i + 3] == "("
+                if i + 5 < len_l
-                    && l[i + 5] == ")" && 3 <= l[i + 4].len()
+                    && self.info.jump_index(&l[i + 2])
+                    && l[i + 3] == "("
+                    && l[i + 5] == ")"
+                    && 3 <= l[i + 4].len()
                     && self.could_be_tzname(res.hour, &tzname, None, &l[i + 4])
                 {
                     // (GMT)
@@ -875,10 +914,14 @@ impl Parser {
             .chars()
             .all(|c| 65u8 as char <= c && c <= 90u8 as char);
 
-        hour.is_some() && tzname.is_none() && tzoffset.is_none() && token.len() <= 5
+        hour.is_some()
-            && all_ascii_upper
+            && tzname.is_none()
+            && tzoffset.is_none()
+            && token.len() <= 5
+            && (all_ascii_upper || self.info.utczone.contains_key(token))
     }
 
+    #[allow(clippy::unnecessary_unwrap)]
     fn ampm_valid(&self, hour: Option<i32>, ampm: Option<bool>, fuzzy: bool) -> ParseResult<bool> {
         let mut val_is_ampm = !(fuzzy && ampm.is_some());
 
@@ -899,13 +942,16 @@ impl Parser {
         Ok(val_is_ampm)
     }
 
-    fn build_naive(&self, res: &ParsingResult, default: &NaiveDateTime) -> ParseResult<NaiveDateTime> {
+    fn build_naive(
+        &self,
+        res: &ParsingResult,
+        default: &NaiveDateTime,
+    ) -> ParseResult<NaiveDateTime> {
         let y = res.year.unwrap_or_else(|| default.year());
         let m = res.month.unwrap_or_else(|| default.month() as i32) as u32;
 
         let d_offset = if res.weekday.is_some() && res.day.is_none() {
-            // TODO: Unwrap not justified
+            let dow = day_of_week(y as u32, m, default.day())?;
-            let dow = day_of_week(y as u32, m, default.day()).unwrap();
 
             // UNWRAP: We've already check res.weekday() is some
             let actual_weekday = (res.weekday.unwrap() + 1) % 7;
@@ -916,20 +962,26 @@ impl Parser {
         };
 
         // TODO: Change month/day to u32
-        let d = NaiveDate::from_ymd(
+        let d = NaiveDate::from_ymd_opt(
             y,
             m,
-            min(res.day.unwrap_or(default.day() as i32) as u32, days_in_month(y, m as i32)?)
+            min(
-        );
+                res.day.unwrap_or(default.day() as i32) as u32,
+                days_in_month(y, m as i32)?,
+            ),
+        )
+        .ok_or_else(|| ParseError::ImpossibleTimestamp("Invalid date range given"))?;
 
         let d = d + d_offset;
 
         let hour = res.hour.unwrap_or(default.hour() as i32) as u32;
         let minute = res.minute.unwrap_or(default.minute() as i32) as u32;
         let second = res.second.unwrap_or(default.second() as i32) as u32;
-        let microsecond = res.microsecond
+        let microsecond = res
+            .microsecond
             .unwrap_or(default.timestamp_subsec_micros() as i32) as u32;
-        let t = NaiveTime::from_hms_micro_opt(hour, minute, second, microsecond).ok_or_else(|| {
+        let t =
+            NaiveTime::from_hms_micro_opt(hour, minute, second, microsecond).ok_or_else(|| {
                 if hour >= 24 {
                     ParseError::ImpossibleTimestamp("Invalid hour")
                 } else if minute >= 60 {
@@ -952,27 +1004,28 @@ impl Parser {
         res: &ParsingResult,
         tzinfos: &HashMap<String, i32>,
     ) -> ParseResult<Option<FixedOffset>> {
-        // TODO: Actual timezone support
         if let Some(offset) = res.tzoffset {
             Ok(Some(FixedOffset::east(offset)))
         } else if res.tzoffset == None
-            && (res.tzname == Some(" ".to_owned()) || res.tzname == Some(".".to_owned())
+            && (res.tzname == Some(" ".to_owned())
-                || res.tzname == Some("-".to_owned()) || res.tzname == None)
+                || res.tzname == Some(".".to_owned())
+                || res.tzname == Some("-".to_owned())
+                || res.tzname == None)
         {
             Ok(None)
         } else if res.tzname.is_some() && tzinfos.contains_key(res.tzname.as_ref().unwrap()) {
             Ok(Some(FixedOffset::east(
                 *tzinfos.get(res.tzname.as_ref().unwrap()).unwrap(),
             )))
-        } else if res.tzname.is_some() {
+        } else if let Some(tzname) = res.tzname.as_ref() {
-            // TODO: Dateutil issues a warning/deprecation notice here. Should we force the issue?
+            println!("tzname {} identified but not understood.", tzname);
-            println!("tzname {} identified but not understood. Ignoring for the time being, but behavior is subject to change.", res.tzname.as_ref().unwrap());
             Ok(None)
         } else {
             Err(ParseError::TimezoneUnsupported)
         }
     }
 
+    #[allow(clippy::unnecessary_unwrap)]
     fn parse_numeric_token(
         &self,
         tokens: &[String],
@@ -991,7 +1044,9 @@ impl Parser {
 
         // TODO: I miss the `x in y` syntax
         // TODO: Decompose this logic a bit
-        if ymd.len() == 3 && (len_li == 2 || len_li == 4) && res.hour.is_none()
+        if ymd.len() == 3
+            && (len_li == 2 || len_li == 4)
+            && res.hour.is_none()
             && (idx + 1 >= len_l
                 || (tokens[idx + 1] != ":" && info.hms_index(&tokens[idx + 1]).is_none()))
         {
@@ -1007,9 +1062,9 @@ impl Parser {
             let s = &tokens[idx];
 
             if ymd.len() == 0 && tokens[idx].find('.') == None {
-                ymd.append(s[0..2].parse::<i32>().unwrap(), &s[0..2], None)?;
+                ymd.append(s[0..2].parse::<i32>()?, &s[0..2], None)?;
-                ymd.append(s[2..4].parse::<i32>().unwrap(), &s[2..4], None)?;
+                ymd.append(s[2..4].parse::<i32>()?, &s[2..4], None)?;
-                ymd.append(s[4..6].parse::<i32>().unwrap(), &s[4..6], None)?;
+                ymd.append(s[4..6].parse::<i32>()?, &s[4..6], None)?;
             } else {
                 // 19990101T235959[.59]
                 res.hour = s[0..2].parse::<i32>().ok();
@@ -1022,9 +1077,9 @@ impl Parser {
         } else if vec![8, 12, 14].contains(&len_li) {
             // YYMMDD
             let s = &tokens[idx];
-            ymd.append(s[..4].parse::<i32>().unwrap(), &s[..4], Some(YMDLabel::Year))?;
+            ymd.append(s[..4].parse::<i32>()?, &s[..4], Some(YMDLabel::Year))?;
-            ymd.append(s[4..6].parse::<i32>().unwrap(), &s[4..6], None)?;
+            ymd.append(s[4..6].parse::<i32>()?, &s[4..6], None)?;
-            ymd.append(s[6..8].parse::<i32>().unwrap(), &s[6..8], None)?;
+            ymd.append(s[6..8].parse::<i32>()?, &s[6..8], None)?;
 
             if len_li > 8 {
                 res.hour = Some(s[8..10].parse::<i32>()?);
@@ -1066,7 +1121,7 @@ impl Parser {
         {
             // TODO: There's got to be a better way of handling the condition above
             let sep = &tokens[idx + 1];
-            ymd.append(value_repr.parse::<i32>().unwrap(), &value_repr, None)?;
+            ymd.append(value_repr.parse::<i32>()?, &value_repr, None)?;
 
             if idx + 2 < len_l && !info.jump_index(&tokens[idx + 2]) {
                 if let Ok(val) = tokens[idx + 2].parse::<i32>() {
@@ -1160,7 +1215,7 @@ impl Parser {
             len_l - 2
         } else if idx > 1 {
             idx - 2
-        } else if len_l == 0{
+        } else if len_l == 0 {
             panic!("Attempting to find_hms_index() wih no tokens.");
         } else {
             0
@@ -1168,13 +1223,18 @@ impl Parser {
 
         if idx + 1 < len_l && info.hms_index(&tokens[idx + 1]).is_some() {
             hms_idx = Some(idx + 1)
-        } else if allow_jump && idx + 2 < len_l && tokens[idx + 1] == " "
+        } else if allow_jump
+            && idx + 2 < len_l
+            && tokens[idx + 1] == " "
             && info.hms_index(&tokens[idx + 2]).is_some()
         {
             hms_idx = Some(idx + 2)
         } else if idx > 0 && info.hms_index(&tokens[idx - 1]).is_some() {
             hms_idx = Some(idx - 1)
-        } else if len_l > 0 && idx > 0 && idx == len_l - 1 && tokens[idx - 1] == " "
+        } else if len_l > 0
+            && idx > 0
+            && idx == len_l - 1
+            && tokens[idx - 1] == " "
             && info.hms_index(&tokens[idx_minus_two]).is_some()
         {
             hms_idx = Some(idx - 2)
@@ -1183,6 +1243,7 @@ impl Parser {
         hms_idx
     }
 
+    #[allow(clippy::unnecessary_unwrap)]
     fn parse_hms(
         &self,
         idx: usize,
@@ -1242,7 +1303,6 @@ impl Parser {
         (minute, second)
     }
 
-    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))] // Need Vec type because of mutability in the function that calls us
     fn recombine_skipped(&self, skipped_idxs: Vec<usize>, tokens: Vec<String>) -> Vec<String> {
         let mut skipped_tokens: Vec<String> = vec![];
 

src/tests/fuzzing.rs

@@ -7,18 +7,56 @@ use Parser;
 
 #[test]
 fn test_fuzz() {
-
+    assert_eq!(
-    assert_eq!(parse("\x2D\x38\x31\x39\x34\x38\x34"), Err(ParseError::ImpossibleTimestamp("Invalid month")));
+        parse("\x2D\x38\x31\x39\x34\x38\x34"),
+        Err(ParseError::ImpossibleTimestamp("Invalid month"))
+    );
 
     // Garbage in the third delimited field
-    assert_eq!(parse("2..\x00\x000d\x00+\x010d\x01\x00\x00\x00+"),
+    assert_eq!(
-               Err(ParseError::UnrecognizedFormat));
+        parse("2..\x00\x000d\x00+\x010d\x01\x00\x00\x00+"),
-    // OverflowError: Python int too large to convert to C long
+        Err(ParseError::UnrecognizedFormat)
-    // assert_eq!(parse("8888884444444888444444444881"), Err(ParseError::AmPmWithoutHour));
+    );
+
     let default = NaiveDate::from_ymd(2016, 6, 29).and_hms(0, 0, 0);
     let p = Parser::default();
-    let res = p.parse("\x0D\x31", None, None, false, false, Some(&default), false, &HashMap::new()).unwrap();
+    let res = p.parse(
-    assert_eq!(res.0, default);
+        "\x0D\x31",
+        None,
+        None,
+        false,
+        false,
+        Some(&default),
+        false,
+        &HashMap::new(),
+    );
+    assert_eq!(res, Err(ParseError::NoDate));
 
-    assert_eq!(parse("\x2D\x2D\x32\x31\x38\x6D"), Err(ParseError::ImpossibleTimestamp("Invalid minute")));
+    assert_eq!(
+        parse("\x2D\x2D\x32\x31\x38\x6D"),
+        Err(ParseError::ImpossibleTimestamp("Invalid minute"))
+    );
+}
+
+#[test]
+fn large_int() {
+    let parse_result = parse("1412409095009.jpg");
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn another_large_int() {
+    let parse_result = parse("1412409095009");
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn an_even_larger_int() {
+    let parse_result = parse("1566997680962280");
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn empty_string() {
+    assert_eq!(parse(""), Err(ParseError::NoDate))
 }

src/tests/pycompat_tokenizer.rs

@@ -1,4 +1,3 @@
-
 //! This code has been generated by running the `build_pycompat_tokenizer.py` script
 //! in the repository root. Please do not edit it, as your edits will be destroyed
 //! upon re-running code generation.
@@ -12,7 +11,9 @@ fn tokenize_assert(test_str: &str, comparison: Vec<&str>) {
 
 #[test]
 fn test_tokenize0() {
-    let comp = vec!["Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28"];
+    let comp = vec![
+        "Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28",
+    ];
     tokenize_assert("Thu Sep 25 10:36:28", comp);
 }
 
@@ -294,7 +295,9 @@ fn test_tokenize46() {
 
 #[test]
 fn test_tokenize47() {
-    let comp = vec!["Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "2003"];
+    let comp = vec![
+        "Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "2003",
+    ];
     tokenize_assert("Thu Sep 25 10:36:28 2003", comp);
 }
 
@@ -306,7 +309,9 @@ fn test_tokenize48() {
 
 #[test]
 fn test_tokenize49() {
-    let comp = vec!["2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41"];
+    let comp = vec![
+        "2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41",
+    ];
     tokenize_assert("2003-09-25T10:49:41", comp);
 }
 
@@ -354,7 +359,9 @@ fn test_tokenize56() {
 
 #[test]
 fn test_tokenize57() {
-    let comp = vec!["2003", "-", "09", "-", "25", " ", "10", ":", "49", ":", "41.502"];
+    let comp = vec![
+        "2003", "-", "09", "-", "25", " ", "10", ":", "49", ":", "41.502",
+    ];
     tokenize_assert("2003-09-25 10:49:41,502", comp);
 }
 
@@ -510,7 +517,10 @@ fn test_tokenize82() {
 
 #[test]
 fn test_tokenize83() {
-    let comp = vec![" ", " ", "July", " ", " ", " ", "4", " ", ",", " ", " ", "1976", " ", " ", " ", "12", ":", "01", ":", "02", " ", " ", " ", "am", " ", " "];
+    let comp = vec![
+        " ", " ", "July", " ", " ", " ", "4", " ", ",", " ", " ", "1976", " ", " ", " ", "12", ":",
+        "01", ":", "02", " ", " ", " ", "am", " ", " ",
+    ];
     tokenize_assert("  July   4 ,  1976   12:01:02   am  ", comp);
 }
 
@@ -522,7 +532,9 @@ fn test_tokenize84() {
 
 #[test]
 fn test_tokenize85() {
-    let comp = vec!["1996", ".", "July", ".", "10", " ", "AD", " ", "12", ":", "08", " ", "PM"];
+    let comp = vec![
+        "1996", ".", "July", ".", "10", " ", "AD", " ", "12", ":", "08", " ", "PM",
+    ];
     tokenize_assert("1996.July.10 AD 12:08 PM", comp);
 }
 
@@ -558,25 +570,33 @@ fn test_tokenize90() {
 
 #[test]
 fn test_tokenize91() {
-    let comp = vec!["0", ":", "01", ":", "02", " ", "on", " ", "July", " ", "4", ",", " ", "1976"];
+    let comp = vec![
+        "0", ":", "01", ":", "02", " ", "on", " ", "July", " ", "4", ",", " ", "1976",
+    ];
     tokenize_assert("0:01:02 on July 4, 1976", comp);
 }
 
 #[test]
 fn test_tokenize92() {
-    let comp = vec!["0", ":", "01", ":", "02", " ", "on", " ", "July", " ", "4", ",", " ", "1976"];
+    let comp = vec![
+        "0", ":", "01", ":", "02", " ", "on", " ", "July", " ", "4", ",", " ", "1976",
+    ];
     tokenize_assert("0:01:02 on July 4, 1976", comp);
 }
 
 #[test]
 fn test_tokenize93() {
-    let comp = vec!["July", " ", "4", ",", " ", "1976", " ", "12", ":", "01", ":", "02", " ", "am"];
+    let comp = vec![
+        "July", " ", "4", ",", " ", "1976", " ", "12", ":", "01", ":", "02", " ", "am",
+    ];
     tokenize_assert("July 4, 1976 12:01:02 am", comp);
 }
 
 #[test]
 fn test_tokenize94() {
-    let comp = vec!["Mon", " ", "Jan", " ", " ", "2", " ", "04", ":", "24", ":", "27", " ", "1995"];
+    let comp = vec![
+        "Mon", " ", "Jan", " ", " ", "2", " ", "04", ":", "24", ":", "27", " ", "1995",
+    ];
     tokenize_assert("Mon Jan  2 04:24:27 1995", comp);
 }
 
@@ -588,7 +608,9 @@ fn test_tokenize95() {
 
 #[test]
 fn test_tokenize96() {
-    let comp = vec!["Jan", " ", "1", " ", "1999", " ", "11", ":", "23", ":", "34.578"];
+    let comp = vec![
+        "Jan", " ", "1", " ", "1999", " ", "11", ":", "23", ":", "34.578",
+    ];
     tokenize_assert("Jan 1 1999 11:23:34.578", comp);
 }
 
@@ -618,13 +640,17 @@ fn test_tokenize100() {
 
 #[test]
 fn test_tokenize101() {
-    let comp = vec!["0099", "-", "01", "-", "01", "T", "00", ":", "00", ":", "00"];
+    let comp = vec![
+        "0099", "-", "01", "-", "01", "T", "00", ":", "00", ":", "00",
+    ];
     tokenize_assert("0099-01-01T00:00:00", comp);
 }
 
 #[test]
 fn test_tokenize102() {
-    let comp = vec!["0031", "-", "01", "-", "01", "T", "00", ":", "00", ":", "00"];
+    let comp = vec![
+        "0031", "-", "01", "-", "01", "T", "00", ":", "00", ":", "00",
+    ];
     tokenize_assert("0031-01-01T00:00:00", comp);
 }
 
@@ -666,31 +692,42 @@ fn test_tokenize108() {
 
 #[test]
 fn test_tokenize109() {
-    let comp = vec!["Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003"];
+    let comp = vec![
+        "Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003",
+    ];
     tokenize_assert("Thu Sep 25 10:36:28 BRST 2003", comp);
 }
 
 #[test]
 fn test_tokenize110() {
-    let comp = vec!["2003", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "25", " ", "Sep", " ", "Thu"];
+    let comp = vec![
+        "2003", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "25", " ", "Sep", " ", "Thu",
+    ];
     tokenize_assert("2003 10:36:28 BRST 25 Sep Thu", comp);
 }
 
 #[test]
 fn test_tokenize111() {
-    let comp = vec!["Thu", ",", " ", "25", " ", "Sep", " ", "2003", " ", "10", ":", "49", ":", "41", " ", "-", "0300"];
+    let comp = vec![
+        "Thu", ",", " ", "25", " ", "Sep", " ", "2003", " ", "10", ":", "49", ":", "41", " ", "-",
+        "0300",
+    ];
     tokenize_assert("Thu, 25 Sep 2003 10:49:41 -0300", comp);
 }
 
 #[test]
 fn test_tokenize112() {
-    let comp = vec!["2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41.5", "-", "03", ":", "00"];
+    let comp = vec![
+        "2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41.5", "-", "03", ":", "00",
+    ];
     tokenize_assert("2003-09-25T10:49:41.5-03:00", comp);
 }
 
 #[test]
 fn test_tokenize113() {
-    let comp = vec!["2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41", "-", "03", ":", "00"];
+    let comp = vec![
+        "2003", "-", "09", "-", "25", "T", "10", ":", "49", ":", "41", "-", "03", ":", "00",
+    ];
     tokenize_assert("2003-09-25T10:49:41-03:00", comp);
 }
 
@@ -708,19 +745,27 @@ fn test_tokenize115() {
 
 #[test]
 fn test_tokenize116() {
-    let comp = vec!["2018", "-", "08", "-", "10", " ", "10", ":", "00", ":", "00", " ", "UTC", "+", "3"];
+    let comp = vec![
+        "2018", "-", "08", "-", "10", " ", "10", ":", "00", ":", "00", " ", "UTC", "+", "3",
+    ];
     tokenize_assert("2018-08-10 10:00:00 UTC+3", comp);
 }
 
 #[test]
 fn test_tokenize117() {
-    let comp = vec!["2018", "-", "08", "-", "10", " ", "03", ":", "36", ":", "47", " ", "PM", " ", "GMT", "-", "4"];
+    let comp = vec![
+        "2018", "-", "08", "-", "10", " ", "03", ":", "36", ":", "47", " ", "PM", " ", "GMT", "-",
+        "4",
+    ];
     tokenize_assert("2018-08-10 03:36:47 PM GMT-4", comp);
 }
 
 #[test]
 fn test_tokenize118() {
-    let comp = vec!["2018", "-", "08", "-", "10", " ", "04", ":", "15", ":", "00", " ", "AM", " ", "Z", "-", "02", ":", "00"];
+    let comp = vec![
+        "2018", "-", "08", "-", "10", " ", "04", ":", "15", ":", "00", " ", "AM", " ", "Z", "-",
+        "02", ":", "00",
+    ];
     tokenize_assert("2018-08-10 04:15:00 AM Z-02:00", comp);
 }
 
@@ -828,91 +873,213 @@ fn test_tokenize135() {
 
 #[test]
 fn test_tokenize136() {
-    let comp = vec!["Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003"];
+    let comp = vec![
+        "Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003",
+    ];
     tokenize_assert("Thu Sep 25 10:36:28 BRST 2003", comp);
 }
 
 #[test]
 fn test_tokenize137() {
-    let comp = vec!["1996", ".", "07", ".", "10", " ", "AD", " ", "at", " ", "15", ":", "08", ":", "56", " ", "PDT"];
+    let comp = vec![
+        "1996", ".", "07", ".", "10", " ", "AD", " ", "at", " ", "15", ":", "08", ":", "56", " ",
+        "PDT",
+    ];
     tokenize_assert("1996.07.10 AD at 15:08:56 PDT", comp);
 }
 
 #[test]
 fn test_tokenize138() {
-    let comp = vec!["Tuesday", ",", " ", "April", " ", "12", ",", " ", "1952", " ", "AD", " ", "3", ":", "30", ":", "42", "pm", " ", "PST"];
+    let comp = vec![
+        "Tuesday", ",", " ", "April", " ", "12", ",", " ", "1952", " ", "AD", " ", "3", ":", "30",
+        ":", "42", "pm", " ", "PST",
+    ];
     tokenize_assert("Tuesday, April 12, 1952 AD 3:30:42pm PST", comp);
 }
 
 #[test]
 fn test_tokenize139() {
-    let comp = vec!["November", " ", "5", ",", " ", "1994", ",", " ", "8", ":", "15", ":", "30", " ", "am", " ", "EST"];
+    let comp = vec![
+        "November", " ", "5", ",", " ", "1994", ",", " ", "8", ":", "15", ":", "30", " ", "am",
+        " ", "EST",
+    ];
     tokenize_assert("November 5, 1994, 8:15:30 am EST", comp);
 }
 
 #[test]
 fn test_tokenize140() {
-    let comp = vec!["1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "-", "05", ":", "00"];
+    let comp = vec![
+        "1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "-", "05", ":", "00",
+    ];
     tokenize_assert("1994-11-05T08:15:30-05:00", comp);
 }
 
 #[test]
 fn test_tokenize141() {
-    let comp = vec!["1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "Z"];
+    let comp = vec![
+        "1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "Z",
+    ];
     tokenize_assert("1994-11-05T08:15:30Z", comp);
 }
 
 #[test]
 fn test_tokenize142() {
-    let comp = vec!["1976", "-", "07", "-", "04", "T", "00", ":", "01", ":", "02", "Z"];
+    let comp = vec![
+        "1976", "-", "07", "-", "04", "T", "00", ":", "01", ":", "02", "Z",
+    ];
     tokenize_assert("1976-07-04T00:01:02Z", comp);
 }
 
 #[test]
 fn test_tokenize143() {
-    let comp = vec!["Tue", " ", "Apr", " ", "4", " ", "00", ":", "22", ":", "12", " ", "PDT", " ", "1995"];
+    let comp = vec![
+        "Tue", " ", "Apr", " ", "4", " ", "00", ":", "22", ":", "12", " ", "PDT", " ", "1995",
+    ];
     tokenize_assert("Tue Apr 4 00:22:12 PDT 1995", comp);
 }
 
 #[test]
 fn test_tokenize144() {
-    let comp = vec!["Today", " ", "is", " ", "25", " ", "of", " ", "September", " ", "of", " ", "2003", ",", " ", "exactly", " ", "at", " ", "10", ":", "49", ":", "41", " ", "with", " ", "timezone", " ", "-", "03", ":", "00", "."];
+    let comp = vec![
-    tokenize_assert("Today is 25 of September of 2003, exactly at 10:49:41 with timezone -03:00.", comp);
+        "Today",
+        " ",
+        "is",
+        " ",
+        "25",
+        " ",
+        "of",
+        " ",
+        "September",
+        " ",
+        "of",
+        " ",
+        "2003",
+        ",",
+        " ",
+        "exactly",
+        " ",
+        "at",
+        " ",
+        "10",
+        ":",
+        "49",
+        ":",
+        "41",
+        " ",
+        "with",
+        " ",
+        "timezone",
+        " ",
+        "-",
+        "03",
+        ":",
+        "00",
+        ".",
+    ];
+    tokenize_assert(
+        "Today is 25 of September of 2003, exactly at 10:49:41 with timezone -03:00.",
+        comp,
+    );
 }
 
 #[test]
 fn test_tokenize145() {
-    let comp = vec!["Today", " ", "is", " ", "25", " ", "of", " ", "September", " ", "of", " ", "2003", ",", " ", "exactly", " ", "at", " ", "10", ":", "49", ":", "41", " ", "with", " ", "timezone", " ", "-", "03", ":", "00", "."];
+    let comp = vec![
-    tokenize_assert("Today is 25 of September of 2003, exactly at 10:49:41 with timezone -03:00.", comp);
+        "Today",
+        " ",
+        "is",
+        " ",
+        "25",
+        " ",
+        "of",
+        " ",
+        "September",
+        " ",
+        "of",
+        " ",
+        "2003",
+        ",",
+        " ",
+        "exactly",
+        " ",
+        "at",
+        " ",
+        "10",
+        ":",
+        "49",
+        ":",
+        "41",
+        " ",
+        "with",
+        " ",
+        "timezone",
+        " ",
+        "-",
+        "03",
+        ":",
+        "00",
+        ".",
+    ];
+    tokenize_assert(
+        "Today is 25 of September of 2003, exactly at 10:49:41 with timezone -03:00.",
+        comp,
+    );
 }
 
 #[test]
 fn test_tokenize146() {
-    let comp = vec!["I", " ", "have", " ", "a", " ", "meeting", " ", "on", " ", "March", " ", "1", ",", " ", "1974"];
+    let comp = vec![
+        "I", " ", "have", " ", "a", " ", "meeting", " ", "on", " ", "March", " ", "1", ",", " ",
+        "1974",
+    ];
     tokenize_assert("I have a meeting on March 1, 1974", comp);
 }
 
 #[test]
 fn test_tokenize147() {
-    let comp = vec!["On", " ", "June", " ", "8", "th", ",", " ", "2020", ",", " ", "I", " ", "am", " ", "going", " ", "to", " ", "be", " ", "the", " ", "first", " ", "man", " ", "on", " ", "Mars"];
+    let comp = vec![
-    tokenize_assert("On June 8th, 2020, I am going to be the first man on Mars", comp);
+        "On", " ", "June", " ", "8", "th", ",", " ", "2020", ",", " ", "I", " ", "am", " ",
+        "going", " ", "to", " ", "be", " ", "the", " ", "first", " ", "man", " ", "on", " ",
+        "Mars",
+    ];
+    tokenize_assert(
+        "On June 8th, 2020, I am going to be the first man on Mars",
+        comp,
+    );
 }
 
 #[test]
 fn test_tokenize148() {
-    let comp = vec!["Meet", " ", "me", " ", "at", " ", "the", " ", "AM", "/", "PM", " ", "on", " ", "Sunset", " ", "at", " ", "3", ":", "00", " ", "AM", " ", "on", " ", "December", " ", "3", "rd", ",", " ", "2003"];
+    let comp = vec![
-    tokenize_assert("Meet me at the AM/PM on Sunset at 3:00 AM on December 3rd, 2003", comp);
+        "Meet", " ", "me", " ", "at", " ", "the", " ", "AM", "/", "PM", " ", "on", " ", "Sunset",
+        " ", "at", " ", "3", ":", "00", " ", "AM", " ", "on", " ", "December", " ", "3", "rd", ",",
+        " ", "2003",
+    ];
+    tokenize_assert(
+        "Meet me at the AM/PM on Sunset at 3:00 AM on December 3rd, 2003",
+        comp,
+    );
 }
 
 #[test]
 fn test_tokenize149() {
-    let comp = vec!["Meet", " ", "me", " ", "at", " ", "3", ":", "00", " ", "AM", " ", "on", " ", "December", " ", "3", "rd", ",", " ", "2003", " ", "at", " ", "the", " ", "AM", "/", "PM", " ", "on", " ", "Sunset"];
+    let comp = vec![
-    tokenize_assert("Meet me at 3:00 AM on December 3rd, 2003 at the AM/PM on Sunset", comp);
+        "Meet", " ", "me", " ", "at", " ", "3", ":", "00", " ", "AM", " ", "on", " ", "December",
+        " ", "3", "rd", ",", " ", "2003", " ", "at", " ", "the", " ", "AM", "/", "PM", " ", "on",
+        " ", "Sunset",
+    ];
+    tokenize_assert(
+        "Meet me at 3:00 AM on December 3rd, 2003 at the AM/PM on Sunset",
+        comp,
+    );
 }
 
 #[test]
 fn test_tokenize150() {
-    let comp = vec!["Jan", " ", "29", ",", " ", "1945", " ", "14", ":", "45", " ", "AM", " ", "I", " ", "going", " ", "to", " ", "see", " ", "you", " ", "there", "?"];
+    let comp = vec![
+        "Jan", " ", "29", ",", " ", "1945", " ", "14", ":", "45", " ", "AM", " ", "I", " ",
+        "going", " ", "to", " ", "see", " ", "you", " ", "there", "?",
+    ];
     tokenize_assert("Jan 29, 1945 14:45 AM I going to see you there?", comp);
 }
 

src/tokenize.rs

@@ -14,7 +14,6 @@ pub(crate) enum ParseState {
 }
 
 impl Tokenizer {
-
     pub(crate) fn new(parse_string: &str) -> Self {
         Tokenizer {
             token_stack: vec![],
@@ -92,7 +91,7 @@ impl Iterator for Tokenizer {
                     } else {
                         break;
                     }
-                },
+                }
                 ParseState::Alpha => {
                     seenletters = true;
                     if self.isword(nextchar) {
@@ -105,19 +104,21 @@ impl Iterator for Tokenizer {
                         self.parse_string.push(nextchar);
                         break;
                     }
-                },
+                }
                 ParseState::Numeric => {
                     if self.isnum(nextchar) {
                         // UNWRAP: Because we're in non-empty parse state, we're guaranteed to have a token
                         token.as_mut().unwrap().push(nextchar);
-                    } else if nextchar == '.' || (nextchar == ',' && token.as_ref().unwrap().len() >= 2) {
+                    } else if nextchar == '.'
+                        || (nextchar == ',' && token.as_ref().unwrap().len() >= 2)
+                    {
                         token.as_mut().unwrap().push(nextchar);
                         state = ParseState::NumericDecimal;
                     } else {
                         self.parse_string.push(nextchar);
                         break;
                     }
-                },
+                }
                 ParseState::AlphaDecimal => {
                     seenletters = true;
                     if nextchar == '.' || self.isword(nextchar) {
@@ -130,7 +131,7 @@ impl Iterator for Tokenizer {
                         self.parse_string.push(nextchar);
                         break;
                     }
-                },
+                }
                 ParseState::NumericDecimal => {
                     if nextchar == '.' || self.isnum(nextchar) {
                         // UNWRAP: Because we're in non-empty parse state, we're guaranteed to have a token
@@ -150,7 +151,12 @@ impl Iterator for Tokenizer {
         // We do something slightly different to express the same logic
         if state == ParseState::AlphaDecimal || state == ParseState::NumericDecimal {
             // UNWRAP: The state check guarantees that we have a value
-            let dot_count = token.as_ref().unwrap().chars().filter(|c| *c == '.').count();
+            let dot_count = token
+                .as_ref()
+                .unwrap()
+                .chars()
+                .filter(|c| *c == '.')
+                .count();
             let last_char = token.as_ref().unwrap().chars().last();
             let last_splittable = last_char == Some('.') || last_char == Some(',');
 

src/weekday.rs

@@ -1,5 +1,5 @@
-use ParseResult;
 use ParseError;
+use ParseResult;
 
 #[derive(Debug, PartialEq)]
 pub enum DayOfWeek {
@@ -9,11 +9,10 @@ pub enum DayOfWeek {
     Wednesday,
     Thursday,
     Friday,
-    Saturday
+    Saturday,
 }
 
 impl DayOfWeek {
-
     pub fn to_numeral(&self) -> u32 {
         match *self {
             DayOfWeek::Sunday => 0,
@@ -35,7 +34,7 @@ impl DayOfWeek {
             4 => DayOfWeek::Thursday,
             5 => DayOfWeek::Friday,
             6 => DayOfWeek::Saturday,
-            _ => panic!("Unreachable.")
+            _ => panic!("Unreachable."),
         }
     }
 
@@ -59,12 +58,12 @@ pub fn day_of_week(year: u32, month: u32, day: u32) -> ParseResult<DayOfWeek> {
         3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 => {
             let c = year / 100;
             (c, year - 100 * c)
-        },
+        }
         1 | 2 => {
             let c = (year - 1) / 100;
             (c, year - 1 - 100 * c)
-        },
+        }
-        _ => return Err(ParseError::ImpossibleTimestamp("Invalid month"))
+        _ => return Err(ParseError::ImpossibleTimestamp("Invalid month")),
     };
 
     let e = match month {
@@ -75,7 +74,7 @@ pub fn day_of_week(year: u32, month: u32, day: u32) -> ParseResult<DayOfWeek> {
         8 => 1,
         9 | 12 => 4,
         10 => 6,
-        _ => panic!("Unreachable.")
+        _ => panic!("Unreachable."),
     };
 
     // This implementation is Gregorian-only.
@@ -84,7 +83,7 @@ pub fn day_of_week(year: u32, month: u32, day: u32) -> ParseResult<DayOfWeek> {
         1 => 5,
         2 => 3,
         3 => 1,
-        _ => panic!("Unreachable.")
+        _ => panic!("Unreachable."),
     };
 
     match (day + e + f + g + g / 4) % 7 {
@@ -95,7 +94,7 @@ pub fn day_of_week(year: u32, month: u32, day: u32) -> ParseResult<DayOfWeek> {
         4 => Ok(DayOfWeek::Thursday),
         5 => Ok(DayOfWeek::Friday),
         6 => Ok(DayOfWeek::Saturday),
-        _ => panic!("Unreachable.")
+        _ => panic!("Unreachable."),
     }
 }
 
@@ -114,7 +113,6 @@ mod test {
 
     #[test]
     fn weekday_difference() {
-
         assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Sunday), 0);
         assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Monday), 1);
         assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Tuesday), 2);