Struct FlexibleDate 

pub struct FlexibleDate {
    pub year: i32,
    pub month: u8,
    pub day: u8,
    pub hour: u8,
    pub minute: u8,
    pub second: u8,
    pub offset_minutes: i32,
    pub format: DateFormat,
}

A parsed calendar date-time with a fixed UTC offset.

This is deliberately a plain component struct (spec A4 allows “your own small struct or components”) rather than a wrapper around a date crate — the project pins its dependency set and the feed plugins only need formatting, not arithmetic.

Examples

use ssg::dates::parse_flexible_date;

let dt = parse_flexible_date("2026-07-01T07:07:07Z").unwrap();
assert_eq!((dt.year, dt.month, dt.day), (2026, 7, 1));
assert_eq!((dt.hour, dt.minute, dt.second), (7, 7, 7));
assert_eq!(dt.offset_minutes, 0);

Fields

year: i32

Calendar year (1–9999).

month: u8

Calendar month (1–12).

day: u8

Day of month (1–31, leap-year validated at parse time).

hour: u8

Hour (0–23).

minute: u8

Minute (0–59).

second: u8

Second (0–59).

offset_minutes: i32

Offset from UTC in minutes (e.g. +0530 is 330).

format: DateFormat

Which input format matched during parsing.

Implementations

impl FlexibleDate

pub fn to_rfc2822(&self) -> String

Format as RFC 2822 for RSS <pubDate> / <lastBuildDate>: Wed, 01 Jul 2026 07:07:07 +0000.

The weekday is computed (Sakamoto’s algorithm), so an input carrying a wrong weekday name is corrected on the way out.

Examples

use ssg::dates::parse_flexible_date;

// "Mon" is wrong — 2026-07-01 is a Wednesday; output corrects it.
let dt = parse_flexible_date("Mon, 01 Jul 2026 07:07:07 +0000").unwrap();
assert_eq!(dt.to_rfc2822(), "Wed, 01 Jul 2026 07:07:07 +0000");

pub fn to_rfc3339(&self) -> String

Format as RFC 3339 / ISO 8601 datetime for Atom <updated>/<published> and JSON Feed date_published: 2026-07-01T07:07:07+00:00.

UTC is rendered as +00:00 (not Z) to match the output the plugins have always produced — golden feed fixtures assert the numeric form.

Examples

use ssg::dates::parse_flexible_date;

let dt = parse_flexible_date("2026-07-01T07:07:07+05:30").unwrap();
assert_eq!(dt.to_rfc3339(), "2026-07-01T07:07:07+05:30");

// Bare dates render as midnight UTC in the numeric form.
let dt = parse_flexible_date("2026-07-01").unwrap();
assert_eq!(dt.to_rfc3339(), "2026-07-01T00:00:00+00:00");

pub fn to_w3c_date(&self) -> String

Format as a W3C datetime for the news sitemap <news:publication_date>. Identical to Self::to_rfc3339 (the W3C datetime profile of ISO 8601 is what Google News accepts); provided under its spec name so call sites read like the sitemap spec.

Examples

use ssg::dates::parse_flexible_date;

let dt = parse_flexible_date("July 1, 2026").unwrap();
assert_eq!(dt.to_w3c_date(), dt.to_rfc3339());
assert_eq!(dt.to_w3c_date(), "2026-07-01T00:00:00+00:00");

pub fn to_iso_date(&self) -> String

Format as a bare ISO 8601 calendar date for sitemap <lastmod>: 2026-07-01.

Examples

use ssg::dates::parse_flexible_date;

let dt = parse_flexible_date("Wed, 01 Jul 2026 07:07:07 +0000").unwrap();
assert_eq!(dt.to_iso_date(), "2026-07-01");

Trait Implementations

impl Clone for FlexibleDate

fn clone(&self) -> FlexibleDate

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FlexibleDate

impl Debug for FlexibleDate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for FlexibleDate

impl Hash for FlexibleDate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FlexibleDate

fn eq(&self, other: &FlexibleDate) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for FlexibleDate