Release version 2.1.0

Don't use `oldtime` feature of chrono

.gitignore

@@ -3,4 +3,6 @@
 **/*.rs.bk
 Cargo.lock
 .vscode
-*.pyc
+*.pyc
+.idea/
+*.swp

.travis.yml

@@ -1,5 +0,0 @@
-language: rust
-rust:
-  - stable
-  - beta
-  - nightly

CHANGELOG.md

@@ -0,0 +1,34 @@
+Version 1.0.3 (2018-09-18)
+==========================
+
+Misc
+----
+
+- Changed the default `parse` function to use a static parser
+
+Version 1.0.2 (2018-08-14)
+==========================
+
+Misc
+----
+
+- Add tests for WASM
+
+Version 1.0.1 (2018-08-11)
+==========================
+
+Bugfixes
+--------
+
+- Fixed an issue with "GMT+3" not being handled correctly
+
+Misc
+----
+
+- Upgrade `lazy_static` and `rust_decimal` dependencies
+
+Version 1.0.0 (2018-08-03)
+==========================
+
+Initial release. Passes all relevant unit tests from Python's
+`dateutil` project.

CONTRIBUTING.md

@@ -0,0 +1,44 @@
+# Contributing
+
+The `dtparse` crate is better for the contributions made by members of the open source community,
+and seeks to make it easy to contribute back to the community it comes from. The goals are
+fairly straight-forward, but here are the ways that would be most beneficial:
+
+## Bug Reports
+
+The testing suite for `dtparse` is built using tests derived from the [`dateutil`](https://github.com/dateutil/dateutil)
+package in Python. Some Rust-specific behavior may show up though, for example in how
+Rust handles nanoseconds where Python's standard library will only go to microseconds.
+
+If you believe that behavior is improper, you are encouraged to file an issue; there are no dumb
+issues or suggestions, and the world is a better place for having your input.
+
+## Testing/Fuzzing
+
+`dtparse`'s history as a port of Python software has led to some behavior being shown in Rust
+that would not otherwise be an issue in Python. Testing for these issues to prevent panics
+is greatly appreciated, and some great work has already happened surrounding fuzzing.
+
+New test cases built either by fuzzers or humans are welcome.
+
+## Feature Requests
+
+Handling weird date formats and quirks is the name of the game. Any ideas on how to improve that
+or utilities useful in handling the mapping of human time to computers is appreciated.
+
+Writing code to implement the feature is never mandatory (though always appreciated); if there's
+something you believe `dtparse` should do that it doesn't currently support, let's make that happen.
+
+# Development Setup
+
+The setup requirements for `dtparse` should be fairly straightforward - the project can be built
+and deployed using only the `cargo` tool in Rust.
+
+Much of the test coee is generated from Python code, and then the generated versions are stored
+in version control. Thi is to ensure that all users can run the tests even without
+installing Python or the other necessary packages.
+
+To regenerate the tests, please use Python 3.6 with the `dateutil` package installed, and run:
+
+- `python build_pycompat.py`
+- `python build_pycompat_tokenizer.py`

CONTRIBUTORS.md

@@ -0,0 +1,7 @@
+This project benefits from the Rust and open source communities, but most specifically from these people:
+
+# Contributors:
+
+- [@messense](https://github.com/messense)
+- [@mjmeehan](https://github.com/mjmeehan)
+- [@neosilky](https://github.com/neosilky)

Cargo.toml

@@ -1,21 +1,26 @@
 [package]
 name = "dtparse"
-version = "0.9.1"
+version = "2.0.1"
 authors = ["Bradlee Speice <bradlee@speice.io>"]
 description = "A dateutil-compatible timestamp parser for Rust"
 repository = "https://github.com/bspeice/dtparse.git"
 readme = "README.md"
 categories = ["date-and-time"]
 license = "Apache-2.0"
+exclude = ["/*.py"]
 
 [badges]
 travis-ci = { repository = "bspeice/dtparse" }
+maintenance = { status = "passively-maintained" }
 
 [lib]
 name = "dtparse"
 
 [dependencies]
-chrono = "0.4"
-lazy_static = "1.0"
-num-traits = "0.2"
-rust_decimal = "0.9"
+chrono = { version = "0.4.24", default-features = false, features = ["clock"] }
+lazy_static = "1.4.0"
+num-traits = "0.2.15"
+rust_decimal = { version = "1.29.1", default-features = false }
+
+[dev-dependencies]
+base64 = "0.21.0"

LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,27 +1,73 @@
 # dtparse
-A [dateutil](https://github.com/dateutil/dateutil)-compatible timestamp parser for Rust
 
-## Where it stands
+[![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/)
 
-The library works really well at the moment, and passes the vast majority of `dateutil`s parser
-test suite. This isn't mission-critical ready, but is more than ready for hobbyist projects.
 
-The issues to be resolved before version 1.0:
+The fully-featured "even I couldn't understand that" time parser.
+Designed to take in strings and give back sensible dates and times.
 
-**Functionality**:
+dtparse has its foundations in the [`dateutil`](dateutil) library for
+Python, which excels at taking "interesting" strings and trying to make
+sense of the dates and times they contain. A couple of quick examples
+from the test cases should give some context:
 
-1. ~~We don't support weekday parsing. In the Python side this is accomplished via `dateutil.relativedelta`~~
-Supported in v0.8
+```rust
+extern crate chrono;
+extern crate dtparse;
+use chrono::prelude::*;
+use dtparse::parse;
 
-2. Named timezones aren't supported very well. [chrono_tz](https://github.com/chronotope/chrono-tz)
-theoretically would provide support, but I'd also like some helper things available (e.g. "EST" is not a named zone in `chrono-tz`).
-Explicit time zones (i.e. "00:00:00 -0300") are working as expected.
+assert_eq!(
+    parse("2008.12.30"),
+    Ok((NaiveDate::from_ymd(2008, 12, 30).and_hms(0, 0, 0), None))
+);
 
-3. ~~"Fuzzy" and "Fuzzy with tokens" modes haven't been tested. The code should work, but I need to get the
-test cases added to the auto-generation suite~~
+// It can even handle timezones!
+assert_eq!(
+    parse("January 4, 2024; 18:30:04 +02:00"),
+    Ok((
+        NaiveDate::from_ymd(2024, 1, 4).and_hms(18, 30, 4),
+        Some(FixedOffset::east(7200))
+    ))
+);
+```
 
-**Non-functional**: This library is intended to be a direct port from Python, and thus the code
-looks a lot more like Python than it does Rust. There are a ton of `TODO` comments in the code
-that need cleaned up, things that could be converted to enums, etc.
+And we can even handle fuzzy strings where dates/times aren't the
+only content if we dig into the implementation a bit!
 
-In addition, some more documentation would be incredibly helpful. It's, uh, sparse at the moment.
+```rust
+extern crate chrono;
+extern crate dtparse;
+use chrono::prelude::*;
+use dtparse::Parser;
+use std::collections::HashMap;
+
+let mut p = Parser::default();
+assert_eq!(
+    p.parse(
+        "I first released this library on the 17th of June, 2018.",
+        None, None,
+        true /* turns on fuzzy mode */,
+        true /* gives us the tokens that weren't recognized */,
+        None, false, &HashMap::new()
+    ),
+    Ok((
+        NaiveDate::from_ymd(2018, 6, 17).and_hms(0, 0, 0),
+        None,
+        Some(vec!["I first released this library on the ",
+                  " of ", ", "].iter().map(|&s| s.into()).collect())
+    ))
+);
+```
+
+Further examples can be found in the [examples](examples) directory on international usage.
+
+# Usage
+
+`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.
+
+[dateutil]: https://github.com/dateutil/dateutil
+[examples]: https://github.com/bspeice/dtparse/tree/master/examples

