mirror of
https://github.com/bspeice/dtparse
synced 2025-04-09 23:41:30 -04:00
Compare commits
No commits in common. "master" and "v0.9.1" have entirely different histories.
4
.gitignore
vendored
4
.gitignore
vendored
@ -3,6 +3,4 @@
|
||||
**/*.rs.bk
|
||||
Cargo.lock
|
||||
.vscode
|
||||
*.pyc
|
||||
.idea/
|
||||
*.swp
|
||||
*.pyc
|
||||
5
.travis.yml
Normal file
5
.travis.yml
Normal file
@ -0,0 +1,5 @@
|
||||
language: rust
|
||||
rust:
|
||||
- stable
|
||||
- beta
|
||||
- nightly
|
||||
34
CHANGELOG.md
34
CHANGELOG.md
@ -1,34 +0,0 @@
|
||||
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.
|
||||
@ -1,44 +0,0 @@
|
||||
# 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`
|
||||
@ -1,7 +0,0 @@
|
||||
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)
|
||||
15
Cargo.toml
15
Cargo.toml
@ -1,26 +1,21 @@
|
||||
[package]
|
||||
name = "dtparse"
|
||||
version = "2.0.1"
|
||||
version = "0.9.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 = { 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"
|
||||
chrono = "0.4"
|
||||
lazy_static = "1.0"
|
||||
num-traits = "0.2"
|
||||
rust_decimal = "0.9"
|
||||
|
||||
202
LICENSE-APACHE
202
LICENSE-APACHE
@ -1,202 +0,0 @@
|
||||
|
||||
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.
|
||||
80
README.md
80
README.md
@ -1,73 +1,27 @@
|
||||
# dtparse
|
||||
A [dateutil](https://github.com/dateutil/dateutil)-compatible timestamp parser for Rust
|
||||
|
||||
[](https://crates.io/crates/dtparse)
|
||||
[](https://docs.rs/dtparse/)
|
||||
## Where it stands
|
||||
|
||||
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 fully-featured "even I couldn't understand that" time parser.
|
||||
Designed to take in strings and give back sensible dates and times.
|
||||
The issues to be resolved before version 1.0:
|
||||
|
||||
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:
|
||||
**Functionality**:
|
||||
|
||||
```rust
|
||||
extern crate chrono;
|
||||
extern crate dtparse;
|
||||
use chrono::prelude::*;
|
||||
use dtparse::parse;
|
||||
1. ~~We don't support weekday parsing. In the Python side this is accomplished via `dateutil.relativedelta`~~
|
||||
Supported in v0.8
|
||||
|
||||
assert_eq!(
|
||||
parse("2008.12.30"),
|
||||
Ok((NaiveDate::from_ymd(2008, 12, 30).and_hms(0, 0, 0), None))
|
||||
);
|
||||
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.
|
||||
|
||||
// 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))
|
||||
))
|
||||
);
|
||||
```
|
||||
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~~
|
||||
|
||||
And we can even handle fuzzy strings where dates/times aren't the
|
||||
only content if we dig into the implementation a bit!
|
||||
**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.
|
||||
|
||||
```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
|
||||
In addition, some more documentation would be incredibly helpful. It's, uh, sparse at the moment.
|
||||
|
||||
50
build_pycompat.py
Executable file → Normal file
50
build_pycompat.py
Executable file → Normal file
@ -1,6 +1,4 @@
|
||||
#!/usr/bin/python3
|
||||
from dateutil.parser import parse
|
||||
from dateutil.tz import tzutc
|
||||
from datetime import datetime
|
||||
|
||||
tests = {
|
||||
@ -50,9 +48,7 @@ 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',
|
||||
# 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"
|
||||
'20030925T104941-0300'
|
||||
],
|
||||
'test_parse_dayfirst': [
|
||||
'10-09-2003', '10.09.2003', '10/09/2003', '10 09 2003',
|
||||
@ -81,7 +77,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', '1986-07-05T08:15:30z',
|
||||
'1994-11-05T08:15:30Z', '1976-07-04T00:01:02Z',
|
||||
'Tue Apr 4 00:22:12 PDT 1995'
|
||||
],
|
||||
'test_fuzzy_tzinfo': [
|
||||
@ -193,10 +189,6 @@ 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;
|
||||
@ -230,10 +222,10 @@ fn parse_and_assert(
|
||||
fuzzy_with_tokens: bool,
|
||||
default: Option<&NaiveDateTime>,
|
||||
ignoretz: bool,
|
||||
tzinfos: &HashMap<String, i32>,
|
||||
tzinfos: HashMap<String, i32>,
|
||||
) {
|
||||
|
||||
let parser = Parser::new(info);
|
||||
let mut parser = Parser::new(info);
|
||||
let rs_parsed = parser.parse(
|
||||
s,
|
||||
dayfirst,
|
||||
@ -280,10 +272,10 @@ fn parse_fuzzy_and_assert(
|
||||
fuzzy_with_tokens: bool,
|
||||
default: Option<&NaiveDateTime>,
|
||||
ignoretz: bool,
|
||||
tzinfos: &HashMap<String, i32>,
|
||||
tzinfos: HashMap<String, i32>,
|
||||
) {
|
||||
|
||||
let parser = Parser::new(info);
|
||||
let mut parser = Parser::new(info);
|
||||
let rs_parsed = parser.parse(
|
||||
s,
|
||||
dayfirst,
|
||||
@ -317,14 +309,14 @@ TEST_PARSE_DEFAULT = '''
|
||||
#[test]
|
||||
fn test_parse_default{i}() {{
|
||||
let info = ParserInfo::default();
|
||||
let default_rsdate = &NaiveDate::from_ymd_opt(2003, 9, 25).unwrap().and_hms_opt(0, 0, 0).unwrap();
|
||||
let default_rsdate = &NaiveDate::from_ymd(2003, 9, 25).and_hms(0, 0, 0);
|
||||
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 = '''
|
||||
@ -348,7 +340,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 = '''
|
||||
@ -361,7 +353,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 = '''
|
||||
@ -374,7 +366,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 = '''
|
||||
@ -387,7 +379,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 = '''
|
||||
@ -400,21 +392,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_opt(2010, 1, 31).unwrap().and_hms_opt(0, 0, 0).unwrap();
|
||||
let default_rsdate = &NaiveDate::from_ymd(2010, 1, 31).and_hms(0, 0, 0);
|
||||
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 = '''
|
||||
@ -427,7 +419,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 = '''
|
||||
@ -435,14 +427,14 @@ TEST_PARSE_DEFAULT_IGNORE = '''
|
||||
#[ignore]
|
||||
fn test_parse_default_ignore{i}() {{
|
||||
let info = ParserInfo::default();
|
||||
let default_rsdate = &NaiveDate::from_ymd_opt(2003, 9, 25).unwrap().and_hms_opt(0, 0, 0).unwrap();
|
||||
let default_rsdate = &NaiveDate::from_ymd(2003, 9, 25).and_hms(0, 0, 0);
|
||||
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 = '''
|
||||
@ -455,7 +447,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 = '''
|
||||
@ -469,7 +461,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 = '''
|
||||
@ -482,7 +474,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'''
|
||||
|
||||
|
||||
|
||||
5
build_pycompat_tokenizer.py
Executable file → Normal file
5
build_pycompat_tokenizer.py
Executable file → Normal file
@ -1,4 +1,3 @@
|
||||
#!/usr/bin/python3
|
||||
from dateutil.parser import _timelex
|
||||
|
||||
from build_pycompat import tests
|
||||
@ -25,10 +24,6 @@ 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>) {
|
||||
|
||||
@ -1,48 +0,0 @@
|
||||
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()
|
||||
);
|
||||
}
|
||||
5
fuzz/.gitignore
vendored
Normal file
5
fuzz/.gitignore
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
|
||||
target
|
||||
libfuzzer
|
||||
corpus
|
||||
artifacts
|
||||
22
fuzz/Cargo.toml
Normal file
22
fuzz/Cargo.toml
Normal file
@ -0,0 +1,22 @@
|
||||
|
||||
[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"
|
||||
10
fuzz/fuzzers/fuzzer_script_1.rs
Normal file
10
fuzz/fuzzers/fuzzer_script_1.rs
Normal file
@ -0,0 +1,10 @@
|
||||
#![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);
|
||||
}
|
||||
}
|
||||
730
src/lib.rs
730
src/lib.rs
File diff suppressed because it is too large
Load Diff
@ -1,106 +1,24 @@
|
||||
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::UnrecognizedFormat)
|
||||
);
|
||||
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);
|
||||
|
||||
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"))
|
||||
);
|
||||
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());
|
||||
}
|
||||
@ -1,14 +1,3 @@
|
||||
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)
|
||||
)
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,6 +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.
|
||||
|
||||
use tokenize::Tokenizer;
|
||||
|
||||
@ -11,9 +8,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -295,9 +290,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -309,9 +302,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -359,9 +350,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -517,10 +506,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -532,9 +518,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -570,33 +554,25 @@ 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);
|
||||
}
|
||||
|
||||
@ -608,9 +584,7 @@ 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);
|
||||
}
|
||||
|
||||
@ -640,17 +614,13 @@ 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);
|
||||
}
|
||||
|
||||
@ -692,42 +662,31 @@ 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);
|
||||
}
|
||||
|
||||
@ -745,346 +704,198 @@ 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_tokenize120() {
|
||||
fn test_tokenize117() {
|
||||
let comp = vec!["10", ".", "09", ".", "2003"];
|
||||
tokenize_assert("10.09.2003", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize121() {
|
||||
fn test_tokenize118() {
|
||||
let comp = vec!["10", "/", "09", "/", "2003"];
|
||||
tokenize_assert("10/09/2003", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize122() {
|
||||
fn test_tokenize119() {
|
||||
let comp = vec!["10", " ", "09", " ", "2003"];
|
||||
tokenize_assert("10 09 2003", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize123() {
|
||||
fn test_tokenize120() {
|
||||
let comp = vec!["090107"];
|
||||
tokenize_assert("090107", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize124() {
|
||||
fn test_tokenize121() {
|
||||
let comp = vec!["2015", " ", "09", " ", "25"];
|
||||
tokenize_assert("2015 09 25", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize125() {
|
||||
fn test_tokenize122() {
|
||||
let comp = vec!["10", "-", "09", "-", "03"];
|
||||
tokenize_assert("10-09-03", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize126() {
|
||||
fn test_tokenize123() {
|
||||
let comp = vec!["10", ".", "09", ".", "03"];
|
||||
tokenize_assert("10.09.03", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize127() {
|
||||
fn test_tokenize124() {
|
||||
let comp = vec!["10", "/", "09", "/", "03"];
|
||||
tokenize_assert("10/09/03", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize128() {
|
||||
fn test_tokenize125() {
|
||||
let comp = vec!["10", " ", "09", " ", "03"];
|
||||
tokenize_assert("10 09 03", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize129() {
|
||||
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);
|
||||
}
|
||||
|
||||
#[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_tokenize134() {
|
||||
fn test_tokenize131() {
|
||||
let comp = vec!["Feb", " ", "2007"];
|
||||
tokenize_assert("Feb 2007", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize135() {
|
||||
fn test_tokenize132() {
|
||||
let comp = vec!["Feb", " ", "2008"];
|
||||
tokenize_assert("Feb 2008", comp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize136() {
|
||||
let comp = vec![
|
||||
"Thu", " ", "Sep", " ", "25", " ", "10", ":", "36", ":", "28", " ", "BRST", " ", "2003",
|
||||
];
|
||||
fn test_tokenize133() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize134() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize135() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize136() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize137() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize138() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize139() {
|
||||
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",
|
||||
];
|
||||
fn test_tokenize140() {
|
||||
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",
|
||||
".",
|
||||
];
|
||||
tokenize_assert(
|
||||
"Today is 25 of September of 2003, exactly at 10:49:41 with timezone -03:00.",
|
||||
comp,
|
||||
);
|
||||
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_tokenize145() {
|
||||
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,
|
||||
);
|
||||
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_tokenize146() {
|
||||
let comp = vec![
|
||||
"I", " ", "have", " ", "a", " ", "meeting", " ", "on", " ", "March", " ", "1", ",", " ",
|
||||
"1974",
|
||||
];
|
||||
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);
|
||||
}
|
||||
|
||||
#[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);
|
||||
}
|
||||
|
||||
#[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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tokenize147() {
|
||||
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", "?",
|
||||
];
|
||||
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() {
|
||||
fn test_tokenize148() {
|
||||
let comp = vec!["2017", "-", "07", "-", "17", " ", "06", ":", "15", ":"];
|
||||
tokenize_assert("2017-07-17 06:15:", comp);
|
||||
}
|
||||
|
||||
@ -14,6 +14,7 @@ pub(crate) enum ParseState {
|
||||
}
|
||||
|
||||
impl Tokenizer {
|
||||
|
||||
pub(crate) fn new(parse_string: &str) -> Self {
|
||||
Tokenizer {
|
||||
token_stack: vec![],
|
||||
@ -91,7 +92,7 @@ impl Iterator for Tokenizer {
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
ParseState::Alpha => {
|
||||
seenletters = true;
|
||||
if self.isword(nextchar) {
|
||||
@ -104,21 +105,19 @@ 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) {
|
||||
@ -131,7 +130,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
|
||||
@ -151,25 +150,20 @@ 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(',', "."));
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use ParseError;
|
||||
use ParseResult;
|
||||
use ParseError;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum DayOfWeek {
|
||||
@ -9,12 +9,13 @@ 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,
|
||||
@ -34,12 +35,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;
|
||||
@ -58,12 +59,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::InvalidMonth)
|
||||
};
|
||||
|
||||
let e = match month {
|
||||
@ -74,7 +75,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.
|
||||
@ -83,7 +84,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 {
|
||||
@ -94,7 +95,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.")
|
||||
}
|
||||
}
|
||||
|
||||
@ -113,18 +114,19 @@ 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user