builder: apply fixed offset before relative adjustments

A fixed offset (e.g. the "UTC" keyword) was applied after relative
items, so "1970/01/01 UTC N seconds" added N seconds to a local
wall-clock that could drift across a DST boundary before being
re-anchored at the offset, yielding an instant off by the DST gap.
Anchor the offset first, then apply relative items.

Fixes uutils/coreutils#12555.

.github/workflows/audit.yml

@@ -0,0 +1,15 @@
+name: Security audit
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: rustsec/audit-check@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -3,7 +3,9 @@ on: [push, pull_request]
 name: Basic CI
 
 env:
+  CARGO_INCREMENTAL: "0"
   CARGO_TERM_COLOR: always
+  RUST_MIN_SRV: "1.71.1"
 
 jobs:
   check:
@@ -13,15 +15,8 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
+      - uses: actions/checkout@v6
+      - run: cargo check
 
   test:
     name: cargo test
@@ -30,31 +25,15 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+      - uses: actions/checkout@v6
+      - run: cargo test
 
   fmt:
     name: cargo fmt --all -- --check
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - uses: actions/checkout@v6
+      - run: cargo fmt --all -- --check
 
   clippy:
     name: cargo clippy -- -D warnings
@@ -63,17 +42,21 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v6
+      - run: cargo clippy --all-targets -- -D warnings
+
+  min_version:
+    name: Minimum Supported Rust Version
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add clippy
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -D warnings
+          toolchain: ${{ env.RUST_MIN_SRV }}
+      - run: cargo check
 
   coverage:
     name: Code Coverage
@@ -86,53 +69,46 @@ jobs:
           - { os: macos-latest   , features: macos }
           - { os: windows-latest , features: windows }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v6
+    - name: emulate nightly toolchain
+      run: echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # toolchain
-        TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
         # * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
         case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
         # * use requested TOOLCHAIN if specified
         if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
         outputs TOOLCHAIN
         # target-specific options
-        # * CARGO_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='--all -- --check' ;  ## default to '--all-features' for code coverage
         # * CODECOV_FLAGS
         CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
         outputs CODECOV_FLAGS
 
     - name: rust toolchain ~ install
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@nightly # this job is not reproducible...
       with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-        default: true
-        profile: minimal # minimal component installation (ie, no documentation)
+        components: llvm-tools-preview
     - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+      run: cargo test --no-fail-fast
       env:
-        CARGO_INCREMENTAL: "0"
         RUSTC_WRAPPER: ""
-        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
         RUSTDOCFLAGS: "-Cpanic=abort"
+        LLVM_PROFILE_FILE: "parse_datetime-%p-%m.profraw"
     - name: "`grcov` ~ install"
       id: build_grcov
       shell: bash
       run: |
-        git clone https://github.com/mozilla/grcov.git ~/grcov/
+        git clone --depth=1 https://github.com/mozilla/grcov.git ~/grcov/
         cd ~/grcov
         # Hardcode the version of crossbeam-epoch. See
         # https://github.com/uutils/coreutils/issues/3680
         sed -i -e "s|tempfile =|crossbeam-epoch = \"=0.9.8\"\ntempfile =|" Cargo.toml
-        cargo install --path .
+        cargo install --path . --locked
         cd -
 # Uncomment when the upstream issue
 # https://github.com/mozilla/grcov/issues/849 is fixed
@@ -150,20 +126,21 @@ jobs:
         COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
         mkdir -p "${COVERAGE_REPORT_DIR}"
         # display coverage files
-        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
+        grcov . --binary-path="${COVERAGE_REPORT_DIR}" --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
         # generate coverage report
-        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
+        grcov . --binary-path="${COVERAGE_REPORT_DIR}" --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" --source-dir .
         echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
     - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+      uses: codecov/codecov-action@v7
       with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
-        file: ${{ steps.coverage.outputs.report }}
-        ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: ${{ steps.coverage.outputs.report }}
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
         name: codecov-umbrella
         fail_ci_if_error: false