build_pycompat.py

@@ -1,4 +1,6 @@
+#!/usr/bin/python3
 from dateutil.parser import parse
+from dateutil.tz import tzutc
 from datetime import datetime
 
 tests = {
@@ -48,7 +50,9 @@ tests = {
     'test_parse_offset': [
         'Thu, 25 Sep 2003 10:49:41 -0300', '2003-09-25T10:49:41.5-03:00',
         '2003-09-25T10:49:41-03:00', '20030925T104941.5-0300',
-        '20030925T104941-0300'
+        '20030925T104941-0300',
+        # dtparse-specific
+        "2018-08-10 10:00:00 UTC+3", "2018-08-10 03:36:47 PM GMT-4", "2018-08-10 04:15:00 AM Z-02:00"
     ],
     'test_parse_dayfirst': [
         '10-09-2003', '10.09.2003', '10/09/2003', '10 09 2003',
@@ -77,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': [
@@ -189,6 +193,10 @@ def test_fuzzy_simple(i, s):
 
 # Here lies all the ugly junk.
 TEST_HEADER = '''
+//! This code has been generated by running the `build_pycompat.py` script
+//! in the repository root. Please do not edit it, as your edits will be destroyed
+//! upon re-running code generation.
+
 extern crate chrono;
 
 use chrono::Datelike;
@@ -222,10 +230,10 @@ fn parse_and_assert(
     fuzzy_with_tokens: bool,
     default: Option<&NaiveDateTime>,
     ignoretz: bool,
-    tzinfos: HashMap<String, i32>,
+    tzinfos: &HashMap<String, i32>,
 ) {
 
-    let mut parser = Parser::new(info);
+    let parser = Parser::new(info);
     let rs_parsed = parser.parse(
         s,
         dayfirst,
@@ -272,10 +280,10 @@ fn parse_fuzzy_and_assert(
     fuzzy_with_tokens: bool,
     default: Option<&NaiveDateTime>,
     ignoretz: bool,
-    tzinfos: HashMap<String, i32>,
+    tzinfos: &HashMap<String, i32>,
 ) {
 
-    let mut parser = Parser::new(info);
+    let parser = Parser::new(info);
     let rs_parsed = parser.parse(
         s,
         dayfirst,
@@ -309,14 +317,14 @@ TEST_PARSE_DEFAULT = '''
 #[test]
 fn test_parse_default{i}() {{
     let info = ParserInfo::default();
-    let default_rsdate = &NaiveDate::from_ymd(2003, 9, 25).and_hms(0, 0, 0);
+    let default_rsdate = &NaiveDate::from_ymd_opt(2003, 9, 25).unwrap().and_hms_opt(0, 0, 0).unwrap();
     let pdt = PyDateTime {{
         year: {d.year}, month: {d.month}, day: {d.day},
         hour: {d.hour}, minute: {d.minute}, second: {d.second},
         micros: {d.microsecond}, tzo: None
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     Some(default_rsdate), false, HashMap::new());
+                     Some(default_rsdate), false, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_SIMPLE = '''
@@ -340,7 +348,7 @@ fn test_parse_tzinfo{i}() {{
         micros: {d.microsecond}, tzo: Some({offset}),
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     None, false, rs_tzinfo_map!());
+                     None, false, &rs_tzinfo_map!());
 }}\n'''
 
 TEST_PARSE_OFFSET = '''
@@ -353,7 +361,7 @@ fn test_parse_offset{i}() {{
         micros: {d.microsecond}, tzo: Some({offset}),
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     None, false, HashMap::new());
+                     None, false, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_DAYFIRST = '''
@@ -366,7 +374,7 @@ fn test_parse_dayfirst{i}() {{
         micros: {d.microsecond}, tzo: None,
     }};
     parse_and_assert(pdt, info, "{s}", Some(true), None, false, false,
-                     None, false, HashMap::new());
+                     None, false, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_YEARFIRST = '''
@@ -379,7 +387,7 @@ fn test_parse_yearfirst{i}() {{
         micros: {d.microsecond}, tzo: None,
     }};
     parse_and_assert(pdt, info, "{s}", None, Some(true), false, false,
-                     None, false, HashMap::new());
+                     None, false, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_DFYF = '''
@@ -392,21 +400,21 @@ fn test_parse_dfyf{i}() {{
         micros: {d.microsecond}, tzo: None,
     }};
     parse_and_assert(pdt, info, "{s}", Some(true), Some(true), false, false,
-                     None, false, HashMap::new());
+                     None, false, &HashMap::new());
 }}\n'''
 
 TEST_UNSPECIFIED_FALLBACK = '''
 #[test]
 fn test_unspecified_fallback{i}() {{
     let info = ParserInfo::default();
-    let default_rsdate = &NaiveDate::from_ymd(2010, 1, 31).and_hms(0, 0, 0);
+    let default_rsdate = &NaiveDate::from_ymd_opt(2010, 1, 31).unwrap().and_hms_opt(0, 0, 0).unwrap();
     let pdt = PyDateTime {{
         year: {d.year}, month: {d.month}, day: {d.day},
         hour: {d.hour}, minute: {d.minute}, second: {d.second},
         micros: {d.microsecond}, tzo: None
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     Some(default_rsdate), false, HashMap::new());
+                     Some(default_rsdate), false, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_IGNORETZ = '''
@@ -419,7 +427,7 @@ fn test_parse_ignoretz{i}() {{
         micros: {d.microsecond}, tzo: None
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     None, true, HashMap::new());
+                     None, true, &HashMap::new());
 }}\n'''
 
 TEST_PARSE_DEFAULT_IGNORE = '''
@@ -427,14 +435,14 @@ TEST_PARSE_DEFAULT_IGNORE = '''
 #[ignore]
 fn test_parse_default_ignore{i}() {{
     let info = ParserInfo::default();
-    let default_rsdate = &NaiveDate::from_ymd(2003, 9, 25).and_hms(0, 0, 0);
+    let default_rsdate = &NaiveDate::from_ymd_opt(2003, 9, 25).unwrap().and_hms_opt(0, 0, 0).unwrap();
     let pdt = PyDateTime {{
         year: {d.year}, month: {d.month}, day: {d.day},
         hour: {d.hour}, minute: {d.minute}, second: {d.second},
         micros: {d.microsecond}, tzo: None
     }};
     parse_and_assert(pdt, info, "{s}", None, None, false, false,
-                     Some(default_rsdate), false, HashMap::new());
+                     Some(default_rsdate), false, &HashMap::new());
 }}\n'''
 
 TEST_FUZZY_TZINFO = '''
@@ -447,7 +455,7 @@ fn test_fuzzy_tzinfo{i}() {{
         micros: {d.microsecond}, tzo: Some({offset})
     }};
     parse_fuzzy_and_assert(pdt, None, info, "{s}", None, None, true, false,
-                           None, false, HashMap::new());
+                           None, false, &HashMap::new());
 }}\n'''
 
 TEST_FUZZY_TOKENS_TZINFO = '''
@@ -461,7 +469,7 @@ fn test_fuzzy_tokens_tzinfo{i}() {{
     }};
     let tokens = vec![{tokens}];
     parse_fuzzy_and_assert(pdt, Some(tokens), info, "{s}", None, None, true, true,
-                           None, false, HashMap::new());
+                           None, false, &HashMap::new());
 }}\n'''
 
 TEST_FUZZY_SIMPLE = '''
@@ -474,7 +482,7 @@ fn test_fuzzy_simple{i}() {{
         micros: {d.microsecond}, tzo: None
     }};
     parse_fuzzy_and_assert(pdt, None, info, "{s}", None, None, true, false,
-                           None, false, HashMap::new());
+                           None, false, &HashMap::new());
 }}\n'''
 
 

build_pycompat_tokenizer.py

@@ -1,3 +1,4 @@
+#!/usr/bin/python3
 from dateutil.parser import _timelex
 
 from build_pycompat import tests
@@ -24,6 +25,10 @@ fn test_tokenize{i}() {{
 
 
 TEST_HEADER = '''
+//! 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.
+
 use tokenize::Tokenizer;
 
 fn tokenize_assert(test_str: &str, comparison: Vec<&str>) {

examples/russian.rs

@@ -0,0 +1,48 @@
+extern crate chrono;
+extern crate dtparse;
+
+use chrono::NaiveDate;
+use dtparse::parse_info;
+use dtparse::Parser;
+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
+
+    let mut info = ParserInfo::default();
+    info.months = parse_info(vec![
+        vec!["янв", "Январь"],
+        vec!["фев", "Февраль"],
+        vec!["мар", "Март"],
+        vec!["апр", "Апрель"],
+        vec!["май", "Май"],
+        vec!["июн", "Июнь"],
+        vec!["июл", "Июль"],
+        vec!["авг", "Август"],
+        vec!["сен", "Сентябрь"],
+        vec!["окт", "Октябрь"],
+        vec!["ноя", "Ноябрь"],
+        vec!["дек", "Декабрь"],
+    ]);
+
+    let p = Parser::new(info);
+
+    assert_eq!(
+        p.parse(
+            "10 Сентябрь 2015 10:20",
+            None,
+            None,
+            false,
+            false,
+            None,
+            false,
+            &HashMap::new()
+        )
+        .unwrap()
+        .0,
+        NaiveDate::from_ymd_opt(2015, 9, 10).unwrap().and_hms_opt(10, 20, 0).unwrap()
+    );
+}