+        verbose: true
+        directory: ./
+        root_dir: ./
 
   fuzz:
     name: Run the fuzzers
@@ -171,20 +148,21 @@ jobs:
     env:
       RUN_FOR: 60
     steps:
-    - uses: actions/checkout@v3
-    - uses: dtolnay/rust-toolchain@nightly
+    - uses: actions/checkout@v6
+    - name: emulate nightly toolchain
+      run: echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
     - name: Install `cargo-fuzz`
-      run: cargo install cargo-fuzz
+      run: cargo install cargo-fuzz --locked
     - uses: Swatinem/rust-cache@v2
-    - name: Run from_str for XX seconds
+    - name: Run fuzz_parse_datetime for XX seconds
       shell: bash
       run: |
         ## Run it
         cd fuzz
-        cargo +nightly fuzz run fuzz_from_str -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
-    - name: Run fuzz_parse_datetime_from_str for XX seconds
+        cargo fuzz run fuzz_parse_datetime -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+    - name: Run fuzz_large_year for XX seconds
       shell: bash
       run: |
         ## Run it
         cd fuzz
-        cargo +nightly fuzz run fuzz_parse_datetime_from_str -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+        cargo fuzz run fuzz_large_year -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0

.github/workflows/codspeed.yml

@@ -0,0 +1,37 @@
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - "main"
+  pull_request:
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  codspeed:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup rust toolchain, cache and cargo-codspeed binary
+        uses: moonrepo/setup-rust@v1
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-codspeed
+
+      - name: Build the benchmark target(s)
+        run: cargo codspeed build
+
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          mode: simulation
+          run: cargo codspeed run

Cargo.toml

@@ -1,12 +1,24 @@
 [package]
 name = "parse_datetime"
-description = " parsing human-readable relative time strings and converting them to a Duration"
-version = "0.4.0"
+description = "parsing human-readable time strings and converting them to a Zoned datetime"
+version = "0.15.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/uutils/parse_datetime"
 readme = "README.md"
+rust-version = "1.71.1"
 
 [dependencies]
-regex = "1.8"
-chrono = { version="0.4", default-features=false, features=["std", "alloc", "clock"] }
+winnow = "1.0.0"
+num-traits = "0.2.19"
+jiff = { version = "0.2.15", default-features = false, features = ["tz-system", "tzdb-bundle-platform", "tzdb-zoneinfo"] }
+
+[dev-dependencies]
+rstest = "0.26"
+
+[dev-dependencies.codspeed-criterion-compat]
+version = "4.0"
+
+[[bench]]
+name = "parse_datetime"
+harness = false

README.md