fuzz/.gitignore

@@ -1,5 +0,0 @@
-
-target
-libfuzzer
-corpus
-artifacts

fuzz/Cargo.toml

@@ -1,22 +0,0 @@
-
-[package]
-name = "dtparse-fuzz"
-version = "0.0.1"
-authors = ["Automatically generated"]
-publish = false
-
-[package.metadata]
-cargo-fuzz = true
-
-[dependencies.dtparse]
-path = ".."
-[dependencies.libfuzzer-sys]
-git = "https://github.com/rust-fuzz/libfuzzer-sys.git"
-
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
-
-[[bin]]
-name = "fuzzer_script_1"
-path = "fuzzers/fuzzer_script_1.rs"

fuzz/fuzzers/fuzzer_script_1.rs

@@ -1,10 +0,0 @@
-#![no_main]
-extern crate libfuzzer_sys;
-extern crate dtparse;
-use dtparse::parse;
-#[export_name="rust_fuzzer_test_input"]
-pub extern fn go(data: &[u8]) {
-    if let Ok(s) = std::str::from_utf8(data) {
-        parse(s);
-    }
-}

src/tests/fuzzing.rs

@@ -1,24 +1,106 @@
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD;
 use chrono::NaiveDate;
 use std::collections::HashMap;
+use std::str;
 
 use parse;
 use ParseError;