@@ -3,54 +3,74 @@
 [![Crates.io](https://img.shields.io/crates/v/parse_datetime.svg)](https://crates.io/crates/parse_datetime)
 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/parse_datetime/blob/main/LICENSE)
 [![CodeCov](https://codecov.io/gh/uutils/parse_datetime/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/parse_datetime)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/uutils/parse_datetime?utm_source=badge)
 
-A Rust crate for parsing human-readable relative time strings and converting them to a `Duration`, or parsing human-readable datetime strings and converting them to a `DateTime`.
+A Rust crate for parsing human-readable relative time strings and
+human-readable datetime strings.
 
 ## Features
 
 - Parses a variety of human-readable and standard time formats.
 - Supports positive and negative durations.
-- Allows for chaining time units (e.g., "1 hour 2 minutes" or "2 days and 2 hours").
+- Allows for chaining time units (e.g., "1 hour 2 minutes" or "2 days 2 hours ago").
 - Calculate durations relative to a specified date.
-- Relies on Chrono
+- Relies on Jiff
 
 ## Usage
 
-Add this to your `Cargo.toml`:
+Add `parse_datetime` to your `Cargo.toml` with:
 
-```toml
-[dependencies]
-parse_datetime = "0.4.0"
+```
+cargo add parse_datetime
 ```
 
-Then, import the crate and use the `from_str` and `from_str_at_date` functions:
+Then, import the crate and use the `parse_datetime_at_date` function:
+
 ```rs
-use parse_datetime::{from_str, from_str_at_date};
-use chrono::Duration;
+use jiff::{ToSpan, Zoned};
+use parse_datetime::{parse_datetime_at_date, ParsedDateTime};
 
-let duration = from_str("+3 days");
-assert_eq!(duration.unwrap(), Duration::days(3));
+let now = Zoned::now();
+let after = parse_datetime_at_date(now.clone(), "+3 days");
 
-let today = Utc::today().naive_utc();
-let yesterday = today - Duration::days(1);
-assert_eq!(
-    from_str_at_date(yesterday, "2 days").unwrap(),
-    Duration::days(1)
-);
+match after.unwrap() {
+  ParsedDateTime::InRange(z) => assert_eq!(now.checked_add(3.days()).unwrap(), z),
+  ParsedDateTime::Extended(_) => unreachable!("unexpected for this input"),
+}
 ```
 
-For DateTime parsing, import the `parse_datetime` module:
-```rs
-use parse_datetime::parse_datetime::from_str;
-use chrono::{Local, TimeZone};
+For DateTime parsing, import the `parse_datetime` function:
 
-let dt = from_str("2021-02-14 06:37:47");
-assert_eq!(dt.unwrap(), Local.with_ymd_and_hms(2021, 2, 14, 6, 37, 47).unwrap());
+```rs
+use jiff::{civil::{date, time} ,Zoned};
+use parse_datetime::{parse_datetime, ParsedDateTime};
+
+let dt = parse_datetime("2021-02-14 06:37:47");
+match dt.unwrap() {
+  ParsedDateTime::InRange(z) => assert_eq!(z, Zoned::now().with().date(date(2021, 2, 14)).time(time(6, 37, 47, 0)).build().unwrap()),
+  ParsedDateTime::Extended(_) => unreachable!("unexpected for this input"),
+}
+```
+
+For years beyond jiff's representable range (e.g., year 10000+), the result is an `ExtendedDateTime`:
+
+```rs
+use parse_datetime::{parse_datetime, ParsedDateTime};
+
+let dt = parse_datetime("12000-01-01").unwrap();
+match dt {
+  ParsedDateTime::Extended(ext) => {
+    assert_eq!(ext.year, 12000);
+    assert_eq!(ext.month, 1);
+    assert_eq!(ext.day, 1);
+  }
+  ParsedDateTime::InRange(_) => unreachable!("year 12000 is out of jiff range"),
+}
 ```
 
 ### Supported Formats
 
-The `from_str` and `from_str_at_date` functions support the following formats for relative time:
+The `parse_datetime` and `parse_datetime_at_date` functions support absolute datetime and the following relative times:
 
 - `num` `unit` (e.g., "-1 hour", "+3 days")
 - `unit` (e.g., "hour", "day")
@@ -58,35 +78,31 @@ The `from_str` and `from_str_at_date` functions support the following formats fo
 - "yesterday"
 - "tomorrow"
 - use "ago" for the past
-- combined units with "and" or "," (e.g., "2 years and 1 month", "1 day, 2 hours" or "2 weeks 1 second")
+- use "next" or "last" with `unit` (e.g., "next week", "last year")
+- unix timestamps (for example "@0" "@1344000")
 
 `num` can be a positive or negative integer.
 `unit` can be one of the following: "fortnight", "week", "day", "hour", "minute", "min", "second", "sec" and their plural forms.
 
 ## Return Values
 
-### Duration
+### parse_datetime and parse_datetime_at_date
 
-The `from_str` and `from_str_at_date` functions return:
+The `parse_datetime` and `parse_datetime_at_date` function return:
 
-- `Ok(Duration)` - If the input string can be parsed as a relative time
-- `Err(ParseDurationError)` - If the input string cannot be parsed as a relative time
-
-This function will return `Err(ParseDurationError::InvalidInput)` if the input string
-cannot be parsed as a relative time.
-
-### parse_datetime
-
-The `from_str` function returns:
-
-- `Ok(DateTime<FixedOffset>)` - If the input string can be prsed as a datetime
-- `Err(ParseDurationError::InvalidInput)` - If the input string cannot be parsed
+- `Ok(ParsedDateTime)` - If the input string can be parsed
+  - `ParsedDateTime::InRange(Zoned)` for years supported by `jiff::Zoned`
+  - `ParsedDateTime::Extended(ExtendedDateTime)` for out-of-range years (for example `>9999`)
+- `Err(ParseDateTimeError::InvalidInput)` - If the input string cannot be parsed
 
 ## Fuzzer
 
 To run the fuzzer:
+
 ```
-$ cargo fuzz run fuzz_from_str
+$ cd fuzz
+$ cargo install cargo-fuzz
+$ cargo +nightly fuzz run fuzz_parse_datetime
 ```
 
 ## License

benches/parse_datetime.rs

@@ -0,0 +1,146 @@
+use codspeed_criterion_compat::{criterion_group, criterion_main, Criterion};
+use jiff::Zoned;
+use parse_datetime::{parse_datetime, parse_datetime_at_date};
+
+fn bench_iso_datetime(c: &mut Criterion) {
+    c.bench_function("parse_iso_datetime", |b| {
+        b.iter(|| parse_datetime("2021-02-14 06:37:47 +0000"))
+    });
+}
+
+fn bench_iso_datetime_t_sep(c: &mut Criterion) {
+    c.bench_function("parse_iso_datetime_t_separator", |b| {
+        b.iter(|| parse_datetime("2021-02-14T22:37:47-0800"))
+    });
+}
+
+fn bench_date_only(c: &mut Criterion) {
+    c.bench_function("parse_date_only", |b| {
+        b.iter(|| parse_datetime("1997-01-01"))
+    });
+}
+
+fn bench_date_slash_format(c: &mut Criterion) {
+    c.bench_function("parse_date_slash_format", |b| {
+        b.iter(|| parse_datetime("05/07/1987"))
+    });
+}
+
+fn bench_epoch_timestamp(c: &mut Criterion) {
+    c.bench_function("parse_epoch_timestamp", |b| {
+        b.iter(|| parse_datetime("@1613371067"))
+    });
+}
+
+fn bench_relative_time(c: &mut Criterion) {
+    let now = Zoned::now();
+    c.bench_function("parse_relative_time", |b| {
+        b.iter(|| parse_datetime_at_date(now.clone(), "+3 days"))
+    });
+}
+
+fn bench_relative_time_complex(c: &mut Criterion) {
+    let now = Zoned::now();
+    c.bench_function("parse_relative_time_complex", |b| {
+        b.iter(|| parse_datetime_at_date(now.clone(), "1 year 3 months 2 days ago"))
+    });
+}
+
+fn bench_relative_keywords(c: &mut Criterion) {
+    c.bench_function("parse_yesterday", |b| {
+        b.iter(|| parse_datetime("yesterday"))
+    });
+    c.bench_function("parse_tomorrow", |b| b.iter(|| parse_datetime("tomorrow")));
+    c.bench_function("parse_now", |b| b.iter(|| parse_datetime("now")));
+}
+
+fn bench_weekday(c: &mut Criterion) {
+    c.bench_function("parse_weekday", |b| b.iter(|| parse_datetime("wednesday")));
+}
+
+fn bench_timezone_offset(c: &mut Criterion) {
+    c.bench_function("parse_timezone_offset", |b| {
+        b.iter(|| parse_datetime("UTC+07:00"))
+    });
+}
+
+fn bench_datetime_with_delta(c: &mut Criterion) {
+    c.bench_function("parse_datetime_with_delta", |b| {
+        b.iter(|| parse_datetime("1997-01-01 00:00:00 +0000 +1 year"))
+    });
+}
+
+fn bench_ctime_format(c: &mut Criterion) {
+    c.bench_function("parse_ctime_format", |b| {
+        b.iter(|| parse_datetime("Wed Jan  1 00:00:00 1997"))
+    });
+}
+
+fn bench_datetime_with_timezone_name(c: &mut Criterion) {
+    c.bench_function("parse_datetime_with_tz_name", |b| {
+        b.iter(|| parse_datetime("1997-01-19 08:17:48 BRT"))
+    });
+}
+
+fn bench_datetime_ending_in_z(c: &mut Criterion) {
+    c.bench_function("parse_datetime_ending_in_z", |b| {
+        b.iter(|| parse_datetime("2023-06-03 12:00:01Z"))
+    });
+}
+
+fn bench_invalid_input(c: &mut Criterion) {
+    c.bench_function("parse_invalid_input", |b| {
+        b.iter(|| parse_datetime("NotADate"))
+    });
+}
+
+fn bench_extended_year(c: &mut Criterion) {
+    c.bench_function("parse_extended_year", |b| {
+        b.iter(|| parse_datetime("10000-01-01"))
+    });
+}
+
+fn bench_extended_year_rollover(c: &mut Criterion) {
+    c.bench_function("parse_extended_year_rollover", |b| {
+        b.iter(|| parse_datetime("9999-12-31 +1 day"))
+    });
+}
+
+fn bench_extended_year_relative(c: &mut Criterion) {
+    let base = jiff::civil::DateTime::from(jiff::civil::date(2000, 1, 1))
+        .to_zoned(jiff::tz::TimeZone::UTC)
+        .unwrap();
+    c.bench_function("parse_extended_year_relative", |b| {
+        b.iter(|| parse_datetime_at_date(base.clone(), "10000-01-01 +1 day"))
+    });
+}
+
+fn bench_extended_large_year(c: &mut Criterion) {
+    c.bench_function("parse_extended_large_year", |b| {
+        b.iter(|| parse_datetime("999999-06-15"))
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_iso_datetime,
+    bench_iso_datetime_t_sep,
+    bench_date_only,
+    bench_date_slash_format,
+    bench_epoch_timestamp,
+    bench_relative_time,
+    bench_relative_time_complex,
+    bench_relative_keywords,
+    bench_weekday,
+    bench_timezone_offset,
+    bench_datetime_with_delta,
+    bench_ctime_format,
+    bench_datetime_with_timezone_name,
+    bench_datetime_ending_in_z,
+    bench_invalid_input,
+    bench_extended_year,
+    bench_extended_year_rollover,
+    bench_extended_year_relative,
+    bench_extended_large_year,
+);
+criterion_main!(benches);

fuzz/.gitignore

@@ -0,0 +1 @@
+corpus

fuzz/Cargo.toml

@@ -1,28 +1,27 @@
 [package]
-name = "fuzz_from_str"
-version = "0.1.0"
-edition = "2018"
+name = "fuzz_parse_datetime"
+version = "0.2.0"
+edition = "2021"
 
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
-rand = "0.8.5"
-libfuzzer-sys = "0.4"
-regex = "1.8.4"
-chrono = "0.4"
+libfuzzer-sys = "0.4.7"
+arbitrary = { version = "1", features = ["derive"] }
+jiff = "0.2"
 
 [dependencies.parse_datetime]
 path = "../"
 
 [[bin]]
-name = "fuzz_from_str"
-path = "fuzz_targets/from_str.rs"
+name = "fuzz_parse_datetime"
+path = "fuzz_targets/parse_datetime.rs"
 test = false
 doc = false
 
 [[bin]]
-name = "fuzz_parse_datetime_from_str"
-path = "fuzz_targets/parse_datetime_from_str.rs"
+name = "fuzz_large_year"
+path = "fuzz_targets/large_year.rs"
 test = false
 doc = false

fuzz/fuzz_targets/large_year.rs

@@ -0,0 +1,64 @@
+#![no_main]
+
+use arbitrary::Arbitrary;
+use jiff::{civil::DateTime, tz::TimeZone};
+use libfuzzer_sys::fuzz_target;
+
+#[derive(Arbitrary, Debug)]
+struct Input {
+    /// Year for the base date (biased toward boundary years).
+    base_year_selector: u8,
+    /// Year to embed in a constructed large-year input string.
+    input_year: u32,
+    month: u8,
+    day: u8,
+    /// Suffix appended after the constructed date (e.g. relative items).
+    suffix: String,
+    /// Whether to also call parse_datetime (no base).
+    try_no_base: bool,
+}
+
+fn base_year(selector: u8) -> i16 {
+    match selector % 6 {
+        0 => 2024,
+        1 => 9998,
+        2 => 9999,
+        3 => 1,
+        4 => 100,
+        _ => (selector as i16) * 40,
+    }
+}
+
+fn clamp_year(y: u32) -> u32 {
+    // Focus on the interesting range: 9990..=100_000 and 0..=20_000
+    match y % 4 {
+        0 => 9990 + (y % 20),          // near boundary
+        1 => 10000 + (y % 90_000),     // large years
+        2 => y % 20_000,               // general range
+        _ => 2_147_485_540 + (y % 10), // near GNU_MAX_YEAR
+    }
+}
+
+fuzz_target!(|input: Input| {
+    let year = clamp_year(input.input_year);
+    let month = (input.month % 12) + 1;
+    let day = (input.day % 28) + 1;
+    let date_str = format!("{year:04}-{month:02}-{day:02} {}", input.suffix);
+
+    // Test parse_datetime (uses current time as base).
+    if input.try_no_base {
+        let _ = parse_datetime::parse_datetime(&date_str);
+    }
+
+    // Test parse_datetime_at_date with a controlled base.
+    let by = base_year(input.base_year_selector);
+    if let Ok(base) = DateTime::new(by, 1, 1, 0, 0, 0, 0) {
+        if let Ok(base) = base.to_zoned(TimeZone::UTC) {
+            let _ = parse_datetime::parse_datetime_at_date(base, &date_str);
+        }
+    }
+
+    // Also try a bare large year as a pure number.
+    let bare = format!("{year}");
+    let _ = parse_datetime::parse_datetime(&bare);
+});

fuzz/fuzz_targets/parse_datetime.rs

@@ -4,5 +4,5 @@ use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: &[u8]| {
     let s = std::str::from_utf8(data).unwrap_or("");
-    let _ = parse_datetime::from_str(s);
+    let _ = parse_datetime::parse_datetime(s);
 });

fuzz/fuzz_targets/parse_datetime_from_str.rs

@@ -1,8 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-
-fuzz_target!(|data: &[u8]| {
-    let s = std::str::from_utf8(data).unwrap_or("");
-    let _ = parse_datetime::parse_datetime::from_str(s);
-});

renovate.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
-    "config:base"
+    "config:recommended"
   ]
 }

src/items/combined.rs

@@ -0,0 +1,76 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parse an ISO 8601 date and time item
+//!
+//! The GNU docs state:
+//!
+//! > The ISO 8601 date and time of day extended format consists of an ISO 8601
+//! > date, a ‘T’ character separator, and an ISO 8601 time of day. This format
+//! > is also recognized if the ‘T’ is replaced by a space.
+//! >
+//! > In this format, the time of day should use 24-hour notation. Fractional
+//! > seconds are allowed, with either comma or period preceding the fraction.
+//! > ISO 8601 fractional minutes and hours are not supported. Typically, hosts
+//! > support nanosecond timestamp resolution; excess precision is silently
+//! > discarded.
+use winnow::{
+    combinator::{alt, trace},
+    seq, ModalResult, Parser,
+};
+
+use crate::items::space;
+
+use super::{date, primitive::s, time};
+
+#[derive(PartialEq, Debug, Clone, Default)]
+pub(crate) struct DateTime {
+    pub(crate) date: date::Date,
+    pub(crate) time: time::Time,
+}
+
+pub(crate) fn parse(input: &mut &str) -> ModalResult<DateTime> {
+    seq!(DateTime {
+        date: trace("iso_date", alt((date::iso1, date::iso2))),
+        // Note: the `T` is lowercased by the main parse function
+        _: alt((s('t').void(), (' ', space).void())),
+        time: trace("iso_time", time::iso),
+    })
+    .parse_next(input)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{parse, DateTime};
+    use crate::items::{date::Date, time::Time};
+
+    #[test]
+    fn some_date() {
+        let reference = Some(DateTime {
+            date: Date {
+                day: 10,
+                month: 10,
+                year: Some(2022),
+            },
+            time: Time {
+                hour: 10,
+                minute: 10,
+                second: 55,
+                nanosecond: 0,
+                offset: None,
+            },
+        });
+
+        for mut s in [
+            "2022-10-10t10:10:55",
+            "2022-10-10 10:10:55",
+            "2022-10-10    t   10:10:55",
+            "2022-10-10       10:10:55",
+            "2022-10-10  (A comment!) t   10:10:55",
+            "2022-10-10  (A comment!)   10:10:55",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).ok(), reference, "Failed string: {old_s}")
+        }
+    }
+}