-use ParseInternalError;
 use Parser;
 
 #[test]
 fn test_fuzz() {
+    assert_eq!(
+        parse("\x2D\x38\x31\x39\x34\x38\x34"),
+        Err(ParseError::ImpossibleTimestamp("Invalid month"))
+    );
 
-    assert_eq!(parse("\x2D\x38\x31\x39\x34\x38\x34"), Err(ParseError::InvalidMonth));
     // Garbage in the third delimited field
-    assert_eq!(parse("2..\x00\x000d\x00+\x010d\x01\x00\x00\x00+"),
-               Err(ParseError::InternalError(ParseInternalError::ValueError("Unknown string format".to_owned()))));
-    // OverflowError: Python int too large to convert to C long
-    // assert_eq!(parse("8888884444444888444444444881"), Err(ParseError::AmPmWithoutHour));
-    let default = NaiveDate::from_ymd(2016, 6, 29).and_hms(0, 0, 0);
-    let mut p = Parser::default();
-    let res = p.parse("\x0D\x31", None, None, false, false, Some(&default), false, HashMap::new()).unwrap();
-    assert_eq!(res.0, default);
+    assert_eq!(
+        parse("2..\x00\x000d\x00+\x010d\x01\x00\x00\x00+"),
+        Err(ParseError::UnrecognizedFormat)
+    );
 
-    assert_eq!(parse("\x2D\x2D\x32\x31\x38\x6D"), Err(ParseError::ImpossibleTimestamp("Invalid minute")));
+    let default = NaiveDate::from_ymd_opt(2016, 6, 29).unwrap().and_hms_opt(0, 0, 0).unwrap();
+    let p = Parser::default();
+    let res = p.parse(
+        "\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"))
+    );
 }
+
+#[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))
+}
+
+#[test]
+fn github_33() {
+    assert_eq!(parse("66:'"), Err(ParseError::InvalidNumeric("'".to_owned())))
+}
+
+#[test]
+fn github_32() {
+    assert_eq!(parse("99999999999999999999999"), Err(ParseError::InvalidNumeric("99999999999999999999999".to_owned())))
+}
+
+#[test]
+fn github_34() {
+    let parse_vec = STANDARD.decode("KTMuLjYpGDYvLjZTNiouNjYuHzZpLjY/NkwuNh42Ry42PzYnKTMuNk02NjY2NjA2NjY2NjY2NjYTNjY2Ni82NjY2NlAuNlAuNlNI").unwrap();
+    let parse_str = str::from_utf8(&parse_vec).unwrap();
+    let parse_result = parse(parse_str);
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn github_35() {
+    let parse_vec = STANDARD.decode("KTY6LjYqNio6KjYn").unwrap();
+    let parse_str = str::from_utf8(&parse_vec).unwrap();
+    let parse_result = parse(parse_str);
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn github_36() {
+    let parse_vec = STANDARD.decode("KTYuLg==").unwrap();
+    let parse_str = str::from_utf8(&parse_vec).unwrap();
+    let parse_result = parse(parse_str);
+    assert!(parse_result.is_err());
+}
+
+#[test]
+fn github_45() {
+    assert!(parse("/2018-fifa-").is_err());
+    assert!(parse("/2009/07/").is_err());
+    assert!(parse("2021-09-").is_err());
+}

src/tests/mod.rs

@@ -1,3 +1,14 @@
 mod fuzzing;
 mod pycompat_parser;
 mod pycompat_tokenizer;
+
+use chrono::NaiveDate;
+use crate::parse;
+
+#[test]
+fn nanosecond_precision() {
+    assert_eq!(
+        parse("2008.12.29T08:09:10.123456789").unwrap(),
+        (NaiveDate::from_ymd_opt(2008, 12, 29).unwrap().and_hms_nano_opt(8, 9, 10, 123_456_789).unwrap(), None)
+    )
+}

src/tests/pycompat_tokenizer.rs

@@ -1,3 +1,6 @@
+//! 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.
 
 use tokenize::Tokenizer;
 
@@ -8,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);
 }
 
@@ -290,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);
 }
 
@@ -302,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);
 }
 
@@ -350,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);
 }
 
@@ -506,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);
 }
 
@@ -518,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);
 }
 
@@ -554,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);
 }
 
@@ -584,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);
 }
 
@@ -614,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);
 }
 
@@ -662,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);
 }
 
@@ -704,198 +745,346 @@ fn test_tokenize115() {
 
 #[test]
 fn test_tokenize116() {
+    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",
+    ];
+    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",
+    ];
+    tokenize_assert("2018-08-10 04:15:00 AM Z-02:00", comp);
+}
+
+#[test]
+fn test_tokenize119() {
     let comp = vec!["10", "-", "09", "-", "2003"];
     tokenize_assert("10-09-2003", comp);
 }
 
 #[test]