src/items/epoch.rs

@@ -0,0 +1,137 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parse a timestamp item.
+//!
+//! From the GNU docs:
+//!
+//! > If you precede a number with ‘@’, it represents an internal timestamp as
+//! > a count of seconds.  The number can contain an internal decimal point
+//! > (either ‘.’ or ‘,’); any excess precision not supported by the internal
+//! > representation is truncated toward minus infinity.  Such a number cannot
+//! > be combined with any other date item, as it specifies a complete
+//! > timestamp.
+//! >
+//! >    On most hosts, these counts ignore the presence of leap seconds.  For
+//! > example, on most hosts ‘@1483228799’ represents 2016-12-31 23:59:59 UTC,
+//! > ‘@1483228800’ represents 2017-01-01 00:00:00 UTC, and there is no way to
+//! > represent the intervening leap second 2016-12-31 23:59:60 UTC.
+
+use winnow::{
+    ascii::digit1,
+    combinator::{opt, preceded},
+    token::one_of,
+    ModalResult, Parser,
+};
+
+use super::primitive::{dec_uint, plus_or_minus, s};
+
+/// Represents a timestamp with nanosecond accuracy.
+///
+/// # Invariants
+///
+/// - `nanosecond` is always in the range of `0..1_000_000_000`.
+/// - Negative timestamps are represented by a negative `second` value and a
+///   positive `nanosecond` value.
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub(super) struct Timestamp {
+    second: i64,
+    nanosecond: u32,
+}
+
+impl TryFrom<Timestamp> for jiff::Timestamp {
+    type Error = &'static str;
+
+    fn try_from(ts: Timestamp) -> Result<Self, Self::Error> {
+        jiff::Timestamp::new(
+            ts.second,
+            i32::try_from(ts.nanosecond).map_err(|_| "nanosecond in timestamp exceeds i32::MAX")?,
+        )
+        .map_err(|_| "timestamp value is out of valid range")
+    }
+}
+
+/// Parse a timestamp in the form of `@1234567890` or `@-1234567890.12345` or
+/// `@1234567890,12345`.
+pub(super) fn parse(input: &mut &str) -> ModalResult<Timestamp> {
+    (s("@"), opt(plus_or_minus), s(sec_and_nsec))
+        .verify_map(|(_, sign, (sec, nsec))| {
+            let sec = i64::try_from(sec).ok()?;
+            let (second, nanosecond) = match (sign, nsec) {
+                (Some('-'), 0) => (-sec, 0),
+                // Truncate towards minus infinity.
+                (Some('-'), _) => ((-sec).checked_sub(1)?, 1_000_000_000 - nsec),
+                _ => (sec, nsec),
+            };
+            Some(Timestamp { second, nanosecond })
+        })
+        .parse_next(input)
+}
+
+/// Parse a second value in the form of `1234567890` or `1234567890.12345` or
+/// `1234567890,12345`.
+///
+/// The first part represents whole seconds. The optional second part represents
+/// fractional seconds, parsed as a nanosecond value from up to 9 digits
+/// (padded with zeros on the right if fewer digits are present). If the second
+/// part is omitted, it defaults to 0 nanoseconds.
+pub(super) fn sec_and_nsec(input: &mut &str) -> ModalResult<(u64, u32)> {
+    (dec_uint, opt(preceded(one_of(['.', ',']), digit1)))
+        .verify_map(|(sec, opt_nsec_str)| match opt_nsec_str {
+            Some(nsec_str) if nsec_str.len() >= 9 => Some((sec, nsec_str[..9].parse().ok()?)),
+            Some(nsec_str) => {
+                let multiplier = 10_u32.pow(9 - nsec_str.len() as u32);
+                Some((sec, nsec_str.parse::<u32>().ok()?.checked_mul(multiplier)?))
+            }
+            None => Some((sec, 0)),
+        })
+        .parse_next(input)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ts(second: i64, nanosecond: u32) -> Timestamp {
+        Timestamp { second, nanosecond }
+    }
+
+    #[test]
+    fn parse_sec_and_nsec() {
+        for (input, expected) in [
+            ("1234567890", (1234567890, 0)),                       // only seconds
+            ("1234567890.12345", (1234567890, 123450000)), // seconds and nanoseconds, '.' as floating point
+            ("1234567890,12345", (1234567890, 123450000)), // seconds and nanoseconds, ',' as floating point
+            ("1234567890.1234567890123", (1234567890, 123456789)), // nanoseconds with more than 9 digits, truncated
+        ] {
+            let mut s = input;
+            assert_eq!(sec_and_nsec(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            ".1234567890", // invalid: no leading seconds
+            "-1234567890", // invalid: negative input not allowed
+        ] {
+            let mut s = input;
+            assert!(sec_and_nsec(&mut s).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn timestamp() {
+        for (input, expected) in [
+            ("@1234567890", ts(1234567890, 0)), // positive seconds, no nanoseconds
+            ("@ 1234567890", ts(1234567890, 0)), // space after '@', positive seconds, no nanoseconds
+            ("@-1234567890", ts(-1234567890, 0)), // negative seconds, no nanoseconds
+            ("@ -1234567890", ts(-1234567890, 0)), // space after '@', negative seconds, no nanoseconds
+            ("@ - 1234567890", ts(-1234567890, 0)), // space after '@' and after '-', negative seconds, no nanoseconds
+            ("@1234567890.12345", ts(1234567890, 123450000)), // positive seconds with nanoseconds, '.' as floating point
+            ("@1234567890,12345", ts(1234567890, 123450000)), // positive seconds with nanoseconds, ',' as floating point
+            ("@-1234567890.12345", ts(-1234567891, 876550000)), // negative seconds with nanoseconds, '.' as floating point
+            ("@1234567890.1234567890123", ts(1234567890, 123456789)), // nanoseconds with more than 9 digits, truncated
+        ] {
+            let mut s = input;
+            assert_eq!(parse(&mut s).unwrap(), expected, "{input}");
+        }
+    }
+}

src/items/error.rs

@@ -0,0 +1,38 @@
+use std::fmt;
+
+use winnow::error::{ContextError, ErrMode};
+
+#[derive(Debug)]
+pub(crate) enum Error {
+    ParseError(String),
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::ParseError(reason) => {
+                write!(f, "{reason}")
+            }
+        }
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(reason: &'static str) -> Self {
+        Error::ParseError(reason.to_owned())
+    }
+}
+
+impl From<ErrMode<ContextError>> for Error {
+    fn from(err: ErrMode<ContextError>) -> Self {
+        Error::ParseError(err.to_string())
+    }
+}
+
+impl From<jiff::Error> for Error {
+    fn from(err: jiff::Error) -> Self {
+        Error::ParseError(err.to_string())
+    }
+}