-fn test_tokenize117() {
+fn test_tokenize120() {
     let comp = vec!["10", ".", "09", ".", "2003"];
     tokenize_assert("10.09.2003", comp);
 }
 
 #[test]
-fn test_tokenize118() {
+fn test_tokenize121() {
     let comp = vec!["10", "/", "09", "/", "2003"];
     tokenize_assert("10/09/2003", comp);
 }
 
 #[test]
-fn test_tokenize119() {
+fn test_tokenize122() {
     let comp = vec!["10", " ", "09", " ", "2003"];
     tokenize_assert("10 09 2003", comp);
 }
 
 #[test]
-fn test_tokenize120() {
+fn test_tokenize123() {
     let comp = vec!["090107"];
     tokenize_assert("090107", comp);
 }
 
 #[test]
-fn test_tokenize121() {
+fn test_tokenize124() {
     let comp = vec!["2015", " ", "09", " ", "25"];
     tokenize_assert("2015 09 25", comp);
 }
 
 #[test]
-fn test_tokenize122() {
+fn test_tokenize125() {
     let comp = vec!["10", "-", "09", "-", "03"];
     tokenize_assert("10-09-03", comp);
 }
 
 #[test]
-fn test_tokenize123() {
+fn test_tokenize126() {
     let comp = vec!["10", ".", "09", ".", "03"];
     tokenize_assert("10.09.03", comp);
 }
 
 #[test]
-fn test_tokenize124() {
+fn test_tokenize127() {
     let comp = vec!["10", "/", "09", "/", "03"];
     tokenize_assert("10/09/03", comp);
 }
 
 #[test]
-fn test_tokenize125() {
+fn test_tokenize128() {
     let comp = vec!["10", " ", "09", " ", "03"];
     tokenize_assert("10 09 03", comp);
 }
 
-#[test]
-fn test_tokenize126() {
-    let comp = vec!["090107"];
-    tokenize_assert("090107", comp);
-}
-
-#[test]
-fn test_tokenize127() {
-    let comp = vec!["2015", " ", "09", " ", "25"];
-    tokenize_assert("2015 09 25", comp);
-}
-
-#[test]
-fn test_tokenize128() {
-    let comp = vec!["090107"];
-    tokenize_assert("090107", comp);
-}
-
 #[test]
 fn test_tokenize129() {
-    let comp = vec!["2015", " ", "09", " ", "25"];
-    tokenize_assert("2015 09 25", comp);
+    let comp = vec!["090107"];
+    tokenize_assert("090107", comp);
 }
 
 #[test]
 fn test_tokenize130() {
+    let comp = vec!["2015", " ", "09", " ", "25"];
+    tokenize_assert("2015 09 25", comp);
+}
+
+#[test]
+fn test_tokenize131() {
+    let comp = vec!["090107"];
+    tokenize_assert("090107", comp);
+}
+
+#[test]
+fn test_tokenize132() {
+    let comp = vec!["2015", " ", "09", " ", "25"];
+    tokenize_assert("2015 09 25", comp);
+}
+
+#[test]
+fn test_tokenize133() {
     let comp = vec!["April", " ", "2009"];
     tokenize_assert("April 2009", comp);
 }
 
 #[test]
-fn test_tokenize131() {
+fn test_tokenize134() {
     let comp = vec!["Feb", " ", "2007"];
     tokenize_assert("Feb 2007", comp);
 }
 
 #[test]
-fn test_tokenize132() {
+fn test_tokenize135() {
     let comp = vec!["Feb", " ", "2008"];
     tokenize_assert("Feb 2008", comp);
 }
 
 #[test]
-fn test_tokenize133() {
-    let comp = vec!["Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003"];
+fn test_tokenize136() {
+    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_tokenize134() {
-    let comp = vec!["1996", ".", "07", ".", "10", " ", "AD", " ", "at", " ", "15", ":", "08", ":", "56", " ", "PDT"];
+fn test_tokenize137() {
+    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_tokenize135() {
-    let comp = vec!["Tuesday", ",", " ", "April", " ", "12", ",", " ", "1952", " ", "AD", " ", "3", ":", "30", ":", "42", "pm", " ", "PST"];
+fn test_tokenize138() {
+    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_tokenize136() {
-    let comp = vec!["November", " ", "5", ",", " ", "1994", ",", " ", "8", ":", "15", ":", "30", " ", "am", " ", "EST"];
+fn test_tokenize139() {
+    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_tokenize137() {
-    let comp = vec!["1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "-", "05", ":", "00"];
+fn test_tokenize140() {
+    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_tokenize138() {
-    let comp = vec!["1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "Z"];
+fn test_tokenize141() {
+    let comp = vec![
+        "1994", "-", "11", "-", "05", "T", "08", ":", "15", ":", "30", "Z",
+    ];
     tokenize_assert("1994-11-05T08:15:30Z", comp);
 }
 
 #[test]
-fn test_tokenize139() {
-    let comp = vec!["1976", "-", "07", "-", "04", "T", "00", ":", "01", ":", "02", "Z"];
+fn test_tokenize142() {
+    let comp = vec![
+        "1976", "-", "07", "-", "04", "T", "00", ":", "01", ":", "02", "Z",
+    ];
     tokenize_assert("1976-07-04T00:01:02Z", comp);
 }
 
 #[test]
-fn test_tokenize140() {
-    let comp = vec!["Tue", " ", "Apr", " ", "4", " ", "00", ":", "22", ":", "12", " ", "PDT", " ", "1995"];
+fn test_tokenize143() {
+    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_tokenize141() {
-    let comp = vec!["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_tokenize142() {
-    let comp = vec!["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_tokenize143() {
-    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_tokenize144() {
-    let comp = vec!["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);
+    let comp = vec![
+        "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!["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);
+    let comp = vec![
+        "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!["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);
+    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!["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);
+    let comp = vec![
+        "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",
+    ];
+    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",
+    ];
+    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", "?",
+    ];
+    tokenize_assert("Jan 29, 1945 14:45 AM I going to see you there?", comp);
+}
+
+#[test]
+fn test_tokenize151() {
     let comp = vec!["2017", "-", "07", "-", "17", " ", "06", ":", "15", ":"];
     tokenize_assert("2017-07-17 06:15:", 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,20 +151,25 @@ 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(',');
-    
+
             if seenletters || dot_count > 1 || last_splittable {
                 let mut l = self.decimal_split(token.as_ref().unwrap());
                 let remaining = l.split_off(1);
-    
+
                 token = Some(l[0].clone());
                 for t in remaining {
                     self.token_stack.push(t);
                 }
             }
-    
+
             if state == ParseState::NumericDecimal && dot_count == 0 {
                 token = Some(token.unwrap().replace(',', "."));
             }

src/weekday.rs

@@ -1,5 +1,5 @@
-use ParseResult;
 use ParseError;
+use ParseResult;
 
 #[derive(Debug, PartialEq)]
 pub enum DayOfWeek {
@@ -9,13 +9,12 @@ pub enum DayOfWeek {
     Wednesday,
     Thursday,
     Friday,
-    Saturday
+    Saturday,
 }
 
 impl DayOfWeek {
-
     pub fn to_numeral(&self) -> u32 {
-        match self {
+        match *self {
             DayOfWeek::Sunday => 0,
             DayOfWeek::Monday => 1,
             DayOfWeek::Tuesday => 2,
@@ -35,12 +34,12 @@ impl DayOfWeek {
             4 => DayOfWeek::Thursday,
             5 => DayOfWeek::Friday,
             6 => DayOfWeek::Saturday,
-            _ => panic!("Unreachable.")
+            _ => panic!("Unreachable."),
         }
     }
 
     /// Given the current day of the week, how many days until the next day?
-    pub fn difference(&self, other: DayOfWeek) -> u32 {
+    pub fn difference(&self, other: &DayOfWeek) -> u32 {
         // Have to use i32 because of wraparound issues
         let s_num = self.to_numeral() as i32;
         let o_num = other.to_numeral() as i32;
@@ -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::InvalidMonth)
+        }
+        _ => 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,19 +113,18 @@ 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);
-        assert_eq!(DayOfWeek::Sunday.difference(DayOfWeek::Wednesday), 3);
-        assert_eq!(DayOfWeek::Sunday.difference(DayOfWeek::Thursday), 4);
-        assert_eq!(DayOfWeek::Sunday.difference(DayOfWeek::Friday), 5);
-        assert_eq!(DayOfWeek::Sunday.difference(DayOfWeek::Saturday), 6);
-        assert_eq!(DayOfWeek::Monday.difference(DayOfWeek::Sunday), 6);
-        assert_eq!(DayOfWeek::Tuesday.difference(DayOfWeek::Sunday), 5);
-        assert_eq!(DayOfWeek::Wednesday.difference(DayOfWeek::Sunday), 4);
-        assert_eq!(DayOfWeek::Thursday.difference(DayOfWeek::Sunday), 3);
-        assert_eq!(DayOfWeek::Friday.difference(DayOfWeek::Sunday), 2);
-        assert_eq!(DayOfWeek::Saturday.difference(DayOfWeek::Sunday), 1);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Sunday), 0);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Monday), 1);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Tuesday), 2);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Wednesday), 3);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Thursday), 4);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Friday), 5);
+        assert_eq!(DayOfWeek::Sunday.difference(&DayOfWeek::Saturday), 6);
+        assert_eq!(DayOfWeek::Monday.difference(&DayOfWeek::Sunday), 6);
+        assert_eq!(DayOfWeek::Tuesday.difference(&DayOfWeek::Sunday), 5);
+        assert_eq!(DayOfWeek::Wednesday.difference(&DayOfWeek::Sunday), 4);
+        assert_eq!(DayOfWeek::Thursday.difference(&DayOfWeek::Sunday), 3);
+        assert_eq!(DayOfWeek::Friday.difference(&DayOfWeek::Sunday), 2);
+        assert_eq!(DayOfWeek::Saturday.difference(&DayOfWeek::Sunday), 1);
     }
-}
+}